给Memoh动了一场省钱手术:Telegram 特化改造记录

type terminalSendProvider struct {
	sdk.Provider
	state *terminalSendState
}
 
func (p *terminalSendProvider) DoGenerate(ctx context.Context, params sdk.GenerateParams) (*sdk.GenerateResult, error) {
	if p.state.isDelivered() {
		return &sdk.GenerateResult{
			FinishReason: sdk.FinishReasonStop,
			Response:     sdk.ResponseMetadata{ID: terminalSendResponseID},
		}, nil
	}
	return p.Provider.DoGenerate(ctx, params)
}
 
func (p *terminalSendProvider) DoStream(ctx context.Context, params sdk.GenerateParams) (*sdk.StreamResult, error) {
	if !p.state.isDelivered() {
		return p.Provider.DoStream(ctx, params)
	}
	parts := make(chan sdk.StreamPart, 2)
	parts <- &sdk.FinishStepPart{
		FinishReason: sdk.FinishReasonStop,
		Response:     sdk.ResponseMetadata{ID: terminalSendResponseID},
	}
	parts <- &sdk.FinishPart{FinishReason: sdk.FinishReasonStop}
	close(parts)
	return &sdk.StreamResult{Stream: parts}, nil
}

func (p *MessageProvider) execSend(ctx context.Context, session SessionContext, toolCallID string, args map[string]any) (any, error) {
	if session.SessionType == sessionmode.Discuss {
		sendResult, err := p.exec.SendDirectForTool(ctx, toMessagingSession(session), "", toolCallID, args)
		if err != nil {
			return messageSendErrorResult(err)
		}
		resp := map[string]any{"ok": true}
		if !session.IsSameConversation(sendResult.Platform, sendResult.Target) {
			resp["platform"] = sendResult.Platform
			resp["target"] = sendResult.Target
			resp["delivered"] = "target"
		}
		return resp, nil
	}

func minimalDiscussSendCall(call sdk.ToolCallPart) sdk.ToolCallPart {
	input := normalizeToolInputMap(call.Input)
	minimal := make(map[string]any, 5)
	// Current-conversation routing is implicit. Keep only audience-visible
	// payload fields and the reply reference needed to understand the exchange.
	for _, key := range []string{"text", "reply_to", "sticker_id", "attachments", "message"} {
		if value, ok := input[key]; ok {
			minimal[key] = value
		}
	}
	return sdk.ToolCallPart{
		ToolCallID: strings.TrimSpace(call.ToolCallID),
		ToolName:   "send",
		Input:      minimal,
	}

send(text[optional], reply_to[optional], sticker_id[optional])

	"github.com/memohai/memoh/internal/delivery"
)
 
const (
	telegramStickerSendGuidance     = " For Telegram, normally pair every coherent public message with at least one context-appropriate Sticker by setting `sticker_id` in the same send call; omit it only when the catalog has no suitable Sticker. Choose from the full visual descriptions, not from the original emoji alone, and avoid repetitive duplicates."
	telegramStickerCatalogSchemaKey = "x-memoh-sticker-catalog"
)
 
type telegramStickerSchemaEntry struct {
	ID          string `json:"id"`
	Description string `json:"description"`
	Emoji       string `json:"emoji"`
	Status      string `json:"status"`
}
 
// mergeTelegramStickerSendTools converts the Sticker MCP into an internal
// backend for the first-party send tool. The model sees one send call whose
// sticker_id enum contains the complete, stable catalog; it never sees a

// systemFileLoadOrder keeps the frequently changing memory summary at the
// tail of the system prompt. Stable instruction/profile content therefore
// remains in the reusable prefix when MEMORY.md changes between turns.
func systemFileLoadOrder() []string {
	return []string{"AGENTS.md", "PROFILES.md", "MEMORY.md"}
}

		MemoryInstructions:    strings.TrimSpace(botSettings.MemoryProviderID) != "",

	TelegramToolCallsEnabledMetadataKey = "telegram_tool_calls_enabled"
	TelegramEnabledToolsMetadataKey     = "telegram_enabled_tools"
	TelegramSkillsEnabledMetadataKey    = "telegram_skills_enabled"
	TelegramMessageMetadataModeKey      = "telegram_message_metadata_mode"

		}
		filtered := make([]sdk.Tool, 0, len(providerTools))
		for _, tool := range providerTools {
			if cfg.ChannelPolicy.AllowsTool(tool.Name) || cfg.ChannelPolicy.AllowsBackendTool(tool.Name) {
				filtered = append(filtered, tool)
			}
		}
		providerTools = filtered

func ProjectUserMessageHeader(content, mode string) string {
	if strings.ToLower(strings.TrimSpace(mode)) != "compact" || !strings.HasPrefix(strings.TrimSpace(content), "<message") {
		return content
	}
	start := strings.Index(content, "<message")
	if start < 0 {
		return content
	}
	endRel := strings.Index(content[start:], ">")
	if endRel < 0 {
		return content
	}
	end := start + endRel
	compactOpening, ok := projectMessageOpeningTag(content[start : end+1])
	if !ok {
		return content
	}
	return content[:start] + compactOpening + content[end+1:]
}

func (s *Service) describeImagesWithAuxiliaryVision(
	ctx context.Context,
	req ChatRequest,
	primarySupportsVision bool,
	attachments []gatewayAttachment,
) string {
	if s == nil || primarySupportsVision {
		return ""
	}
	images := extractNativeImageParts(attachmentsToAny(attachments))
	return s.describeImagePartsWithAuxiliaryVision(ctx, req, primarySupportsVision, images)
}
 
func (s *Service) describeImagePartsWithAuxiliaryVision(

func appendAuxiliaryVisionToLastUserMessage(messages []sdk.Message, visionContext string) []sdk.Message {
	visionContext = strings.TrimSpace(visionContext)
	if visionContext == "" {
		return messages
	}
	for i := len(messages) - 1; i >= 0; i-- {
		if messages[i].Role != sdk.MessageRoleUser {
			continue
		}
		messages[i].Content = append(messages[i].Content, sdk.TextPart{Text: "\n\n" + visionContext})
		return messages
	}
	return append(messages, sdk.UserMessage(visionContext))
}