@ddlqhd/agent-sdk 0.1.0 → 0.2.0

package/dist/{chunk-NDSL7NPN.js → chunk-D3UZNLZO.js}

@@ -1,14 +1,358 @@
 #!/usr/bin/env node
-import { BaseModelAdapter, toolsToModelSchema } from './chunk-WH3APNQ5.js';
+import { BaseModelAdapter, toolsToModelSchema } from './chunk-LOYIGOBZ.js';
+import { randomUUID } from 'crypto';
 
-// src/models/openai.ts
-var OPENAI_CAPABILITIES = {
-  "gpt-4o": { contextLength: 128e3, maxOutputTokens: 16384 },
-  "gpt-4o-mini": { contextLength: 128e3, maxOutputTokens: 16384 },
-  "gpt-4-turbo": { contextLength: 128e3, maxOutputTokens: 4096 },
-  "gpt-4": { contextLength: 8192, maxOutputTokens: 4096 },
-  "gpt-3.5-turbo": { contextLength: 16385, maxOutputTokens: 4096 }
+// 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: 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 BaseModelAdapter {
   name;
   apiKey;
@@ -25,11 +369,11 @@ var OpenAIAdapter = class extends BaseModelAdapter {
       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 ?? OPENAI_CAPABILITIES[this.model] ?? { contextLength: 128e3, maxOutputTokens: 4096 };
+    this.capabilities = config.capabilities ?? DEFAULT_ADAPTER_CAPABILITIES;
   }
   async *stream(params) {
     const body = this.buildRequestBody(params, true);
-    const response = await this.fetch("/chat/completions", body, params.signal);
+    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}`);
@@ -128,7 +472,18 @@ var OpenAIAdapter = class extends BaseModelAdapter {
                 ...raw
               };
             }
-          } catch {
+          } catch (error) {
+            logModelStreamParseError(
+              {
+                provider: "openai",
+                model: this.model,
+                path: "/chat/completions",
+                operation: "stream",
+                params
+              },
+              trimmed,
+              error
+            );
           }
         }
       }
@@ -150,7 +505,7 @@ var OpenAIAdapter = class extends BaseModelAdapter {
   }
   async complete(params) {
     const body = this.buildRequestBody(params, false);
-    const response = await this.fetch("/chat/completions", body);
+    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}`);
@@ -181,13 +536,14 @@ var OpenAIAdapter = class extends BaseModelAdapter {
   }
   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 },
-      ...params.maxTokens !== void 0 && { max_tokens: params.maxTokens },
+      max_tokens: params.maxTokens ?? defaultMaxTokens,
       ...params.stopSequences && { stop: params.stopSequences }
     };
     if (params.tools && params.tools.length > 0) {
@@ -198,20 +554,55 @@ var OpenAIAdapter = class extends BaseModelAdapter {
     }
     return body;
   }
-  async fetch(path, body, signal) {
+  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}`
+      "Authorization": `Bearer ${this.apiKey}`,
+      "X-Client-Request-Id": requestLog.clientRequestId
     };
     if (this.organization) {
       headers["OpenAI-Organization"] = this.organization;
     }
-    return globalThis.fetch(`${this.baseUrl}${path}`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(body),
-      signal
-    });
+    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 {
@@ -226,33 +617,114 @@ function createOpenAI(config) {
 }
 
 // src/models/anthropic.ts
-var ANTHROPIC_CAPABILITIES = {
-  "claude-sonnet-4-20250514": { contextLength: 2e5, maxOutputTokens: 16384 },
-  "claude-haiku": { contextLength: 2e5, maxOutputTokens: 8192 },
-  "claude-3-5-sonnet-20241022": { contextLength: 2e5, maxOutputTokens: 8192 },
-  "claude-3-haiku-20240307": { contextLength: 2e5, maxOutputTokens: 4096 }
+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 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 ?? ANTHROPIC_CAPABILITIES[this.model] ?? { contextLength: 2e5, maxOutputTokens: 4096 };
+    this.capabilities = config.capabilities ?? DEFAULT_ADAPTER_CAPABILITIES;
   }
   async *stream(params) {
     const body = this.buildRequestBody(params, true);
-    const response = await this.fetch("/v1/messages", body, params.signal);
+    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}`);
@@ -350,6 +822,7 @@ var AnthropicAdapter = class extends BaseModelAdapter {
                   currentToolCall = null;
                 }
                 if (currentThinkingBlock) {
+                  yield { type: "thinking_block_end", ...raw };
                   currentThinkingBlock = null;
                 }
                 break;
@@ -391,7 +864,18 @@ var AnthropicAdapter = class extends BaseModelAdapter {
                 }
                 break;
             }
-          } catch {
+          } catch (error) {
+            logModelStreamParseError(
+              {
+                provider: "anthropic",
+                model: this.model,
+                path: "/v1/messages",
+                operation: "stream",
+                params
+              },
+              jsonStr,
+              error
+            );
           }
         }
       }
