feat(managed-kimi-code): support Anthropic-compatible protocol (#1170)

* fix(agent-core): recover from context overflow 413

- track provider-observed effective context limit after overflow
- compact with the reduced limit before retrying the turn
- treat large plain 413 responses as recoverable context overflow
- add CLI patch changeset

* feat(managed-kimi-code): support Anthropic-compatible protocol

- switch managed provider to anthropic when models declare anthropic protocol
- add base64 video content blocks to the kosong anthropic provider
- downgrade unsupported media parts to text placeholders by capability
- pass prompt cache key as Anthropic metadata.user_id for session affinity

* feat(agent-core): add protocol/type to request and video upload telemetry

- turn_started now carries `type` (configured provider wire type) and
  `protocol` (effective transport, i.e. alias.protocol ?? provider.type)
- new video_upload event reports mime type, size, latency and
  success/failure, plus type/protocol/model context
- ResolvedRuntimeProvider gains `type` and `protocol` fields

Author: sailist

.changeset/recover-from-context-overflow-413.md

@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Recover from provider 413 context overflows by compacting before retrying.

.changeset/support-managed-anthropic-protocol.md

@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Support the Anthropic-compatible protocol for managed Kimi Code, including video input.

apps/kimi-code/src/tui/controllers/session-event-handler.ts

@@ -401,9 +401,10 @@ export class SessionEventHandler {
 
   private isAnthropicSessionActive(): boolean {
     const { state } = this.host;
-    const providerKey = state.appState.availableModels[state.appState.model]?.provider;
-    if (providerKey === undefined) return false;
-    return state.appState.availableProviders[providerKey]?.type === 'anthropic';
+    const model = state.appState.availableModels[state.appState.model];
+    if (model === undefined) return false;
+    if (model.protocol === 'anthropic') return true;
+    return state.appState.availableProviders[model.provider]?.type === 'anthropic';
   }
 
   private handleStepInterrupted(event: TurnStepInterruptedEvent): void {

packages/agent-core/src/agent/compaction/full.ts

@@ -8,8 +8,10 @@ import {
   APIEmptyResponseError,
   isRetryableGenerateError,
   type GenerateResult,
+  type Message,
   type TokenUsage,
   APIContextOverflowError,
+  APIStatusError,
   createUserMessage,
 } from '@moonshot-ai/kosong';
 
@@ -23,6 +25,7 @@ import { renderPrompt } from '../../utils/render-prompt';
 import {
   estimateTokens,
   estimateTokensForMessages,
+  estimateTokensForTools,
 } from '../../utils/tokens';
 import {
   applyCompletionBudget,
@@ -39,14 +42,9 @@ import {
 
 export const MAX_COMPACTION_RETRY_ATTEMPTS = 5;
 
-/**
- * Default hard cap on compaction output tokens when `maxOutputSize` is not
- * configured on the model alias. Without this, compaction falls back to the
- * full context window size, which exceeds the `max_tokens` ceiling enforced
- * by many OpenAI-compatible providers. 128k matches the chat-completions
- * ceiling applied by the OpenAI Legacy provider.
- */
 const DEFAULT_COMPACTION_MAX_COMPLETION_TOKENS = 128 * 1024;
+const OVERFLOW_CONTEXT_SAFETY_RATIO = 0.85;
+const OVERFLOW_STATUS_RECOVERY_RATIO = 0.5;
 
 class CompactionTruncatedError extends Error {
   constructor() {
@@ -62,6 +60,7 @@ export class FullCompaction {
     promise: Promise<void>;
     blockedByTurn: boolean;
   } | null = null;
+  private readonly observedMaxContextTokensByModel = new Map<string, number>();
   protected readonly strategy: CompactionStrategy;
 
   constructor(
@@ -71,7 +70,7 @@ export class FullCompaction {
     this.strategy =
       strategy ??
       new DefaultCompactionStrategy(
-        () => agent.config.modelCapabilities.max_context_tokens,
+        () => this.getEffectiveMaxContextTokens(),
         {
           ...DEFAULT_COMPACTION_CONFIG,
           reservedContextSize:
@@ -85,6 +84,45 @@ export class FullCompaction {
     return this.compacting !== null;
   }
 
+  getEffectiveMaxContextTokens(): number {
+    const configured = this.agent.config.modelCapabilities.max_context_tokens;
+    const modelAlias = this.agent.config.modelAlias;
+    const observed =
+      modelAlias === undefined ? undefined : this.observedMaxContextTokensByModel.get(modelAlias);
+    if (observed === undefined) return configured;
+    if (configured <= 0) return observed;
+    return Math.min(configured, observed);
+  }
+
+  estimateCurrentRequestTokens(): number {
+    return this.estimateRequestTokens(this.agent.context.messages);
+  }
+
+  shouldRecoverFromContextOverflow(
+    error: unknown,
+    estimatedRequestTokens = this.estimateCurrentRequestTokens(),
+  ): boolean {
+    if (error instanceof APIContextOverflowError) return true;
+    if (!(error instanceof APIStatusError) || error.statusCode !== 413) return false;
+    const effectiveMax = this.getEffectiveMaxContextTokens();
+    return (
+      effectiveMax > 0 && estimatedRequestTokens >= effectiveMax * OVERFLOW_STATUS_RECOVERY_RATIO
+    );
+  }
+
+  observeContextOverflow(estimatedRequestTokens: number): void {
+    if (!Number.isFinite(estimatedRequestTokens) || estimatedRequestTokens <= 0) return;
+    const modelAlias = this.agent.config.modelAlias;
+    if (modelAlias === undefined) return;
+    const observed = Math.max(
+      1,
+      Math.floor(estimatedRequestTokens * OVERFLOW_CONTEXT_SAFETY_RATIO),
+    );
+    const current = this.getEffectiveMaxContextTokens();
+    if (current > 0 && observed >= current) return;
+    this.observedMaxContextTokensByModel.set(modelAlias, observed);
+  }
+
   begin(data: Readonly<CompactionBeginData>): void {
     if (this.compacting) return;
     if (data.source === 'manual') {
@@ -145,6 +183,14 @@ export class FullCompaction {
     return this.agent.context.tokenCountWithPending;
   }
 
+  private estimateRequestTokens(messages: readonly Message[]): number {
+    return (
+      estimateTokens(this.agent.config.systemPrompt) +
+      estimateTokensForTools(this.agent.tools.loopTools) +
+      estimateTokensForMessages(messages)
+    );
+  }
+
   resetForTurn(): void {
     this.compactionCountInTurn = 0;
   }
@@ -300,6 +346,7 @@ export class FullCompaction {
           ...this.agent.context.project(messagesToCompact),
           createUserMessage(renderPrompt(compactionInstructionTemplate, { customInstruction: data.instruction ?? '' })),
         ];
+        const estimatedCompactionRequestTokens = this.estimateRequestTokens(messages);
         try {
           const response = await this.agent.generate(
             provider,
@@ -316,8 +363,15 @@ export class FullCompaction {
           summary = extractCompactionSummary(response);
           break;
         } catch (error) {
+          const isContextOverflow = this.shouldRecoverFromContextOverflow(
+            error,
+            estimatedCompactionRequestTokens,
+          );
+          if (isContextOverflow) {
+            this.observeContextOverflow(estimatedCompactionRequestTokens);
+          }
           if (
-            error instanceof APIContextOverflowError ||
+            isContextOverflow ||
             error instanceof CompactionTruncatedError ||
             error instanceof APIEmptyResponseError // e.g. think-only
           ) {

packages/agent-core/src/agent/tool/index.ts

@@ -537,8 +537,58 @@ export class ToolManager {
     const withAuth = this.agent.modelProvider?.resolveAuth?.(modelAlias, {
       log: this.agent.log,
     });
-    if (withAuth === undefined) return (input) => uploadVideo(input);
-    return (input) => withAuth((auth) => uploadVideo(input, { auth }));
+    const baseProps = this.videoUploadTelemetryProps(modelAlias);
+    const upload =
+      withAuth === undefined
+        ? (input: b.VideoUploadInput) => uploadVideo(input)
+        : (input: b.VideoUploadInput) => withAuth((auth) => uploadVideo(input, { auth }));
+
+    return async (input) => {
+      const startedAt = Date.now();
+      const base = {
+        ...baseProps,
+        mime_type: input.mimeType,
+        size_bytes: input.data.length,
+      };
+      const track = (props: Record<string, string | number | boolean | undefined>): void => {
+        try {
+          this.agent.telemetry.track('video_upload', props);
+        } catch {
+          // Telemetry must never affect the upload outcome.
+        }
+      };
+      try {
+        const part = await upload(input);
+        track({ ...base, success: true, latency_ms: Date.now() - startedAt });
+        return part;
+      } catch (error) {
+        track({
+          ...base,
+          success: false,
+          latency_ms: Date.now() - startedAt,
+          error: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+      }
+    };
+  }
+
+  private videoUploadTelemetryProps(modelAlias: string): {
+    type?: string;
+    protocol?: string;
+    model: string;
+  } {
+    try {
+      const resolved = this.agent.modelProvider?.resolveProviderConfig(modelAlias);
+      if (resolved === undefined) return { model: modelAlias };
+      return {
+        model: modelAlias,
+        type: resolved.type,
+        protocol: resolved.protocol ?? resolved.type,
+      };
+    } catch {
+      return { model: modelAlias };
+    }
   }
 
   get loopTools(): readonly ExecutableTool[] {

packages/agent-core/src/agent/turn/index.ts

@@ -455,7 +455,7 @@ export class TurnFlow {
     const telemetryMode = this.telemetryMode();
     this.telemetryModeByTurn.set(turnId, telemetryMode);
     this.currentStepByTurn.set(turnId, 0);
-    this.agent.telemetry.track('turn_started', { mode: telemetryMode });
+    this.agent.telemetry.track('turn_started', { mode: telemetryMode, ...this.requestProtocolProps() });
     this.agent.fullCompaction.resetForTurn();
     this.agent.usage.beginTurn();
     this.agent.emitEvent({ type: 'turn.started', turnId, origin });
@@ -760,10 +760,19 @@ export class TurnFlow {
 
         return result.stopReason;
       } catch (error) {
-        if (
+        const isContextOverflow =
           error instanceof APIContextOverflowError ||
-          (isKimiError(error) && error.code === ErrorCodes.CONTEXT_OVERFLOW)
+          (isKimiError(error) && error.code === ErrorCodes.CONTEXT_OVERFLOW);
+        const estimatedRequestTokens = isContextOverflow
+          ? this.agent.fullCompaction.estimateCurrentRequestTokens()
+          : undefined;
+        if (
+          isContextOverflow ||
+          this.agent.fullCompaction.shouldRecoverFromContextOverflow(error, estimatedRequestTokens)
         ) {
+          this.agent.fullCompaction.observeContextOverflow(
+            estimatedRequestTokens ?? this.agent.fullCompaction.estimateCurrentRequestTokens(),
+          );
           await this.agent.fullCompaction.handleOverflowError(signal, error);
           continue; // Retry with compacted context
         }
@@ -921,6 +930,27 @@ export class TurnFlow {
     return this.agent.planMode.isActive ? 'plan' : 'agent';
   }
 
+  /**
+   * Resolve the current model's provider wire type and any model-level protocol
+   * override for request telemetry. Never throws — telemetry must not break a
+   * turn over an unresolvable provider config (the step loop will surface that
+   * error on its own).
+   */
+  private requestProtocolProps(): { type?: string; protocol?: string } {
+    const model = this.agent.config.modelAlias;
+    if (model === undefined) return {};
+    try {
+      const resolved = this.agent.modelProvider?.resolveProviderConfig(model);
+      if (resolved === undefined) return {};
+      return {
+        type: resolved.type,
+        protocol: resolved.protocol ?? resolved.type,
+      };
+    } catch {
+      return {};
+    }
+  }
+
   private shouldTrackApiError(turnId: number): boolean {
     const failure = this.stepFailureByTurn.get(turnId);
     return failure?.reason === 'error' && failure.activeStep !== undefined;

packages/agent-core/src/agent/turn/kosong-llm.ts

@@ -19,7 +19,9 @@ import {
   emptyUsage,
   generate as kosongGenerate,
   isRetryableGenerateError,
+  isUnknownCapability,
   type ChatProvider,
+  type ContentPart,
   type GenerateCallbacks,
   type Message,
   type ModelCapability,
@@ -119,7 +121,7 @@ export class KosongLLM implements LLM {
       effectiveProvider,
       this.systemPrompt,
       [...params.tools],
-      params.messages,
+      downgradeUnsupportedMedia(params.messages, this.capability),
       callbacks,
       options,
     );
@@ -263,3 +265,50 @@ export function buildMessagesWithSystem(systemPrompt: string, history: Message[]
     ...history,
   ];
 }
+
+export function downgradeUnsupportedMedia(
+  messages: readonly Message[],
+  capability: ModelCapability | undefined,
+): Message[] {
+  if (capability === undefined || isUnknownCapability(capability)) return [...messages];
+  const dropImage = !capability.image_in;
+  const dropVideo = !capability.video_in;
+  const dropAudio = !capability.audio_in;
+  if (!dropImage && !dropVideo && !dropAudio) return [...messages];
+
+  const drop = { dropImage, dropVideo, dropAudio };
+  let changed = false;
+  const out: Message[] = [];
+  for (const message of messages) {
+    let nextContent: ContentPart[] | undefined;
+    for (let i = 0; i < message.content.length; i++) {
+      const part = message.content[i]!;
+      const placeholder = mediaPlaceholder(part, drop);
+      if (placeholder === undefined) {
+        nextContent?.push(part);
+        continue;
+      }
+      nextContent ??= message.content.slice(0, i);
+      nextContent.push({ type: 'text', text: placeholder });
+      changed = true;
+    }
+    out.push(nextContent === undefined ? message : { ...message, content: nextContent });
+  }
+  return changed ? out : [...messages];
+}
+
+function mediaPlaceholder(
+  part: ContentPart,
+  drop: { readonly dropImage: boolean; readonly dropVideo: boolean; readonly dropAudio: boolean },
+): string | undefined {
+  if (part.type === 'image_url' && drop.dropImage) {
+    return '[image omitted: current model has no image input]';
+  }
+  if (part.type === 'video_url' && drop.dropVideo) {
+    return '[video omitted: current model has no video input]';
+  }
+  if (part.type === 'audio_url' && drop.dropAudio) {
+    return '[audio omitted: current model has no audio input]';
+  }
+  return undefined;
+}

packages/agent-core/src/config/schema.ts

@@ -45,6 +45,7 @@ export const ModelAliasSchema = z.object({
   capabilities: z.array(z.string()).optional(),
   displayName: z.string().optional(),
   reasoningKey: z.string().optional(),
+  protocol: z.literal('anthropic').optional(),
   // Explicitly declare adaptive-thinking support, overriding the kosong
   // model-name version inference. Needed for custom-named Anthropic endpoints
   // whose model name does not encode a parseable Claude version.