@ai-setting/roy-agent-core 1.7.53 → 1.7.56

package/dist/shared/@ai-setting/{roy-agent-core-zy3hqfwg.js → roy-agent-core-yv9x4wmg.js}

@@ -1,8 +1,19 @@
+import {
+  sniffImageMime
+} from "./roy-agent-core-zjdzk1gg.js";
+import {
+  TracedAs,
+  embedParamFilter,
+  embedResultFilter,
+  init_decorator,
+  init_trace_filters
+} from "./roy-agent-core-b599jgyd.js";
 import {
   createLogger,
   init_logger
 } from "./roy-agent-core-8seq65bp.js";
 import {
+  __legacyDecorateClassTS,
   __require
 } from "./roy-agent-core-fs0mn2jk.js";
 
@@ -59,13 +70,15 @@ function buildOpencodeHeaders(providerId, conversationId, baseURL) {
   return { "x-opencode-session": getOrCreateOpencodeSessionId(conversationId) };
 }
 
-// src/env/llm/invoke.ts
-import { randomUUID } from "crypto";
-import { streamText, jsonSchema } from "ai";
-import { createOpenAI } from "@ai-sdk/openai";
-import { createAnthropic } from "@ai-sdk/anthropic";
-import { createGoogleGenerativeAI } from "@ai-sdk/google";
-import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+// src/env/llm/adapter-pi-ai.ts
+init_decorator();
+init_trace_filters();
+init_logger();
+import {
+  complete,
+  stream as piStream,
+  getModel
+} from "@earendil-works/pi-ai";
 
 // src/env/llm/tool-schema.ts
 import { zodToJsonSchema } from "zod-to-json-schema";
@@ -152,12 +165,479 @@ function toolParametersToJsonSchema(parameters) {
   return deref;
 }
 
