pi-provider-kimi-code 0.6.11 → 0.6.13

package/src/payload.ts

@@ -31,12 +31,14 @@ export function resolveCacheRetention(value?: CacheRetention): CacheRetention {
 }
 
 export interface KimiPayloadContext {
-  api: "anthropic-messages" | "openai-completions";
+  api: "anthropic-messages" | "openai-completions" | "openai-responses";
   upload?: Uploader;
   uploadCacheScope?: string;
   cacheKey?: string;
   cacheRetention: CacheRetention;
   reasoning?: ThinkingLevel;
+  /** Per-request cap from the caller (pi options.maxTokens); wins over the omission policy. */
+  requestMaxTokens?: number;
   modelConfig: KimiResolvedModelConfig;
 }
 
@@ -264,6 +266,155 @@ async function transformOpenAIPayloadFiles(
   }
 }
 
+// -----------------------------------------------------------------------------
+// Per-request inline media budget (upstream kimi-code #3784,
+// mediaResolverService.applyMediaBudget): accumulated inline media count
+// against a 20 MB per-request base64 wire-size budget (not decoded media
+// bytes); when exceeded, the oldest items are dropped until the total is under
+// the 10 MB base64 wire-size low-water mark and replaced with an omission
+// placeholder. OpenAI data URLs count the full data: URL string, including its
+// small prefix overhead, while Anthropic base64 blocks count the source data
+// string. Uploaded ms:// references are tiny and never counted. Media is
+// deduped by content hash so a repeated image counts once and every occurrence
+// is dropped together.
+// -----------------------------------------------------------------------------
+
+const REQUEST_MEDIA_BUDGET_BYTES = 20 * 1024 * 1024;
+const REQUEST_MEDIA_BUDGET_LOW_BYTES = 10 * 1024 * 1024;
+
+interface InlineMediaBudgetEntry {
+  kind: "image" | "video";
+  key: string;
+  bytes: number;
+  /** Indices into messages[...].content[...] (a third index addresses a tool_result's content). */
+  path: number[];
+}
+
+function inlineMediaKey(kind: string, payload: string): string {
+  return createHash("sha256").update(kind).update("\0").update(payload).digest("hex");
+}
+
+function collectOpenAIInlineMedia(payload: JsonRecord): InlineMediaBudgetEntry[] {
+  const entries: InlineMediaBudgetEntry[] = [];
+  if (!Array.isArray(payload.messages)) return entries;
+  for (const [messageIndex, message] of payload.messages.entries()) {
+    if (!isRecord(message) || !Array.isArray(message.content)) continue;
+    for (const [blockIndex, block] of (message.content as unknown[]).entries()) {
+      if (!isRecord(block)) continue;
+      const field =
+        block.type === "image_url" ? "image_url" : block.type === "video_url" ? "video_url" : null;
+      if (!field) continue;
+      const kind = block.type === "image_url" ? "image" : "video";
+      const value = block[field];
+      const url =
+        typeof value === "string"
+          ? value
+          : isRecord(value) && typeof value.url === "string"
+            ? value.url
+            : null;
+      if (!url || !url.startsWith("data:")) continue;
+      entries.push({
+        kind,
+        key: inlineMediaKey(kind, url),
+        bytes: url.length,
+        path: [messageIndex, blockIndex],
+      });
+    }
+  }
+  return entries;
+}
+
+function collectAnthropicInlineMedia(payload: JsonRecord): InlineMediaBudgetEntry[] {
+  const entries: InlineMediaBudgetEntry[] = [];
+  if (!Array.isArray(payload.messages)) return entries;
+  const collect = (messageIndex: number, path: number[], block: unknown): void => {
+    if (!isRecord(block)) return;
+    const kind = block.type === "image" || block.type === "video" ? block.type : null;
+    if (
+      kind &&
+      isRecord(block.source) &&
+      block.source.type === "base64" &&
+      typeof block.source.media_type === "string" &&
+      typeof block.source.data === "string"
+    ) {
+      const data = block.source.data;
+      entries.push({
+        kind,
+        key: inlineMediaKey(kind, `${block.source.media_type}\0${data}`),
+        bytes: data.length,
+        path: [messageIndex, ...path],
+      });
+    }
+  };
+  for (const [messageIndex, message] of payload.messages.entries()) {
+    if (!isRecord(message) || !Array.isArray(message.content)) continue;
+    for (const [blockIndex, block] of (message.content as unknown[]).entries()) {
+      if (isRecord(block) && block.type === "tool_result" && Array.isArray(block.content)) {
+        for (const [nestedIndex, nested] of (block.content as unknown[]).entries()) {
+          collect(messageIndex, [blockIndex, nestedIndex], nested);
+        }
+        continue;
+      }
+      collect(messageIndex, [blockIndex], block);
+    }
+  }
+  return entries;
+}
+
+export function applyInlineMediaBudget(
+  payload: JsonRecord,
+  api: "anthropic-messages" | "openai-completions",
+  budgetBytes: number = REQUEST_MEDIA_BUDGET_BYTES,
+  lowBytes: number = REQUEST_MEDIA_BUDGET_LOW_BYTES,
+): boolean {
+  const entries =
+    api === "anthropic-messages"
+      ? collectAnthropicInlineMedia(payload)
+      : collectOpenAIInlineMedia(payload);
+  if (entries.length === 0) return false;
+
+  // Deduplicate by content: repeated media counts once, drops hit every copy.
+  const bytesByKey = new Map<string, number>();
+  for (const entry of entries) {
+    if (!bytesByKey.has(entry.key)) bytesByKey.set(entry.key, entry.bytes);
+  }
+  let total = 0;
+  for (const bytes of bytesByKey.values()) total += bytes;
+  if (total <= budgetBytes) return false;
+
+  const dropped = new Set<string>();
+  for (const [key, bytes] of bytesByKey) {
+    if (total <= lowBytes) break;
+    if (bytes === 0) continue;
+    dropped.add(key);
+    total -= bytes;
+  }
+
+  const messages = payload.messages as unknown[];
+  let droppedCount = 0;
+  for (const entry of entries) {
+    if (!dropped.has(entry.key)) continue;
+    const message = messages[entry.path[0]] as JsonRecord;
+    const content = message.content as unknown[];
+    const placeholder = {
+      type: "text",
+      text: `[${entry.kind} omitted: dropped to fit the request media budget]`,
+    };
+    if (entry.path.length === 2) {
+      content[entry.path[1]] = placeholder;
+    } else {
+      const toolResult = content[entry.path[1]] as JsonRecord;
+      (toolResult.content as unknown[])[entry.path[2]] = placeholder;
+    }
+    droppedCount += 1;
+  }
+  console.warn(
+    `[kimi-coding] inline media exceeded the ${String(budgetBytes / (1024 * 1024))} MB ` +
+      `per-request budget; ${String(droppedCount)} media item(s) omitted`,
+  );
+  return true;
+}
+
 function isEffectivelyEmptyOpenAIContent(content: unknown): boolean {
   if (typeof content === "string") return content.trim() === "";
   if (!Array.isArray(content)) return false;
@@ -410,10 +561,12 @@ function recurseJsonSchemaPropertyTypes(node: unknown): void {
 function normalizeOpenAIToolSchemas(payload: JsonRecord): void {
   if (!Array.isArray(payload.tools)) return;
   for (const tool of payload.tools) {
-    if (!isRecord(tool) || !isRecord(tool.function)) continue;
-    const parameters = tool.function.parameters;
-    if (!isRecord(parameters)) continue;
-    recurseJsonSchemaPropertyTypes(parameters);
+    if (!isRecord(tool)) continue;
+    // Chat Completions nests the schema under tool.function.parameters;
+    // Responses function tools carry parameters at the top level.
+    const holder: JsonRecord = isRecord(tool.function) ? tool.function : tool;
+    if (!isRecord(holder.parameters)) continue;
+    recurseJsonSchemaPropertyTypes(holder.parameters);
   }
 }
 
@@ -468,6 +621,141 @@ async function transformAnthropicPayloadFiles(
 // steps below testable with fixture payloads.
 // =============================================================================
 
+const RESPONSES_EFFORTS = new Set(["low", "high", "max"]);
+
+// Empty/whitespace-only text parts in the Responses `input` array. Assistant
+// turns that produced no text (reasoning + tool calls only) replay as
+// output_text:"" and upstream 400s on text non-emptiness; see issue #78.
+const RESPONSES_TEXT_PART_TYPES = new Set(["output_text", "text", "input_text"]);
+
+function isEmptyTextPart(part: unknown): boolean {
+  return (
+    isRecord(part) &&
+    typeof part.type === "string" &&
+    RESPONSES_TEXT_PART_TYPES.has(part.type) &&
+    (typeof part.text !== "string" || part.text.trim() === "")
+  );
+}
+
+export function stripEmptyResponsesTextParts(payload: JsonRecord): boolean {
+  if (!Array.isArray(payload.input)) return false;
+  let changed = false;
+  const input: unknown[] = [];
+  for (const item of payload.input) {
+    if (!isRecord(item)) {
+      input.push(item);
+      continue;
+    }
+    // Typed non-message items (function_call, reasoning, ...) pass through.
+    if (typeof item.type === "string" && item.type !== "message") {
+      input.push(item);
+      continue;
+    }
+    const role = item.role;
+    const content = item.content;
+    const isAssistantLike = role === "assistant" || role == null;
+    if (typeof content === "string") {
+      if (isAssistantLike && content.trim() === "") {
+        changed = true;
+        continue;
+      }
+      input.push(item);
+      continue;
+    }
+    if (!Array.isArray(content)) {
+      // A message item with missing/non-array content carries nothing to
+      // render; drop assistant-shaped ones instead of replaying a
+      // contentless message (the upstream 400 path this fix targets).
+      if (isAssistantLike && (content === undefined || content === null)) {
+        changed = true;
+        continue;
+      }
+      input.push(item);
+      continue;
+    }
+    const next = content.filter((part) => !isEmptyTextPart(part));
+    // An assistant message with nothing left — either filtered here or
+    // arriving empty — carries no information; drop it rather than send a
+    // contentless message. User/system messages keep their content.
+    if (next.length === 0 && isAssistantLike) {
+      changed = true;
+      continue;
+    }
+    if (next.length === content.length) {
+      input.push(item);
+      continue;
+    }
+    changed = true;
+    input.push({ ...item, content: next });
+  }
+  if (changed) payload.input = input;
+  return changed;
+}
+
+function responsesSupportedEfforts(ctx: KimiPayloadContext): string[] {
+  const advertised = ctx.modelConfig.supportEfforts;
+  if (advertised?.length) return advertised.filter((effort) => RESPONSES_EFFORTS.has(effort));
+  return [...RESPONSES_EFFORTS];
+}
+
+function setResponsesReasoning(payload: JsonRecord, effort: string | null): void {
+  const oldReasoning = isRecord(payload.reasoning) ? payload.reasoning : {};
+  if (!effort) {
+    delete payload.reasoning;
+    return;
+  }
+  const reasoning: JsonRecord = { ...oldReasoning, effort };
+  if (reasoning.summary === undefined) reasoning.summary = "auto";
+  payload.reasoning = reasoning;
+}
+
+function normalizeResponsesUpstreamEffort(payload: JsonRecord, ctx: KimiPayloadContext): void {
+  const supported = responsesSupportedEfforts(ctx);
+  const oldEffort = isRecord(payload.reasoning) ? payload.reasoning.effort : undefined;
+  if (typeof oldEffort === "string" && supported.includes(oldEffort)) return;
+  if (typeof oldEffort === "string") {
+    const mapped = resolveReasoningForLevel(oldEffort, ctx.modelConfig);
+    if (mapped?.enabled && mapped.effort && supported.includes(mapped.effort)) {
+      setResponsesReasoning(payload, mapped.effort);
+      return;
+    }
+  }
+  const fallback = ctx.modelConfig.defaultEffort;
+  setResponsesReasoning(payload, fallback && supported.includes(fallback) ? fallback : null);
+}
+
+function applyResponsesThinking(payload: JsonRecord, ctx: KimiPayloadContext): void {
+  delete payload.thinking;
+  delete payload.reasoning_effort;
+  delete payload.output_config;
+  if (ctx.modelConfig.supportsThinkingType === "no") {
+    delete payload.reasoning;
+    return;
+  }
+  const resolvedReasoning = resolveThinkingLevel(ctx);
+  if (!resolvedReasoning) {
+    normalizeResponsesUpstreamEffort(payload, ctx);
+    return;
+  }
+  const mapped = resolveReasoningForLevel(resolvedReasoning, ctx.modelConfig);
+  if (!mapped) {
+    normalizeResponsesUpstreamEffort(payload, ctx);
+    return;
+  }
+  if (!mapped.enabled) {
+    delete payload.reasoning;
+    return;
+  }
+  const effort = ctx.reasoning ? mapped.effort : (ctx.modelConfig.defaultEffort ?? mapped.effort);
+  const supported = responsesSupportedEfforts(ctx);
+  const oldReasoning = isRecord(payload.reasoning) ? payload.reasoning : {};
+  const reasoning: JsonRecord = { ...oldReasoning };
+  delete reasoning.effort;
+  if (effort !== null && supported.includes(effort)) reasoning.effort = effort;
+  if (reasoning.summary === undefined) reasoning.summary = "auto";
+  payload.reasoning = reasoning;
+}
+
 export async function applyKimiPayloadMutations(
   payload: JsonRecord,
   ctx: KimiPayloadContext,
@@ -479,6 +767,19 @@ export async function applyKimiPayloadMutations(
     );
   }
 
+  // 1b. Responses wire: drop empty text parts replayed from text-less
+  // assistant turns (issue #78). pi-ai's Responses serializer keeps empty
+  // output_text blocks — unlike its Chat Completions serializer, which
+  // filters them — so a reasoning/tool-only turn is replayed as
+  // {role:"assistant", content:[{type:"output_text", text:""}]} on every
+  // subsequent request, and upstream endpoints reject the whole payload with
+  // a 400-class text-non-emptiness error. function_call / reasoning / all
+  // other part types are untouched; an assistant message left with no
+  // content is dropped entirely.
+  if (ctx.api === "openai-responses") {
+    stripEmptyResponsesTextParts(payload);
+  }
+
   // 2. File upload dispatch (protocol-specific).
   if (ctx.upload) {
     const uploadCache = ctx.uploadCacheScope ? uploadedFileCache : new Map<string, string>();
@@ -489,8 +790,15 @@ export async function applyKimiPayloadMutations(
       await transformAnthropicPayloadFiles(payload, ctx.upload, uploadCache, uploadCacheScope);
     }
   }
+  if (ctx.api === "openai-completions" || ctx.api === "anthropic-messages") {
+    // Runs after the upload transforms so media already promoted to ms://
+    // references (tiny URLs) are never counted against the budget.
+    applyInlineMediaBudget(payload, ctx.api);
+  }
   if (ctx.api === "openai-completions") {
     normalizeOpenAIAssistantToolCalls(payload);
+  }
+  if (ctx.api === "openai-completions" || ctx.api === "openai-responses") {
     normalizeOpenAIToolSchemas(payload);
   }
   if (Array.isArray(payload.tools)) {
@@ -520,8 +828,12 @@ export async function applyKimiPayloadMutations(
 
   // 5. Spread extra_body into the top-level payload before normalization and
   //    config caps. Top-level fields retain precedence over extra_body.
+  let extraBodyHadCap = false;
   if (isRecord(payload.extra_body)) {
     const extraBody = payload.extra_body as JsonRecord;
+    extraBodyHadCap = ["max_tokens", "max_completion_tokens", "max_output_tokens"].some(
+      (key) => typeof extraBody[key] === "number",
+    );
     delete payload.extra_body;
     for (const [key, value] of Object.entries(extraBody)) {
       if (payload[key] === undefined) {
@@ -530,16 +842,49 @@ export async function applyKimiPayloadMutations(
     }
   }
 
-  // 6. Normalize deprecated max_tokens (OpenAI path only — Anthropic
-  //    /messages uses max_tokens natively).
+  // 6. Normalize output-token field names per protocol.
   if (ctx.api === "openai-completions") {
     if (payload.max_completion_tokens === undefined && typeof payload.max_tokens === "number") {
       payload.max_completion_tokens = payload.max_tokens;
     }
     delete payload.max_tokens;
+  } else if (ctx.api === "openai-responses") {
+    if (payload.max_output_tokens === undefined) {
+      if (typeof payload.max_completion_tokens === "number") {
+        payload.max_output_tokens = payload.max_completion_tokens;
+      } else if (typeof payload.max_tokens === "number") {
+        payload.max_output_tokens = payload.max_tokens;
+      }
+    }
+    delete payload.max_tokens;
+    delete payload.max_completion_tokens;
+    delete payload.prompt_cache_retention;
   }
 
   const generation = ctx.modelConfig.generation;
+  // Output cap policy (mirrors upstream kimi-code #4091): omit the completion
+  // cap on the OpenAI wires unless explicitly configured. pi-ai seeds a cap
+  // clamped to the context window (clampMaxTokensToContext), and forwarding
+  // that value breaks strict serving stacks (e.g. bare vLLM) that reject a
+  // cap above the model's real output limit with repeated 400s. A cap counts
+  // as explicit when generation.maxCompletionTokens is configured
+  // (KIMI_MODEL_MAX_COMPLETION_TOKENS / config generation.maxCompletionTokens),
+  // model.maxTokens holds a non-window value, or the caller supplies a
+  // per-request cap through options.maxTokens / extra_body. Anthropic /messages requires
+  // max_tokens, so that wire keeps pi-ai's window-clamped cap — the same
+  // window - usedContextTokens value upstream fills in when unset.
+  if (ctx.api === "openai-completions" || ctx.api === "openai-responses") {
+    const capKey = ctx.api === "openai-responses" ? "max_output_tokens" : "max_completion_tokens";
+    const explicitModelCap =
+      typeof ctx.modelConfig.maxTokens === "number" &&
+      ctx.modelConfig.maxTokens > 0 &&
+      ctx.modelConfig.maxTokens !== ctx.modelConfig.contextWindow;
+    const explicitRequestCap =
+      extraBodyHadCap || (typeof ctx.requestMaxTokens === "number" && ctx.requestMaxTokens > 0);
+    if (generation.maxCompletionTokens === undefined && !explicitModelCap && !explicitRequestCap) {
+      delete payload[capKey];
+    }
+  }
   // Official kimi-code sends temperature/top_p only when explicitly configured
   // (env KIMI_MODEL_TEMPERATURE / KIMI_MODEL_TOP_P → generation.*); otherwise it
   // omits them and lets the server apply its own defaults. Mirror that exactly:
@@ -552,7 +897,12 @@ export async function applyKimiPayloadMutations(
   // Output cap: an explicit cap (KIMI_MODEL_MAX_COMPLETION_TOKENS / config →
   // generation.maxCompletionTokens) is honored as a hardCap on the request value.
   if (generation.maxCompletionTokens !== undefined) {
-    const maxTokensKey = ctx.api === "anthropic-messages" ? "max_tokens" : "max_completion_tokens";
+    const maxTokensKey =
+      ctx.api === "anthropic-messages"
+        ? "max_tokens"
+        : ctx.api === "openai-responses"
+          ? "max_output_tokens"
+          : "max_completion_tokens";
     const currentMaxTokens = payload[maxTokensKey];
     payload[maxTokensKey] =
       typeof currentMaxTokens === "number"
@@ -560,87 +910,98 @@ export async function applyKimiPayloadMutations(
         : generation.maxCompletionTokens;
   }
 
-  // 7. Reasoning effort mapping. Kimi now accepts effort only inside the
-  //    thinking object, and only for values advertised by the model catalog.
-  delete payload.reasoning_effort;
-  if (ctx.modelConfig.supportsThinkingType === "no") {
-    delete payload.thinking;
-  }
-  const resolvedReasoning = resolveThinkingLevel(ctx);
-  if (resolvedReasoning) {
-    const mapped = resolveReasoningForLevel(resolvedReasoning, ctx.modelConfig);
-    if (mapped) {
-      const oldThinking = isRecord(payload.thinking) ? payload.thinking : {};
-      const effort = ctx.reasoning
-        ? mapped.effort
-        : (ctx.modelConfig.defaultEffort ?? mapped.effort);
-      const effortSupported =
-        effort !== null && ctx.modelConfig.supportEfforts?.includes(effort) === true;
-      if (ctx.api === "anthropic-messages" && oldThinking.type === "adaptive") {
-        // pi-ai >=0.82 builds adaptive thinking for models carrying
-        // compat.forceAdaptiveThinking (streamSimpleKimi sets it on the
-        // anthropic runtime model). Keep the adaptive shape — effort lives in
-        // top-level output_config there, not inside thinking — and only
-        // replace it with an explicit disable when the level maps to off.
-        if (mapped.enabled) {
-          if (effortSupported) payload.output_config = { effort };
-          else delete payload.output_config;
+  // 7. Reasoning effort mapping.
+  // Completions/Anthropic: effort lives in thinking / output_config.
+  // Responses: pi-ai's native transport uses reasoning.effort; drop the
+  // Completions thinking object and clamp effort to the catalog.
+  if (ctx.api === "openai-responses") {
+    applyResponsesThinking(payload, ctx);
+  } else {
+    delete payload.reasoning_effort;
+    if (ctx.modelConfig.supportsThinkingType === "no") {
+      delete payload.thinking;
+    }
+    const resolvedReasoning = resolveThinkingLevel(ctx);
+    if (resolvedReasoning) {
+      const mapped = resolveReasoningForLevel(resolvedReasoning, ctx.modelConfig);
+      if (mapped) {
+        const oldThinking = isRecord(payload.thinking) ? payload.thinking : {};
+        const effort = ctx.reasoning
+          ? mapped.effort
+          : (ctx.modelConfig.defaultEffort ?? mapped.effort);
+        const effortSupported =
+          effort !== null && ctx.modelConfig.supportEfforts?.includes(effort) === true;
+        if (ctx.api === "anthropic-messages" && oldThinking.type === "adaptive") {
+          // pi-ai >=0.82 builds adaptive thinking for models carrying
+          // compat.forceAdaptiveThinking (streamSimpleKimi sets it on the
+          // anthropic runtime model). Keep the adaptive shape — effort lives in
+          // top-level output_config there, not inside thinking — and only
+          // replace it with an explicit disable when the level maps to off.
+          if (mapped.enabled) {
+            if (effortSupported) payload.output_config = { effort };
+            else delete payload.output_config;
+          } else {
+            payload.thinking = { type: "disabled" };
+            delete payload.output_config;
+          }
         } else {
-          payload.thinking = { type: "disabled" };
-          delete payload.output_config;
+          const thinking: JsonRecord = {
+            ...oldThinking,
+            type: mapped.enabled ? "enabled" : "disabled",
+          };
+          delete thinking.effort;
+          if (!mapped.enabled) delete thinking.keep;
+          if (mapped.enabled && effortSupported) {
+            thinking.effort = effort;
+          }
+          if (mapped.enabled && ctx.modelConfig.thinkingKeep) {
+            thinking.keep = ctx.modelConfig.thinkingKeep;
+          }
+          payload.thinking = thinking;
         }
-      } else {
-        const thinking: JsonRecord = {
-          ...oldThinking,
-          type: mapped.enabled ? "enabled" : "disabled",
-        };
-        delete thinking.effort;
-        if (!mapped.enabled) delete thinking.keep;
-        if (mapped.enabled && effortSupported) {
-          thinking.effort = effort;
-        }
-        if (mapped.enabled && ctx.modelConfig.thinkingKeep) {
-          thinking.keep = ctx.modelConfig.thinkingKeep;
-        }
-        payload.thinking = thinking;
       }
     }
-  }
 
-  // Preserved-thinking Kimi endpoints require every replayed assistant turn to
-  // carry reasoning_content, including turns whose reasoning delta was empty.
-  // pi-ai drops empty thinking blocks while building Chat Completions history,
-  // so restore the explicit empty field after the final thinking mode is known.
-  if (
-    ctx.api === "openai-completions" &&
-    isRecord(payload.thinking) &&
-    payload.thinking.type !== "disabled" &&
-    payload.thinking.keep === "all" &&
-    Array.isArray(payload.messages)
-  ) {
-    for (const message of payload.messages) {
-      if (
-        isRecord(message) &&
-        message.role === "assistant" &&
-        message.reasoning_content === undefined
-      ) {
-        message.reasoning_content = "";
+    // Preserved-thinking Kimi endpoints require every replayed assistant turn to
+    // carry reasoning_content, including turns whose reasoning delta was empty.
+    // pi-ai drops empty thinking blocks while building Chat Completions history,
+    // so restore the explicit empty field after the final thinking mode is known.
+    if (
+      ctx.api === "openai-completions" &&
+      isRecord(payload.thinking) &&
+      payload.thinking.type !== "disabled" &&
+      payload.thinking.keep === "all" &&
+      Array.isArray(payload.messages)
+    ) {
+      for (const message of payload.messages) {
+        if (
+          isRecord(message) &&
+          message.role === "assistant" &&
+          message.reasoning_content === undefined
+        ) {
+          message.reasoning_content = "";
+        }
       }
     }
   }
 
-  // 8. K2.7 Code API constraints: the server rejects tool_choice "required" /
-  //    function-specific when thinking is enabled (always-on). temperature/top_p
-  //    are handled in step 6 — omitted unless explicitly configured, matching the
-  //    official kimi-code client rather than pinned to 1.0/0.95.
+  // 8. Kimi coding endpoint constraints: the server rejects tool_choice "required" /
+  //    function-specific when thinking is enabled (always-on). Responses only
+  //    accepts auto. temperature/top_p are handled in step 6 — omitted unless
+  //    explicitly configured, matching the official kimi-code client rather
+  //    than pinned to 1.0/0.95.
   if (payload.tool_choice !== undefined) {
-    const tc = payload.tool_choice;
-    const isAllowed =
-      tc === "auto" ||
-      tc === "none" ||
-      (isRecord(tc) && (tc.type === "auto" || tc.type === "none"));
-    if (!isAllowed) {
-      payload.tool_choice = isRecord(tc) ? { type: "auto" } : "auto";
+    if (ctx.api === "openai-responses") {
+      payload.tool_choice = "auto";
+    } else {
+      const tc = payload.tool_choice;
+      const isAllowed =
+        tc === "auto" ||
+        tc === "none" ||
+        (isRecord(tc) && (tc.type === "auto" || tc.type === "none"));
+      if (!isAllowed) {
+        payload.tool_choice = isRecord(tc) ? { type: "auto" } : "auto";
+      }
     }
   }
 }

package/src/schema-dedup.ts

@@ -232,9 +232,12 @@ export function optimizeToolSchemas(tools: unknown[]): unknown[] {
 
   let changed = false;
   const result = tools.map((tool) => {
-    if (!isRecord(tool) || !isRecord(tool.function)) return tool;
-    const fn = tool.function as JsonRecord;
-    const params = fn.parameters;
+    if (!isRecord(tool)) return tool;
+    // Chat Completions nests the schema under tool.function.parameters;
+    // Responses function tools carry parameters at the top level.
+    const fn = isRecord(tool.function) ? tool.function : undefined;
+    const holder: JsonRecord = fn ?? tool;
+    const params = holder.parameters;
     if (!isRecord(params)) return tool;
 
     const size = jsonSize(params);
@@ -242,7 +245,9 @@ export function optimizeToolSchemas(tools: unknown[]): unknown[] {
 
     const optimized = deduplicateSchema(params);
     changed = true;
-    return { ...tool, function: { ...fn, parameters: optimized } };
+    return fn
+      ? { ...tool, function: { ...fn, parameters: optimized } }
+      : { ...tool, parameters: optimized };
   });
 
   cachedFingerprint = fp;