privateer-agent 0.15.4 → 0.15.6

package/dist-boot/c-DIFDBYOP.mjs

@@ -0,0 +1,1258 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  buildCopilotDynamicHeaders,
+  hasCopilotVisionInput
+} from "./c-UWVIYPQS.mjs";
+import {
+  adjustMaxTokensForThinking,
+  buildBaseOptions,
+  clampMaxTokensToContext,
+  getJsonSchemaToolParameters,
+  getPiUserAgent,
+  resolveJsonSchemaStrictSampling,
+  splitErrorToolResultImages,
+  transformMessages
+} from "./c-C6S2YB53.mjs";
+import {
+  sanitizeSurrogates
+} from "./c-5GV3X3RB.mjs";
+import {
+  retryProviderRequest
+} from "./c-EYZGSAJU.mjs";
+import {
+  headersToRecord
+} from "./c-ZJYLGIC3.mjs";
+import {
+  Anthropic
+} from "./c-6QHOZXKQ.mjs";
+import {
+  ANTHROPIC_FEDERATION_RULE_ID_ENV,
+  ANTHROPIC_IDENTITY_TOKEN_FILE_ENV,
+  ANTHROPIC_ORGANIZATION_ID_ENV,
+  ANTHROPIC_SERVICE_ACCOUNT_ID_ENV,
+  ANTHROPIC_WORKSPACE_ID_ENV
+} from "./c-O5PP6CTX.mjs";
+import {
+  getProviderEnvValue
+} from "./c-CDBEJSBF.mjs";
+import {
+  parseJsonWithRepair,
+  parseStreamingJson,
+  parseToolCallArguments
+} from "./c-DEE67DJO.mjs";
+import {
+  calculateCost,
+  getCurrentTools,
+  getInitialSystemMessage,
+  getSystemMessageText,
+  renderSystemMessageUpdate,
+  resolveTranscript
+} from "./c-WO3QSZUU.mjs";
+import {
+  AssistantMessageEventStream,
+  appendAssistantMessageDiagnostic
+} from "./c-S2RVHR3M.mjs";
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/@earendil-works/pi-ai/dist/api/anthropic-messages.js
+function resolveCacheRetention(cacheRetention, env) {
+  if (cacheRetention) {
+    return cacheRetention;
+  }
+  if (getProviderEnvValue("PI_CACHE_RETENTION", env) === "long") {
+    return "long";
+  }
+  return "short";
+}
+__name(resolveCacheRetention, "resolveCacheRetention");
+function getCacheControl(model, cacheRetention, env) {
+  const retention = resolveCacheRetention(cacheRetention, env);
+  if (retention === "none") {
+    return { retention };
+  }
+  const ttl = retention === "long" && getAnthropicCompat(model).supportsLongCacheRetention ? "1h" : void 0;
+  return {
+    retention,
+    cacheControl: { type: "ephemeral", ...ttl && { ttl } }
+  };
+}
+__name(getCacheControl, "getCacheControl");
+var claudeCodeVersion = "2.1.280";
+var claudeCodeTools = [
+  "Read",
+  "Write",
+  "Edit",
+  "Bash",
+  "Grep",
+  "Glob",
+  "AskUserQuestion",
+  "EnterPlanMode",
+  "ExitPlanMode",
+  "KillShell",
+  "NotebookEdit",
+  "Skill",
+  "Task",
+  "TaskOutput",
+  "TodoWrite",
+  "WebFetch",
+  "WebSearch"
+];
+var ccToolLookup = new Map(claudeCodeTools.map((t) => [t.toLowerCase(), t]));
+var toClaudeCodeName = /* @__PURE__ */ __name((name) => ccToolLookup.get(name.toLowerCase()) ?? name, "toClaudeCodeName");
+var fromClaudeCodeName = /* @__PURE__ */ __name((name, tools) => {
+  if (tools && tools.length > 0) {
+    const lowerName = name.toLowerCase();
+    const matchedTool = tools.find((tool) => tool.name.toLowerCase() === lowerName);
+    if (matchedTool)
+      return matchedTool.name;
+  }
+  return name;
+}, "fromClaudeCodeName");
+function convertImageBlock(image) {
+  return {
+    type: "image",
+    source: {
+      type: "base64",
+      media_type: image.mimeType,
+      data: image.data
+    }
+  };
+}
+__name(convertImageBlock, "convertImageBlock");
+function convertContentBlocks(content) {
+  const hasImages = content.some((c) => c.type === "image");
+  if (!hasImages) {
+    return sanitizeSurrogates(content.map((c) => c.text).join("\n"));
+  }
+  const blocks = content.map((block) => {
+    if (block.type === "text") {
+      return {
+        type: "text",
+        text: sanitizeSurrogates(block.text)
+      };
+    }
+    return convertImageBlock(block);
+  });
+  const hasText = blocks.some((b) => b.type === "text");
+  if (!hasText) {
+    blocks.unshift({
+      type: "text",
+      text: "(see attached image)"
+    });
+  }
+  return blocks;
+}
+__name(convertContentBlocks, "convertContentBlocks");
+var FINE_GRAINED_TOOL_STREAMING_BETA = "fine-grained-tool-streaming-2025-05-14";
+var INTERLEAVED_THINKING_BETA = "interleaved-thinking-2025-05-14";
+var SERVER_SIDE_FALLBACK_BETA = "server-side-fallback-2026-07-01";
+var MID_CONVERSATION_OUTPUT_CONFIG_BETA = "mid-conversation-output-config-2026-07-01";
+var THINKING_BINDING_CONTROLS_BETA = "thinking-binding-controls-2026-08-01";
+var INLINE_TOOLS_BETA = "inline-tools-2026-09-15";
+var DEFERRED_TOOL_PLACEHOLDER = {
+  name: "__pi_deferred_placeholder__",
+  description: "Reserved placeholder. Never available. Never call this.",
+  input_schema: { type: "object", properties: {}, required: [] },
+  defer_loading: true
+};
+function shouldUseServerSideFallbackBeta(model) {
+  return (model.compat?.allowedFallbackModels?.length ?? 0) > 0;
+}
+__name(shouldUseServerSideFallbackBeta, "shouldUseServerSideFallbackBeta");
+function getAnthropicCompat(model) {
+  const isOpenRouter = model.provider === "openrouter" || model.baseUrl.includes("openrouter.ai");
+  return {
+    supportsEagerToolInputStreaming: model.compat?.supportsEagerToolInputStreaming ?? true,
+    supportsLongCacheRetention: model.compat?.supportsLongCacheRetention ?? true,
+    sendSessionAffinityHeaders: model.compat?.sendSessionAffinityHeaders ?? isOpenRouter,
+    sessionAffinityFormat: model.compat?.sessionAffinityFormat ?? (isOpenRouter ? "openrouter" : void 0),
+    supportsCacheControlOnTools: model.compat?.supportsCacheControlOnTools ?? true,
+    supportsTemperature: model.compat?.supportsTemperature ?? true,
+    allowEmptySignature: model.compat?.allowEmptySignature ?? false,
+    supportsStrictTools: model.compat?.supportsStrictTools ?? false,
+    supportsMidConvoSystemMessages: model.compat?.supportsMidConvoSystemMessages ?? false,
+    supportsMidConvoToolChanges: model.compat?.supportsMidConvoToolChanges ?? false
+  };
+}
+__name(getAnthropicCompat, "getAnthropicCompat");
+function mergeHeaders(...headerSources) {
+  const merged = {};
+  for (const headers of headerSources) {
+    if (headers) {
+      Object.assign(merged, headers);
+    }
+  }
+  return merged;
+}
+__name(mergeHeaders, "mergeHeaders");
+function mergeClientHeaders(...headerSources) {
+  return mergeHeaders({ "User-Agent": getPiUserAgent() }, ...headerSources);
+}
+__name(mergeClientHeaders, "mergeClientHeaders");
+function hasHeader(headers, name) {
+  if (!headers)
+    return false;
+  const expected = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === expected && value !== null && value.trim().length > 0)
+      return true;
+  }
+  return false;
+}
+__name(hasHeader, "hasHeader");
+function hasRequestAuth(apiKey, headers) {
+  return !!apiKey || hasHeader(headers, "authorization") || hasHeader(headers, "x-api-key") || hasHeader(headers, "cf-aig-authorization");
+}
+__name(hasRequestAuth, "hasRequestAuth");
+function assertRequestAuth(provider, apiKey, headers) {
+  if (!hasRequestAuth(apiKey, headers))
+    throw new Error(`No API key for provider: ${provider}`);
+}
+__name(assertRequestAuth, "assertRequestAuth");
+var PiAnthropic = class extends Anthropic {
+  static {
+    __name(this, "PiAnthropic");
+  }
+  _shouldResolveDefaultCredentials() {
+    return false;
+  }
+};
+function getAnthropicFederation(model, apiKey, headers, env) {
+  if (model.provider !== "anthropic" || hasRequestAuth(apiKey, headers))
+    return void 0;
+  const federationRuleId = getProviderEnvValue(ANTHROPIC_FEDERATION_RULE_ID_ENV, env);
+  const organizationId = getProviderEnvValue(ANTHROPIC_ORGANIZATION_ID_ENV, env);
+  const identityTokenFile = getProviderEnvValue(ANTHROPIC_IDENTITY_TOKEN_FILE_ENV, env);
+  if (!federationRuleId || !organizationId || !identityTokenFile)
+    return void 0;
+  return {
+    organization_id: organizationId,
+    workspace_id: getProviderEnvValue(ANTHROPIC_WORKSPACE_ID_ENV, env),
+    authentication: {
+      type: "oidc_federation",
+      federation_rule_id: federationRuleId,
+      service_account_id: getProviderEnvValue(ANTHROPIC_SERVICE_ACCOUNT_ID_ENV, env),
+      identity_token: { source: "file", path: identityTokenFile }
+    }
+  };
+}
+__name(getAnthropicFederation, "getAnthropicFederation");
+var federationClient;
+var ANTHROPIC_MESSAGE_EVENTS = /* @__PURE__ */ new Set([
+  "message_start",
+  "message_delta",
+  "message_stop",
+  "content_block_start",
+  "content_block_delta",
+  "content_block_stop"
+]);
+function flushSseEvent(state) {
+  if (!state.event && state.data.length === 0) {
+    return null;
+  }
+  const event = {
+    event: state.event,
+    data: state.data.join("\n"),
+    raw: [...state.raw]
+  };
+  state.event = null;
+  state.data = [];
+  state.raw = [];
+  return event;
+}
+__name(flushSseEvent, "flushSseEvent");
+function decodeSseLine(line, state) {
+  if (line === "") {
+    return flushSseEvent(state);
+  }
+  state.raw.push(line);
+  if (line.startsWith(":")) {
+    return null;
+  }
+  const delimiterIndex = line.indexOf(":");
+  const fieldName = delimiterIndex === -1 ? line : line.slice(0, delimiterIndex);
+  let value = delimiterIndex === -1 ? "" : line.slice(delimiterIndex + 1);
+  if (value.startsWith(" ")) {
+    value = value.slice(1);
+  }
+  if (fieldName === "event") {
+    state.event = value;
+  } else if (fieldName === "data") {
+    state.data.push(value);
+  }
+  return null;
+}
+__name(decodeSseLine, "decodeSseLine");
+function nextLineBreakIndex(text) {
+  const carriageReturnIndex = text.indexOf("\r");
+  const newlineIndex = text.indexOf("\n");
+  if (carriageReturnIndex === -1) {
+    return newlineIndex;
+  }
+  if (newlineIndex === -1) {
+    return carriageReturnIndex;
+  }
+  return Math.min(carriageReturnIndex, newlineIndex);
+}
+__name(nextLineBreakIndex, "nextLineBreakIndex");
+function consumeLine(text) {
+  const lineBreakIndex = nextLineBreakIndex(text);
+  if (lineBreakIndex === -1) {
+    return null;
+  }
+  let nextIndex = lineBreakIndex + 1;
+  if (text[lineBreakIndex] === "\r" && text[nextIndex] === "\n") {
+    nextIndex += 1;
+  }
+  return {
+    line: text.slice(0, lineBreakIndex),
+    rest: text.slice(nextIndex)
+  };
+}
+__name(consumeLine, "consumeLine");
+async function* iterateSseMessages(body, signal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  const state = { event: null, data: [], raw: [] };
+  let buffer = "";
+  try {
+    while (true) {
+      if (signal?.aborted) {
+        throw new Error("Request was aborted");
+      }
+      const { value, done } = await reader.read();
+      if (done) {
+        break;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      let consumed2 = consumeLine(buffer);
+      while (consumed2) {
+        buffer = consumed2.rest;
+        const event = decodeSseLine(consumed2.line, state);
+        if (event) {
+          yield event;
+        }
+        consumed2 = consumeLine(buffer);
+      }
+    }
+    buffer += decoder.decode();
+    let consumed = consumeLine(buffer);
+    while (consumed) {
+      buffer = consumed.rest;
+      const event = decodeSseLine(consumed.line, state);
+      if (event) {
+        yield event;
+      }
+      consumed = consumeLine(buffer);
+    }
+    if (buffer.length > 0) {
+      const event = decodeSseLine(buffer, state);
+      if (event) {
+        yield event;
+      }
+    }
+    const trailingEvent = flushSseEvent(state);
+    if (trailingEvent) {
+      yield trailingEvent;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+__name(iterateSseMessages, "iterateSseMessages");
+async function* iterateAnthropicEvents(response, signal) {
+  if (!response.body) {
+    throw new Error("Attempted to iterate over an Anthropic response with no body");
+  }
+  let sawMessageStart = false;
+  let sawMessageEnd = false;
+  for await (const sse of iterateSseMessages(response.body, signal)) {
+    if (sse.event === "error") {
+      throw new Error(sse.data);
+    }
+    if (!ANTHROPIC_MESSAGE_EVENTS.has(sse.event ?? "")) {
+      continue;
+    }
+    try {
+      const event = parseJsonWithRepair(sse.data);
+      if (event.type === "message_start") {
+        sawMessageStart = true;
+      } else if (event.type === "message_stop") {
+        sawMessageEnd = true;
+      }
+      yield event;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Could not parse Anthropic SSE event ${sse.event}: ${message}; data=${sse.data}; raw=${sse.raw.join("\\n")}`);
+    }
+  }
+  if (sawMessageStart && !sawMessageEnd) {
+    throw new Error("Anthropic stream ended before message_stop");
+  }
+}
+__name(iterateAnthropicEvents, "iterateAnthropicEvents");
+var stream = /* @__PURE__ */ __name((model, context, options) => {
+  const stream2 = new AssistantMessageEventStream();
+  const normalizedContext = resolveTranscript(context, getAnthropicCompat(model).supportsMidConvoSystemMessages);
+  const currentTools = getCurrentTools(normalizedContext.messages);
+  (async () => {
+    const output = {
+      role: "assistant",
+      content: [],
+      api: model.api,
+      provider: model.provider,
+      model: model.id,
+      usage: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+      },
+      stopReason: "pending",
+      timestamp: Date.now()
+    };
+    try {
+      let client;
+      let isOAuth;
+      let usageModel = model;
+      let inputTransformations;
+      if (options?.client) {
+        client = options.client;
+        isOAuth = false;
+      } else {
+        const apiKey = options?.apiKey;
+        const federation = getAnthropicFederation(model, apiKey, options?.headers, options?.env);
+        if (!federation)
+          assertRequestAuth(model.provider, apiKey, options?.headers);
+        let copilotDynamicHeaders;
+        if (model.provider === "github-copilot") {
+          const hasImages = hasCopilotVisionInput(normalizedContext.messages);
+          copilotDynamicHeaders = buildCopilotDynamicHeaders({
+            messages: normalizedContext.messages,
+            hasImages
+          });
+        }
+        const cacheRetention = resolveCacheRetention(options?.cacheRetention, options?.env);
+        const cacheSessionId = cacheRetention === "none" ? void 0 : options?.sessionId;
+        const created = createClient(model, apiKey, options?.headers, options?.fetch, copilotDynamicHeaders, cacheSessionId, federation);
+        client = created.client;
+        isOAuth = created.isOAuthToken;
+      }
+      const requestOptions = {
+        ...options?.signal ? { signal: options.signal } : {},
+        ...options?.timeoutMs !== void 0 ? { timeout: options.timeoutMs } : {},
+        maxRetries: 0
+      };
+      let disablePreferredStrictTools = false;
+      let response;
+      for (; ; ) {
+        options?.signal?.throwIfAborted();
+        const built = buildParams(model, normalizedContext, isOAuth, options, disablePreferredStrictTools);
+        if (built.providerThinkingLevel)
+          output.providerThinkingLevel = built.providerThinkingLevel;
+        let params = built.params;
+        const nextParams = await options?.onPayload?.(params, model);
+        if (nextParams !== void 0) {
+          params = { ...nextParams, stream: true };
+        }
+        try {
+          response = await retryProviderRequest(() => client.beta.messages.create(params, requestOptions).asResponse(), {
+            maxRetries: options?.maxRetries,
+            maxRetryDelayMs: options?.maxRetryDelayMs,
+            signal: options?.signal
+          });
+          break;
+        } catch (error) {
+          if (options?.signal?.aborted || disablePreferredStrictTools || !built.hasPreferredStrictTools || !(error instanceof Anthropic.APIError) || error.status !== 400 || error.type !== "invalid_request_error" || ![
+            "The compiled grammar is too large",
+            "Too many strict tools (",
+            "Schemas contains too many parameters with union types ("
+          ].some((message) => error.message.includes(message))) {
+            throw error;
+          }
+          disablePreferredStrictTools = true;
+          appendAssistantMessageDiagnostic(output, {
+            type: "anthropic_strict_tools_fallback",
+            timestamp: Date.now(),
+            error: { message: error.message },
+            details: { reason: "strict_tool_limits_exceeded" }
+          });
+        }
+      }
+      await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
+      stream2.push({ type: "start", partial: output });
+      const blocks = output.content;
+      for await (const event of iterateAnthropicEvents(response, options?.signal)) {
+        await options?.onProviderStreamEvent?.(event, model);
+        if (event.type === "message_start") {
+          output.responseId = event.message.id;
+          const transformations = event.message.input_transformations;
+          if (Array.isArray(transformations))
+            inputTransformations = transformations;
+          const responseModel = event.message.model;
+          if (responseModel !== model.id)
+            output.responseModel = responseModel;
+          const fallbackCost = responseModel === model.id ? void 0 : model.compat?.allowedFallbackModels?.find((fallback) => fallback.provider === model.provider && fallback.model === responseModel)?.cost;
+          usageModel = fallbackCost ? { ...model, id: responseModel, cost: fallbackCost } : model;
+          output.usage.input = event.message.usage.input_tokens || 0;
+          output.usage.output = event.message.usage.output_tokens || 0;
+          output.usage.cacheRead = event.message.usage.cache_read_input_tokens || 0;
+          output.usage.cacheWrite = event.message.usage.cache_creation_input_tokens || 0;
+          output.usage.cacheWrite1h = event.message.usage.cache_creation?.ephemeral_1h_input_tokens || 0;
+          output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
+          calculateCost(usageModel, output.usage);
+        } else if (event.type === "content_block_start") {
+          if (event.content_block.type === "fallback") {
+            if (output.content.length > 0) {
+              throw new Error("Anthropic performed an unsupported mid-output model fallback");
+            }
+            continue;
+          }
+          if (event.content_block.type === "text") {
+            const block = {
+              type: "text",
+              text: event.content_block.text ?? "",
+              index: event.index
+            };
+            output.content.push(block);
+            stream2.push({ type: "text_start", contentIndex: output.content.length - 1, partial: output });
+          } else if (event.content_block.type === "thinking") {
+            const block = {
+              type: "thinking",
+              thinking: event.content_block.thinking ?? "",
+              thinkingSignature: event.content_block.signature ?? "",
+              index: event.index
+            };
+            output.content.push(block);
+            stream2.push({ type: "thinking_start", contentIndex: output.content.length - 1, partial: output });
+          } else if (event.content_block.type === "redacted_thinking") {
+            const block = {
+              type: "thinking",
+              thinking: "[Reasoning redacted]",
+              thinkingSignature: event.content_block.data,
+              redacted: true,
+              index: event.index
+            };
+            output.content.push(block);
+            stream2.push({ type: "thinking_start", contentIndex: output.content.length - 1, partial: output });
+          } else if (event.content_block.type === "tool_use") {
+            const block = {
+              type: "toolCall",
+              id: event.content_block.id,
+              name: isOAuth ? fromClaudeCodeName(event.content_block.name, currentTools) : event.content_block.name,
+              arguments: event.content_block.input ?? {},
+              partialJson: "",
+              index: event.index
+            };
+            output.content.push(block);
+            stream2.push({ type: "toolcall_start", contentIndex: output.content.length - 1, partial: output });
+          }
+        } else if (event.type === "content_block_delta") {
+          if (event.delta.type === "text_delta") {
+            const index = blocks.findIndex((b) => b.index === event.index);
+            const block = blocks[index];
+            if (block && block.type === "text") {
+              block.text += event.delta.text;
+              stream2.push({
+                type: "text_delta",
+                contentIndex: index,
+                delta: event.delta.text,
+                partial: output
+              });
+            }
+          } else if (event.delta.type === "thinking_delta") {
+            const index = blocks.findIndex((b) => b.index === event.index);
+            const block = blocks[index];
+            if (block && block.type === "thinking") {
+              block.thinking += event.delta.thinking;
+              stream2.push({
+                type: "thinking_delta",
+                contentIndex: index,
+                delta: event.delta.thinking,
+                partial: output
+              });
+            }
+          } else if (event.delta.type === "input_json_delta") {
+            const index = blocks.findIndex((b) => b.index === event.index);
+            const block = blocks[index];
+            if (block && block.type === "toolCall") {
+              block.partialJson += event.delta.partial_json;
+              block.arguments = parseStreamingJson(block.partialJson);
+              stream2.push({
+                type: "toolcall_delta",
+                contentIndex: index,
+                delta: event.delta.partial_json,
+                partial: output
+              });
+            }
+          } else if (event.delta.type === "signature_delta") {
+            const index = blocks.findIndex((b) => b.index === event.index);
+            const block = blocks[index];
+            if (block && block.type === "thinking") {
+              block.thinkingSignature = block.thinkingSignature || "";
+              block.thinkingSignature += event.delta.signature;
+            }
+          }
+        } else if (event.type === "content_block_stop") {
+          const index = blocks.findIndex((b) => b.index === event.index);
+          const block = blocks[index];
+          if (block) {
+            delete block.index;
+            if (block.type === "text") {
+              stream2.push({
+                type: "text_end",
+                contentIndex: index,
+                content: block.text,
+                partial: output
+              });
+            } else if (block.type === "thinking") {
+              stream2.push({
+                type: "thinking_end",
+                contentIndex: index,
+                content: block.thinking,
+                partial: output
+              });
+            } else if (block.type === "toolCall") {
+              Object.assign(block, parseToolCallArguments(block.partialJson));
+              delete block.partialJson;
+              stream2.push({
+                type: "toolcall_end",
+                contentIndex: index,
+                toolCall: block,
+                partial: output
+              });
+            }
+          }
+        } else if (event.type === "message_delta") {
+          const transformations = event.input_transformations;
+          if (Array.isArray(transformations))
+            inputTransformations = transformations;
+          if (event.delta.stop_reason) {
+            output.rawStopReason = event.delta.stop_reason;
+            const stopReasonResult = mapStopReason(event.delta.stop_reason, event.delta.stop_details);
+            output.stopReason = stopReasonResult.stopReason;
+            if (stopReasonResult.errorMessage) {
+              output.errorMessage = stopReasonResult.errorMessage;
+            }
+          }
+          if (event.usage) {
+            if (event.usage.input_tokens != null) {
+              output.usage.input = event.usage.input_tokens;
+            }
+            if (event.usage.output_tokens != null) {
+              output.usage.output = event.usage.output_tokens;
+            }
+            if (event.usage.cache_read_input_tokens != null) {
+              output.usage.cacheRead = event.usage.cache_read_input_tokens;
+            }
+            if (event.usage.cache_creation_input_tokens != null) {
+              output.usage.cacheWrite = event.usage.cache_creation_input_tokens;
+            }
+            const cacheCreation = event.usage.cache_creation;
+            if (cacheCreation?.ephemeral_1h_input_tokens != null) {
+              output.usage.cacheWrite1h = cacheCreation.ephemeral_1h_input_tokens;
+            }
+            const thinkingTokens = event.usage.output_tokens_details?.thinking_tokens;
+            if (thinkingTokens != null) {
+              output.usage.reasoning = thinkingTokens;
+            }
+          }
+          output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
+          calculateCost(usageModel, output.usage);
+        }
+      }
+      if (options?.signal?.aborted) {
+        throw new Error("Request was aborted");
+      }
+      if (output.stopReason === "pending") {
+        throw new Error("Anthropic stream ended without a stop reason");
+      }
+      if (output.stopReason === "aborted" || output.stopReason === "error") {
+        throw new Error(output.errorMessage || "An unknown error occurred");
+      }
+      if (inputTransformations && inputTransformations.length > 0) {
+        appendAssistantMessageDiagnostic(output, {
+          type: "anthropic_input_transformations",
+          timestamp: Date.now(),
+          details: {
+            transformations: inputTransformations.map((transformation) => ({
+              type: transformation.type ?? void 0,
+              path: transformation.path ?? void 0,
+              reason: transformation.reason ?? void 0
+            }))
+          }
+        });
+      }
+      stream2.push({ type: "done", reason: output.stopReason, message: output });
+      stream2.end();
+    } catch (error) {
+      for (const block of output.content) {
+        delete block.index;
+        delete block.partialJson;
+      }
+      output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+      output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+      stream2.push({ type: "error", reason: output.stopReason, error: output });
+      stream2.end();
+    }
+  })();
+  return stream2;
+}, "stream");
+function mapThinkingLevelToEffort(model, level) {
+  const mapped = level ? model.thinkingLevelMap?.[level] : void 0;
+  if (typeof mapped === "string")
+    return mapped;
+  switch (level) {
+    case "minimal":
+    case "low":
+      return "low";
+    case "medium":
+      return "medium";
+    case "high":
+      return "high";
+    default:
+      return "high";
+  }
+}
+__name(mapThinkingLevelToEffort, "mapThinkingLevelToEffort");
+var streamSimple = /* @__PURE__ */ __name((model, context, options) => {
+  if (!getAnthropicFederation(model, options?.apiKey, options?.headers, options?.env)) {
+    assertRequestAuth(model.provider, options?.apiKey, options?.headers);
+  }
+  const base = {
+    ...buildBaseOptions(model, context, options, options?.apiKey),
+    toolChoice: options?.toolChoice
+  };
+  if (!options?.reasoning) {
+    return stream(model, context, {
+      ...base,
+      thinkingEnabled: false
+    });
+  }
+  if (model.compat?.forceAdaptiveThinking === true) {
+    const effort = mapThinkingLevelToEffort(model, options.reasoning);
+    return stream(model, context, {
+      ...base,
+      thinkingEnabled: true,
+      effort
+    });
+  }
+  const adjusted = adjustMaxTokensForThinking(base.maxTokens, model.maxTokens, options.reasoning, options.thinkingBudgets);
+  const maxTokens = clampMaxTokensToContext(model, context, adjusted.maxTokens);
+  return stream(model, context, {
+    ...base,
+    maxTokens,
+    thinkingEnabled: true,
+    thinkingBudgetTokens: Math.min(adjusted.thinkingBudget, Math.max(0, maxTokens - 1024))
+  });
+}, "streamSimple");
+function isOAuthToken(apiKey) {
+  return apiKey.includes("sk-ant-oat");
+}
+__name(isOAuthToken, "isOAuthToken");
+function createClient(model, apiKey, optionsHeaders, fetch, dynamicHeaders, sessionId, federation) {
+  if (model.provider === "github-copilot") {
+    const client2 = new PiAnthropic({
+      apiKey: null,
+      authToken: apiKey ?? null,
+      baseURL: model.baseUrl,
+      dangerouslyAllowBrowser: true,
+      fetch,
+      defaultHeaders: mergeClientHeaders({
+        accept: "application/json",
+        "anthropic-dangerous-direct-browser-access": "true"
+      }, model.headers, dynamicHeaders, optionsHeaders)
+    });
+    return { client: client2, isOAuthToken: false };
+  }
+  if (apiKey && isOAuthToken(apiKey)) {
+    const client2 = new PiAnthropic({
+      apiKey: null,
+      authToken: apiKey,
+      baseURL: model.baseUrl,
+      dangerouslyAllowBrowser: true,
+      fetch,
+      defaultHeaders: mergeClientHeaders({
+        accept: "application/json",
+        "anthropic-dangerous-direct-browser-access": "true",
+        "user-agent": `claude-cli/${claudeCodeVersion}`,
+        "x-app": "cli"
+      }, model.headers, optionsHeaders)
+    });
+    return { client: client2, isOAuthToken: true };
+  }
+  const compat = getAnthropicCompat(model);
+  const sessionAffinityHeaders = {};
+  if (sessionId && compat.sendSessionAffinityHeaders) {
+    const header = compat.sessionAffinityFormat === "openrouter" ? "x-session-id" : "x-session-affinity";
+    sessionAffinityHeaders[header] = sessionId;
+  }
+  const defaultHeaders = mergeClientHeaders({
+    accept: "application/json",
+    "anthropic-dangerous-direct-browser-access": "true"
+  }, sessionAffinityHeaders, model.headers, optionsHeaders);
+  if (federation) {
+    const key = JSON.stringify([model.baseUrl, federation]);
+    if (federationClient?.key !== key || federationClient.fetch !== fetch) {
+      const client2 = new PiAnthropic({
+        apiKey: null,
+        authToken: null,
+        config: federation,
+        baseURL: model.baseUrl,
+        dangerouslyAllowBrowser: true,
+        fetch
+      });
+      federationClient = { key, fetch, client: client2 };
+    }
+    return { client: federationClient.client.withOptions({ defaultHeaders }), isOAuthToken: false };
+  }
+  const client = new PiAnthropic({
+    apiKey: apiKey ?? null,
+    authToken: null,
+    baseURL: model.baseUrl,
+    dangerouslyAllowBrowser: true,
+    fetch,
+    defaultHeaders
+  });
+  return { client, isOAuthToken: false };
+}
+__name(createClient, "createClient");
+function getBetaFeatures(model, context, isOAuthToken2, nativeToolChanges, options) {
+  let configuredFeatures;
+  for (const headers of [model.headers, options?.headers]) {
+    for (const [name, value] of Object.entries(headers ?? {})) {
+      if (name.toLowerCase() === "anthropic-beta")
+        configuredFeatures = value;
+    }
+  }
+  if (configuredFeatures === null)
+    return [];
+  if (configuredFeatures !== void 0) {
+    return [
+      ...new Set(configuredFeatures.split(",").map((feature) => feature.trim()).filter((feature) => feature.length > 0))
+    ];
+  }
+  const features = [];
+  if (isOAuthToken2)
+    features.push("claude-code-20250219", "oauth-2025-04-20");
+  if (shouldUseFineGrainedToolStreamingBeta(model, context))
+    features.push(FINE_GRAINED_TOOL_STREAMING_BETA);
+  if (model.reasoning && options?.thinkingEnabled === true && (options.interleavedThinking ?? true) && model.compat?.forceAdaptiveThinking !== true) {
+    features.push(INTERLEAVED_THINKING_BETA);
+  }
+  if (shouldUseServerSideFallbackBeta(model))
+    features.push(SERVER_SIDE_FALLBACK_BETA);
+  if (model.compat?.supportsMidConvoEffort === true) {
+    features.push(MID_CONVERSATION_OUTPUT_CONFIG_BETA, THINKING_BINDING_CONTROLS_BETA);
+  }
+  if (nativeToolChanges)
+    features.push(INLINE_TOOLS_BETA);
+  return [...new Set(features)];
+}
+__name(getBetaFeatures, "getBetaFeatures");
+function buildParams(model, context, isOAuthToken2, options, disablePreferredStrictTools = false) {
+  const { cacheControl } = getCacheControl(model, options?.cacheRetention, options?.env);
+  const compat = getAnthropicCompat(model);
+  const initialSystemMessage = getInitialSystemMessage(context.messages);
+  const initialSystemText = initialSystemMessage ? getSystemMessageText(initialSystemMessage) : "";
+  const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId);
+  const conversationMessages = initialSystemMessage ? transformedMessages.slice(1) : transformedMessages;
+  let hasPreferredStrictTools = false;
+  const convertToolDefinitions = /* @__PURE__ */ __name((tools, toolCacheControl2) => {
+    const definitions = convertTools(tools, isOAuthToken2, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, toolCacheControl2, disablePreferredStrictTools);
+    if (definitions.some((definition, index) => {
+      const config = tools[index].constrainedSampling;
+      return definition.strict === true && config && config.type === "json_schema" && config.strict === "prefer";
+    })) {
+      hasPreferredStrictTools = true;
+    }
+    return definitions;
+  }, "convertToolDefinitions");
+  const initialTools = initialSystemMessage?.toolsAdded ?? [];
+  const nativeToolChanges = compat.supportsMidConvoSystemMessages && compat.supportsMidConvoToolChanges && initialTools.length > 0;
+  const thinkingDisabled = model.reasoning && options?.thinkingEnabled === false && model.thinkingLevelMap?.off !== null;
+  const effortMessages = model.compat?.supportsMidConvoEffort === true && !thinkingDisabled;
+  const converted = convertMessages(conversationMessages, isOAuthToken2, cacheControl, compat.allowEmptySignature, effortMessages ? model.provider : void 0, nativeToolChanges ? convertToolDefinitions : void 0);
+  const activeEffort = options?.effort ?? "high";
+  const betaFeatures = getBetaFeatures(model, context, isOAuthToken2, nativeToolChanges, options);
+  const params = {
+    model: model.id,
+    messages: effortMessages ? insertThinkingLevelMessages(converted, activeEffort) : converted.messages,
+    max_tokens: options?.maxTokens ?? model.maxTokens,
+    stream: true,
+    ...betaFeatures.length > 0 ? { betas: betaFeatures } : {}
+  };
+  if (isOAuthToken2) {
+    params.system = [
+      {
+        type: "text",
+        text: "You are Claude Code, Anthropic's official CLI for Claude.",
+        ...cacheControl ? { cache_control: cacheControl } : {}
+      }
+    ];
+    if (initialSystemText) {
+      params.system.push({
+        type: "text",
+        text: sanitizeSurrogates(initialSystemText),
+        ...cacheControl ? { cache_control: cacheControl } : {}
+      });
+    }
+  } else if (initialSystemText) {
+    params.system = [
+      {
+        type: "text",
+        text: sanitizeSurrogates(initialSystemText),
+        ...cacheControl ? { cache_control: cacheControl } : {}
+      }
+    ];
+  }
+  if (options?.temperature !== void 0 && !options?.thinkingEnabled && model.compat?.supportsMidConvoEffort !== true && compat.supportsTemperature) {
+    params.temperature = options.temperature;
+  }
+  const toolCacheControl = compat.supportsCacheControlOnTools ? cacheControl : void 0;
+  if (nativeToolChanges) {
+    params.tools = [...convertToolDefinitions(initialTools, toolCacheControl), DEFERRED_TOOL_PLACEHOLDER];
+  } else {
+    const tools = getCurrentTools(context.messages);
+    if (tools.length > 0) {
+      params.tools = convertToolDefinitions(tools, toolCacheControl);
+    }
+  }
+  if (thinkingDisabled) {
+    params.thinking = { type: "disabled" };
+  } else if (effortMessages) {
+    params.thinking = {
+      type: "adaptive",
+      display: options?.thinkingDisplay ?? "summarized",
+      block_binding: { prefix_mismatch_behavior: "drop_block" }
+    };
+    params.output_config = { effort: "high" };
+  } else if (model.reasoning && options?.thinkingEnabled) {
+    const display = options.thinkingDisplay ?? "summarized";
+    if (model.compat?.forceAdaptiveThinking === true) {
+      params.thinking = { type: "adaptive", display };
+      if (options.effort) {
+        params.output_config = { effort: options.effort };
+      }
+    } else {
+      params.thinking = {
+        type: "enabled",
+        budget_tokens: options.thinkingBudgetTokens || 1024,
+        display
+      };
+    }
+  }
+  if (options?.metadata) {
+    const userId = options.metadata.user_id;
+    if (typeof userId === "string") {
+      params.metadata = { user_id: userId };
+    }
+  }
+  if (options?.toolChoice) {
+    if (typeof options.toolChoice === "string") {
+      params.tool_choice = { type: options.toolChoice };
+    } else {
+      params.tool_choice = options.toolChoice;
+    }
+  }
+  const allowedFallbackModels = model.compat?.allowedFallbackModels;
+  if (allowedFallbackModels && allowedFallbackModels.length > 0) {
+    params.fallbacks = allowedFallbackModels.map((fallback) => ({ model: fallback.model }));
+  }
+  return { params, hasPreferredStrictTools, providerThinkingLevel: effortMessages ? activeEffort : void 0 };
+}
+__name(buildParams, "buildParams");
+function normalizeToolCallId(id) {
+  return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+}
+__name(normalizeToolCallId, "normalizeToolCallId");
+function convertToolResult(msg, content = msg.content) {
+  return {
+    type: "tool_result",
+    tool_use_id: msg.toolCallId,
+    content: convertContentBlocks(content),
+    is_error: msg.isError
+  };
+}
+__name(convertToolResult, "convertToolResult");
+function convertMessages(transformedMessages, isOAuthToken2, cacheControl, allowEmptySignature = false, managedProvider, convertToolDefinitions) {
+  const params = [];
+  const assistantLevels = /* @__PURE__ */ new Map();
+  const pendingSystemMessages = [];
+  const flushPendingSystemMessages = /* @__PURE__ */ __name(() => {
+    params.push(...pendingSystemMessages);
+    pendingSystemMessages.length = 0;
+  }, "flushPendingSystemMessages");
+  for (let i = 0; i < transformedMessages.length; i++) {
+    const msg = transformedMessages[i];
+    if (msg.role === "system") {
+      const text = renderSystemMessageUpdate(msg);
+      const blocks = [];
+      if (text.length > 0)
+        blocks.push({ type: "text", text: sanitizeSurrogates(text) });
+      if (convertToolDefinitions) {
+        const added = msg.toolsAdded ?? [];
+        const redefined = new Set(added.map((tool) => tool.name));
+        for (const tool of msg.toolsRemoved ?? []) {
+          if (redefined.has(tool.name))
+            continue;
+          blocks.push({
+            type: "tool_removal",
+            tool: { type: "tool_reference", name: isOAuthToken2 ? toClaudeCodeName(tool.name) : tool.name }
+          });
+        }
+        for (const definition of convertToolDefinitions(added)) {
+          blocks.push({ type: "tool_addition", tool: { type: "tool_definition", definition } });
+        }
+      }
+      if (blocks.length > 0)
+        pendingSystemMessages.push({ role: "system", content: blocks });
+    } else if (msg.role === "user") {
+      if (typeof msg.content === "string") {
+        if (msg.content.trim().length > 0) {
+          params.push({
+            role: "user",
+            content: sanitizeSurrogates(msg.content)
+          });
+        }
+      } else {
+        const blocks = msg.content.map((item) => {
+          if (item.type === "text") {
+            return {
+              type: "text",
+              text: sanitizeSurrogates(item.text)
+            };
+          } else {
+            return convertImageBlock(item);
+          }
+        });
+        const filteredBlocks = blocks.filter((b) => {
+          if (b.type === "text") {
+            return b.text.trim().length > 0;
+          }
+          return true;
+        });
+        if (filteredBlocks.length === 0)
+          continue;
+        params.push({
+          role: "user",
+          content: filteredBlocks
+        });
+      }
+    } else if (msg.role === "assistant") {
+      flushPendingSystemMessages();
+      const blocks = [];
+      for (const block of msg.content) {
+        if (block.type === "text") {
+          if (block.text.trim().length === 0)
+            continue;
+          blocks.push({
+            type: "text",
+            text: sanitizeSurrogates(block.text)
+          });
+        } else if (block.type === "thinking") {
+          if (block.redacted) {
+            blocks.push({
+              type: "redacted_thinking",
+              data: block.thinkingSignature
+            });
+            continue;
+          }
+          const thinkingSignature = block.thinkingSignature;
+          const hasThinkingSignature = !!thinkingSignature && thinkingSignature.trim().length > 0;
+          if (block.thinking.trim().length === 0 && !hasThinkingSignature)
+            continue;
+          if (!hasThinkingSignature) {
+            blocks.push(allowEmptySignature ? {
+              type: "thinking",
+              thinking: sanitizeSurrogates(block.thinking),
+              signature: ""
+            } : {
+              type: "text",
+              text: sanitizeSurrogates(block.thinking)
+            });
+          } else {
+            blocks.push({
+              type: "thinking",
+              thinking: sanitizeSurrogates(block.thinking),
+              signature: thinkingSignature
+            });
+          }
+        } else if (block.type === "toolCall") {
+          blocks.push({
+            type: "tool_use",
+            id: block.id,
+            name: isOAuthToken2 ? toClaudeCodeName(block.name) : block.name,
+            input: block.arguments ?? {}
+          });
+        }
+      }
+      if (blocks.length === 0)
+        continue;
+      const messageIndex = params.length;
+      params.push({
+        role: "assistant",
+        content: blocks
+      });
+      if (managedProvider !== void 0 && msg.api === "anthropic-messages" && msg.provider === managedProvider && isAnthropicEffort(msg.providerThinkingLevel)) {
+        assistantLevels.set(messageIndex, msg.providerThinkingLevel);
+      }
+    } else if (msg.role === "toolResult") {
+      const toolResults = [];
+      const errorImages = [];
+      let j = i;
+      while (j < transformedMessages.length && transformedMessages[j].role === "toolResult") {
+        const toolMsg = transformedMessages[j];
+        const split = splitErrorToolResultImages(toolMsg);
+        toolResults.push(convertToolResult(toolMsg, split?.content));
+        if (split) {
+          errorImages.push({ type: "text", text: split.caption }, ...split.images.map(convertImageBlock));
+        }
+        j++;
+      }
+      i = j - 1;
+      params.push({
+        role: "user",
+        content: [...toolResults, ...errorImages]
+      });
+    }
+  }
+  flushPendingSystemMessages();
+  if (cacheControl && params.length > 0) {
+    const lastMessage = params[params.length - 1];
+    if (lastMessage.role === "user" || lastMessage.role === "system") {
+      if (Array.isArray(lastMessage.content)) {
+        const lastBlock = lastMessage.content[lastMessage.content.length - 1];
+        if (lastBlock && (lastBlock.type === "text" || lastBlock.type === "image" || lastBlock.type === "tool_result" || lastBlock.type === "tool_addition" || lastBlock.type === "tool_removal")) {
+          lastBlock.cache_control = cacheControl;
+        }
+      } else if (typeof lastMessage.content === "string") {
+        lastMessage.content = [
+          {
+            type: "text",
+            text: lastMessage.content,
+            cache_control: cacheControl
+          }
+        ];
+      }
+    }
+  }
+  return { messages: params, assistantLevels };
+}
+__name(convertMessages, "convertMessages");
+function isAnthropicEffort(value) {
+  return value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max";
+}
+__name(isAnthropicEffort, "isAnthropicEffort");
+function insertThinkingLevelMessages(converted, activeEffort) {
+  const messages = [];
+  for (let index = 0; index < converted.messages.length; index++) {
+    const historicalEffort = converted.assistantLevels.get(index);
+    if (historicalEffort !== void 0) {
+      messages.push({ role: "system", content: [], output_config: { effort: historicalEffort } });
+    }
+    messages.push(converted.messages[index]);
+  }
+  messages.push({ role: "system", content: [], output_config: { effort: activeEffort } });
+  return messages;
+}
+__name(insertThinkingLevelMessages, "insertThinkingLevelMessages");
+function shouldUseFineGrainedToolStreamingBeta(model, context) {
+  return getCurrentTools(context.messages).length > 0 && !getAnthropicCompat(model).supportsEagerToolInputStreaming;
+}
+__name(shouldUseFineGrainedToolStreamingBeta, "shouldUseFineGrainedToolStreamingBeta");
+var ANTHROPIC_STRICT_UNSUPPORTED_KEYWORDS = /* @__PURE__ */ new Set([
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "multipleOf",
+  "maxItems",
+  "uniqueItems",
+  "minContains",
+  "maxContains",
+  "minProperties",
+  "maxProperties"
+]);
+var ANTHROPIC_STRICT_STRING_FORMATS = /* @__PURE__ */ new Set([
+  "date-time",
+  "time",
+  "date",
+  "duration",
+  "email",
+  "hostname",
+  "uri",
+  "ipv4",
+  "ipv6",
+  "uuid"
+]);
+var isAnthropicStrictUnsupportedKeyword = /* @__PURE__ */ __name((key, value) => {
+  if (ANTHROPIC_STRICT_UNSUPPORTED_KEYWORDS.has(key))
+    return true;
+  if (key === "minItems")
+    return value !== 0 && value !== 1;
+  if (key === "format")
+    return typeof value !== "string" || !ANTHROPIC_STRICT_STRING_FORMATS.has(value);
+  return false;
+}, "isAnthropicStrictUnsupportedKeyword");
+function convertTools(tools, isOAuthToken2, supportsEagerToolInputStreaming, supportsStrictTools, cacheControl, disablePreferredStrictTools = false) {
+  if (!tools)
+    return [];
+  return tools.map((tool, index) => {
+    const config = tool.constrainedSampling;
+    const strict = disablePreferredStrictTools && config && config.type === "json_schema" && config.strict === "prefer" ? void 0 : resolveJsonSchemaStrictSampling(tool, supportsStrictTools, isAnthropicStrictUnsupportedKeyword);
+    const parameters = getJsonSchemaToolParameters(tool, strict);
+    const schema = parameters;
+    const legacyInputSchema = {
+      type: "object",
+      properties: schema.properties ?? {},
+      required: schema.required ?? []
+    };
+    const inputSchema = strict === true ? {
+      ...parameters,
+      ...legacyInputSchema
+    } : legacyInputSchema;
+    return {
+      name: isOAuthToken2 ? toClaudeCodeName(tool.name) : tool.name,
+      description: tool.description,
+      ...supportsEagerToolInputStreaming ? { eager_input_streaming: true } : {},
+      ...strict === true ? { strict: true } : {},
+      input_schema: inputSchema,
+      ...cacheControl && index === tools.length - 1 ? { cache_control: cacheControl } : {}
+    };
+  });
+}
+__name(convertTools, "convertTools");
+function mapStopReason(reason, stopDetails) {
+  switch (reason) {
+    case "end_turn":
+      return { stopReason: "stop" };
+    case "max_tokens":
+      return { stopReason: "length" };
+    case "tool_use":
+      return { stopReason: "toolUse" };
+    case "refusal":
+      return {
+        stopReason: "error",
+        errorMessage: stopDetails?.explanation || `The model refused to complete the request`
+      };
+    case "pause_turn":
+      return { stopReason: "stop" };
+    case "stop_sequence":
+      return { stopReason: "stop" };
+    // We don't supply stop sequences, so this should never happen
+    case "sensitive":
+      return { stopReason: "error", errorMessage: "Provider stopped with: sensitive" };
+    default:
+      throw new Error(`Unhandled stop reason: ${reason}`);
+  }
+}
+__name(mapStopReason, "mapStopReason");
+export {
+  stream,
+  streamSimple
+};