@ddlqhd/agent-sdk 0.1.0 → 0.2.0

package/dist/chunk-NYZD3THB.cjs

@@ -0,0 +1,1521 @@
+#!/usr/bin/env node
+'use strict';
+
+var chunkOZO7D77N_cjs = require('./chunk-OZO7D77N.cjs');
+var crypto = require('crypto');
+
+// src/models/default-capabilities.ts
+var DEFAULT_ADAPTER_CAPABILITIES = {
+  contextLength: 2e5,
+  maxOutputTokens: 32e3
+};
+
+// src/core/logger.ts
+var TRUTHY = /^(1|true|yes)$/i;
+var DEFAULT_MAX_BODY_CHARS = 4e3;
+var DEFAULT_REDACT_KEYS = [
+  "authorization",
+  "proxy-authorization",
+  "x-api-key",
+  "api-key",
+  "apikey",
+  "api_key",
+  "cookie",
+  "set-cookie",
+  "token",
+  "access_token",
+  "refresh_token",
+  "password",
+  "secret"
+];
+var LEVEL_PRIORITY = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40,
+  silent: 99
+};
+function parseEnvLogLevel(raw) {
+  switch ((raw ?? "").trim().toLowerCase()) {
+    case "debug":
+    case "info":
+    case "warn":
+    case "error":
+    case "silent":
+      return (raw ?? "").trim().toLowerCase();
+    default:
+      return void 0;
+  }
+}
+function parseBooleanEnv(name) {
+  const raw = process.env[name];
+  if (raw == null || raw === "") {
+    return void 0;
+  }
+  if (TRUTHY.test(raw.trim())) {
+    return true;
+  }
+  if (/^(0|false|no)$/i.test(raw.trim())) {
+    return false;
+  }
+  return void 0;
+}
+function parseNumericEnv(name) {
+  const raw = process.env[name];
+  if (raw == null || raw === "") {
+    return void 0;
+  }
+  const value = Number(raw);
+  return Number.isFinite(value) ? value : void 0;
+}
+function resolveSDKLogLevel(level, hasLogger = false) {
+  if (level != null) {
+    return level;
+  }
+  const fromEnv = parseEnvLogLevel(process.env.AGENT_SDK_LOG_LEVEL);
+  if (fromEnv != null) {
+    return fromEnv;
+  }
+  if (hasLogger) {
+    return "info";
+  }
+  return "silent";
+}
+function resolveLogRedaction(config) {
+  const envIncludeBodies = parseBooleanEnv("AGENT_SDK_LOG_BODIES");
+  const envIncludeToolArgs = parseBooleanEnv("AGENT_SDK_LOG_INCLUDE_TOOL_ARGS");
+  const envMaxBodyChars = parseNumericEnv("AGENT_SDK_LOG_MAX_BODY_CHARS");
+  return {
+    includeBodies: config?.includeBodies ?? envIncludeBodies ?? false,
+    includeToolArguments: config?.includeToolArguments ?? envIncludeToolArgs ?? false,
+    maxBodyChars: Math.max(
+      0,
+      Math.floor(config?.maxBodyChars ?? envMaxBodyChars ?? DEFAULT_MAX_BODY_CHARS)
+    ),
+    redactKeys: [
+      ...DEFAULT_REDACT_KEYS,
+      ...config?.redactKeys ?? []
+    ]
+  };
+}
+function shouldEmitLog(configuredLevel, hasLogger, eventLevel) {
+  const effectiveLevel = resolveSDKLogLevel(configuredLevel, hasLogger);
+  return LEVEL_PRIORITY[eventLevel] >= LEVEL_PRIORITY[effectiveLevel];
+}
+function truncateString(value, maxChars) {
+  if (maxChars <= 0 || value.length <= maxChars) {
+    return value;
+  }
+  return `${value.slice(0, maxChars)}... [truncated ${value.length - maxChars} chars]`;
+}
+function isSensitiveKey(key, redaction) {
+  if (key == null || redaction == null) {
+    return false;
+  }
+  const normalized = key.toLowerCase();
+  return redaction.redactKeys.some((candidate) => candidate.toLowerCase() === normalized);
+}
+function sanitizeObjectEntries(entries, redaction) {
+  const output = {};
+  for (const [key, value] of entries) {
+    if (isSensitiveKey(key, redaction)) {
+      output[key] = "[REDACTED]";
+      continue;
+    }
+    if (key === "messages" && !redaction.includeBodies && Array.isArray(value)) {
+      output[key] = `[REDACTED_MESSAGES:${value.length}]`;
+      continue;
+    }
+    if ((key === "arguments" || key === "input") && !redaction.includeToolArguments) {
+      output[key] = "[REDACTED_TOOL_ARGUMENTS]";
+      continue;
+    }
+    output[key] = sanitizeForLogging(value, redaction, key);
+  }
+  return output;
+}
+function sanitizeForLogging(value, redaction, key) {
+  if (isSensitiveKey(key, redaction)) {
+    return "[REDACTED]";
+  }
+  if (typeof value === "string") {
+    if (!redaction.includeBodies && (key === "content" || key === "text" || key === "thinking")) {
+      return "[REDACTED_BODY]";
+    }
+    return truncateString(value, redaction.maxBodyChars);
+  }
+  if (typeof value === "number" || typeof value === "boolean" || value == null) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    if (!redaction.includeBodies && key === "messages") {
+      return `[REDACTED_MESSAGES:${value.length}]`;
+    }
+    return value.map((item) => sanitizeForLogging(item, redaction));
+  }
+  if (typeof value === "object") {
+    return sanitizeObjectEntries(Object.entries(value), redaction);
+  }
+  return String(value);
+}
+function formatSDKLog(event) {
+  const prefix = `[agent-sdk][${event.component}][${event.event}]`;
+  const details = [];
+  if (event.provider) details.push(`provider=${event.provider}`);
+  if (event.model) details.push(`model=${event.model}`);
+  if (event.sessionId) details.push(`sessionId=${event.sessionId}`);
+  if (event.iteration !== void 0) details.push(`iteration=${event.iteration}`);
+  if (event.statusCode !== void 0) details.push(`statusCode=${event.statusCode}`);
+  if (event.durationMs !== void 0) details.push(`durationMs=${event.durationMs}`);
+  if (event.toolName) details.push(`tool=${event.toolName}`);
+  if (event.requestId) details.push(`requestId=${event.requestId}`);
+  if (event.clientRequestId) details.push(`clientRequestId=${event.clientRequestId}`);
+  const suffix = details.length > 0 ? ` ${details.join(" ")}` : "";
+  return event.message ? `${prefix} ${event.message}${suffix}` : `${prefix}${suffix}`;
+}
+function consoleMethod(level) {
+  if (level === "error") return console.error.bind(console);
+  if (level === "warn") return console.warn.bind(console);
+  if (level === "info") return console.info.bind(console);
+  return console.debug.bind(console);
+}
+function createConsoleSDKLogger() {
+  const write = (level, event) => {
+    const line = formatSDKLog(event);
+    const logFn = consoleMethod(level);
+    if (event.metadata != null) {
+      logFn(line, event.metadata);
+    } else {
+      logFn(line);
+    }
+  };
+  return {
+    debug(event) {
+      write("debug", event);
+    },
+    info(event) {
+      write("info", event);
+    },
+    warn(event) {
+      write("warn", event);
+    },
+    error(event) {
+      write("error", event);
+    }
+  };
+}
+function emitSDKLog(args) {
+  if (!shouldEmitLog(args.logLevel, args.logger != null, args.level)) {
+    return;
+  }
+  const logger = args.logger ?? createConsoleSDKLogger();
+  const payload = {
+    source: "agent-sdk",
+    ...args.event
+  };
+  logger[args.level]?.(payload);
+}
+function extractProviderRequestId(headers) {
+  if (headers == null) {
+    return void 0;
+  }
+  return headers.get("x-request-id") ?? headers.get("request-id") ?? headers.get("x-amzn-requestid") ?? void 0;
+}
+
+// src/models/model-request-log.ts
+function countMessages(body) {
+  if (body == null || typeof body !== "object" || !("messages" in body)) {
+    return void 0;
+  }
+  const messages = body.messages;
+  return Array.isArray(messages) ? messages.length : void 0;
+}
+function countTools(body) {
+  if (body == null || typeof body !== "object" || !("tools" in body)) {
+    return void 0;
+  }
+  const tools = body.tools;
+  return Array.isArray(tools) ? tools.length : void 0;
+}
+function buildRequestMetadata(body, params) {
+  const redaction = resolveLogRedaction(params?.redaction);
+  const metadata = {};
+  const messageCount = countMessages(body);
+  const toolCount = countTools(body);
+  if (messageCount !== void 0) metadata.messageCount = messageCount;
+  if (toolCount !== void 0) metadata.toolCount = toolCount;
+  if (redaction.includeBodies) {
+    metadata.requestBody = sanitizeForLogging(body, redaction);
+  }
+  return metadata;
+}
+function logModelRequestStart(context, body, extraMetadata) {
+  const state = {
+    clientRequestId: crypto.randomUUID(),
+    startedAt: Date.now()
+  };
+  emitSDKLog({
+    logger: context.params?.logger,
+    logLevel: context.params?.logLevel,
+    level: "info",
+    event: {
+      component: "model",
+      event: "model.request.start",
+      message: `Starting ${context.operation} request`,
+      provider: context.provider,
+      model: context.model,
+      operation: context.operation,
+      sessionId: context.params?.sessionId,
+      iteration: context.iteration,
+      clientRequestId: state.clientRequestId,
+      metadata: {
+        path: context.path,
+        ...buildRequestMetadata(body, context.params),
+        ...extraMetadata
+      }
+    }
+  });
+  return state;
+}
+function logModelRequestEnd(context, state, response, extraMetadata) {
+  emitSDKLog({
+    logger: context.params?.logger,
+    logLevel: context.params?.logLevel,
+    level: response.ok ? "info" : "warn",
+    event: {
+      component: "model",
+      event: response.ok ? "model.request.end" : "model.request.error",
+      message: response.ok ? "Model request completed" : "Model request returned error response",
+      provider: context.provider,
+      model: context.model,
+      operation: context.operation,
+      sessionId: context.params?.sessionId,
+      iteration: context.iteration,
+      clientRequestId: state.clientRequestId,
+      requestId: extractProviderRequestId(response.headers),
+      statusCode: response.status,
+      durationMs: Date.now() - state.startedAt,
+      metadata: {
+        path: context.path,
+        ...extraMetadata
+      }
+    }
+  });
+}
+function logModelRequestFailure(context, state, error, extraMetadata) {
+  const err = error instanceof Error ? error : new Error(String(error));
+  emitSDKLog({
+    logger: context.params?.logger,
+    logLevel: context.params?.logLevel,
+    level: err.name === "AbortError" ? "info" : "error",
+    event: {
+      component: "model",
+      event: err.name === "AbortError" ? "model.request.aborted" : "model.request.error",
+      message: err.name === "AbortError" ? "Model request aborted" : "Model request failed",
+      provider: context.provider,
+      model: context.model,
+      operation: context.operation,
+      sessionId: context.params?.sessionId,
+      iteration: context.iteration,
+      clientRequestId: state.clientRequestId,
+      durationMs: Date.now() - state.startedAt,
+      errorName: err.name,
+      errorMessage: err.message,
+      metadata: {
+        path: context.path,
+        ...extraMetadata
+      }
+    }
+  });
+}
+function logModelStreamParseError(context, rawChunk, error) {
+  const err = error instanceof Error ? error : new Error(String(error));
+  const redaction = resolveLogRedaction(context.params?.redaction);
+  emitSDKLog({
+    logger: context.params?.logger,
+    logLevel: context.params?.logLevel,
+    level: "warn",
+    event: {
+      component: "streaming",
+      event: "model.stream.parse_error",
+      message: "Failed to parse provider stream chunk",
+      provider: context.provider,
+      model: context.model,
+      operation: context.operation,
+      sessionId: context.params?.sessionId,
+      iteration: context.iteration,
+      errorName: err.name,
+      errorMessage: err.message,
+      metadata: {
+        path: context.path,
+        rawChunk: sanitizeForLogging(rawChunk, redaction)
+      }
+    }
+  });
+}
+
+// src/models/openai.ts
+var OpenAIAdapter = class extends chunkOZO7D77N_cjs.BaseModelAdapter {
+  name;
+  apiKey;
+  baseUrl;
+  model;
+  organization;
+  constructor(config = {}) {
+    super();
+    this.apiKey = config.apiKey || process.env.OPENAI_API_KEY || "";
+    this.baseUrl = config.baseUrl || process.env.OPENAI_BASE_URL || "https://api.openai.com/v1";
+    this.model = config.model || "gpt-4o";
+    this.organization = config.organization || process.env.OPENAI_ORG_ID;
+    if (!this.apiKey) {
+      throw new Error("OpenAI API key is required. Set OPENAI_API_KEY environment variable or pass apiKey in config.");
+    }
+    this.name = `openai/${this.model}`;
+    this.capabilities = config.capabilities ?? DEFAULT_ADAPTER_CAPABILITIES;
+  }
+  async *stream(params) {
+    const body = this.buildRequestBody(params, true);
+    const response = await this.fetch("/chat/completions", body, "stream", params);
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`OpenAI API error: ${response.status} - ${error}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new Error("No response body");
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let currentToolCall = null;
+    try {
+      while (true) {
+        if (params.signal?.aborted) {
+          reader.cancel();
+          break;
+        }
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed === "data: [DONE]") continue;
+          if (!trimmed.startsWith("data: ")) continue;
+          try {
+            const data = JSON.parse(trimmed.slice(6));
+            const choice = data.choices?.[0];
+            if (!choice) continue;
+            const raw = params.includeRawStreamEvents ? { providerRaw: data } : {};
+            if (choice.delta?.content) {
+              yield { type: "text", content: choice.delta.content, ...raw };
+            }
+            if (choice.delta?.tool_calls) {
+              for (const toolCall of choice.delta.tool_calls) {
+                if (toolCall.index !== void 0) {
+                  if (toolCall.id && toolCall.function?.name) {
+                    if (currentToolCall) {
+                      yield {
+                        type: "tool_call",
+                        toolCall: {
+                          id: currentToolCall.id,
+                          name: currentToolCall.name,
+                          arguments: this.safeParseJSON(currentToolCall.arguments)
+                        },
+                        ...raw
+                      };
+                    }
+                    currentToolCall = {
+                      id: toolCall.id,
+                      name: toolCall.function.name,
+                      arguments: toolCall.function.arguments || ""
+                    };
+                    yield {
+                      type: "tool_call_start",
+                      content: toolCall.function.name,
+                      toolCallId: toolCall.id,
+                      ...raw
+                    };
+                  } else if (toolCall.function?.arguments && currentToolCall) {
+                    currentToolCall.arguments += toolCall.function.arguments;
+                    yield {
+                      type: "tool_call_delta",
+                      content: toolCall.function.arguments,
+                      toolCallId: currentToolCall.id,
+                      ...raw
+                    };
+                  }
+                }
+              }
+            }
+            if (choice.finish_reason === "tool_calls" && currentToolCall) {
+              yield {
+                type: "tool_call",
+                toolCall: {
+                  id: currentToolCall.id,
+                  name: currentToolCall.name,
+                  arguments: this.safeParseJSON(currentToolCall.arguments)
+                },
+                ...raw
+              };
+              currentToolCall = null;
+            }
+            if (data.usage) {
+              yield {
+                type: "metadata",
+                usagePhase: "output",
+                metadata: {
+                  usage: {
+                    promptTokens: data.usage.prompt_tokens,
+                    completionTokens: data.usage.completion_tokens,
+                    totalTokens: data.usage.total_tokens
+                  }
+                },
+                ...raw
+              };
+            }
+          } catch (error) {
+            logModelStreamParseError(
+              {
+                provider: "openai",
+                model: this.model,
+                path: "/chat/completions",
+                operation: "stream",
+                params
+              },
+              trimmed,
+              error
+            );
+          }
+        }
+      }
+      if (currentToolCall) {
+        yield {
+          type: "tool_call",
+          toolCall: {
+            id: currentToolCall.id,
+            name: currentToolCall.name,
+            arguments: this.safeParseJSON(currentToolCall.arguments)
+          },
+          ...params.includeRawStreamEvents ? { providerRaw: { trailing: true } } : {}
+        };
+      }
+      yield { type: "done" };
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  async complete(params) {
+    const body = this.buildRequestBody(params, false);
+    const response = await this.fetch("/chat/completions", body, "complete", params);
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`OpenAI API error: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
+    const choice = data.choices?.[0];
+    if (!choice) {
+      throw new Error("No completion choice returned");
+    }
+    const result = {
+      content: choice.message?.content || ""
+    };
+    if (choice.message?.tool_calls) {
+      result.toolCalls = choice.message.tool_calls.map((tc) => ({
+        id: tc.id,
+        name: tc.function.name,
+        arguments: this.safeParseJSON(tc.function.arguments)
+      }));
+    }
+    if (data.usage) {
+      result.usage = {
+        promptTokens: data.usage.prompt_tokens,
+        completionTokens: data.usage.completion_tokens,
+        totalTokens: data.usage.total_tokens
+      };
+    }
+    return result;
+  }
+  buildRequestBody(params, stream) {
+    const messages = this.transformMessages(params.messages);
+    const defaultMaxTokens = this.capabilities?.maxOutputTokens ?? DEFAULT_ADAPTER_CAPABILITIES.maxOutputTokens;
+    const body = {
+      model: this.model,
+      messages,
+      stream,
+      ...stream && { stream_options: { include_usage: true } },
+      ...params.temperature !== void 0 && { temperature: params.temperature },
+      max_tokens: params.maxTokens ?? defaultMaxTokens,
+      ...params.stopSequences && { stop: params.stopSequences }
+    };
+    if (params.tools && params.tools.length > 0) {
+      body.tools = chunkOZO7D77N_cjs.toolsToModelSchema(params.tools).map((tool) => ({
+        type: "function",
+        function: tool
+      }));
+    }
+    return body;
+  }
+  async fetch(path, body, operation, params) {
+    const requestLog = logModelRequestStart({
+      provider: "openai",
+      model: this.model,
+      path,
+      operation,
+      params
+    }, body);
+    const headers = {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${this.apiKey}`,
+      "X-Client-Request-Id": requestLog.clientRequestId
+    };
+    if (this.organization) {
+      headers["OpenAI-Organization"] = this.organization;
+    }
+    try {
+      const response = await globalThis.fetch(`${this.baseUrl}${path}`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        signal: params.signal
+      });
+      logModelRequestEnd(
+        {
+          provider: "openai",
+          model: this.model,
+          path,
+          operation,
+          params
+        },
+        requestLog,
+        response
+      );
+      return response;
+    } catch (error) {
+      logModelRequestFailure(
+        {
+          provider: "openai",
+          model: this.model,
+          path,
+          operation,
+          params
+        },
+        requestLog,
+        error
+      );
+      throw error;
+    }
+  }
+  safeParseJSON(str) {
+    try {
+      return JSON.parse(str);
+    } catch {
+      return str;
+    }
+  }
+};
+function createOpenAI(config) {
+  return new OpenAIAdapter(config);
+}
+
+// src/models/anthropic.ts
+var DEFAULT_FETCH_RETRY = {
+  maxAttempts: 2,
+  baseDelayMs: 200,
+  maxDelayMs: 2e3
+};
+function normalizeFetchRetry(options) {
+  if (options == null) {
+    return { ...DEFAULT_FETCH_RETRY };
+  }
+  const maxAttempts = Math.max(1, Math.floor(options.maxAttempts ?? DEFAULT_FETCH_RETRY.maxAttempts));
+  const baseDelayMs = Math.max(0, options.baseDelayMs ?? DEFAULT_FETCH_RETRY.baseDelayMs);
+  const maxDelayMs = Math.max(baseDelayMs, options.maxDelayMs ?? DEFAULT_FETCH_RETRY.maxDelayMs);
+  return { maxAttempts, baseDelayMs, maxDelayMs };
+}
+function isAbortError(e) {
+  if (e instanceof DOMException && e.name === "AbortError") {
+    return true;
+  }
+  return typeof e === "object" && e !== null && e.name === "AbortError";
+}
+function isRetriableFetchError(e) {
+  if (isAbortError(e)) {
+    return false;
+  }
+  if (e instanceof TypeError) {
+    return true;
+  }
+  const cause = typeof e === "object" && e !== null && "cause" in e ? e.cause : void 0;
+  const code = cause?.code;
+  return code === "ECONNRESET" || code === "ETIMEDOUT" || code === "EPIPE" || code === "UND_ERR_SOCKET";
+}
+function isRetriableHttpStatus(status) {
+  return status === 429 || status === 502 || status === 503 || status === 504;
+}
+function parseRetryAfterMs(header) {
+  if (header == null || header === "") {
+    return void 0;
+  }
+  const trimmed = header.trim();
+  const asNum = Number(trimmed);
+  if (Number.isFinite(asNum) && asNum >= 0) {
+    return asNum * 1e3;
+  }
+  const parsed = Date.parse(trimmed);
+  if (!Number.isNaN(parsed)) {
+    const delta = parsed - Date.now();
+    return delta > 0 ? delta : 0;
+  }
+  return void 0;
+}
+function computeBackoffMs(attemptIndex, baseDelayMs, maxDelayMs) {
+  const exp = Math.min(maxDelayMs, baseDelayMs * 2 ** attemptIndex);
+  const jitter = 0.5 + Math.random() * 0.5;
+  return Math.min(maxDelayMs, Math.floor(exp * jitter));
+}
+async function delay(ms, signal) {
+  if (ms <= 0) {
+    return;
+  }
+  await new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new DOMException("The operation was aborted.", "AbortError"));
+      return;
+    }
+    const id = setTimeout(() => {
+      if (signal) {
+        signal.removeEventListener("abort", onAbort);
+      }
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(id);
+      reject(new DOMException("The operation was aborted.", "AbortError"));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function drainResponseBody(response) {
+  try {
+    await response.arrayBuffer();
+  } catch {
+  }
+}
+var AnthropicAdapter = class extends chunkOZO7D77N_cjs.BaseModelAdapter {
+  name;
+  apiKey;
+  baseUrl;
+  model;
+  version;
+  requestMetadata;
+  fetchRetry;
+  constructor(config = {}) {
+    super();
+    this.apiKey = config.apiKey || process.env.ANTHROPIC_API_KEY || "";
+    this.baseUrl = config.baseUrl || process.env.ANTHROPIC_BASE_URL || "https://api.anthropic.com";
+    this.model = config.model || "claude-sonnet-4-20250514";
+    this.version = config.version || "2023-06-01";
+    this.requestMetadata = config.metadata;
+    this.fetchRetry = normalizeFetchRetry(config.fetchRetry);
+    if (!this.apiKey) {
+      throw new Error("Anthropic API key is required. Set ANTHROPIC_API_KEY environment variable or pass apiKey in config.");
+    }
+    this.name = `anthropic/${this.model}`;
+    this.capabilities = config.capabilities ?? DEFAULT_ADAPTER_CAPABILITIES;
+  }
+  async *stream(params) {
+    const body = this.buildRequestBody(params, true);
+    const response = await this.fetch("/v1/messages", body, "stream", params);
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Anthropic API error: ${response.status} - ${error}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new Error("No response body");
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let currentToolCall = null;
+    let currentThinkingBlock = null;
+    try {
+      while (true) {
+        if (params.signal?.aborted) {
+          reader.cancel();
+          break;
+        }
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || !trimmed.startsWith("data:")) continue;
+          let jsonStart = 5;
+          if (trimmed.length > 5 && trimmed[5] === " ") {
+            jsonStart = 6;
+          }
+          const jsonStr = trimmed.slice(jsonStart);
+          try {
+            const data = JSON.parse(jsonStr);
+            const raw = params.includeRawStreamEvents ? { providerRaw: data } : {};
+            switch (data.type) {
+              case "content_block_start":
+                if (data.content_block?.type === "tool_use") {
+                  currentToolCall = {
+                    id: data.content_block.id,
+                    name: data.content_block.name,
+                    input: ""
+                  };
+                  yield {
+                    type: "tool_call_start",
+                    toolCall: {
+                      id: data.content_block.id,
+                      name: data.content_block.name,
+                      arguments: {}
+                    },
+                    ...raw
+                  };
+                } else if (data.content_block?.type === "thinking") {
+                  currentThinkingBlock = {
+                    signature: data.content_block.signature
+                  };
+                  yield {
+                    type: "thinking",
+                    content: data.content_block.thinking,
+                    signature: currentThinkingBlock.signature,
+                    ...raw
+                  };
+                }
+                break;
+              case "content_block_delta":
+                if (data.delta?.type === "text_delta") {
+                  yield { type: "text", content: data.delta.text, ...raw };
+                } else if (data.delta?.type === "thinking_delta") {
+                  yield {
+                    type: "thinking",
+                    content: data.delta.thinking,
+                    signature: currentThinkingBlock?.signature,
+                    ...raw
+                  };
+                } else if (data.delta?.type === "input_json_delta" && currentToolCall) {
+                  currentToolCall.input += data.delta.partial_json;
+                  yield {
+                    type: "tool_call_delta",
+                    content: data.delta.partial_json,
+                    toolCallId: currentToolCall.id,
+                    ...raw
+                  };
+                }
+                break;
+              case "content_block_stop":
+                if (currentToolCall) {
+                  yield {
+                    type: "tool_call",
+                    toolCall: {
+                      id: currentToolCall.id,
+                      name: currentToolCall.name,
+                      arguments: this.safeParseJSON(currentToolCall.input)
+                    },
+                    ...raw
+                  };
+                  currentToolCall = null;
+                }
+                if (currentThinkingBlock) {
+                  yield { type: "thinking_block_end", ...raw };
+                  currentThinkingBlock = null;
+                }
+                break;
+              case "message_start":
+                if (data.message?.usage) {
+                  const usage = data.message.usage;
+                  const actualInputTokens = usage.input_tokens + (usage.cache_read_input_tokens || 0);
+                  yield {
+                    type: "metadata",
+                    usagePhase: "input",
+                    metadata: {
+                      usage: {
+                        promptTokens: actualInputTokens,
+                        completionTokens: 0,
+                        totalTokens: actualInputTokens,
+                        // 传递缓存信息
+                        cacheReadTokens: usage.cache_read_input_tokens || 0,
+                        cacheWriteTokens: usage.cache_creation_input_tokens || 0
+                      }
+                    },
+                    ...raw
+                  };
+                }
+                break;
+              case "message_delta":
+                if (data.usage) {
+                  yield {
+                    type: "metadata",
+                    usagePhase: "output",
+                    metadata: {
+                      usage: {
+                        promptTokens: 0,
+                        completionTokens: data.usage.output_tokens,
+                        totalTokens: data.usage.output_tokens
+                      }
+                    },
+                    ...raw
+                  };
+                }
+                break;
+            }
+          } catch (error) {
+            logModelStreamParseError(
+              {
+                provider: "anthropic",
+                model: this.model,
+                path: "/v1/messages",
+                operation: "stream",
+                params
+              },
+              jsonStr,
+              error
+            );
+          }
+        }
+      }
+      yield { type: "done" };
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  async complete(params) {
+    const body = this.buildRequestBody(params, false);
+    const response = await this.fetch("/v1/messages", body, "complete", params);
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Anthropic API error: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
+    const result = {
+      content: ""
+    };
+    const toolCalls = [];
+    for (const block of data.content || []) {
+      if (block.type === "text") {
+        result.content += block.text;
+      } else if (block.type === "tool_use") {
+        toolCalls.push({
+          id: block.id,
+          name: block.name,
+          arguments: block.input
+        });
+      }
+    }
+    if (toolCalls.length > 0) {
+      result.toolCalls = toolCalls;
+    }
+    if (data.usage) {
+      const usage = data.usage;
+      const actualInputTokens = usage.input_tokens + (usage.cache_read_input_tokens || 0);
+      result.usage = {
+        promptTokens: actualInputTokens,
+        completionTokens: usage.output_tokens,
+        totalTokens: actualInputTokens + usage.output_tokens
+      };
+    }
+    return result;
+  }
+  buildRequestBody(params, stream) {
+    const { system, messages } = this.extractSystemMessage(params.messages);
+    const transformedMessages = this.transformAnthropicMessages(messages);
+    const defaultMaxTokens = this.capabilities?.maxOutputTokens ?? DEFAULT_ADAPTER_CAPABILITIES.maxOutputTokens;
+    const body = {
+      model: this.model,
+      max_tokens: params.maxTokens ?? defaultMaxTokens,
+      messages: transformedMessages,
+      stream,
+      ...system && { system },
+      ...params.temperature !== void 0 && { temperature: params.temperature }
+    };
+    if (params.tools && params.tools.length > 0) {
+      body.tools = chunkOZO7D77N_cjs.toolsToModelSchema(params.tools).map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        input_schema: tool.parameters
+      }));
+    }
+    const mergedMetadata = this.mergeAnthropicMetadata(params);
+    if (mergedMetadata && Object.keys(mergedMetadata).length > 0) {
+      body.metadata = mergedMetadata;
+    }
+    return body;
+  }
+  /**
+   * Build Messages API `metadata`: `sessionId` → `user_id`, merged with resolved adapter `metadata` (dict or fn).
+   * Config `metadata` keys override `user_id` when duplicated.
+   */
+  mergeAnthropicMetadata(params) {
+    const extra = this.resolveMetadataExtra(params);
+    const hasSession = params.sessionId !== void 0 && params.sessionId !== "";
+    if (!hasSession && extra === void 0) {
+      return void 0;
+    }
+    const merged = {};
+    if (hasSession) {
+      merged.user_id = params.sessionId;
+    }
+    if (extra !== void 0) {
+      Object.assign(merged, extra);
+    }
+    return Object.keys(merged).length > 0 ? merged : void 0;
+  }
+  resolveMetadataExtra(params) {
+    const raw = this.requestMetadata;
+    if (raw == null) {
+      return void 0;
+    }
+    if (typeof raw === "function") {
+      const v = raw(params);
+      if (typeof v !== "object" || v === null || Array.isArray(v) || Object.keys(v).length === 0) {
+        return void 0;
+      }
+      return { ...v };
+    }
+    if (typeof raw === "object" && !Array.isArray(raw) && Object.keys(raw).length > 0) {
+      return { ...raw };
+    }
+    return void 0;
+  }
+  extractSystemMessage(messages) {
+    const systemMessages = messages.filter((m) => m.role === "system");
+    const otherMessages = messages.filter((m) => m.role !== "system");
+    const combinedSystem = systemMessages.length > 0 ? systemMessages.map((m) => m.content).join("\n\n") : void 0;
+    return {
+      system: combinedSystem,
+      messages: otherMessages
+    };
+  }
+  transformAnthropicMessages(messages) {
+    return messages.map((msg) => {
+      const transformed = {
+        role: msg.role === "assistant" ? "assistant" : "user",
+        content: []
+      };
+      if (typeof msg.content === "string") {
+        transformed.content = [{ type: "text", text: msg.content }];
+      } else if (Array.isArray(msg.content)) {
+        const contentParts = [];
+        for (const part of msg.content) {
+          if (part.type === "thinking") {
+            contentParts.push(part);
+          } else if (part.type === "text") {
+            contentParts.push({ type: "text", text: part.text });
+          } else {
+            contentParts.push(part);
+          }
+        }
+        transformed.content = contentParts;
+        if (contentParts.length === 0) {
+          transformed.content = "";
+        }
+      }
+      if (msg.toolCalls && msg.role === "assistant") {
+        for (const tc of msg.toolCalls) {
+          transformed.content.push({
+            type: "tool_use",
+            id: tc.id,
+            name: tc.name,
+            input: tc.arguments
+          });
+        }
+      }
+      if (msg.role === "tool" && msg.toolCallId) {
+        transformed.role = "user";
+        transformed.content = [{
+          type: "tool_result",
+          tool_use_id: msg.toolCallId,
+          content: msg.content
+        }];
+      }
+      return transformed;
+    });
+  }
+  /**
+   * 发起 POST；按 `fetchRetry` 对网络错误与 429/502/503/504 重试（不含响应体已开始消费后的 SSE 读失败）。
+   */
+  async fetch(path, body, operation, params) {
+    const requestLog = logModelRequestStart(
+      {
+        provider: "anthropic",
+        model: this.model,
+        path,
+        operation,
+        params
+      },
+      body,
+      { httpMaxAttempts: this.fetchRetry.maxAttempts }
+    );
+    const url = `${this.baseUrl}${path}`;
+    const init = {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.apiKey,
+        "anthropic-version": this.version
+      },
+      body: JSON.stringify(body),
+      signal: params.signal
+    };
+    for (let attempt = 0; attempt < this.fetchRetry.maxAttempts; attempt++) {
+      const httpAttemptMeta = {
+        httpAttempt: attempt + 1,
+        httpMaxAttempts: this.fetchRetry.maxAttempts
+      };
+      if (params.signal?.aborted) {
+        logModelRequestFailure(
+          {
+            provider: "anthropic",
+            model: this.model,
+            path,
+            operation,
+            params
+          },
+          requestLog,
+          new DOMException("The operation was aborted.", "AbortError"),
+          { httpMaxAttempts: this.fetchRetry.maxAttempts }
+        );
+        throw new DOMException("The operation was aborted.", "AbortError");
+      }
+      try {
+        const response = await globalThis.fetch(url, init);
+        if (response.ok) {
+          logModelRequestEnd(
+            {
+              provider: "anthropic",
+              model: this.model,
+              path,
+              operation,
+              params
+            },
+            requestLog,
+            response,
+            httpAttemptMeta
+          );
+          return response;
+        }
+        const canRetryHttp = attempt < this.fetchRetry.maxAttempts - 1 && isRetriableHttpStatus(response.status);
+        if (canRetryHttp) {
+          await drainResponseBody(response);
+          const fromHeader = parseRetryAfterMs(response.headers.get("Retry-After"));
+          const backoff = computeBackoffMs(attempt, this.fetchRetry.baseDelayMs, this.fetchRetry.maxDelayMs);
+          const waitMs = fromHeader != null ? Math.min(fromHeader, this.fetchRetry.maxDelayMs) : backoff;
+          await delay(waitMs, params.signal);
+          continue;
+        }
+        logModelRequestEnd(
+          {
+            provider: "anthropic",
+            model: this.model,
+            path,
+            operation,
+            params
+          },
+          requestLog,
+          response,
+          httpAttemptMeta
+        );
+        return response;
+      } catch (e) {
+        if (isAbortError(e) || params.signal?.aborted) {
+          logModelRequestFailure(
+            {
+              provider: "anthropic",
+              model: this.model,
+              path,
+              operation,
+              params
+            },
+            requestLog,
+            e,
+            httpAttemptMeta
+          );
+          throw e;
+        }
+        if (attempt < this.fetchRetry.maxAttempts - 1 && isRetriableFetchError(e)) {
+          const backoff = computeBackoffMs(attempt, this.fetchRetry.baseDelayMs, this.fetchRetry.maxDelayMs);
+          await delay(backoff, params.signal);
+          continue;
+        }
+        logModelRequestFailure(
+          {
+            provider: "anthropic",
+            model: this.model,
+            path,
+            operation,
+            params
+          },
+          requestLog,
+          e,
+          httpAttemptMeta
+        );
+        throw e;
+      }
+    }
+    throw new Error("Anthropic fetch: unexpected retry loop exit");
+  }
+  safeParseJSON(str) {
+    try {
+      return JSON.parse(str);
+    } catch {
+      return str;
+    }
+  }
+};
+function createAnthropic(config) {
+  return new AnthropicAdapter(config);
+}
+
+// src/models/ollama.ts
+function ollamaStreamChunksFromChatData(data, parseToolArguments, nextToolCallId) {
+  const chunks = [];
+  const msg = data.message;
+  if (!msg) return chunks;
+  const thinking = msg.thinking;
+  if (typeof thinking === "string" && thinking.length > 0) {
+    chunks.push({ type: "thinking", content: thinking });
+  }
+  const content = msg.content;
+  if (typeof content === "string" && content.length > 0) {
+    chunks.push({ type: "text", content });
+  }
+  const toolCalls = msg.tool_calls;
+  if (toolCalls && Array.isArray(toolCalls)) {
+    for (const tc of toolCalls) {
+      const t = tc;
+      const fn = t.function;
+      chunks.push({
+        type: "tool_call",
+        toolCall: {
+          id: nextToolCallId(),
+          name: (typeof fn?.name === "string" ? fn.name : "") || "",
+          arguments: parseToolArguments(fn?.arguments)
+        }
+      });
+    }
+  }
+  return chunks;
+}
+function ollamaMessageContentToApiString(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const texts = [];
+  for (const part of content) {
+    if (part.type === "text") {
+      texts.push(part.text);
+    }
+  }
+  return texts.join("\n\n");
+}
+function uniqueOllamaToolCallId(batchMs, index) {
+  return `ollama_${batchMs}_${index}_${Math.random().toString(36).slice(2, 11)}`;
+}
+var OllamaAdapter = class extends chunkOZO7D77N_cjs.BaseModelAdapter {
+  name;
+  baseUrl;
+  model;
+  think;
+  constructor(config = {}) {
+    super();
+    this.baseUrl = config.baseUrl || process.env.OLLAMA_BASE_URL || "http://localhost:11434";
+    this.model = config.model || "qwen3.5:0.8b";
+    this.think = config.think;
+    this.name = `ollama/${this.model}`;
+    this.capabilities = config.capabilities ?? DEFAULT_ADAPTER_CAPABILITIES;
+  }
+  async *stream(params) {
+    const body = this.buildRequestBody(params, true);
+    const response = await this.fetch("/api/chat", body, "stream", params);
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Ollama API error: ${response.status} - ${error}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new Error("No response body");
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const nextToolCallId = () => `ollama_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+    try {
+      while (true) {
+        if (params.signal?.aborted) {
+          reader.cancel();
+          break;
+        }
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          try {
+            const data = JSON.parse(trimmed);
+            const raw = params.includeRawStreamEvents ? { providerRaw: data } : {};
+            const messageChunks = ollamaStreamChunksFromChatData(
+              data,
+              (args) => this.parseToolArguments(args),
+              nextToolCallId
+            );
+            for (const chunk of messageChunks) {
+              yield { ...chunk, ...raw };
+            }
+            if (data.done) {
+              if (data.prompt_eval_count || data.eval_count) {
+                yield {
+                  type: "metadata",
+                  usagePhase: "output",
+                  metadata: {
+                    usage: {
+                      promptTokens: data.prompt_eval_count || 0,
+                      completionTokens: data.eval_count || 0,
+                      totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0)
+                    }
+                  },
+                  ...raw
+                };
+              }
+              yield { type: "done", ...raw };
+            }
+          } catch (error) {
+            logModelStreamParseError(
+              {
+                provider: "ollama",
+                model: this.model,
+                path: "/api/chat",
+                operation: "stream",
+                params
+              },
+              trimmed,
+              error
+            );
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  async complete(params) {
+    const body = this.buildRequestBody(params, false);
+    const response = await this.fetch("/api/chat", body, "complete", params);
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Ollama API error: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
+    const result = {
+      content: data.message?.content || ""
+    };
+    const thinking = data.message?.thinking;
+    if (typeof thinking === "string" && thinking.length > 0) {
+      result.thinking = thinking;
+    }
+    if (data.message?.tool_calls) {
+      const batchMs = Date.now();
+      result.toolCalls = data.message.tool_calls.map((tc, index) => ({
+        id: uniqueOllamaToolCallId(batchMs, index),
+        name: tc.function?.name || "",
+        arguments: this.parseToolArguments(tc.function?.arguments)
+      }));
+    }
+    if (data.prompt_eval_count || data.eval_count) {
+      result.usage = {
+        promptTokens: data.prompt_eval_count || 0,
+        completionTokens: data.eval_count || 0,
+        totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0)
+      };
+    }
+    return result;
+  }
+  parseToolArguments(args) {
+    if (args == null) return {};
+    if (typeof args === "object" && !Array.isArray(args)) return args;
+    if (typeof args === "string") {
+      try {
+        const parsed = JSON.parse(args);
+        return typeof parsed === "object" && parsed !== null ? parsed : { value: parsed };
+      } catch {
+        return {};
+      }
+    }
+    return {};
+  }
+  /**
+   * Ollama 要求 tool_calls.function.arguments 为对象，而非 JSON 字符串。
+   * 工具结果消息使用 tool_name（见 https://docs.ollama.com/capabilities/tool-calling ），非 OpenAI 的 tool_call_id。
+   */
+  transformMessages(messages) {
+    const toolCallIdToName = /* @__PURE__ */ new Map();
+    for (const msg of messages) {
+      if (msg.role === "assistant" && msg.toolCalls) {
+        for (const tc of msg.toolCalls) {
+          toolCallIdToName.set(tc.id, tc.name);
+        }
+      }
+    }
+    return messages.map((msg) => {
+      if (msg.role === "tool" && msg.toolCallId) {
+        const toolName = toolCallIdToName.get(msg.toolCallId) ?? msg.name;
+        return {
+          role: "tool",
+          content: ollamaMessageContentToApiString(msg.content),
+          ...toolName && { tool_name: toolName }
+        };
+      }
+      return {
+        role: msg.role,
+        content: ollamaMessageContentToApiString(msg.content),
+        ...msg.toolCalls && { tool_calls: msg.toolCalls.map((tc) => ({
+          id: tc.id,
+          type: "function",
+          function: {
+            name: tc.name,
+            arguments: this.parseToolArguments(tc.arguments)
+          }
+        })) }
+      };
+    });
+  }
+  buildRequestBody(params, stream) {
+    const defaultMaxTokens = this.capabilities?.maxOutputTokens ?? DEFAULT_ADAPTER_CAPABILITIES.maxOutputTokens;
+    const options = {
+      num_predict: params.maxTokens ?? defaultMaxTokens
+    };
+    if (params.temperature !== void 0) {
+      options.temperature = params.temperature;
+    }
+    const body = {
+      model: this.model,
+      messages: this.transformMessages(params.messages),
+      stream,
+      options
+    };
+    if (this.think !== void 0) {
+      body.think = this.think;
+    }
+    if (params.tools && params.tools.length > 0) {
+      body.tools = chunkOZO7D77N_cjs.toolsToModelSchema(params.tools).map((tool) => ({
+        type: "function",
+        function: tool
+      }));
+    }
+    return body;
+  }
+  async fetch(path, body, operation, params) {
+    const requestLog = logModelRequestStart({
+      provider: "ollama",
+      model: this.model,
+      path,
+      operation,
+      params
+    }, body);
+    try {
+      const response = await globalThis.fetch(`${this.baseUrl}${path}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body),
+        signal: params.signal
+      });
+      logModelRequestEnd(
+        {
+          provider: "ollama",
+          model: this.model,
+          path,
+          operation,
+          params
+        },
+        requestLog,
+        response
+      );
+      return response;
+    } catch (error) {
+      logModelRequestFailure(
+        {
+          provider: "ollama",
+          model: this.model,
+          path,
+          operation,
+          params
+        },
+        requestLog,
+        error
+      );
+      throw error;
+    }
+  }
+};
+function createOllama(config) {
+  return new OllamaAdapter(config);
+}
+
+// src/core/process-env-merge.ts
+function mergeProcessEnv(overrides) {
+  const base = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (typeof value === "string") {
+      base[key] = value;
+    }
+  }
+  return overrides ? { ...base, ...overrides } : base;
+}
+function mergeMcpStdioEnv(agentEnv, serverEnv) {
+  const merged = mergeProcessEnv(agentEnv);
+  return serverEnv ? { ...merged, ...serverEnv } : merged;
+}
+
+// src/models/index.ts
+function createModel(modelConfig, agentEnv) {
+  const merged = mergeProcessEnv(agentEnv);
+  switch (modelConfig.provider) {
+    case "openai":
+      return new OpenAIAdapter({
+        apiKey: modelConfig.apiKey || merged.OPENAI_API_KEY || "",
+        baseUrl: modelConfig.baseUrl || merged.OPENAI_BASE_URL,
+        model: modelConfig.model,
+        organization: merged.OPENAI_ORG_ID
+      });
+    case "anthropic":
+      return new AnthropicAdapter({
+        apiKey: modelConfig.apiKey || merged.ANTHROPIC_API_KEY || "",
+        baseUrl: modelConfig.baseUrl || merged.ANTHROPIC_BASE_URL,
+        model: modelConfig.model
+      });
+    case "ollama":
+      return new OllamaAdapter({
+        baseUrl: modelConfig.baseUrl || merged.OLLAMA_BASE_URL,
+        model: modelConfig.model,
+        think: modelConfig.think
+      });
+  }
+  throw new Error(`Unknown model provider: ${modelConfig.provider}`);
+}
+
+exports.AnthropicAdapter = AnthropicAdapter;
+exports.DEFAULT_ADAPTER_CAPABILITIES = DEFAULT_ADAPTER_CAPABILITIES;
+exports.OllamaAdapter = OllamaAdapter;
+exports.OpenAIAdapter = OpenAIAdapter;
+exports.createAnthropic = createAnthropic;
+exports.createConsoleSDKLogger = createConsoleSDKLogger;
+exports.createModel = createModel;
+exports.createOllama = createOllama;
+exports.createOpenAI = createOpenAI;
+exports.emitSDKLog = emitSDKLog;
+exports.formatSDKLog = formatSDKLog;
+exports.mergeMcpStdioEnv = mergeMcpStdioEnv;
+exports.mergeProcessEnv = mergeProcessEnv;
+exports.ollamaMessageContentToApiString = ollamaMessageContentToApiString;
+exports.ollamaStreamChunksFromChatData = ollamaStreamChunksFromChatData;
+//# sourceMappingURL=chunk-NYZD3THB.cjs.map
+//# sourceMappingURL=chunk-NYZD3THB.cjs.map