+// src/env/llm/reasoning-defense.ts
+var DEEPSEEK_PROVIDER_PREFIX = "deepseek";
+var DEEPSEEK_MODEL_MARKER = "deepseek";
+function shouldInjectReasoningContent(provider, modelId) {
+  const p = (provider ?? "").toLowerCase();
+  const m = (modelId ?? "").toLowerCase();
+  if (p === DEEPSEEK_PROVIDER_PREFIX || p.startsWith(`${DEEPSEEK_PROVIDER_PREFIX}-`)) {
+    return true;
+  }
+  return m.includes(DEEPSEEK_MODEL_MARKER);
+}
+function injectReasoningContent(messages) {
+  return messages.map((msg) => {
+    if (msg?.role !== "assistant")
+      return msg;
+    if ("reasoning_content" in msg)
+      return msg;
+    return { ...msg, reasoning_content: "" };
+  });
+}
+function applyReasoningDefense(payload, target) {
+  if (!payload || typeof payload !== "object")
+    return payload;
+  if (!shouldInjectReasoningContent(target.provider, target.modelId))
+    return payload;
+  const messages = payload.messages;
+  if (!Array.isArray(messages))
+    return payload;
+  return { ...payload, messages: injectReasoningContent(messages) };
+}
+function createReasoningDefenseHook(target) {
+  return (payload) => applyReasoningDefense(payload, target);
+}
+
+// src/env/llm/adapter-pi-ai.ts
+var logger = createLogger("llm:adapter-pi-ai");
+var KNOWN_PROVIDER_APIS = {
+  anthropic: {
+    api: "anthropic-messages",
+    apiProtocol: "anthropic-messages",
+    contextLimit: 200000,
+    maxTokensLimit: 8192
+  },
+  openai: {
+    api: "openai-responses",
+    apiProtocol: "openai-responses",
+    contextLimit: 128000,
+    maxTokensLimit: 16384
+  },
+  google: {
+    api: "google-generative-ai",
+    apiProtocol: "google-generative-ai",
+    contextLimit: 1e6,
+    maxTokensLimit: 8192
+  },
+  "google-vertex": {
+    api: "google-vertex",
+    apiProtocol: "google-vertex",
+    contextLimit: 1e6,
+    maxTokensLimit: 8192
+  },
+  deepseek: {
+    api: "openai-completions",
+    apiProtocol: "openai-completions",
+    contextLimit: 64000,
+    maxTokensLimit: 8192
+  },
+  glm: {
+    api: "openai-completions",
+    apiProtocol: "openai-completions",
+    contextLimit: 128000,
+    maxTokensLimit: 8192
+  },
+  xai: {
+    api: "openai-completions",
+    apiProtocol: "openai-completions",
+    contextLimit: 131072,
+    maxTokensLimit: 8192
+  },
+  groq: {
+    api: "openai-completions",
+    apiProtocol: "openai-completions",
+    contextLimit: 32768,
+    maxTokensLimit: 8192
+  },
+  minimax: {
+    api: "anthropic-messages",
+    apiProtocol: "anthropic-messages",
+    contextLimit: 128000,
+    maxTokensLimit: 8192
+  },
+  "minimax-cn": {
+    api: "anthropic-messages",
+    apiProtocol: "anthropic-messages",
+    contextLimit: 128000,
+    maxTokensLimit: 8192
+  },
+  moonshotai: {
+    api: "openai-completions",
+    apiProtocol: "openai-completions",
+    contextLimit: 128000,
+    maxTokensLimit: 8192
+  },
+  "kimi-coding": {
+    api: "openai-completions",
+    apiProtocol: "openai-completions",
+    contextLimit: 128000,
+    maxTokensLimit: 8192
+  }
+};
+var PROVIDER_ENDPOINT_APIS = {
+  minimax: [
+    { pathIncludes: "/anthropic", apiProtocol: "anthropic-messages" },
+    { pathIncludes: "/v1", apiProtocol: "openai-completions" }
+  ],
+  "minimax-cn": [
+    { pathIncludes: "/anthropic", apiProtocol: "anthropic-messages" },
+    { pathIncludes: "/v1", apiProtocol: "openai-completions" }
+  ]
+};
+var ENDPOINT_RULES_SORTED = Object.fromEntries(Object.entries(PROVIDER_ENDPOINT_APIS).map(([provider, rules]) => [
+  provider,
+  [...rules].sort((a, b) => b.pathIncludes.length - a.pathIncludes.length)
+]));
+var PROVIDER_API_OVERRIDES = {
+  "minimax-responses": "openai-responses",
+  "minimax-openai": "openai-completions"
+};
+function resolveApiProtocol(provider, baseURL, explicitProtocol) {
+  if (explicitProtocol)
+    return explicitProtocol;
+  if (PROVIDER_API_OVERRIDES[provider])
+    return PROVIDER_API_OVERRIDES[provider];
+  const endpointRules = ENDPOINT_RULES_SORTED[provider];
+  if (endpointRules) {
+    for (const rule of endpointRules) {
+      if (baseURL?.includes(rule.pathIncludes))
+        return rule.apiProtocol;
+    }
+  }
+  const declared = KNOWN_PROVIDER_APIS[provider]?.apiProtocol;
+  if (declared)
+    return declared;
+  if (baseURL?.includes("/responses"))
+    return "openai-responses";
+  if (baseURL?.includes("anthropic")) {
+    logger.warn(`[adapter-pi-ai] provider "${provider}" 的协议靠 baseURL 含 "anthropic" 推断为 anthropic-messages；` + `建议在 KNOWN_PROVIDER_APIS 或调用处显式声明 apiProtocol（Task #4383 P1）`, { provider, inferred_api_protocol: "anthropic-messages", base_url: baseURL });
+    return "anthropic-messages";
+  }
+  return KNOWN_PROVIDER_APIS[provider]?.api || "openai-completions";
+}
+var REASONING_COMPAT_PIN = {
+  supportsDeveloperRole: false,
+  thinkingFormat: "openai",
+  supportsReasoningEffort: false
+};
+var REASONING_SAFE_PROTOCOLS = new Set([
+  "openai-completions",
+  "anthropic-messages"
+]);
+var warnedReasoningRefusals = new Set;
+function resolveModelReasoning(provider, modelId, capabilities, apiProtocol) {
+  const requested = capabilities?.reasoning === true;
+  if (!requested)
+    return false;
+  if (!apiProtocol || !REASONING_SAFE_PROTOCOLS.has(apiProtocol)) {
+    const key = `${provider}:${apiProtocol ?? "<unresolved>"}`;
+    if (!warnedReasoningRefusals.has(key)) {
+      warnedReasoningRefusals.add(key);
+      logger.warn(`[adapter-pi-ai] provider "${provider}" (${apiProtocol ?? "unresolved"}) 的 capabilities.reasoning=true 被忽略：` + `该协议无法通过 compat pin 保持请求体字节一致，打开会破坏 prompt cache 前缀（Task #4403）`, { provider, model_id: modelId, api_protocol: apiProtocol });
+    }
+    return false;
+  }
+  return true;
+}
+function buildPiCacheOptions(args) {
+  const out = {};
+  if (args.sessionId)
+    out.sessionId = args.sessionId;
+  if (args.apiProtocol === "openai-completions") {
+    out.cacheRetention = args.cacheRetention ?? "long";
+  } else if (args.cacheRetention) {
+    out.cacheRetention = args.cacheRetention;
+  }
+  return out;
+}
+function resolvePiModel(provider, modelId, baseURL, capabilities) {
+  const builtIn = getModel(provider, modelId);
+  if (builtIn)
+    return baseURL ? { ...builtIn, baseUrl: baseURL } : builtIn;
+  const configuredApi = resolveApiProtocol(provider, baseURL);
+  const reasoning = resolveModelReasoning(provider, modelId, capabilities, configuredApi);
+  return {
+    id: modelId,
+    name: modelId,
+    api: configuredApi,
+    provider,
+    baseUrl: baseURL || "",
+    reasoning,
+    ...reasoning ? { compat: { ...REASONING_COMPAT_PIN } } : {},
+    input: ["text", "image"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: KNOWN_PROVIDER_APIS[provider]?.contextLimit || 128000,
+    maxTokens: KNOWN_PROVIDER_APIS[provider]?.maxTokensLimit || 8192
+  };
+}
+function toPiMessages(messages) {
+  const out = [];
+  const ts = Date.now();
+  for (const m of messages) {
+    if (m.role === "system")
+      continue;
+    if (m.role === "user") {
+      if (typeof m.content === "string") {
+        out.push({ role: "user", content: m.content, timestamp: ts });
+      } else {
+        out.push({ role: "user", content: m.content.flatMap((c) => {
+          if (c.type === "text")
+            return [{ type: "text", text: c.text }];
+          if (c.type === "image")
+            return [{ type: "image", data: c.image instanceof Uint8Array ? Buffer.from(c.image).toString("base64") : c.image, mimeType: sniffImageMime(c.image, c.mediaType) }];
+          return [{ type: "text", text: `[file:${c.mediaType}] ${typeof c.file === "string" ? c.file : Buffer.from(c.file).toString("base64")}` }];
+        }), timestamp: ts });
+      }
+      continue;
+    }
+    if (m.role === "tool") {
+      out.push({ role: "toolResult", toolCallId: m.toolCallId || "", toolName: m.name || "", content: [{ type: "text", text: typeof m.content === "string" ? m.content : JSON.stringify(m.content) }], isError: false, timestamp: ts });
+      continue;
+    }
+    const content = [];
+    if (typeof m.content === "string" && m.content)
+      content.push({ type: "text", text: m.content });
+    else if (Array.isArray(m.content))
+      for (const c of m.content) {
+        if (c.type === "text")
+          content.push({ type: "text", text: c.text });
+        else if (c.type === "image")
+          content.push({ type: "image", data: c.image instanceof Uint8Array ? Buffer.from(c.image).toString("base64") : c.image, mimeType: sniffImageMime(c.image, c.mediaType) });
+        else
+          content.push({ type: "text", text: `[file:${c.mediaType}] ${typeof c.file === "string" ? c.file : Buffer.from(c.file).toString("base64")}` });
+      }
+    for (const tc of m.toolCalls || [])
+      content.push({ type: "toolCall", id: tc.id, name: tc.name, arguments: safeJson(tc.arguments) });
+    out.push({ role: "assistant", content, api: "openai-completions", model: "", provider: "", usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } }, stopReason: "stop", timestamp: ts });
+  }
+  return out;
+}
+function extractSystemPrompt(messages) {
+  const prompts = messages.filter((m) => m.role === "system").map((m) => typeof m.content === "string" ? m.content : m.content.filter((c) => c.type === "text").map((c) => c.text).join(""));
+  return prompts.length ? prompts.join(`
+
+`) : undefined;
+}
+function safeJson(s) {
+  try {
+    return JSON.parse(s);
+  } catch (e) {
+    logger.warn(`[safeJson] JSON.parse failed`, {
+      parse_failed: true,
+      input_length: s.length,
+      error: e.message
+    });
+    return {};
+  }
+}
+function convertToolParameters(parameters) {
+  return toolParametersToJsonSchema(parameters);
+}
+function toPiTools(tools) {
+  if (!tools)
+    return;
+  return tools.map((t) => ({
+    name: t.name,
+    description: t.description || "",
+    parameters: convertToolParameters(t.parameters)
+  }));
+}
+function piRequestExtras(req) {
+  const headers = buildOpencodeHeaders(req.provider, req.sessionId, req.baseURL);
+  return Object.keys(headers).length > 0 ? { headers } : {};
+}
+function fromAssistantMessage(msg) {
+  let text = "";
+  const toolCalls = [];
+  for (const block of msg.content) {
+    const b = block;
+    if (b.type === "text") {
+      text += b.text || "";
+    } else if (b.type === "toolCall") {
+      toolCalls.push({
+        id: b.id || "",
+        name: b.name || "",
+        arguments: typeof b.arguments === "string" ? b.arguments : JSON.stringify(b.arguments ?? {})
+      });
+    }
+  }
+  return {
+    text,
+    finishReason: msg.stopReason || "stop",
+    toolCalls: toolCalls.length ? toolCalls : undefined,
+    usage: {
+      promptTokens: msg.usage?.input ?? 0,
+      completionTokens: msg.usage?.output ?? 0,
+      totalTokens: msg.usage?.totalTokens ?? 0,
+      cacheRead: msg.usage?.cacheRead,
+      cacheWrite: msg.usage?.cacheWrite
+    },
+    raw: msg
+  };
+}
+
+class EmbeddingNotSupportedError extends Error {
+  constructor(adapter) {
+    super(`Embedding is not supported by ${adapter}; use AiSdkAdapter.embed() or apply at higher layer.`);
+    this.name = "EmbeddingNotSupportedError";
+  }
+}
+
+class PiAiAdapter {
+  name = "pi-ai";
+  async chat(req) {
+    const model = resolvePiModel(req.provider, req.modelId, req.baseURL, req.capabilities);
+    const ctx = {
+      systemPrompt: [req.systemPrompt, extractSystemPrompt(req.messages)].filter(Boolean).join(`
+
+`) || undefined,
+      messages: toPiMessages(req.messages),
+      tools: toPiTools(req.tools)
+    };
+    const msg = await complete(model, ctx, {
+      apiKey: req.apiKey,
+      baseURL: req.baseURL,
+      temperature: req.temperature,
+      maxTokens: req.maxTokens,
+      signal: req.signal,
+      ...buildPiCacheOptions({
+        apiProtocol: model.api,
+        sessionId: req.sessionId,
+        cacheRetention: req.cacheRetention
+      }),
+      onPayload: createReasoningDefenseHook({
+        provider: req.provider,
+        modelId: req.modelId
+      }),
+      ...piRequestExtras(req)
+    });
+    return fromAssistantMessage(msg);
+  }
+  async stream(req) {
+    const model = resolvePiModel(req.provider, req.modelId, req.baseURL, req.capabilities);
+    const ctx = {
+      systemPrompt: [req.systemPrompt, extractSystemPrompt(req.messages)].filter(Boolean).join(`
+
+`) || undefined,
+      messages: toPiMessages(req.messages),
+      tools: toPiTools(req.tools)
+    };
+    const eventStream = piStream(model, ctx, {
+      apiKey: req.apiKey,
+      baseURL: req.baseURL,
+      temperature: req.temperature,
+      maxTokens: req.maxTokens,
+      signal: req.signal,
+      ...buildPiCacheOptions({
+        apiProtocol: model.api,
+        sessionId: req.sessionId,
+        cacheRetention: req.cacheRetention
+      }),
+      onPayload: createReasoningDefenseHook({
+        provider: req.provider,
+        modelId: req.modelId
+      }),
+      ...piRequestExtras(req)
+    });
+    return { events: eventStream, result: async () => fromAssistantMessage(await eventStream.result()) };
+  }
+  async embed(_req) {
+    throw new EmbeddingNotSupportedError(this.name);
+  }
+  async resolveProvider(provider, modelId) {
+    const model = resolvePiModel(provider, modelId);
+    const caps = KNOWN_PROVIDER_APIS[provider] || {
+      api: model.api,
+      contextLimit: model.contextWindow,
+      maxTokensLimit: model.maxTokens
+    };
+    return {
+      api: model.api,
+      provider,
+      modelId,
+      contextLimit: caps.contextLimit,
+      maxTokensLimit: caps.maxTokensLimit
+    };
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("llm.adapter.chat", {
+    recordParams: true,
+    recordResult: true,
+    log: true,
+    paramFilter: (args) => {
+      const req = args[0];
+      return {
+        provider: req?.provider,
+        model_id: req?.modelId,
+        messages_count: req?.messages?.length,
+        tools_count: req?.tools?.length,
+        temperature: req?.temperature,
+        max_tokens: req?.maxTokens
+      };
+    },
+    resultFilter: (r) => ({
+      finish_reason: r?.finishReason,
+      usage_input: r?.usage?.promptTokens,
+      usage_output: r?.usage?.completionTokens,
+      usage_total: r?.usage?.totalTokens,
+      content_length: r?.text?.length
+    })
+  })
+], PiAiAdapter.prototype, "chat", null);
+__legacyDecorateClassTS([
+  TracedAs("llm.adapter.stream", {
+    recordParams: true,
+    recordResult: false,
+    log: true,
+    paramFilter: (args) => {
+      const req = args[0];
+      return {
+        provider: req?.provider,
+        model_id: req?.modelId,
+        messages_count: req?.messages?.length
+      };
+    }
+  })
+], PiAiAdapter.prototype, "stream", null);
+__legacyDecorateClassTS([
+  TracedAs("llm.adapter.embed", {
+    paramFilter: embedParamFilter,
+    resultFilter: embedResultFilter,
+    recordResult: false,
+    log: true
+  })
+], PiAiAdapter.prototype, "embed", null);
+__legacyDecorateClassTS([
+  TracedAs("llm.adapter.resolve_provider", {
+    recordParams: true,
+    recordResult: true,
+    log: true,
+    paramFilter: (args) => ({
+      provider: args[0],
+      model_id: args[1]
+    }),
+    resultFilter: (r) => ({
+      api: r?.api,
+      context_limit: r?.contextLimit,
+      max_tokens_limit: r?.maxTokensLimit
+    })
+  })
+], PiAiAdapter.prototype, "resolveProvider", null);
+
 // src/env/llm/invoke.ts
