pi-provider-kimi-code 0.6.11 → 0.6.12

package/README.md

@@ -183,7 +183,7 @@ If you already use another search or fetch tool, pick one path for a session. Ov
 Most users do not need environment variables. Two are worth knowing:
 
 - `KIMI_API_KEY` — static API key for CI or key-based access.
-- `KIMI_CODE_PROTOCOL` — `openai` by default; set to `anthropic` for Anthropic-compatible requests.
+- `KIMI_CODE_PROTOCOL` — `openai` by default; set to `anthropic` for Anthropic-compatible requests, or `responses` for the OpenAI Responses API.
 
 Tools, protocol, and upload threshold are all configurable through `/kimi-settings` or JSON config files.
 

package/index.ts

@@ -43,6 +43,7 @@ import {
 } from "./src/config.ts";
 import {
   KIMI_GLOBAL_FALLBACK_SOURCE_ID,
+  KIMI_WIRE_PROTOCOLS,
   PROVIDER_ID,
   PROVIDER_VERSION,
   getBaseUrl,
@@ -340,7 +341,7 @@ async function openSettingsMenu(
       label: "Protocol",
       description: "API protocol for Kimi requests",
       currentValue: drafts[scope].protocol,
-      values: ["openai", "anthropic"],
+      values: ["openai", "anthropic", "responses"],
     });
     items.push({
       id: "uploadThreshold",
@@ -462,8 +463,8 @@ const MODULE_UNAVAILABLE_CODES = new Set([
 // model was resolved, so a session created before a protocol switch still
 // carries the other id and would keep crashing. streamSimpleKimi routes on the
 // model's wireProtocol / the resolved runtime config and never on model.api, so
-// both ids dispatch identically.
-const KIMI_FALLBACK_APIS = [getKimiApiType("openai"), getKimiApiType("anthropic")];
+// all three ids dispatch identically.
+const KIMI_FALLBACK_APIS = KIMI_WIRE_PROTOCOLS.map((protocol) => getKimiApiType(protocol));
 
 type PiAiApiRegistry = {
   registerApiProvider: (

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-provider-kimi-code",
-  "version": "0.6.11",
+  "version": "0.6.12",
   "description": "Kimi Code models (K3, K2.7, HighSpeed) in Pi: OAuth shared login with kimi-code CLI, file uploads, and Kimi-native tools",
   "keywords": [
     "ai-provider",
@@ -57,14 +57,14 @@
     "proper-lockfile": "^4.1.2"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.83.0",
-    "@earendil-works/pi-coding-agent": "^0.83.0",
-    "@earendil-works/pi-tui": "^0.83.0",
-    "@j178/prek": "^0.4.4",
+    "@earendil-works/pi-ai": "^0.85.1",
+    "@earendil-works/pi-coding-agent": "^0.85.1",
+    "@earendil-works/pi-tui": "^0.85.1",
+    "@j178/prek": "^0.5.2",
     "@types/node": "^24.0.0",
     "@types/proper-lockfile": "^4.1.4",
-    "oxfmt": "^0.44.0",
-    "oxlint": "^1.59.0",
+    "oxfmt": "^0.67.0",
+    "oxlint": "^1.82.0",
     "typescript": "^5.9.0"
   },
   "peerDependencies": {

package/src/config.ts

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 
-import { PROVIDER_ID } from "./constants.ts";
+import { PROVIDER_ID, type KimiWireProtocol } from "./constants.ts";
 
 export const KIMI_TOOL_NAMES = ["moonshot_search", "moonshot_fetch", "kimi_datasource"] as const;
 
@@ -46,7 +46,7 @@ export interface KimiCodeConfig {
   model: ModelConfig;
   tools: Record<KimiToolName, { enabled: boolean; default_collapsed: boolean }>;
   uploads: { thresholdBytes: number };
-  protocol: "openai" | "anthropic";
+  protocol: KimiWireProtocol;
 }
 
 export type KimiCodeConfigPatch = Partial<{
@@ -315,8 +315,12 @@ function requireProtocol(
   configPath: string,
   pointer: string,
 ): KimiCodeConfig["protocol"] {
-  if (raw === "openai" || raw === "anthropic") return raw;
-  return fail(configPath, pointer, `expected "openai" | "anthropic", got ${JSON.stringify(raw)}`);
+  if (raw === "openai" || raw === "anthropic" || raw === "responses") return raw;
+  return fail(
+    configPath,
+    pointer,
+    `expected "openai" | "anthropic" | "responses", got ${JSON.stringify(raw)}`,
+  );
 }
 
 function requireInputArray(raw: unknown, configPath: string, pointer: string): KimiInputModality[] {

package/src/constants.ts

@@ -9,39 +9,54 @@ import { join } from "node:path";
 export const CLIENT_ID = "17e5f671-d194-4dfb-9706-5516cb48c098";
 export const DEFAULT_OAUTH_HOST = "https://auth.kimi.com";
 
-export type KimiWireProtocol = "openai" | "anthropic";
+export const KIMI_WIRE_PROTOCOLS = ["openai", "anthropic", "responses"] as const;
+export type KimiWireProtocol = (typeof KIMI_WIRE_PROTOCOLS)[number];
+export type KimiApiProtocol = "openai-completions" | "anthropic-messages" | "openai-responses";
+export type KimiApiType =
+  | "kimi-openai-completions"
+  | "kimi-anthropic-messages"
+  | "kimi-openai-responses";
+
+// KIMI_CODE_PROTOCOL supports openai (default), anthropic, and responses.
+// Unknown values fall back to openai, matching the previous two-protocol parser.
+export function parseKimiWireProtocol(value: string | undefined): KimiWireProtocol {
+  if (value === "anthropic" || value === "responses") return value;
+  return "openai";
+}
 
-// KIMI_CODE_PROTOCOL supports two values: "openai" (default) and "anthropic".
-export const ENV_KIMI_CODE_PROTOCOL: KimiWireProtocol =
-  process.env.KIMI_CODE_PROTOCOL === "anthropic" ? "anthropic" : "openai";
+export const ENV_KIMI_CODE_PROTOCOL: KimiWireProtocol = parseKimiWireProtocol(
+  process.env.KIMI_CODE_PROTOCOL,
+);
 
 export const IS_OPENAI_PROTOCOL = ENV_KIMI_CODE_PROTOCOL === "openai";
 
-export function getApiProtocol(
-  protocol: KimiWireProtocol,
-): "openai-completions" | "anthropic-messages" {
-  return protocol === "openai" ? "openai-completions" : "anthropic-messages";
+export function getApiProtocol(protocol: KimiWireProtocol): KimiApiProtocol {
+  if (protocol === "anthropic") return "anthropic-messages";
+  if (protocol === "responses") return "openai-responses";
+  return "openai-completions";
 }
 
 export const PROTOCOL = getApiProtocol(ENV_KIMI_CODE_PROTOCOL);
 
-export function getKimiApiType(
-  protocol: KimiWireProtocol,
-): "kimi-openai-completions" | "kimi-anthropic-messages" {
-  return protocol === "openai" ? "kimi-openai-completions" : "kimi-anthropic-messages";
+export function getKimiApiType(protocol: KimiWireProtocol): KimiApiType {
+  if (protocol === "anthropic") return "kimi-anthropic-messages";
+  if (protocol === "responses") return "kimi-openai-responses";
+  return "kimi-openai-completions";
 }
 
 // Use a custom api identifier so this provider never conflicts with the
-// built-in "anthropic-messages" or "openai-completions" stream handlers.
+// built-in anthropic-messages / openai-completions / openai-responses handlers.
 export const KIMI_API_TYPE = getKimiApiType(ENV_KIMI_CODE_PROTOCOL);
 
 export function getDefaultBaseUrl(protocol: KimiWireProtocol): string {
-  return protocol === "openai" ? "https://api.kimi.com/coding/v1" : "https://api.kimi.com/coding";
+  return protocol === "anthropic"
+    ? "https://api.kimi.com/coding"
+    : "https://api.kimi.com/coding/v1";
 }
 
 export const DEFAULT_BASE_URL = getDefaultBaseUrl(ENV_KIMI_CODE_PROTOCOL);
 
-export const PROVIDER_VERSION = "0.6.11";
+export const PROVIDER_VERSION = "0.6.12";
 
 export const KIMI_CODE_USER_AGENT = `pi-provider-kimi-code/${PROVIDER_VERSION}`;
 export const KIMI_PLATFORM = "pi";

package/src/models.ts

@@ -186,6 +186,14 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// Server /v1/models uses "response"; kimi-code maps that to openai_responses.
+// Accept the server value plus the user-facing and internal aliases.
+function parseKimiCatalogProtocol(value: unknown): KimiWireProtocol | undefined {
+  if (value === "openai" || value === "anthropic" || value === "responses") return value;
+  if (value === "response" || value === "openai_responses") return "responses";
+  return undefined;
+}
+
 function parseThinkEfforts(value: unknown): {
   supportEfforts?: string[];
   defaultEffort?: string;
@@ -223,9 +231,8 @@ function parseKimiModelMetadata(model: KimiServerModel): KimiModelMetadata | und
   if (typeof model.supports_video_in === "boolean") {
     metadata.supportsVideoIn = model.supports_video_in;
   }
-  if (model.protocol === "openai" || model.protocol === "anthropic") {
-    metadata.protocol = model.protocol;
-  }
+  const protocol = parseKimiCatalogProtocol(model.protocol);
+  if (protocol) metadata.protocol = protocol;
   Object.assign(metadata, parseThinkEfforts(model.think_efforts));
   return metadata;
 }

package/src/payload.ts

@@ -31,7 +31,7 @@ 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;
@@ -410,10 +410,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 +470,72 @@ async function transformAnthropicPayloadFiles(
 // steps below testable with fixture payloads.
 // =============================================================================
 
+const RESPONSES_EFFORTS = new Set(["low", "high", "max"]);
+
+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,
@@ -491,6 +559,8 @@ export async function applyKimiPayloadMutations(
   }
   if (ctx.api === "openai-completions") {
     normalizeOpenAIAssistantToolCalls(payload);
+  }
+  if (ctx.api === "openai-completions" || ctx.api === "openai-responses") {
     normalizeOpenAIToolSchemas(payload);
   }
   if (Array.isArray(payload.tools)) {
@@ -530,13 +600,23 @@ 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;
@@ -552,7 +632,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 +645,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;
-        }
-      } 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;
+          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;
         }
-        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.
+  //    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;

package/src/stream.ts

@@ -32,8 +32,10 @@ type KimiStreamSimple = (
 const piAiRuntime = piAi as unknown as {
   anthropicMessagesApi?: () => { streamSimple: KimiStreamSimple };
   openAICompletionsApi?: () => { streamSimple: KimiStreamSimple };
+  openAIResponsesApi?: () => { streamSimple: KimiStreamSimple };
   streamSimpleAnthropic?: KimiStreamSimple;
   streamSimpleOpenAICompletions?: KimiStreamSimple;
+  streamSimpleOpenAIResponses?: KimiStreamSimple;
   lazyApi?: (load: () => Promise<object>) => { streamSimple: KimiStreamSimple };
 };
 
@@ -43,22 +45,43 @@ const piAiRuntime = piAi as unknown as {
 // evaluated in plain-Node environments where the subpaths do resolve.
 const anthropicMessagesModule = "@earendil-works/pi-ai/api/anthropic-messages";
 const openAICompletionsModule = "@earendil-works/pi-ai/api/openai-completions";
+const openAIResponsesModule = "@earendil-works/pi-ai/api/openai-responses";
 
-const streamSimpleAnthropic: KimiStreamSimple =
-  piAiRuntime.anthropicMessagesApi?.().streamSimple ??
-  piAiRuntime.streamSimpleAnthropic ??
-  piAiRuntime.lazyApi?.(() => import(anthropicMessagesModule)).streamSimple!;
-const streamSimpleOpenAICompletions: KimiStreamSimple =
-  piAiRuntime.openAICompletionsApi?.().streamSimple ??
-  piAiRuntime.streamSimpleOpenAICompletions ??
-  piAiRuntime.lazyApi?.(() => import(openAICompletionsModule)).streamSimple!;
+// lazyApi is the last resort; it only exists on pi-ai versions that ship the
+// ./api/* subpath modules. Undefined when none of the three lookup paths
+// resolve (e.g. pi <=0.79 has no responses entry point at all).
+function lazyStreamSimple(load: () => Promise<object>): KimiStreamSimple | undefined {
+  return piAiRuntime.lazyApi?.(load)?.streamSimple;
+}
+
+// Not readonly: tests swap entries to simulate runtimes missing an API.
+const streamSimpleImpls: Record<KimiWireProtocol, KimiStreamSimple | undefined> = {
+  openai:
+    piAiRuntime.openAICompletionsApi?.().streamSimple ??
+    piAiRuntime.streamSimpleOpenAICompletions ??
+    lazyStreamSimple(() => import(openAICompletionsModule)),
+  anthropic:
+    piAiRuntime.anthropicMessagesApi?.().streamSimple ??
+    piAiRuntime.streamSimpleAnthropic ??
+    lazyStreamSimple(() => import(anthropicMessagesModule)),
+  responses:
+    piAiRuntime.openAIResponsesApi?.().streamSimple ??
+    piAiRuntime.streamSimpleOpenAIResponses ??
+    lazyStreamSimple(() => import(openAIResponsesModule)),
+};
 import {
   DEFAULT_KIMI_CODE_CONFIG,
   type KimiCodeConfig,
   type KimiResolvedModelConfig,
 } from "./config.ts";
 
-import { ENV_KIMI_CODE_PROTOCOL, PROVIDER_ID, getApiProtocol, getBaseUrl } from "./constants.ts";
+import {
+  ENV_KIMI_CODE_PROTOCOL,
+  PROVIDER_ID,
+  type KimiWireProtocol,
+  getApiProtocol,
+  getBaseUrl,
+} from "./constants.ts";
 import { getKimiProviderHeaders } from "./device.ts";
 import {
   isKimiAuthErrorMessage,
@@ -224,6 +247,40 @@ export function mergeKimiRequestHeaders(headers?: HeaderMap): HeaderMap {
   return { ...getKimiProviderHeaders(), ...headers };
 }
 
+function streamSimpleForProtocol(
+  protocol: KimiWireProtocol,
+  model: Model<Api>,
+  context: Context,
+  options: SimpleStreamOptions,
+): AssistantMessageEventStream {
+  const impl = streamSimpleImpls[protocol];
+  // Resolution runs once at module load against whichever pi-ai shape is
+  // installed, so an old pi-ai can leave the entry point undefined. Throw a
+  // descriptive error here — the caller invokes this inside the retry loop's
+  // try, so it surfaces as a stream error event instead of an unhandled
+  // rejection from a bare "not a function" TypeError.
+  if (!impl) {
+    throw new Error(
+      `installed pi-ai has no streamSimple entry point for ${getApiProtocol(protocol)}; ` +
+        "upgrade pi-ai or choose another KIMI_CODE_PROTOCOL",
+    );
+  }
+  return impl(model, context, options);
+}
+
+// Test hook: swap a resolved stream factory (pass undefined to simulate a
+// pi-ai runtime that lacks the entry point). Returns a restore function.
+export function overrideStreamSimpleForTests(
+  protocol: KimiWireProtocol,
+  impl: KimiStreamSimple | undefined,
+): () => void {
+  const original = streamSimpleImpls[protocol];
+  streamSimpleImpls[protocol] = impl;
+  return () => {
+    streamSimpleImpls[protocol] = original;
+  };
+}
+
 export function streamSimpleKimi(
   model: Model<Api>,
   context: Context,
@@ -332,8 +389,9 @@ export function streamSimpleKimi(
       const patchedOptions = buildPatchedOptions(currentKey);
       // Route by the module-level protocol flag, not model.api, since we
       // register with a custom api type (kimi-openai-completions /
-      // kimi-anthropic-messages) to avoid overriding the built-in
-      // Anthropic/OpenAI stream handlers.
+      // kimi-anthropic-messages / kimi-openai-responses) to avoid overriding
+      // the built-in Anthropic/OpenAI stream handlers.
+      const existingCompat = (model as { compat?: Record<string, unknown> }).compat;
       const runtimeModel = {
         ...model,
         api: apiProtocol,
@@ -342,33 +400,38 @@ export function streamSimpleKimi(
         // rejects/ignores the interleaved-thinking beta header; pi-ai >=0.82
         // keys both behaviors off these compat flags (its own built-in
         // kimi-coding models carry them in generated metadata).
+        // Responses rejects prompt_cache_retention (400) unless this is off.
         ...(wireProtocol === "anthropic"
           ? {
               compat: {
-                ...(model as { compat?: Record<string, unknown> }).compat,
+                ...existingCompat,
                 forceAdaptiveThinking: true,
                 allowEmptySignature: true,
               },
             }
-          : {}),
+          : wireProtocol === "responses"
+            ? {
+                compat: {
+                  ...existingCompat,
+                  supportsLongCacheRetention: false,
+                },
+              }
+            : {}),
       } as Model<Api>;
-      const upstream =
-        wireProtocol === "openai"
-          ? streamSimpleOpenAICompletions(
-              runtimeModel as Model<"openai-completions">,
-              context,
-              patchedOptions,
-            )
-          : streamSimpleAnthropic(
-              runtimeModel as Model<"anthropic-messages">,
-              context,
-              patchedOptions,
-            );
 
       let shouldRetry = false;
       let prefixBuffer: AssistantMessageEvent[] = [];
 
       try {
+        // Inside the try so a missing pi-ai stream entry point (old pi-ai +
+        // a protocol it does not ship) surfaces through the catch's error
+        // event instead of escaping the async IIFE as an unhandled rejection.
+        const upstream = streamSimpleForProtocol(
+          wireProtocol,
+          runtimeModel,
+          context,
+          patchedOptions,
+        );
         for await (const event of filterEmptyResponseStream(upstream)) {
           // streamAnthropic emits a synthetic "start" event synchronously,
           // before the for-await loop begins iterating and therefore before