@@ -402,7 +886,7 @@ var AnthropicAdapter = class extends BaseModelAdapter {
   }
   async complete(params) {
     const body = this.buildRequestBody(params, false);
-    const response = await this.fetch("/v1/messages", body);
+    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}`);
@@ -440,9 +924,10 @@ var AnthropicAdapter = class extends BaseModelAdapter {
   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 || 4096,
+      max_tokens: params.maxTokens ?? defaultMaxTokens,
       messages: transformedMessages,
       stream,
       ...system && { system },
@@ -455,8 +940,48 @@ var AnthropicAdapter = class extends BaseModelAdapter {
         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");
@@ -511,8 +1036,23 @@ var AnthropicAdapter = class extends BaseModelAdapter {
       return transformed;
     });
   }
-  async fetch(path, body, signal) {
-    return globalThis.fetch(`${this.baseUrl}${path}`, {
+  /**
+   * 发起 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",
@@ -520,8 +1060,104 @@ var AnthropicAdapter = class extends BaseModelAdapter {
         "anthropic-version": this.version
       },
       body: JSON.stringify(body),
-      signal
-    });
+      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 {
@@ -536,12 +1172,6 @@ function createAnthropic(config) {
 }
 
 // src/models/ollama.ts
-var OLLAMA_CAPABILITIES = {
-  "qwen3.5:0.8b": { contextLength: 32768, maxOutputTokens: 4096 },
-  "minimax-m2.7:cloud": { contextLength: 128e3, maxOutputTokens: 16384 },
-  "nemotron-3-super:cloud": { contextLength: 128e3, maxOutputTokens: 16384 },
-  "glm-5:cloud": { contextLength: 128e3, maxOutputTokens: 16384 }
-};
 function ollamaStreamChunksFromChatData(data, parseToolArguments, nextToolCallId) {
   const chunks = [];
   const msg = data.message;
@@ -596,11 +1226,11 @@ var OllamaAdapter = class extends BaseModelAdapter {
     this.model = config.model || "qwen3.5:0.8b";
     this.think = config.think;
     this.name = `ollama/${this.model}`;
-    this.capabilities = config.capabilities ?? OLLAMA_CAPABILITIES[this.model] ?? { contextLength: 4096, maxOutputTokens: 2048 };
+    this.capabilities = config.capabilities ?? DEFAULT_ADAPTER_CAPABILITIES;
   }
   async *stream(params) {
     const body = this.buildRequestBody(params, true);
-    const response = await this.fetch("/api/chat", body, params.signal);
+    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}`);
@@ -654,7 +1284,18 @@ var OllamaAdapter = class extends BaseModelAdapter {
               }
               yield { type: "done", ...raw };
             }
-          } catch {
+          } catch (error) {
+            logModelStreamParseError(
+              {
+                provider: "ollama",
+                model: this.model,
+                path: "/api/chat",
+                operation: "stream",
+                params
+              },
+              trimmed,
+              error
+            );
           }
         }
       }
@@ -664,7 +1305,7 @@ var OllamaAdapter = class extends BaseModelAdapter {
   }
   async complete(params) {
     const body = this.buildRequestBody(params, false);
-    const response = await this.fetch("/api/chat", body);
+    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}`);
@@ -744,11 +1385,18 @@ var OllamaAdapter = class extends BaseModelAdapter {
     });
   }
   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,
-      ...params.temperature !== void 0 && { options: { temperature: params.temperature } }
+      options
     };
     if (this.think !== void 0) {
       body.think = this.think;
@@ -761,47 +1409,97 @@ var OllamaAdapter = class extends BaseModelAdapter {
     }
     return body;
   }
-  async fetch(path, body, signal) {
-    return globalThis.fetch(`${this.baseUrl}${path}`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(body),
-      signal
-    });
+  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(config) {
-  switch (config.provider) {
+function createModel(modelConfig, agentEnv) {
+  const merged = mergeProcessEnv(agentEnv);
+  switch (modelConfig.provider) {
     case "openai":
       return new OpenAIAdapter({
-        apiKey: config.apiKey,
-        baseUrl: config.baseUrl,
-        model: config.model
+        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: config.apiKey,
-        baseUrl: config.baseUrl,
-        model: config.model
+        apiKey: modelConfig.apiKey || merged.ANTHROPIC_API_KEY || "",
+        baseUrl: modelConfig.baseUrl || merged.ANTHROPIC_BASE_URL,
+        model: modelConfig.model
       });
     case "ollama":
       return new OllamaAdapter({
-        baseUrl: config.baseUrl,
-        model: config.model,
-        think: config.think
+        baseUrl: modelConfig.baseUrl || merged.OLLAMA_BASE_URL,
+        model: modelConfig.model,
+        think: modelConfig.think
       });
-    default:
-      throw new Error(`Unknown model provider: ${config.provider}`);
   }
+  throw new Error(`Unknown model provider: ${modelConfig.provider}`);
 }
 
-export { AnthropicAdapter, OllamaAdapter, OpenAIAdapter, createAnthropic, createModel, createOllama, createOpenAI, ollamaMessageContentToApiString, ollamaStreamChunksFromChatData };
-//# sourceMappingURL=chunk-NDSL7NPN.js.map
-//# sourceMappingURL=chunk-NDSL7NPN.js.map
+export { AnthropicAdapter, DEFAULT_ADAPTER_CAPABILITIES, OllamaAdapter, OpenAIAdapter, createAnthropic, createConsoleSDKLogger, createModel, createOllama, createOpenAI, emitSDKLog, formatSDKLog, mergeMcpStdioEnv, mergeProcessEnv, ollamaMessageContentToApiString, ollamaStreamChunksFromChatData };
+//# sourceMappingURL=chunk-D3UZNLZO.js.map
+//# sourceMappingURL=chunk-D3UZNLZO.js.map