+import { randomUUID } from "crypto";
+import { streamText, jsonSchema } from "ai";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 init_logger();
 
 // src/env/llm/tool-args-parser.ts
 init_logger();
-var logger = createLogger("llm:tool-args-parser");
+var logger2 = createLogger("llm:tool-args-parser");
 var ARG_KEY_RE = /<arg_key>([\s\S]*?)<\/arg_key>\s*<arg_value>([\s\S]*?)<\/arg_value>/g;
 function salvageTextualToolArgs(raw) {
   if (!raw.includes("<arg_key>"))
@@ -201,7 +681,7 @@ function parseToolArgsStrict(args) {
   const direct = tryParseObject(raw);
   if (direct.ok) {
     if (raw.includes("<arg_key>") || raw.includes("<arg_value>") || raw.includes("<tool_call>")) {
-      logger.warn("[parseToolArgsStrict] arguments 里出现上游文本工具调用标记，已清洗值中的 marker");
+      logger2.warn("[parseToolArgsStrict] arguments 里出现上游文本工具调用标记，已清洗值中的 marker");
       return { ok: true, args: sanitizeArgValues(direct.args), salvaged: true };
     }
     return { ok: true, args: direct.args };
@@ -210,12 +690,12 @@ function parseToolArgsStrict(args) {
     const stripped = stripTextualToolArgsMarkers(raw);
     const afterStrip = tryParseObject(stripped);
     if (afterStrip.ok) {
-      logger.warn("[parseToolArgsStrict] 上游把文本工具调用标记混进了 arguments，已剥离 marker 后恢复");
+      logger2.warn("[parseToolArgsStrict] 上游把文本工具调用标记混进了 arguments，已剥离 marker 后恢复");
       return { ok: true, args: afterStrip.args, salvaged: true };
     }
     const salvaged = salvageTextualToolArgs(raw);
     if (salvaged) {
-      logger.warn("[parseToolArgsStrict] 上游输出的是文本工具调用格式，已按 <arg_key>/<arg_value> 重建参数", { keys: Object.keys(salvaged).join(",") });
+      logger2.warn("[parseToolArgsStrict] 上游输出的是文本工具调用格式，已按 <arg_key>/<arg_value> 重建参数", { keys: Object.keys(salvaged).join(",") });
       return { ok: true, args: salvaged, salvaged: true };
     }
   }
@@ -269,33 +749,33 @@ function tryParseObject(raw) {
 var MAX_SAFE_DEPTH = 5;
 function safeParseToolArgs(args, depth = 0) {
   if (depth >= MAX_SAFE_DEPTH) {
-    logger.warn(`[safeParseToolArgs] Max recursion depth (${MAX_SAFE_DEPTH}) exceeded at depth ${depth}. ` + "Input may be malicious or abnormally deeply nested. Returning empty object.", { depth, argsType: typeof args });
+    logger2.warn(`[safeParseToolArgs] Max recursion depth (${MAX_SAFE_DEPTH}) exceeded at depth ${depth}. ` + "Input may be malicious or abnormally deeply nested. Returning empty object.", { depth, argsType: typeof args });
     return {};
   }
   if (typeof args === "object" && args !== null && !Array.isArray(args)) {
     return args;
   }
   if (Array.isArray(args)) {
-    logger.debug(`[safeParseToolArgs] Input is an array. Tool arguments should be objects. Returning empty object.`, { depth, arrayLength: args.length });
+    logger2.debug(`[safeParseToolArgs] Input is an array. Tool arguments should be objects. Returning empty object.`, { depth, arrayLength: args.length });
     return {};
   }
   if (typeof args === "string") {
     try {
       const parsed = JSON.parse(args);
       if (typeof parsed === "string") {
-        logger.debug(`[safeParseToolArgs] Detected double/multi-stringified JSON at depth ${depth}. ` + "LLM may be double-stringifying tool arguments. Parsing recursively.", { depth, parsedLength: parsed.length });
+        logger2.debug(`[safeParseToolArgs] Detected double/multi-stringified JSON at depth ${depth}. ` + "LLM may be double-stringifying tool arguments. Parsing recursively.", { depth, parsedLength: parsed.length });
         return safeParseToolArgs(parsed, depth + 1);
       }
       if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
         return parsed;
       }
       if (Array.isArray(parsed)) {
-        logger.debug(`[safeParseToolArgs] Parsed result is an array at depth ${depth}. ` + "Tool arguments should be objects, not arrays. Returning empty object.", { depth, parsedLength: parsed.length });
+        logger2.debug(`[safeParseToolArgs] Parsed result is an array at depth ${depth}. ` + "Tool arguments should be objects, not arrays. Returning empty object.", { depth, parsedLength: parsed.length });
         return {};
       }
       return { value: parsed };
     } catch (e) {
-      logger.warn(`[safeParseToolArgs] JSON.parse failed at depth ${depth}`, {
+      logger2.warn(`[safeParseToolArgs] JSON.parse failed at depth ${depth}`, {
         parse_failed: true,
         input_length: args.length,
         depth,
@@ -366,8 +846,98 @@ function canonicalizeToolCallArgsInPlace(value) {
     }
   }
 }
+
+// src/env/llm/outbound-defense.ts
+var CONVERSATION_LIST_KEYS = ["messages", "input"];
+function findConversationList(body, wireProtocol) {
+  if (wireProtocol === "openai-responses") {
+    return Array.isArray(body.input) ? { key: "input", list: body.input } : null;
+  }
+  if (wireProtocol === "openai-chat" || wireProtocol === "anthropic") {
+    return Array.isArray(body.messages) ? { key: "messages", list: body.messages } : null;
+  }
+  for (const key of CONVERSATION_LIST_KEYS) {
+    if (Array.isArray(body[key])) {
+      return { key, list: body[key] };
+    }
+  }
+  return null;
+}
+function protocolSupportsCacheKeys(wireProtocol) {
+  return wireProtocol === undefined || wireProtocol === "openai-chat" || wireProtocol === "openai-responses";
+}
+function protocolSupportsReasoningField(wireProtocol) {
+  return wireProtocol === undefined || wireProtocol === "openai-chat" || wireProtocol === "openai-responses";
+}
+function applyOutboundDefense(body, target) {
+  let next = null;
+  const writable = () => {
+    if (!next)
+      next = { ...body };
+    return next;
+  };
+  if (protocolSupportsReasoningField(target.wireProtocol) && shouldInjectReasoningContent(target.provider, target.modelId)) {
+    const found = findConversationList(body, target.wireProtocol);
+    if (found) {
+      const injected = injectReasoningContent(found.list);
+      const changed = injected.some((m, i) => m !== found.list[i]);
+      if (changed)
+        writable()[found.key] = injected;
+    }
+  }
+  if (protocolSupportsCacheKeys(target.wireProtocol) && target.sessionId) {
+    const retention = target.cacheRetention ?? "long";
+    if (retention !== "none") {
+      if (body.prompt_cache_key === undefined) {
+        writable().prompt_cache_key = clampOpenAIPromptCacheKey(target.sessionId);
+      }
+      if (retention === "long" && body.prompt_cache_retention === undefined) {
+        writable().prompt_cache_retention = "24h";
+      }
+    }
+  }
+  return next ?? body;
+}
+function createOutboundDefenseFetch(target, inner = (...args) => globalThis.fetch(...args)) {
+  return async (input, init) => {
+    if (!init || typeof init.body !== "string" || init.body.length === 0) {
+      return inner(input, init);
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(init.body);
+    } catch {
+      return inner(input, init);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return inner(input, init);
+    }
+    let patched;
+    try {
+      patched = applyOutboundDefense(parsed, target);
+    } catch {
+      return inner(input, init);
+    }
+    if (patched === parsed) {
+      return inner(input, init);
+    }
+    return inner(input, { ...init, body: JSON.stringify(patched) });
+  };
+}
+function wireProtocolFromApiProtocol(apiProtocol) {
+  switch (apiProtocol) {
+    case "openai-responses":
+      return "openai-responses";
+    case "anthropic-messages":
+      return "anthropic";
+    case "openai-completions":
+      return "openai-chat";
+    default:
+      return "openai-chat";
+  }
+}
 // src/env/llm/invoke.ts
-var logger2 = createLogger("llm:invoke");
+var logger3 = createLogger("llm:invoke");
 var MAX_RETRIES = 3;
 var DEFAULT_TIMEOUT = 60000;
 
@@ -587,7 +1157,7 @@ function convertToSDKMessages(messages, options) {
     }
     if (msg.role === "tool") {
       if (!msg.toolCallId) {
-        logger2.warn("Tool message missing toolCallId", { msg });
+        logger3.warn("Tool message missing toolCallId", { msg });
       }
       let outputValue = "";
       const content = msg.content;
@@ -675,7 +1245,7 @@ function convertToolChoice(toolChoice) {
 }
 function createEnvEventEmitter(env, context) {
   if (!env || typeof env.pushEnvEvent !== "function") {
-    logger2.warn("[invoke] createEnvEventEmitter: env is null/undefined or pushEnvEvent is unavailable, streaming events will be disabled");
+    logger3.warn("[invoke] createEnvEventEmitter: env is null/undefined or pushEnvEvent is unavailable, streaming events will be disabled");
     return null;
   }
   return (event) => {
@@ -693,7 +1263,7 @@ function createEnvEventEmitter(env, context) {
         payload: event
       });
     } catch (err) {
-      logger2.warn("Failed to push env event", { error: String(err), eventType: event.type });
+      logger3.warn("Failed to push env event", { error: String(err), eventType: event.type });
     }
   };
 }
@@ -776,12 +1346,12 @@ function processThinkingStream(textDelta, config, state) {
 async function invoke(config, options, ctx) {
   try {
     const emitToEnv = createEnvEventEmitter(options.env, options.context);
-    logger2.info("[invoke] Created event emitter", {
+    logger3.info("[invoke] Created event emitter", {
       envAvailable: !!options.env,
       hasContext: options.context !== undefined
     });
     const { providerId, modelId } = parseModelString(options.model || config.model);
-    const provider = createProviderInstance(providerId, config.apiKey, config.baseURL, options.context?.sessionId);
+    const provider = createProviderInstance(providerId, config.apiKey, config.baseURL, options.context?.sessionId, options.cacheRetention, modelId);
     if (!provider) {
       throw new Error(`Failed to create provider for ${providerId}`);
     }
@@ -815,7 +1385,7 @@ async function invoke(config, options, ctx) {
     const missingToolResults = assistantToolCalls.filter((tc) => !toolResultIds.includes(tc.id));
     const orphanedToolResults = toolResultIds.filter((id) => !toolCallIds.has(id));
     if (assistantToolCalls.length > 0 || toolResultIds.length > 0) {
-      logger2.debug("[invoke] ToolCallId matching analysis:", {
+      logger3.debug("[invoke] ToolCallId matching analysis:", {
         assistantToolCalls,
         toolResultIds,
         missingToolResults: missingToolResults.length > 0 ? missingToolResults : "none",
@@ -829,10 +1399,10 @@ async function invoke(config, options, ctx) {
     });
     const model = `${providerId}/${modelId}`;
     if (emitToEnv) {
-      logger2.info("[invoke] Emitting llm.start event");
+      logger3.info("[invoke] Emitting llm.start event");
       emitToEnv({ type: "start", metadata: { model } });
     } else {
-      logger2.warn("[invoke] emitToEnv is null, skipping llm.start event");
+      logger3.warn("[invoke] emitToEnv is null, skipping llm.start event");
     }
     const streamTextOptions = {
       model: provider.languageModel(modelId),
@@ -954,7 +1524,7 @@ async function invoke(config, options, ctx) {
 `).filter(Boolean);
       const uniqueLines = new Set(outputLines);
       if (outputLines.length !== uniqueLines.size) {
-        logger2.warn("[DEBUG_DUPLICATE] outputContent has duplicate lines", {
+        logger3.warn("[DEBUG_DUPLICATE] outputContent has duplicate lines", {
           fullContent,
           rawFullContent,
           outputContent,
@@ -962,7 +1532,7 @@ async function invoke(config, options, ctx) {
           textDeltas: textDeltaLog
         });
       } else {
-        logger2.info("[DEBUG_DUPLICATE] outputContent OK", {
+        logger3.info("[DEBUG_DUPLICATE] outputContent OK", {
           charCount: outputContent.length,
           lineCount: outputLines.length,
           uniqueLineCount: uniqueLines.size,
@@ -1000,7 +1570,7 @@ async function invoke(config, options, ctx) {
     const rawMessage = error instanceof Error ? error.message : String(error);
     const rawStack = error instanceof Error ? error.stack : undefined;
     const safeMessage = redactSecrets(rawMessage, [config.apiKey]);
-    logger2.error("Error during invocation", {
+    logger3.error("Error during invocation", {
       error: safeMessage,
       stack: rawStack ? redactSecrets(rawStack, [config.apiKey]) : undefined
     });
@@ -1023,18 +1593,37 @@ function redactSecrets(text, knownSecrets = []) {
   out = out.replace(/\bBearer\s+[A-Za-z0-9._\-+/=]{12,}\b/g, "<redacted>");
   return out;
 }
-function createProviderInstance(providerId, apiKey, baseURL, conversationId) {
+function resolveDefenseProtocol(providerId, baseURL) {
+  if (providerId === "openai")
+    return "openai-responses";
+  return wireProtocolFromApiProtocol(resolveApiProtocol(providerId, baseURL));
+}
+function createProviderInstance(providerId, apiKey, baseURL, conversationId, cacheRetention, modelId) {
   try {
     if (providerId === "openai") {
       const openai = createOpenAI({
         apiKey,
-        baseURL
+        baseURL,
+        fetch: createOutboundDefenseFetch({
+          provider: providerId,
+          modelId,
+          sessionId: conversationId,
+          cacheRetention,
+          wireProtocol: resolveDefenseProtocol(providerId, baseURL)
+        })
       });
       return openai;
     }
     if (providerId === "anthropic") {
       const anthropic = createAnthropic({
-        apiKey
+        apiKey,
+        fetch: createOutboundDefenseFetch({
+          provider: providerId,
+          modelId,
+          sessionId: conversationId,
+          cacheRetention,
+          wireProtocol: resolveDefenseProtocol(providerId, baseURL)
+        })
       });
       return anthropic;
     }
@@ -1050,17 +1639,24 @@ function createProviderInstance(providerId, apiKey, baseURL, conversationId) {
       apiKey,
       baseURL: baseURL || "",
       includeUsage: true,
-      headers: providerHeaders
+      headers: providerHeaders,
+      fetch: createOutboundDefenseFetch({
+        provider: providerId,
+        modelId,
+        sessionId: conversationId,
+        cacheRetention,
+        wireProtocol: resolveDefenseProtocol(providerId, baseURL)
+      })
     });
     return defaultProvider;
   } catch (error) {
-    logger2.error(`Failed to create provider ${providerId}`, { error: String(error) });
+    logger3.error(`Failed to create provider ${providerId}`, { error: String(error) });
     return null;
   }
 }
 async function invokeNonStream(config, options, ctx) {
   const { providerId, modelId } = parseModelString(options.model || config.model);
-  const provider = createProviderInstance(providerId, config.apiKey, config.baseURL, options.context?.sessionId);
+  const provider = createProviderInstance(providerId, config.apiKey, config.baseURL, options.context?.sessionId, options.cacheRetention, modelId);
   if (!provider) {
     throw new Error(`Failed to create provider for ${providerId}`);
   }
@@ -1126,4 +1722,4 @@ function createInvokeConfig(model, apiKey, baseURL) {
   };
 }
 
-export { toolParametersToJsonSchema, parseToolArgsStrict, safeParseToolArgs, generateOpencodeSessionId, isOpencodeProvider, isOpencodeEndpoint, getOrCreateOpencodeSessionId, buildOpencodeHeaders, canonicalizeParts, withTimeout, parseModelString, convertToSDKMessages, invoke, invokeNonStream, createInvokeConfig };
+export { parseToolArgsStrict, safeParseToolArgs, generateOpencodeSessionId, isOpencodeProvider, isOpencodeEndpoint, getOrCreateOpencodeSessionId, buildOpencodeHeaders, canonicalizeParts, PiAiAdapter, withTimeout, parseModelString, convertToSDKMessages, invoke, invokeNonStream, createInvokeConfig };