ai-sdk-provider-claude-code 3.4.4 → 3.5.0

package/dist/index.cjs

@@ -20,17 +20,34 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AbortError: () => import_claude_agent_sdk3.AbortError,
   ClaudeCodeLanguageModel: () => ClaudeCodeLanguageModel,
+  HOOK_EVENTS: () => import_claude_agent_sdk3.HOOK_EVENTS,
+  InMemorySessionStore: () => import_claude_agent_sdk3.InMemorySessionStore,
+  SYSTEM_PROMPT_DYNAMIC_BOUNDARY: () => import_claude_agent_sdk3.SYSTEM_PROMPT_DYNAMIC_BOUNDARY,
   claudeCode: () => claudeCode,
   createAPICallError: () => createAPICallError,
+  createAiSdkMcpServer: () => createAiSdkMcpServer,
   createAuthenticationError: () => createAuthenticationError,
   createClaudeCode: () => createClaudeCode,
   createCustomMcpServer: () => createCustomMcpServer,
   createSdkMcpServer: () => import_claude_agent_sdk3.createSdkMcpServer,
   createTimeoutError: () => createTimeoutError,
+  deleteSession: () => import_claude_agent_sdk4.deleteSession,
+  foldSessionSummary: () => import_claude_agent_sdk4.foldSessionSummary,
+  forkSession: () => import_claude_agent_sdk4.forkSession,
   getErrorMetadata: () => getErrorMetadata,
+  getSessionInfo: () => import_claude_agent_sdk4.getSessionInfo,
+  getSessionMessages: () => import_claude_agent_sdk4.getSessionMessages,
+  getSubagentMessages: () => import_claude_agent_sdk4.getSubagentMessages,
+  importSessionToStore: () => import_claude_agent_sdk4.importSessionToStore,
   isAuthenticationError: () => isAuthenticationError,
   isTimeoutError: () => isTimeoutError,
+  listSessions: () => import_claude_agent_sdk4.listSessions,
+  listSubagents: () => import_claude_agent_sdk4.listSubagents,
+  renameSession: () => import_claude_agent_sdk4.renameSession,
+  startup: () => import_claude_agent_sdk5.startup,
+  tagSession: () => import_claude_agent_sdk4.tagSession,
   tool: () => import_claude_agent_sdk3.tool
 });
 module.exports = __toCommonJS(index_exports);
@@ -45,6 +62,23 @@ var import_provider_utils = require("@ai-sdk/provider-utils");
 // src/convert-to-claude-code-messages.ts
 var IMAGE_URL_WARNING = "Image URLs are not supported by this provider; supply base64/data URLs.";
 var IMAGE_CONVERSION_WARNING = "Unable to convert image content; supply base64/data URLs.";
+var MAX_TOOL_CALL_INPUT_LENGTH = 1e3;
+function serializeToolCallInput(input) {
+  let serialized;
+  if (input === void 0) {
+    serialized = "";
+  } else {
+    try {
+      serialized = JSON.stringify(input) ?? String(input);
+    } catch {
+      serialized = String(input);
+    }
+  }
+  if (serialized.length > MAX_TOOL_CALL_INPUT_LENGTH) {
+    return `${serialized.slice(0, MAX_TOOL_CALL_INPUT_LENGTH)}...[truncated]`;
+  }
+  return serialized;
+}
 function normalizeBase64(base64) {
   return base64.replace(/\s+/g, "");
 }
@@ -227,8 +261,9 @@ function convertToClaudeCodeMessages(prompt) {
           }
           const toolCalls = message.content.filter((part) => part.type === "tool-call");
           if (toolCalls.length > 0) {
-            assistantContent += `
-[Tool calls made]`;
+            const serializedCalls = toolCalls.map((call) => `[Tool call: ${call.toolName}(${serializeToolCallInput(call.input)})]`).join("\n");
+            assistantContent += assistantContent ? `
+${serializedCalls}` : serializedCalls;
           }
         }
         const formattedAssistant = `Assistant: ${assistantContent}`;
@@ -437,6 +472,9 @@ function mapClaudeCodeFinishReason(subtype, stopReason) {
 // src/validation.ts
 var import_zod = require("zod");
 var import_fs = require("fs");
+function isBlankResume(value) {
+  return typeof value === "string" && value.trim() === "";
+}
 var loggerFunctionSchema = import_zod.z.object({
   debug: import_zod.z.any().refine((val) => typeof val === "function", {
     message: "debug must be a function"
@@ -457,23 +495,29 @@ var claudeCodeSettingsSchema = import_zod.z.object({
   appendSystemPrompt: import_zod.z.string().optional(),
   systemPrompt: import_zod.z.union([
     import_zod.z.string(),
+    import_zod.z.array(import_zod.z.string()),
     import_zod.z.object({
       type: import_zod.z.literal("preset"),
       preset: import_zod.z.literal("claude_code"),
-      append: import_zod.z.string().optional()
+      append: import_zod.z.string().optional(),
+      excludeDynamicSections: import_zod.z.boolean().optional()
     })
   ]).optional(),
   maxTurns: import_zod.z.number().int().min(1).max(100).optional(),
   maxThinkingTokens: import_zod.z.number().int().positive().max(1e5).optional(),
   thinking: import_zod.z.union([
-    import_zod.z.object({ type: import_zod.z.literal("adaptive") }).strict(),
+    import_zod.z.object({
+      type: import_zod.z.literal("adaptive"),
+      display: import_zod.z.enum(["summarized", "omitted"]).optional()
+    }).strict(),
     import_zod.z.object({
       type: import_zod.z.literal("enabled"),
-      budgetTokens: import_zod.z.number().int().positive().optional()
+      budgetTokens: import_zod.z.number().int().positive().optional(),
+      display: import_zod.z.enum(["summarized", "omitted"]).optional()
     }).strict(),
     import_zod.z.object({ type: import_zod.z.literal("disabled") }).strict()
   ]).optional(),
-  effort: import_zod.z.enum(["low", "medium", "high", "max"]).optional(),
+  effort: import_zod.z.enum(["low", "medium", "high", "xhigh", "max"]).optional(),
   promptSuggestions: import_zod.z.boolean().optional(),
   cwd: import_zod.z.string().refine(
     (val) => {
@@ -486,11 +530,19 @@ var claudeCodeSettingsSchema = import_zod.z.object({
   ).optional(),
   executable: import_zod.z.enum(["bun", "deno", "node"]).optional(),
   executableArgs: import_zod.z.array(import_zod.z.string()).optional(),
-  permissionMode: import_zod.z.enum(["default", "acceptEdits", "bypassPermissions", "plan", "delegate", "dontAsk"]).optional(),
+  // Mirrors the SDK 0.3.x PermissionMode union ('auto' and 'dontAsk' were
+  // added in 0.3.x; 'delegate' was dropped AND is rejected by the CLI's
+  // --permission-mode flag parser, so it is rejected here too).
+  permissionMode: import_zod.z.enum(["default", "acceptEdits", "bypassPermissions", "plan", "dontAsk", "auto"]).optional(),
   permissionPromptToolName: import_zod.z.string().optional(),
   continue: import_zod.z.boolean().optional(),
   resume: import_zod.z.string().optional(),
-  sessionId: import_zod.z.string().optional(),
+  // The CLI rejects --session-id values that are not valid UUIDs, so
+  // enforce the UUID shape here instead of failing at query time.
+  sessionId: import_zod.z.string().refine(
+    (val) => /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(val),
+    { message: "sessionId must be a valid UUID (the CLI rejects non-UUID session IDs)" }
+  ).optional(),
   allowedTools: import_zod.z.array(import_zod.z.string()).optional(),
   disallowedTools: import_zod.z.array(import_zod.z.string()).optional(),
   betas: import_zod.z.array(import_zod.z.string()).optional(),
@@ -499,7 +551,9 @@ var claudeCodeSettingsSchema = import_zod.z.object({
   maxBudgetUsd: import_zod.z.number().min(0).optional(),
   plugins: import_zod.z.array(
     import_zod.z.object({
-      type: import_zod.z.string(),
+      // SDK SdkPluginConfig: only 'local' is supported; the SDK throws
+      // 'Unsupported plugin type' at query time for anything else.
+      type: import_zod.z.literal("local"),
       path: import_zod.z.string()
     }).passthrough()
   ).optional(),
@@ -514,12 +568,41 @@ var claudeCodeSettingsSchema = import_zod.z.object({
       preset: import_zod.z.literal("claude_code")
     })
   ]).optional(),
+  skills: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.literal("all")]).optional(),
+  settings: import_zod.z.union([
+    import_zod.z.string(),
+    import_zod.z.record(import_zod.z.string(), import_zod.z.any())
+    // inline Settings object
+  ]).optional(),
+  managedSettings: import_zod.z.record(import_zod.z.string(), import_zod.z.any()).optional(),
+  toolAliases: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional(),
+  toolConfig: import_zod.z.object({
+    askUserQuestion: import_zod.z.object({
+      previewFormat: import_zod.z.enum(["markdown", "html"]).optional()
+    }).passthrough().optional()
+  }).passthrough().optional(),
+  planModeInstructions: import_zod.z.string().optional(),
+  title: import_zod.z.string().optional(),
+  forwardSubagentText: import_zod.z.boolean().optional(),
+  agentProgressSummaries: import_zod.z.boolean().optional(),
+  includeHookEvents: import_zod.z.boolean().optional(),
+  taskBudget: import_zod.z.object({ total: import_zod.z.number().positive() }).strict().optional(),
+  sessionStore: import_zod.z.any().refine(
+    (val) => val === void 0 || typeof val === "object" && val !== null && typeof val.append === "function" && typeof val.load === "function",
+    { message: "sessionStore must be an object with append() and load() functions" }
+  ).optional(),
+  sessionStoreFlush: import_zod.z.enum(["batched", "eager"]).optional(),
+  loadTimeoutMs: import_zod.z.number().int().positive().optional(),
   settingSources: import_zod.z.array(import_zod.z.enum(["user", "project", "local"])).optional(),
   streamingInput: import_zod.z.enum(["auto", "always", "off"]).optional(),
   // Hooks and tool-permission callback (permissive validation of shapes)
   canUseTool: import_zod.z.any().refine((v) => v === void 0 || typeof v === "function", {
     message: "canUseTool must be a function"
   }).optional(),
+  onUserDialog: import_zod.z.any().refine((v) => v === void 0 || typeof v === "function", {
+    message: "onUserDialog must be a function"
+  }).optional(),
+  supportedDialogKinds: import_zod.z.array(import_zod.z.string()).optional(),
   hooks: import_zod.z.record(
     import_zod.z.string(),
     import_zod.z.array(
@@ -572,7 +655,8 @@ var claudeCodeSettingsSchema = import_zod.z.object({
       tools: import_zod.z.array(import_zod.z.string()).optional(),
       disallowedTools: import_zod.z.array(import_zod.z.string()).optional(),
       prompt: import_zod.z.string(),
-      model: import_zod.z.enum(["sonnet", "opus", "haiku", "inherit"]).optional(),
+      // SDK 0.3.x AgentDefinition accepts any model alias or full model ID
+      model: import_zod.z.string().optional(),
       mcpServers: import_zod.z.array(
         import_zod.z.union([
           import_zod.z.string(),
@@ -603,10 +687,14 @@ var claudeCodeSettingsSchema = import_zod.z.object({
   }).optional(),
   onStreamStart: import_zod.z.any().refine((val) => val === void 0 || typeof val === "function", {
     message: "onStreamStart must be a function"
+  }).optional(),
+  // Callback invoked with the predicted next user prompt (active unless promptSuggestions: false)
+  onPromptSuggestion: import_zod.z.any().refine((val) => val === void 0 || typeof val === "function", {
+    message: "onPromptSuggestion must be a function"
   }).optional()
 }).strict();
 function validateModelId(modelId) {
-  const knownModels = ["opus", "sonnet", "haiku"];
+  const knownModels = ["opus", "sonnet", "haiku", "fable"];
   if (!modelId || modelId.trim() === "") {
     throw new Error("Model ID cannot be empty");
   }
@@ -630,6 +718,51 @@ function validateSettings(settings) {
       return { valid: false, warnings, errors };
     }
     const validSettings = result.data;
+    const sdkOptionsRecord = validSettings.sdkOptions;
+    const effective = (key) => {
+      const override = sdkOptionsRecord?.[key];
+      return override !== void 0 ? override : validSettings[key];
+    };
+    const effSessionStore = effective("sessionStore");
+    const effectiveResumeId = () => {
+      for (const candidate of [sdkOptionsRecord?.resume, validSettings.resume]) {
+        if (typeof candidate === "string" && !isBlankResume(candidate)) {
+          return candidate;
+        }
+      }
+      return void 0;
+    };
+    if (effSessionStore !== void 0 && effective("persistSession") === false) {
+      errors.push(
+        "sessionStore cannot be combined with persistSession: false. Transcript mirroring requires local session writes; remove persistSession: false or drop sessionStore."
+      );
+      return { valid: false, warnings, errors };
+    }
+    if (effSessionStore !== void 0 && effective("enableFileCheckpointing") === true) {
+      errors.push(
+        "sessionStore cannot be combined with enableFileCheckpointing: true. Checkpoint backup blobs are not mirrored to the store (rewindFiles() fails after a store-backed resume); remove enableFileCheckpointing or drop sessionStore."
+      );
+      return { valid: false, warnings, errors };
+    }
+    if (effective("continue") === true && effSessionStore !== void 0 && effectiveResumeId() === void 0 && typeof effSessionStore.listSessions !== "function") {
+      errors.push(
+        "continue: true with sessionStore requires the store to implement listSessions() (used to discover the most recent session). Implement listSessions(), pass resume with an explicit session ID, or drop continue."
+      );
+      return { valid: false, warnings, errors };
+    }
+    const effSettingsOption = effective("settings");
+    if (effective("sandbox") !== void 0 && typeof effSettingsOption === "string" && !(effSettingsOption.trim().startsWith("{") && effSettingsOption.trim().endsWith("}"))) {
+      errors.push(
+        "sandbox cannot be combined with a settings file path. Pass settings as an inline Settings object, or move the sandbox configuration into the settings file and drop the sandbox option."
+      );
+      return { valid: false, warnings, errors };
+    }
+    if (effective("sessionId") !== void 0 && effective("forkSession") !== true && (effective("continue") === true || effectiveResumeId() !== void 0)) {
+      errors.push(
+        "sessionId cannot be combined with continue or resume unless forkSession: true is also set (it then names the forked session's ID). Remove sessionId, remove continue/resume, or add forkSession: true."
+      );
+      return { valid: false, warnings, errors };
+    }
     if (validSettings.maxTurns && validSettings.maxTurns > 20) {
       warnings.push(
         `High maxTurns value (${validSettings.maxTurns}) may lead to long-running conversations`
@@ -658,11 +791,30 @@ function validateSettings(settings) {
     if (validSettings.disallowedTools) {
       validateToolNames(validSettings.disallowedTools, "disallowed");
     }
-    if (validSettings.allowedTools?.includes("Skill") && !validSettings.settingSources) {
+    const effDialogKinds = effective("supportedDialogKinds");
+    if (Array.isArray(effDialogKinds) && effDialogKinds.length > 0 && effective("onUserDialog") == null) {
+      errors.push(
+        "supportedDialogKinds is set without onUserDialog. The SDK requires the onUserDialog callback to render declared dialog kinds and throws when a non-empty list is passed without it; provide onUserDialog or remove supportedDialogKinds."
+      );
+      return { valid: false, warnings, errors };
+    }
+    const effAllowedTools = effective("allowedTools");
+    if (Array.isArray(effAllowedTools) && effAllowedTools.includes("Skill") && !effective("settingSources")) {
       warnings.push(
         "allowedTools includes 'Skill' but settingSources is not set. Skills require settingSources (e.g., ['user', 'project']) to load skill definitions."
       );
     }
+    if (validSettings.agents) {
+      const knownAgentModelAliases = ["sonnet", "opus", "haiku", "fable", "inherit"];
+      for (const [agentName, agent] of Object.entries(validSettings.agents)) {
+        const agentModel = agent.model;
+        if (agentModel !== void 0 && !knownAgentModelAliases.includes(agentModel) && !agentModel.includes("-")) {
+          warnings.push(
+            `Unknown model alias '${agentModel}' for agent '${agentName}'. Known aliases are: ${knownAgentModelAliases.join(", ")}; full model IDs (e.g. 'claude-sonnet-4-5') are also accepted.`
+          );
+        }
+      }
+    }
     return { valid: true, warnings, errors };
   } catch (error) {
     errors.push(`Validation error: ${error instanceof Error ? error.message : String(error)}`);
@@ -683,6 +835,137 @@ function validateSessionId(sessionId) {
   return void 0;
 }
 
+// src/sanitize-json-schema.ts
+var SUBSCHEMA_MAP_KEYWORDS = [
+  "properties",
+  "patternProperties",
+  "$defs",
+  "definitions",
+  "dependentSchemas",
+  // draft-07 `dependencies` values are either subschemas (schema form) or
+  // arrays of property-name strings (array form); sanitizeNode passes
+  // string arrays through untouched, so walking both forms is safe.
+  "dependencies"
+];
+var SUBSCHEMA_KEYWORDS = [
+  "items",
+  // may also be an array of subschemas (draft-07 tuple form)
+  "additionalItems",
+  "additionalProperties",
+  "unevaluatedItems",
+  "unevaluatedProperties",
+  "not",
+  "contains",
+  "propertyNames",
+  "contentSchema",
+  "if",
+  "then",
+  "else"
+];
+var SUBSCHEMA_LIST_KEYWORDS = ["prefixItems", "anyOf", "oneOf", "allOf"];
+function sanitizeJsonSchemaForOutputFormat(schema) {
+  const strippedFormatPaths = [];
+  const sanitized = sanitizeNode(schema, "#", /* @__PURE__ */ new WeakSet(), strippedFormatPaths);
+  return {
+    schema: sanitized ?? schema,
+    strippedFormatPaths
+  };
+}
+function sanitizeNode(node, path, visiting, strippedFormatPaths) {
+  if (typeof node !== "object" || node === null) {
+    return node;
+  }
+  if (visiting.has(node)) {
+    return node;
+  }
+  visiting.add(node);
+  try {
+    if (Array.isArray(node)) {
+      return sanitizeList(node, path, visiting, strippedFormatPaths);
+    }
+    const record = node;
+    let result = record;
+    const setKey = (key, value) => {
+      if (result === record) {
+        result = { ...record };
+      }
+      result[key] = value;
+    };
+    if (typeof record.format === "string") {
+      const format = record.format;
+      const existingDescription = record.description;
+      result = { ...record };
+      delete result.format;
+      if (typeof existingDescription === "string" && existingDescription.length > 0) {
+        result.description = `${existingDescription} (expected format: ${format})`;
+      } else if (existingDescription === void 0 || existingDescription === "") {
+        result.description = `Expected format: ${format}`;
+      }
+      strippedFormatPaths.push(path);
+    }
+    for (const keyword of SUBSCHEMA_MAP_KEYWORDS) {
+      const map = record[keyword];
+      if (typeof map !== "object" || map === null || Array.isArray(map)) continue;
+      const mapRecord = map;
+      let newMap = mapRecord;
+      for (const [name, child] of Object.entries(mapRecord)) {
+        const sanitizedChild = sanitizeNode(
+          child,
+          `${path}/${keyword}/${name}`,
+          visiting,
+          strippedFormatPaths
+        );
+        if (sanitizedChild !== child) {
+          if (newMap === mapRecord) {
+            newMap = { ...mapRecord };
+          }
+          newMap[name] = sanitizedChild;
+        }
+      }
+      if (newMap !== mapRecord) {
+        setKey(keyword, newMap);
+      }
+    }
+    for (const keyword of SUBSCHEMA_KEYWORDS) {
+      const child = record[keyword];
+      if (typeof child !== "object" || child === null) continue;
+      const sanitizedChild = sanitizeNode(
+        child,
+        `${path}/${keyword}`,
+        visiting,
+        strippedFormatPaths
+      );
+      if (sanitizedChild !== child) {
+        setKey(keyword, sanitizedChild);
+      }
+    }
+    for (const keyword of SUBSCHEMA_LIST_KEYWORDS) {
+      const list = record[keyword];
+      if (!Array.isArray(list)) continue;
+      const sanitizedList = sanitizeList(list, `${path}/${keyword}`, visiting, strippedFormatPaths);
+      if (sanitizedList !== list) {
+        setKey(keyword, sanitizedList);
+      }
+    }
+    return result;
+  } finally {
+    visiting.delete(node);
+  }
+}
+function sanitizeList(list, path, visiting, strippedFormatPaths) {
+  let result = list;
+  for (let i = 0; i < list.length; i++) {
+    const sanitizedChild = sanitizeNode(list[i], `${path}/${i}`, visiting, strippedFormatPaths);
+    if (sanitizedChild !== list[i]) {
+      if (result === list) {
+        result = [...list];
+      }
+      result[i] = sanitizedChild;
+    }
+  }
+  return result;
+}
+
 // src/logger.ts
 var defaultLogger = {
   // eslint-disable-next-line no-console
@@ -729,6 +1012,8 @@ function createVerboseLogger(logger, verbose = false) {
 
 // src/claude-code-language-model.ts
 var import_claude_agent_sdk = require("@anthropic-ai/claude-agent-sdk");
+var PROVIDER_VERSION = "3.5.0";
+var DEFAULT_CLIENT_APP = `ai-sdk-provider-claude-code/${PROVIDER_VERSION}`;
 var CLAUDE_CODE_TRUNCATION_WARNING = "Claude Code SDK output ended unexpectedly; returning truncated response from buffered text. Await upstream fix to avoid data loss.";
 var MIN_TRUNCATION_LENGTH = 512;
 function isClaudeCodeTruncationError(error, bufferedText) {
@@ -760,6 +1045,34 @@ function isClaudeCodeTruncationError(error, bufferedText) {
   }
   return true;
 }
+var MISSING_STRUCTURED_OUTPUT_ERROR_MESSAGE = "Structured output was requested (responseFormat with a JSON schema) but the Claude Code CLI returned no structured_output, and the prose response could not be parsed as JSON. This usually means the schema contains constructs the CLI cannot enforce (e.g. complex regex patterns with lookaheads/backreferences), causing it to silently fall back to prose. Simplify the generation schema and validate strictly client-side. See the 'Structured Outputs' section of the ai-sdk-provider-claude-code README for the list of known limitations.";
+function extractJsonObjectText(text) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  const candidates = [trimmed];
+  const fencedBlocks = Array.from(trimmed.matchAll(/```(?:json)?\s*\n?([\s\S]*?)```/gi)).map((match) => match[1]?.trim()).filter((block) => block !== void 0 && block.length > 0);
+  candidates.push(...fencedBlocks.reverse());
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    try {
+      const parsed = JSON.parse(candidate);
+      if (typeof parsed === "object" && parsed !== null) {
+        return candidate;
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+function getStructuredErrorKind(error) {
+  if (typeof error === "object" && error !== null && "errorKind" in error) {
+    const kind = error.errorKind;
+    if (typeof kind === "string") return kind;
+  }
+  return void 0;
+}
 function isAbortError(err) {
   if (err && typeof err === "object") {
     const e = err;
@@ -770,6 +1083,7 @@ function isAbortError(err) {
 }
 var DEFAULT_INHERITED_ENV_VARS = process.platform === "win32" ? [
   "APPDATA",
+  "COMSPEC",
   "HOMEDRIVE",
   "HOMEPATH",
   "LOCALAPPDATA",
@@ -784,23 +1098,89 @@ var DEFAULT_INHERITED_ENV_VARS = process.platform === "win32" ? [
   "WINDIR"
 ] : ["HOME", "LOGNAME", "PATH", "SHELL", "TERM", "USER", "LANG", "LC_ALL", "TMPDIR"];
 var CLAUDE_ENV_VARS = ["CLAUDE_CONFIG_DIR"];
+var NETWORK_ENV_VARS = [
+  "HTTP_PROXY",
+  "HTTPS_PROXY",
+  "NO_PROXY",
+  "http_proxy",
+  "https_proxy",
+  "no_proxy",
+  "NODE_EXTRA_CA_CERTS",
+  "SSL_CERT_FILE",
+  "SSL_CERT_DIR"
+];
+var CLOUD_ENV_VARS = ["GCLOUD_PROJECT", "CLOUD_ML_REGION"];
+var INHERITED_ENV_PREFIXES = ["ANTHROPIC_", "CLAUDE_", "AWS_", "GOOGLE_"];
 function getBaseProcessEnv() {
   const env = {};
-  const allowedKeys = /* @__PURE__ */ new Set([...DEFAULT_INHERITED_ENV_VARS, ...CLAUDE_ENV_VARS]);
-  for (const key of allowedKeys) {
+  const allowedKeys = /* @__PURE__ */ new Set([
+    ...DEFAULT_INHERITED_ENV_VARS,
+    ...CLAUDE_ENV_VARS,
+    ...NETWORK_ENV_VARS,
+    ...CLOUD_ENV_VARS
+  ]);
+  const addIfSafe = (key) => {
     const value = process.env[key];
     if (typeof value !== "string") {
-      continue;
+      return;
     }
     if (value.startsWith("()")) {
-      continue;
+      return;
     }
     env[key] = value;
+  };
+  for (const key of allowedKeys) {
+    addIfSafe(key);
+  }
+  for (const key of Object.keys(process.env)) {
+    if (INHERITED_ENV_PREFIXES.some((prefix) => key.startsWith(prefix))) {
+      addIfSafe(key);
+    }
   }
   return env;
 }
 var STREAMING_FEATURE_WARNING = "Claude Agent SDK features (hooks/MCP/images) require streaming input. Set `streamingInput: 'always'` or provide `canUseTool` (auto streams only when canUseTool is set).";
 var SDK_OPTIONS_BLOCKLIST = /* @__PURE__ */ new Set(["model", "abortController", "prompt", "outputFormat"]);
+var SUBAGENT_TOOL_NAMES = /* @__PURE__ */ new Set(["Task", "Agent"]);
+function isSubagentToolName(name) {
+  return SUBAGENT_TOOL_NAMES.has(name);
+}
+function resolveToolParentId(messageLevel, blockLevel, inferFallback) {
+  if (messageLevel !== void 0) return messageLevel;
+  if (typeof blockLevel === "string") return blockLevel;
+  return inferFallback();
+}
+function computeRetractedToolCallIds(retracted, descriptors) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const { toolCallId, uuid } of descriptors) {
+    if (uuid !== void 0 && retracted.has(uuid)) {
+      ids.add(toolCallId);
+    }
+  }
+  return ids;
+}
+function applySupersede(message, evict, logger, guard = "array") {
+  const supersedes = message.supersedes;
+  const triggered = guard === "truthy" ? Boolean(supersedes && supersedes.length > 0) : Array.isArray(supersedes) && supersedes.length > 0;
+  if (!triggered) {
+    return false;
+  }
+  logger.debug(`[claude-code] Assistant message supersedes ${supersedes.length} prior message(s)`);
+  evict(new Set(supersedes));
+  return true;
+}
+function buildRetractionEvictor(evict) {
+  return (uuids) => evict(new Set(uuids));
+}
+var INFORMATIONAL_SYSTEM_SUBTYPES = /* @__PURE__ */ new Set([
+  "notification",
+  "status",
+  "task_updated",
+  "session_state_changed",
+  "commands_changed",
+  "memory_recall",
+  "plugin_install"
+]);
 function isContentBlock(item) {
   return typeof item === "object" && item !== null && "type" in item;
 }
@@ -1023,6 +1403,9 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
   // 100KB warning threshold
   static MAX_DELTA_CALC_SIZE = 1e4;
   // 10KB delta computation threshold
+  // Upper bound for draining post-result messages (prompt_suggestion) so a
+  // lingering CLI subprocess cannot be held open indefinitely after finish.
+  static PROMPT_SUGGESTION_DRAIN_TIMEOUT_MS = 1e4;
   modelId;
   settings;
   sessionId;
@@ -1070,27 +1453,71 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     return sanitized;
   }
   getEffectiveResume(sdkOptions) {
-    return sdkOptions?.resume ?? this.settings.resume ?? this.sessionId;
-  }
-  extractTextAndThinking(content) {
-    if (!Array.isArray(content)) return { text: "", thinking: [] };
-    let text = "";
-    const thinking = [];
-    for (const part of content) {
-      if (!isContentBlock(part)) continue;
-      if (part.type === "text" && typeof part.text === "string") {
-        text += part.text;
-      } else if (part.type === "thinking" && typeof part.thinking === "string") {
-        thinking.push(part.thinking);
+    for (const candidate of [sdkOptions?.resume, this.settings.resume, this.sessionId]) {
+      if (typeof candidate === "string" && !isBlankResume(candidate)) {
+        return candidate;
       }
     }
-    if (text.length > 0 && typeof text !== "string") {
-      throw new Error("extractTextAndThinking: accumulated text must be a string");
-    }
-    if (thinking.some((t) => typeof t !== "string")) {
-      throw new Error("extractTextAndThinking: all thinking entries must be strings");
+    return void 0;
+  }
+  /**
+   * Single source of truth for the CLI's `--session-id` exclusivity rule.
+   *
+   * The CLI rejects `--session-id` together with `--resume`/`--continue`
+   * unless `--fork-session` is also set (forkSession then names the forked
+   * session's own ID). This predicate captures "there IS a resume/continue
+   * target AND we are not forking", i.e. the case where a session id must NOT
+   * coexist. It is referenced by both:
+   *   - the pre-merge forwarding guard (via its inverse), which decides whether
+   *     to forward `settings.sessionId` onto the base options, and
+   *   - the post-merge exclusivity drop, which removes any session id that the
+   *     generic sdkOptions overlay (or the auto-resume turn) re-introduced.
+   *
+   * Keeping one definition guarantees both sites agree on what "conflicts with
+   * a session id" means. The mirror in validation.ts (construction-time)
+   * intentionally stays separate: it reads settings+sdkOptions, not a built
+   * opts object.
+   */
+  static sessionIdConflictsWithResumeOrContinue(args) {
+    return (args.resumePresent || args.continue) && !args.forkSession;
+  }
+  /**
+   * Owns ALL session-id / resume cross-option resolution on the FINAL merged
+   * options, in the single correct order. Called once, immediately after the
+   * generic sdkOptions overlay in createQueryOptions.
+   *
+   * Two concerns, in this exact order (order matters: step 1 can change whether
+   * step 2 sees a resume target):
+   *
+   *  1. Blank-resume restoration. The overlay copies the raw `sdkOptions.resume`
+   *     verbatim, which can re-introduce a blank/whitespace value over the
+   *     base `resume` that getEffectiveResume already normalized. The SDK treats
+   *     a blank resume as absent, so a blank must NOT clobber the computed
+   *     fallback — restore `effectiveResume` (already blank-stripped; may itself
+   *     be undefined for a genuinely new session) rather than leaving '' or
+   *     forcing undefined, which would erase a real settings.resume / captured
+   *     session id.
+   *
+   *  2. Session-id exclusivity. Drop `opts.sessionId` whenever it conflicts with
+   *     a resume/continue target (see sessionIdConflictsWithResumeOrContinue).
+   *     This runs on the merged opts so it catches a sessionId re-added by the
+   *     sdkOptions overlay AND the auto-resumed second turn (where resume was
+   *     populated from the captured session id). It complements — does not
+   *     replace — the pre-merge forwarding guard, which governs whether
+   *     settings.sessionId was forwarded BEFORE the overlay could mutate
+   *     forkSession/continue/resume.
+   */
+  applySessionResolution(opts, effectiveResume) {
+    if (isBlankResume(opts.resume)) {
+      opts.resume = effectiveResume;
+    }
+    if (opts.sessionId !== void 0 && _ClaudeCodeLanguageModel.sessionIdConflictsWithResumeOrContinue({
+      resumePresent: opts.resume !== void 0,
+      continue: opts.continue === true,
+      forkSession: opts.forkSession === true
+    })) {
+      opts.sessionId = void 0;
     }
-    return { text, thinking };
   }
   extractToolUses(content) {
     return filterContentBlocks(content, "tool_use").map((block) => {
@@ -1184,6 +1611,153 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     }
     return result;
   }
+  /**
+   * Builds a provider-executed `tool-call` part from an assistant `tool_use`
+   * block. Shared by doGenerate (content part) and doStream (stream part) so
+   * the two paths cannot drift in field shape.
+   */
+  buildToolCallPart(toolCallId, toolName, input, parentToolCallId) {
+    return {
+      type: "tool-call",
+      toolCallId,
+      toolName,
+      input,
+      providerExecuted: true,
+      dynamic: true,
+      // V3 field: indicates tool is provider-defined (not in user's tools map)
+      providerMetadata: {
+        "claude-code": {
+          // rawInput preserves the original serialized format before AI SDK normalization.
+          // Use this if you need the exact string sent to the Claude CLI, which may differ
+          // from the `input` field after AI SDK processing.
+          rawInput: input,
+          parentToolCallId: parentToolCallId ?? null
+        }
+      }
+    };
+  }
+  /**
+   * Builds a provider-executed `tool-result` part from a user-message
+   * `tool_result` block, applying normalization and `maxToolResultSize`
+   * truncation. Shared by doGenerate and doStream.
+   */
+  buildToolResultPart(toolCallId, toolName, result, isError, parentToolCallId) {
+    const normalizedResult = this.normalizeToolResult(result);
+    const rawResult = typeof result === "string" ? result : result === void 0 ? (
+      // tool_result blocks may omit `content` entirely; '' keeps both
+      // `result` (NonNullable<JSONValue>) and rawResult (JSONValue) valid.
+      ""
+    ) : (() => {
+      try {
+        return JSON.stringify(result) ?? String(result);
+      } catch {
+        return String(result);
+      }
+    })();
+    const maxToolResultSize = this.settings.maxToolResultSize;
+    const truncatedResult = truncateToolResultForStream(normalizedResult, maxToolResultSize);
+    const truncatedRawResult = truncateToolResultForStream(rawResult, maxToolResultSize);
+    const rawResultTruncated = truncatedRawResult !== rawResult;
+    return {
+      type: "tool-result",
+      toolCallId,
+      toolName,
+      // `?? ''`: absent `content` (undefined) and string results that
+      // normalize to JSON null (e.g. the string "null") must not violate the
+      // NonNullable<JSONValue> contract of LanguageModelV3ToolResult.result.
+      result: truncatedResult ?? "",
+      isError,
+      providerExecuted: true,
+      dynamic: true,
+      // V3 field: indicates tool is provider-defined
+      providerMetadata: {
+        "claude-code": {
+          // rawResult preserves the original CLI output string before JSON parsing.
+          // Use this when you need the exact string returned by the tool, especially
+          // if the `result` field has been parsed/normalized and you need the original format.
+          rawResult: truncatedRawResult,
+          rawResultTruncated,
+          parentToolCallId: parentToolCallId ?? null
+        }
+      }
+    };
+  }
+  serializeToolError(error) {
+    return typeof error === "string" ? error : typeof error === "object" && error !== null ? (() => {
+      try {
+        return JSON.stringify(error) ?? String(error);
+      } catch {
+        return String(error);
+      }
+    })() : String(error);
+  }
+  /**
+   * Builds a provider-executed `tool-error` STREAM part from a user-message
+   * `tool_error` block (doStream only; AI SDK core handles tool-error stream
+   * parts natively).
+   */
+  buildToolErrorPart(toolCallId, toolName, error, parentToolCallId) {
+    const rawError = this.serializeToolError(error);
+    return {
+      type: "tool-error",
+      toolCallId,
+      toolName,
+      error: rawError,
+      providerExecuted: true,
+      dynamic: true,
+      // V3 field: indicates tool is provider-defined
+      providerMetadata: {
+        "claude-code": {
+          rawError,
+          parentToolCallId: parentToolCallId ?? null
+        }
+      }
+    };
+  }
+  /**
+   * Builds a V3 `tool-result` CONTENT part with `isError: true` from a
+   * user-message `tool_error` block (doGenerate only). The V3 content union
+   * has no `tool-error` member and AI SDK core's asContent() silently drops
+   * unknown content part types, so an extension tool-error part would never
+   * reach `generateText` users — an isError tool-result, by contrast,
+   * round-trips into a proper tool-error part in steps content.
+   */
+  buildToolErrorResultPart(toolCallId, toolName, error, parentToolCallId) {
+    const rawError = this.serializeToolError(error);
+    return {
+      type: "tool-result",
+      toolCallId,
+      toolName,
+      result: rawError,
+      isError: true,
+      providerExecuted: true,
+      dynamic: true,
+      // V3 field: indicates tool is provider-defined
+      providerMetadata: {
+        "claude-code": {
+          rawError,
+          parentToolCallId: parentToolCallId ?? null
+        }
+      }
+    };
+  }
+  /**
+   * Policy (P3): late-frame drop guard, shared by all four tool_result/tool_error
+   * sites (doGenerate result+error, doStream result+error). When a frame's tool
+   * id is tombstoned (its tool-call was retracted by a supersede/refusal-fallback
+   * signal), the frame must be DROPPED rather than re-synthesized into an orphan
+   * tool-call. Centralizing the predicate + debug message keeps the four sites in
+   * lockstep so a future tombstone change can't be applied to only some of them.
+   */
+  isRetractedToolFrame(id, tombstone, frameKind) {
+    if (!tombstone.has(id)) {
+      return false;
+    }
+    this.logger.debug(
+      `[claude-code] Dropping tool ${frameKind} for retracted (superseded) tool ID: ${id}`
+    );
+    return true;
+  }
   generateAllWarnings(options, prompt) {
     const warnings = [];
     const unsupportedParams = [];
@@ -1204,6 +1778,27 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
         });
       }
     }
+    if (options.tools !== void 0 && options.tools.length > 0) {
+      warnings.push({
+        type: "unsupported",
+        feature: "tools",
+        details: "The Claude Code CLI executes its own tools; AI SDK tools cannot be auto-bridged at the provider layer and will be ignored. To expose custom tools to the CLI, build an in-process MCP server with the createAiSdkMcpServer helper (exported by this package) and pass it via the mcpServers setting (plus allowedTools)."
+      });
+    }
+    if (options.toolChoice !== void 0 && options.toolChoice.type !== "auto") {
+      warnings.push({
+        type: "unsupported",
+        feature: "toolChoice",
+        details: `Claude Code CLI does not support toolChoice '${options.toolChoice.type}'. Only automatic tool selection is available; the toolChoice parameter will be ignored.`
+      });
+    }
+    if (options.maxOutputTokens !== void 0) {
+      warnings.push({
+        type: "unsupported",
+        feature: "maxOutputTokens",
+        details: "Claude Code CLI does not accept an output token cap. The maxOutputTokens parameter will be ignored."
+      });
+    }
     if (this.modelValidationWarning) {
       warnings.push({
         type: "other",
@@ -1236,7 +1831,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     const opts = {
       model: this.getModel(),
       abortController,
-      resume: effectiveResume ?? this.settings.resume ?? this.sessionId,
+      resume: effectiveResume,
       pathToClaudeCodeExecutable: this.settings.pathToClaudeCodeExecutable,
       maxTurns: this.settings.maxTurns,
       maxThinkingTokens: this.settings.maxThinkingTokens,
@@ -1262,6 +1857,12 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       mcpServers: this.settings.mcpServers,
       canUseTool: this.settings.canUseTool
     };
+    if (this.settings.onUserDialog !== void 0) {
+      opts.onUserDialog = this.settings.onUserDialog;
+    }
+    if (this.settings.supportedDialogKinds !== void 0) {
+      opts.supportedDialogKinds = this.settings.supportedDialogKinds;
+    }
     if (this.settings.systemPrompt !== void 0) {
       opts.systemPrompt = this.settings.systemPrompt;
     } else if (this.settings.customSystemPrompt !== void 0) {
@@ -1281,6 +1882,8 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     }
     if (this.settings.settingSources !== void 0) {
       opts.settingSources = this.settings.settingSources;
+    } else {
+      opts.settingSources = [];
     }
     if (this.settings.additionalDirectories !== void 0) {
       opts.additionalDirectories = this.settings.additionalDirectories;
@@ -1288,6 +1891,48 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     if (this.settings.agents !== void 0) {
       opts.agents = this.settings.agents;
     }
+    if (this.settings.skills !== void 0) {
+      opts.skills = this.settings.skills;
+    }
+    if (this.settings.settings !== void 0) {
+      opts.settings = this.settings.settings;
+    }
+    if (this.settings.managedSettings !== void 0) {
+      opts.managedSettings = this.settings.managedSettings;
+    }
+    if (this.settings.toolAliases !== void 0) {
+      opts.toolAliases = this.settings.toolAliases;
+    }
+    if (this.settings.toolConfig !== void 0) {
+      opts.toolConfig = this.settings.toolConfig;
+    }
+    if (this.settings.planModeInstructions !== void 0) {
+      opts.planModeInstructions = this.settings.planModeInstructions;
+    }
+    if (this.settings.title !== void 0) {
+      opts.title = this.settings.title;
+    }
+    if (this.settings.forwardSubagentText !== void 0) {
+      opts.forwardSubagentText = this.settings.forwardSubagentText;
+    }
+    if (this.settings.agentProgressSummaries !== void 0) {
+      opts.agentProgressSummaries = this.settings.agentProgressSummaries;
+    }
+    if (this.settings.includeHookEvents !== void 0) {
+      opts.includeHookEvents = this.settings.includeHookEvents;
+    }
+    if (this.settings.taskBudget !== void 0) {
+      opts.taskBudget = this.settings.taskBudget;
+    }
+    if (this.settings.sessionStore !== void 0) {
+      opts.sessionStore = this.settings.sessionStore;
+    }
+    if (this.settings.sessionStoreFlush !== void 0) {
+      opts.sessionStoreFlush = this.settings.sessionStoreFlush;
+    }
+    if (this.settings.loadTimeoutMs !== void 0) {
+      opts.loadTimeoutMs = this.settings.loadTimeoutMs;
+    }
     if (this.settings.includePartialMessages !== void 0) {
       opts.includePartialMessages = this.settings.includePartialMessages;
     }
@@ -1312,7 +1957,13 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     if (this.settings.hooks) {
       opts.hooks = this.settings.hooks;
     }
-    if (this.settings.sessionId !== void 0) {
+    const effectiveForkSession = sdkOptions?.forkSession ?? this.settings.forkSession;
+    const effectiveContinue = sdkOptions?.continue ?? this.settings.continue;
+    if (this.settings.sessionId !== void 0 && !_ClaudeCodeLanguageModel.sessionIdConflictsWithResumeOrContinue({
+      resumePresent: opts.resume !== void 0,
+      continue: effectiveContinue === true,
+      forkSession: effectiveForkSession === true
+    })) {
       opts.sessionId = this.settings.sessionId;
     }
     if (this.settings.debug !== void 0) {
@@ -1328,7 +1979,17 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       const rest = { ...sdkOverrides };
       delete rest.env;
       delete rest.stderr;
-      Object.assign(opts, rest);
+      for (const [key, value] of Object.entries(rest)) {
+        if (value !== void 0) {
+          opts[key] = value;
+        }
+      }
+    }
+    this.applySessionResolution(opts, effectiveResume);
+    if (typeof opts.fallbackModel === "string" && opts.fallbackModel === opts.model) {
+      throw new Error(
+        `fallbackModel cannot be the same as the model ('${String(opts.model)}'). Specify a different model for fallbackModel, or remove it.`
+      );
     }
     const userStderrCallback = sdkStderr ?? this.settings.stderr;
     if (stderrCollector || userStderrCallback) {
@@ -1337,14 +1998,27 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
         if (userStderrCallback) userStderrCallback(data);
       };
     }
-    if (this.settings.env !== void 0 || sdkEnv !== void 0) {
-      const baseEnv = getBaseProcessEnv();
-      opts.env = { ...baseEnv, ...this.settings.env, ...sdkEnv };
+    const mergedEnv = {
+      ...getBaseProcessEnv(),
+      ...this.settings.env,
+      ...sdkEnv
+    };
+    if (!("CLAUDE_AGENT_SDK_CLIENT_APP" in mergedEnv)) {
+      mergedEnv.CLAUDE_AGENT_SDK_CLIENT_APP = DEFAULT_CLIENT_APP;
     }
+    opts.env = mergedEnv;
     if (responseFormat?.type === "json" && responseFormat.schema) {
+      const { schema: sanitizedSchema, strippedFormatPaths } = sanitizeJsonSchemaForOutputFormat(
+        responseFormat.schema
+      );
+      if (strippedFormatPaths.length > 0) {
+        this.logger.debug(
+          `[claude-code] Stripped unsupported 'format' keywords from outputFormat schema (hints folded into descriptions; client-side Zod validation still enforces them) at: ${strippedFormatPaths.join(", ")}`
+        );
+      }
       opts.outputFormat = {
         type: "json_schema",
-        schema: responseFormat.schema
+        schema: sanitizedSchema
       };
     }
     return opts;
@@ -1353,6 +2027,9 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     if (isAbortError(error)) {
       throw error;
     }
+    if (error instanceof import_provider2.APICallError || error instanceof import_provider2.LoadAPIKeyError) {
+      return error;
+    }
     const isErrorWithMessage = (err) => {
       return typeof err === "object" && err !== null && "message" in err;
     };
@@ -1369,11 +2046,14 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       "claude auth login",
       "/login",
       // CLI returns "Please run /login"
-      "invalid api key"
+      "invalid api key",
+      "oauth_org_not_allowed"
+      // SDK 0.3.x assistant error kind: OAuth org not permitted
     ];
     const errorMessage = isErrorWithMessage(error) && error.message ? error.message.toLowerCase() : "";
+    const errorKind = getStructuredErrorKind(error);
     const exitCode = isErrorWithCode(error) && typeof error.exitCode === "number" ? error.exitCode : void 0;
-    const isAuthError = authErrorPatterns.some((pattern) => errorMessage.includes(pattern)) || exitCode === 401;
+    const isAuthError = errorKind === "authentication_failed" || errorKind === "oauth_org_not_allowed" || authErrorPatterns.some((pattern) => errorMessage.includes(pattern)) || exitCode === 401;
     if (isAuthError) {
       return createAuthenticationError({
         message: isErrorWithMessage(error) && error.message ? error.message : "Authentication failed. Please ensure Claude Code SDK is properly authenticated."
@@ -1388,9 +2068,30 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
         // It's controlled by the consumer via AbortSignal
       });
     }
-    const isRetryable = errorCode === "ENOENT" || errorCode === "ECONNREFUSED" || errorCode === "ETIMEDOUT" || errorCode === "ECONNRESET";
     const stderrFromError = isErrorWithCode(error) && typeof error.stderr === "string" ? error.stderr : void 0;
     const stderr = stderrFromError || collectedStderr || void 0;
+    if (errorKind === "overloaded" || errorKind === "rate_limit" || errorMessage.includes("overloaded")) {
+      return createAPICallError({
+        message: isErrorWithMessage(error) && error.message ? error.message : "Anthropic API is overloaded. Please retry.",
+        code: errorCode || void 0,
+        exitCode,
+        stderr,
+        promptExcerpt: messagesPrompt.substring(0, 200),
+        isRetryable: true
+      });
+    }
+    if (errorKind === "model_not_found" || errorMessage.includes("model_not_found") || errorMessage.includes("no such model")) {
+      const originalMessage = isErrorWithMessage(error) && error.message ? error.message : "Model not found";
+      return createAPICallError({
+        message: `${originalMessage}. The requested model was not found. Verify the model id passed to the provider (e.g. 'opus', 'sonnet', 'haiku', or a full model name) and that your account has access to it.`,
+        code: errorCode || void 0,
+        exitCode,
+        stderr,
+        promptExcerpt: messagesPrompt.substring(0, 200),
+        isRetryable: false
+      });
+    }
+    const isRetryable = errorCode === "ENOENT" || errorCode === "ECONNREFUSED" || errorCode === "ETIMEDOUT" || errorCode === "ECONNRESET";
     return createAPICallError({
       message: isErrorWithMessage(error) && error.message ? error.message : "Claude Code SDK error",
       code: errorCode || void 0,
@@ -1426,6 +2127,152 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     }).join(", ");
     this.logger.warn(`[claude-code] MCP servers not connected: ${details}`);
   }
+  /**
+   * Handles SDK 0.3.x system messages other than 'init', shared by doGenerate
+   * and doStream:
+   * - 'api_retry' is counted into providerMetadata (`apiRetries`) and debug-logged.
+   * - 'permission_denied' is warn-logged and recorded into providerMetadata
+   *   (`permissionDenials`); without this a denial is invisible until the
+   *   model talks about it.
+   * - 'model_refusal_fallback' is debug-logged (the superseding assistant
+   *   message is handled by the text-dedup guard in the message loops).
+   * - 'thinking_tokens' deltas are accumulated into providerMetadata
+   *   (`estimatedThinkingTokens`); the estimate is explicitly not the
+   *   authoritative billed output tokens, so it is surfaced as metadata
+   *   instead of feeding `usage.outputTokens.reasoning`.
+   * - The subtypes in {@link INFORMATIONAL_SYSTEM_SUBTYPES} are intentionally
+   *   informational and only debug-logged.
+   */
+  handleSystemMessage(message, tracking, onRetractedUuids) {
+    switch (message.subtype) {
+      case "api_retry":
+        tracking.apiRetries += 1;
+        this.logger.debug(
+          `[claude-code] API retry ${message.attempt}/${message.max_retries} in ${message.retry_delay_ms}ms - Status: ${message.error_status ?? "unknown"}, Error: ${message.error}`
+        );
+        break;
+      case "permission_denied": {
+        const reason = message.decision_reason ?? message.message;
+        tracking.permissionDenials.push({
+          toolName: message.tool_name,
+          toolUseId: message.tool_use_id,
+          ...reason !== void 0 && { reason }
+        });
+        this.logger.warn(
+          `[claude-code] Permission denied - Tool: ${message.tool_name}${reason ? `, Reason: ${reason}` : ""}`
+        );
+        break;
+      }
+      case "mirror_error": {
+        const mirrorError = message.error ?? "unknown error";
+        const mirrorSessionId = message.key?.sessionId ?? message.session_id ?? "unknown";
+        tracking.mirrorErrors.push({ error: mirrorError, sessionId: mirrorSessionId });
+        this.logger.warn(
+          `[claude-code] SessionStore mirror error (transcript batch dropped) - Session: ${mirrorSessionId}, Error: ${mirrorError}`
+        );
+        break;
+      }
+      case "model_refusal_fallback": {
+        this.logger.debug(
+          `[claude-code] Model refusal fallback - ${message.original_model} -> ${message.fallback_model} (direction: ${message.direction})`
+        );
+        const retractedUuids = message.retracted_message_uuids;
+        if (onRetractedUuids && retractedUuids && retractedUuids.length > 0) {
+          this.logger.debug(
+            `[claude-code] Refusal fallback retracts ${retractedUuids.length} message uuid(s)`
+          );
+          onRetractedUuids(retractedUuids);
+        }
+        break;
+      }
+      case "thinking_tokens":
+        tracking.estimatedThinkingTokens += message.estimated_tokens_delta;
+        this.logger.debug(
+          `[claude-code] Thinking tokens estimate - block total: ${message.estimated_tokens}, delta: ${message.estimated_tokens_delta}, accumulated: ${tracking.estimatedThinkingTokens}`
+        );
+        break;
+      default:
+        if (INFORMATIONAL_SYSTEM_SUBTYPES.has(message.subtype)) {
+          this.logger.debug(
+            `[claude-code] Ignoring informational system message: ${message.subtype}`
+          );
+        } else {
+          this.logger.debug(`[claude-code] Unhandled system message subtype: ${message.subtype}`);
+        }
+        break;
+    }
+  }
+  /**
+   * Merges the result message's `permission_denials` list into the tracked
+   * denials. PreToolUse-hook denies bypass canUseTool and emit no
+   * `permission_denied` system event (per the SDK docs on
+   * SDKPermissionDeniedMessage), so the result list is the only place they
+   * surface. Entries already recorded from stream-time events are deduped by
+   * `tool_use_id`.
+   */
+  mergeResultPermissionDenials(message, tracking) {
+    for (const denial of message.permission_denials ?? []) {
+      const alreadyTracked = tracking.permissionDenials.some(
+        (d) => d.toolUseId !== void 0 && d.toolUseId === denial.tool_use_id
+      );
+      if (!alreadyTracked) {
+        tracking.permissionDenials.push({
+          toolName: denial.tool_name,
+          toolUseId: denial.tool_use_id
+        });
+      }
+    }
+  }
+  /**
+   * Bounded post-result drain for the `prompt_suggestion` message
+   * (promptSuggestions: true), shared by doGenerate and doStream. The
+   * suggestion arrives AFTER the result message; the SDK emits at most one
+   * per turn, so stop once it is delivered, and a timeout closes the
+   * iterator (tearing down the subprocess) if the CLI lingers after the
+   * result without emitting one. Advances the response's own generator, so
+   * the caller's surrounding loop resumes to a finished iterator.
+   */
+  async drainPromptSuggestion(response, onPromptSuggestion) {
+    const iterator = response[Symbol.asyncIterator]();
+    let drainTimer;
+    const drainTimeout = new Promise((resolve) => {
+      drainTimer = setTimeout(
+        () => resolve("timeout"),
+        _ClaudeCodeLanguageModel.PROMPT_SUGGESTION_DRAIN_TIMEOUT_MS
+      );
+      drainTimer.unref?.();
+    });
+    try {
+      while (true) {
+        const winner = await Promise.race([iterator.next(), drainTimeout]);
+        if (winner === "timeout") {
+          this.logger.debug("[claude-code] Post-result drain timed out; closing SDK iterator");
+          void iterator.return?.().catch(() => {
+          });
+          break;
+        }
+        if (winner.done) {
+          break;
+        }
+        const trailingMessage = winner.value;
+        this.logger.debug(`[claude-code] Post-result message type: ${trailingMessage.type}`);
+        if (trailingMessage.type === "prompt_suggestion") {
+          onPromptSuggestion(trailingMessage.suggestion);
+          void iterator.return?.().catch(() => {
+          });
+          break;
+        }
+      }
+    } catch (drainError) {
+      this.logger.debug(
+        `[claude-code] Error draining post-result messages: ${drainError instanceof Error ? drainError.message : String(drainError)}`
+      );
+    } finally {
+      if (drainTimer !== void 0) {
+        clearTimeout(drainTimer);
+      }
+    }
+  }
   async doGenerate(options) {
     this.logger.debug(`[claude-code] Starting doGenerate request with model: ${this.modelId}`);
     this.logger.debug(`[claude-code] Response format: ${options.responseFormat?.type ?? "none"}`);
@@ -1442,9 +2289,6 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     let abortListener;
     if (options.abortSignal?.aborted) {
       abortController.abort(options.abortSignal.reason);
-    } else if (options.abortSignal) {
-      abortListener = () => abortController.abort(options.abortSignal?.reason);
-      options.abortSignal.addEventListener("abort", abortListener, { once: true });
     }
     let collectedStderr = "";
     const stderrCollector = (data) => {
@@ -1459,15 +2303,77 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       sdkOptions,
       effectiveResume
     );
+    if (options.abortSignal && !options.abortSignal.aborted) {
+      abortListener = () => abortController.abort(options.abortSignal?.reason);
+      options.abortSignal.addEventListener("abort", abortListener, { once: true });
+    }
     let text = "";
-    const thinkingTraces = [];
+    const contentSegments = [];
+    const joinTextSegments = () => contentSegments.filter((segment) => segment.kind === "text").map((segment) => segment.text).join("");
+    const joinFinalTurnTextSegments = () => {
+      let start = 0;
+      for (let i = 0; i < contentSegments.length; i++) {
+        const kind = contentSegments[i]?.kind;
+        if (kind === "tool-result" || kind === "tool-error") {
+          start = i + 1;
+        }
+      }
+      return contentSegments.slice(start).filter((segment) => segment.kind === "text").map((segment) => segment.text).join("");
+    };
+    const knownTools = /* @__PURE__ */ new Map();
+    const retractedToolIds = /* @__PURE__ */ new Set();
+    const evictBuffered = (retracted) => {
+      if (retracted.size === 0) return;
+      const retractedToolCallIds = computeRetractedToolCallIds(
+        retracted,
+        contentSegments.filter(
+          (segment) => segment.kind === "tool-call" || segment.kind === "tool-result" || segment.kind === "tool-error"
+        ).map((segment) => ({
+          toolCallId: segment.toolCallId,
+          uuid: segment.uuid
+        }))
+      );
+      for (const toolCallId of retractedToolCallIds) {
+        retractedToolIds.add(toolCallId);
+        knownTools.delete(toolCallId);
+        activeTaskTools.delete(toolCallId);
+      }
+      for (let i = contentSegments.length - 1; i >= 0; i--) {
+        const segment = contentSegments[i];
+        if (segment === void 0) continue;
+        const segmentUuid = "uuid" in segment ? segment.uuid : void 0;
+        const retractsSegment = segmentUuid !== void 0 && retracted.has(segmentUuid) || (segment.kind === "tool-result" || segment.kind === "tool-error") && retractedToolCallIds.has(segment.toolCallId);
+        if (retractsSegment) {
+          contentSegments.splice(i, 1);
+        }
+      }
+    };
+    const activeTaskTools = /* @__PURE__ */ new Map();
+    const getFallbackParentId = () => {
+      if (activeTaskTools.size === 1) {
+        return activeTaskTools.keys().next().value ?? null;
+      }
+      return null;
+    };
     let structuredOutput;
+    let receivedResultMessage = false;
     let usage = createEmptyUsage();
     let finishReason = { unified: "stop", raw: void 0 };
     let wasTruncated = false;
     let costUsd;
     let durationMs;
     let modelUsage;
+    let ttftMs;
+    let ttftStreamMs;
+    let timeToRequestMs;
+    let warmSpareClaimed;
+    let terminalReason;
+    const metadataTracking = {
+      apiRetries: 0,
+      permissionDenials: [],
+      mirrorErrors: [],
+      estimatedThinkingTokens: 0
+    };
     const warnings = this.generateAllWarnings(options, messagesPrompt);
     if (messageWarnings) {
       messageWarnings.forEach((warning) => {
@@ -1513,23 +2419,195 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
         options: queryOptions
       });
       this.settings.onQueryCreated?.(response);
-      for await (const message of response) {
+      let lastAssistantErrorKind;
+      const sdkIterator = response[Symbol.asyncIterator]();
+      const detachableResponse = {
+        [Symbol.asyncIterator]: () => ({
+          next: () => sdkIterator.next(),
+          return: () => {
+            void sdkIterator.return?.().catch(() => {
+            });
+            return Promise.resolve({ done: true, value: void 0 });
+          }
+        })
+      };
+      for await (const message of detachableResponse) {
         this.logger.debug(`[claude-code] Received message type: ${message.type}`);
         if (message.type === "assistant") {
-          const { text: messageText, thinking: messageThinking } = this.extractTextAndThinking(
-            message.message.content
-          );
-          text += messageText;
-          thinkingTraces.push(...messageThinking);
+          if (typeof message.error === "string") {
+            lastAssistantErrorKind = message.error;
+          }
+          applySupersede(message, evictBuffered, this.logger, "truthy");
+          const messageUuid = typeof message.uuid === "string" ? message.uuid : void 0;
+          const sdkParentToolUseId = message.parent_tool_use_id;
+          const content = message.message.content;
+          if (Array.isArray(content)) {
+            for (const block of content) {
+              if (!isContentBlock(block)) continue;
+              if (block.type === "text" && typeof block.text === "string") {
+                if (block.text.length > 0) {
+                  contentSegments.push({
+                    kind: "text",
+                    ...messageUuid !== void 0 && { uuid: messageUuid },
+                    text: block.text
+                  });
+                }
+              } else if (block.type === "thinking" && typeof block.thinking === "string") {
+                contentSegments.push({
+                  kind: "reasoning",
+                  ...messageUuid !== void 0 && { uuid: messageUuid },
+                  text: block.thinking
+                });
+              } else if (block.type === "tool_use") {
+                const [tool3] = this.extractToolUses([block]);
+                if (!tool3) continue;
+                const parentToolCallId = isSubagentToolName(tool3.name) ? null : resolveToolParentId(
+                  sdkParentToolUseId,
+                  tool3.parentToolUseId,
+                  getFallbackParentId
+                );
+                this.logger.debug(
+                  `[claude-code] Tool use detected - Tool: ${tool3.name}, ID: ${tool3.id}, SDK parent: ${sdkParentToolUseId}, resolved parent: ${parentToolCallId}`
+                );
+                knownTools.set(tool3.id, { name: tool3.name, parentToolCallId });
+                if (isSubagentToolName(tool3.name)) {
+                  activeTaskTools.set(tool3.id, { startTime: Date.now() });
+                }
+                contentSegments.push({
+                  kind: "tool-call",
+                  ...messageUuid !== void 0 && { uuid: messageUuid },
+                  toolCallId: tool3.id,
+                  part: this.buildToolCallPart(
+                    tool3.id,
+                    tool3.name,
+                    this.serializeToolInput(tool3.input),
+                    parentToolCallId
+                  )
+                });
+              }
+            }
+          }
+          text = joinTextSegments();
+        } else if (message.type === "user") {
+          if (!message.message?.content) {
+            this.logger.warn(
+              `[claude-code] Unexpected user message structure: missing content field. Message type: ${message.type}. This may indicate an SDK protocol violation.`
+            );
+            continue;
+          }
+          const sdkParentToolUseIdForResults = message.parent_tool_use_id;
+          const resultMessageUuid = typeof message.uuid === "string" ? message.uuid : void 0;
+          const content = message.message.content;
+          for (const result of this.extractToolResults(content)) {
+            if (this.isRetractedToolFrame(result.id, retractedToolIds, "result")) {
+              continue;
+            }
+            const known = knownTools.get(result.id);
+            const toolName = result.name ?? known?.name ?? _ClaudeCodeLanguageModel.UNKNOWN_TOOL_NAME;
+            this.logger.debug(
+              `[claude-code] Tool result received - Tool: ${toolName}, ID: ${result.id}`
+            );
+            let parentToolCallId;
+            if (known) {
+              known.name = toolName;
+              parentToolCallId = known.parentToolCallId;
+            } else {
+              this.logger.warn(
+                `[claude-code] Received tool result for unknown tool ID: ${result.id}`
+              );
+              parentToolCallId = isSubagentToolName(toolName) ? null : resolveToolParentId(sdkParentToolUseIdForResults, void 0, getFallbackParentId);
+              knownTools.set(result.id, { name: toolName, parentToolCallId });
+              contentSegments.push({
+                kind: "tool-call",
+                toolCallId: result.id,
+                part: this.buildToolCallPart(result.id, toolName, "", parentToolCallId)
+              });
+            }
+            if (isSubagentToolName(toolName)) {
+              activeTaskTools.delete(result.id);
+            }
+            contentSegments.push({
+              kind: "tool-result",
+              ...resultMessageUuid !== void 0 && { uuid: resultMessageUuid },
+              toolCallId: result.id,
+              part: this.buildToolResultPart(
+                result.id,
+                toolName,
+                result.result,
+                result.isError,
+                parentToolCallId
+              )
+            });
+          }
+          for (const error of this.extractToolErrors(content)) {
+            if (this.isRetractedToolFrame(error.id, retractedToolIds, "error")) {
+              continue;
+            }
+            const known = knownTools.get(error.id);
+            const toolName = error.name ?? known?.name ?? _ClaudeCodeLanguageModel.UNKNOWN_TOOL_NAME;
+            this.logger.debug(
+              `[claude-code] Tool error received - Tool: ${toolName}, ID: ${error.id}`
+            );
+            let parentToolCallId;
+            if (known) {
+              known.name = toolName;
+              parentToolCallId = known.parentToolCallId;
+            } else {
+              this.logger.warn(
+                `[claude-code] Received tool error for unknown tool ID: ${error.id}`
+              );
+              parentToolCallId = isSubagentToolName(toolName) ? null : resolveToolParentId(sdkParentToolUseIdForResults, void 0, getFallbackParentId);
+              knownTools.set(error.id, { name: toolName, parentToolCallId });
+              contentSegments.push({
+                kind: "tool-call",
+                toolCallId: error.id,
+                part: this.buildToolCallPart(error.id, toolName, "", parentToolCallId)
+              });
+            }
+            if (isSubagentToolName(toolName)) {
+              activeTaskTools.delete(error.id);
+            }
+            contentSegments.push({
+              kind: "tool-error",
+              ...resultMessageUuid !== void 0 && { uuid: resultMessageUuid },
+              toolCallId: error.id,
+              part: this.buildToolErrorResultPart(
+                error.id,
+                toolName,
+                error.error,
+                parentToolCallId
+              )
+            });
+          }
         } else if (message.type === "result") {
           done();
+          receivedResultMessage = true;
           this.setSessionId(message.session_id);
           costUsd = message.total_cost_usd;
           durationMs = message.duration_ms;
           modelUsage = message.modelUsage;
+          if ("ttft_ms" in message) {
+            ttftMs = message.ttft_ms;
+          }
+          if ("ttft_stream_ms" in message) {
+            ttftStreamMs = message.ttft_stream_ms;
+          }
+          if ("time_to_request_ms" in message) {
+            timeToRequestMs = message.time_to_request_ms;
+          }
+          if ("warm_spare_claimed" in message) {
+            warmSpareClaimed = message.warm_spare_claimed;
+          }
+          terminalReason = message.terminal_reason;
+          this.mergeResultPermissionDenials(message, metadataTracking);
           if ("is_error" in message && message.is_error === true) {
-            const errorMessage = "result" in message && typeof message.result === "string" ? message.result : "Claude Code CLI returned an error";
-            throw Object.assign(new Error(errorMessage), { exitCode: 1 });
+            const resultText = "result" in message && typeof message.result === "string" ? message.result : void 0;
+            const errorsText = "errors" in message && Array.isArray(message.errors) ? message.errors.filter((e) => typeof e === "string").join("; ") : "";
+            const errorMessage = resultText ?? (errorsText || "Claude Code CLI returned an error");
+            throw Object.assign(new Error(errorMessage), {
+              exitCode: 1,
+              errorKind: lastAssistantErrorKind
+            });
           }
           if (message.subtype === "error_max_structured_output_retries") {
             throw new Error(
@@ -1552,10 +2630,21 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
           const stopReason = "stop_reason" in message ? message.stop_reason : void 0;
           finishReason = mapClaudeCodeFinishReason(message.subtype, stopReason);
           this.logger.debug(`[claude-code] Finish reason: ${finishReason.unified}`);
+          const effectivePromptSuggestions = sdkOptions?.promptSuggestions ?? this.settings.promptSuggestions;
+          if (this.settings.onPromptSuggestion && effectivePromptSuggestions !== false) {
+            await this.drainPromptSuggestion(response, this.settings.onPromptSuggestion);
+          }
+          break;
         } else if (message.type === "system" && message.subtype === "init") {
           this.logMcpConnectionIssues(message.mcp_servers);
           this.setSessionId(message.session_id);
           this.logger.info(`[claude-code] Session initialized: ${message.session_id}`);
+        } else if (message.type === "system") {
+          this.handleSystemMessage(
+            message,
+            metadataTracking,
+            buildRetractionEvictor(evictBuffered)
+          );
         }
       }
     } catch (error) {
@@ -1585,15 +2674,45 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
         options.abortSignal.removeEventListener("abort", abortListener);
       }
     }
-    const finalText = structuredOutput !== void 0 ? JSON.stringify(structuredOutput) : text;
+    if (options.responseFormat?.type === "json" && options.responseFormat.schema !== void 0 && receivedResultMessage && structuredOutput === void 0 && !wasTruncated && finishReason.unified === "stop") {
+      const recoveredJsonText = extractJsonObjectText(joinFinalTurnTextSegments()) ?? extractJsonObjectText(joinTextSegments());
+      if (recoveredJsonText !== void 0) {
+        this.logger.warn(
+          "[claude-code] outputFormat was requested but the CLI returned no structured_output; recovered JSON by parsing the prose response. The schema likely contains constructs the CLI cannot enforce - see the README structured-output limitations."
+        );
+        structuredOutput = JSON.parse(recoveredJsonText);
+      } else {
+        throw createAPICallError({
+          message: MISSING_STRUCTURED_OUTPUT_ERROR_MESSAGE,
+          promptExcerpt: messagesPrompt.substring(0, 200),
+          isRetryable: false
+        });
+      }
+    }
+    const thinkingTraces = contentSegments.filter((segment) => segment.kind === "reasoning").map((segment) => segment.text);
+    const contentParts = [];
+    for (const segment of contentSegments) {
+      if (segment.kind === "reasoning") {
+        contentParts.push({ type: "reasoning", text: segment.text });
+      } else if (segment.kind === "text") {
+        if (structuredOutput !== void 0) continue;
+        const last = contentParts[contentParts.length - 1];
+        if (last !== void 0 && last.type === "text") {
+          last.text += segment.text;
+        } else {
+          contentParts.push({ type: "text", text: segment.text });
+        }
+      } else {
+        contentParts.push(segment.part);
+      }
+    }
+    if (structuredOutput !== void 0) {
+      contentParts.push({ type: "text", text: JSON.stringify(structuredOutput) });
+    } else if (!contentParts.some((part) => part.type === "text")) {
+      contentParts.push({ type: "text", text: "" });
+    }
     return {
-      content: [
-        ...thinkingTraces.map((trace) => ({
-          type: "reasoning",
-          text: trace
-        })),
-        { type: "text", text: finalText }
-      ],
+      content: contentParts,
       usage,
       finishReason,
       warnings,
@@ -1611,6 +2730,21 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
           ...costUsd !== void 0 && { costUsd },
           ...durationMs !== void 0 && { durationMs },
           ...modelUsage !== void 0 && { modelUsage },
+          ...ttftMs !== void 0 && { ttftMs },
+          ...ttftStreamMs !== void 0 && { ttftStreamMs },
+          ...timeToRequestMs !== void 0 && { timeToRequestMs },
+          ...warmSpareClaimed !== void 0 && { warmSpareClaimed },
+          ...terminalReason !== void 0 && { terminalReason },
+          ...metadataTracking.apiRetries > 0 && { apiRetries: metadataTracking.apiRetries },
+          ...metadataTracking.permissionDenials.length > 0 && {
+            permissionDenials: metadataTracking.permissionDenials
+          },
+          ...metadataTracking.mirrorErrors.length > 0 && {
+            mirrorErrors: metadataTracking.mirrorErrors
+          },
+          ...metadataTracking.estimatedThinkingTokens > 0 && {
+            estimatedThinkingTokens: metadataTracking.estimatedThinkingTokens
+          },
           ...wasTruncated && { truncated: true },
           ...thinkingTraces.length > 0 && { thinkingTraces }
         }
@@ -1633,9 +2767,6 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     let abortListener;
     if (options.abortSignal?.aborted) {
       abortController.abort(options.abortSignal.reason);
-    } else if (options.abortSignal) {
-      abortListener = () => abortController.abort(options.abortSignal?.reason);
-      options.abortSignal.addEventListener("abort", abortListener, { once: true });
     }
     let collectedStderr = "";
     const stderrCollector = (data) => {
@@ -1650,6 +2781,10 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       sdkOptions,
       effectiveResume
     );
+    if (options.abortSignal && !options.abortSignal.aborted) {
+      abortListener = () => abortController.abort(options.abortSignal?.reason);
+      options.abortSignal.addEventListener("abort", abortListener, { once: true });
+    }
     if (queryOptions.includePartialMessages === void 0) {
       queryOptions.includePartialMessages = true;
     }
@@ -1680,6 +2815,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
           done = () => resolve(void 0);
         });
         const toolStates = /* @__PURE__ */ new Map();
+        const retractedStreamToolIds = /* @__PURE__ */ new Set();
         const activeTaskTools = /* @__PURE__ */ new Map();
         const getFallbackParentId = () => {
           if (activeTaskTools.size === 1) {
@@ -1702,24 +2838,14 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
             return;
           }
           closeToolInput(toolId, state);
-          controller.enqueue({
-            type: "tool-call",
-            toolCallId: toolId,
-            toolName: state.name,
-            input: state.lastSerializedInput ?? "",
-            providerExecuted: true,
-            dynamic: true,
-            // V3 field: indicates tool is provider-defined (not in user's tools map)
-            providerMetadata: {
-              "claude-code": {
-                // rawInput preserves the original serialized format before AI SDK normalization.
-                // Use this if you need the exact string sent to the Claude CLI, which may differ
-                // from the `input` field after AI SDK processing.
-                rawInput: state.lastSerializedInput ?? "",
-                parentToolCallId: state.parentToolCallId ?? null
-              }
-            }
-          });
+          controller.enqueue(
+            this.buildToolCallPart(
+              toolId,
+              state.name,
+              state.lastSerializedInput ?? "",
+              state.parentToolCallId
+            )
+          );
           state.callEmitted = true;
         };
         const finalizeToolCalls = () => {
@@ -1730,16 +2856,61 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
         };
         let usage = createEmptyUsage();
         let accumulatedText = "";
+        const textSegments = [];
         let textPartId;
         let streamedTextLength = 0;
+        let emittedTextSinceLastAssistant = "";
         let hasReceivedStreamEvents = false;
         let hasStreamedJson = false;
+        let lastAssistantErrorKind;
+        const metadataTracking = {
+          apiRetries: 0,
+          permissionDenials: [],
+          mirrorErrors: [],
+          estimatedThinkingTokens: 0
+        };
         const toolBlocksByIndex = /* @__PURE__ */ new Map();
         const toolInputAccumulators = /* @__PURE__ */ new Map();
         const textBlocksByIndex = /* @__PURE__ */ new Map();
         let textStreamedViaContentBlock = false;
         const reasoningBlocksByIndex = /* @__PURE__ */ new Map();
         let currentReasoningPartId;
+        const evictLive = (retracted) => {
+          if (retracted.size === 0) return;
+          for (let i = textSegments.length - 1; i >= 0; i--) {
+            const segmentUuid = textSegments[i]?.uuid;
+            if (segmentUuid !== void 0 && retracted.has(segmentUuid)) {
+              textSegments.splice(i, 1);
+            }
+          }
+          accumulatedText = textSegments.map((segment) => segment.text).join("");
+          const retractedToolCallIds = computeRetractedToolCallIds(
+            retracted,
+            [...toolStates].map(([toolId, state]) => ({
+              toolCallId: toolId,
+              uuid: state.messageUuid
+            }))
+          );
+          for (const toolId of retractedToolCallIds) {
+            const state = toolStates.get(toolId);
+            if (!state) continue;
+            activeTaskTools.delete(toolId);
+            if (!state.callEmitted) {
+              closeToolInput(toolId, state);
+              toolStates.delete(toolId);
+              retractedStreamToolIds.add(toolId);
+              toolInputAccumulators.delete(toolId);
+              for (const [blockIndex, mappedId] of toolBlocksByIndex) {
+                if (mappedId === toolId) {
+                  toolBlocksByIndex.delete(blockIndex);
+                }
+              }
+              this.logger.debug(
+                `[claude-code] Retracted pending tool call from superseded message - ID: ${toolId}`
+              );
+            }
+          }
+        };
         try {
           controller.enqueue({ type: "stream-start", warnings });
           if (effectiveCanUseTool && effectivePermissionPromptToolName) {
@@ -1789,6 +2960,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                 });
                 accumulatedText += deltaText;
                 streamedTextLength += deltaText.length;
+                emittedTextSinceLastAssistant += deltaText;
               }
               if (event.type === "content_block_delta" && event.delta.type === "input_json_delta" && "partial_json" in event.delta && event.delta.partial_json) {
                 const jsonDelta = event.delta.partial_json;
@@ -1848,13 +3020,16 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                 toolInputAccumulators.set(toolId, "");
                 let state = toolStates.get(toolId);
                 if (!state) {
-                  const currentParentId = toolName === "Task" ? null : getFallbackParentId();
+                  const partialParentId = message.parent_tool_use_id;
+                  const currentParentId = isSubagentToolName(toolName) ? null : resolveToolParentId(partialParentId, void 0, getFallbackParentId);
+                  const envelopeUuid = message.uuid;
                   state = {
                     name: toolName,
                     inputStarted: false,
                     inputClosed: false,
                     callEmitted: false,
-                    parentToolCallId: currentParentId
+                    parentToolCallId: currentParentId,
+                    ...typeof envelopeUuid === "string" && { messageUuid: envelopeUuid }
                   };
                   toolStates.set(toolId, state);
                 }
@@ -1874,7 +3049,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                       }
                     }
                   });
-                  if (toolName === "Task") {
+                  if (isSubagentToolName(toolName)) {
                     activeTaskTools.set(toolId, { startTime: Date.now() });
                   }
                   state.inputStarted = true;
@@ -1958,20 +3133,14 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                     const effectiveInput = accumulatedInput || state.lastSerializedInput || "";
                     state.lastSerializedInput = effectiveInput;
                     if (!state.callEmitted) {
-                      controller.enqueue({
-                        type: "tool-call",
-                        toolCallId: toolId,
-                        toolName: state.name,
-                        input: effectiveInput,
-                        providerExecuted: true,
-                        dynamic: true,
-                        providerMetadata: {
-                          "claude-code": {
-                            rawInput: effectiveInput,
-                            parentToolCallId: state.parentToolCallId ?? null
-                          }
-                        }
-                      });
+                      controller.enqueue(
+                        this.buildToolCallPart(
+                          toolId,
+                          state.name,
+                          effectiveInput,
+                          state.parentToolCallId
+                        )
+                      );
                       state.callEmitted = true;
                     }
                   }
@@ -2013,6 +3182,10 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
               continue;
             }
             if (message.type === "assistant") {
+              if (typeof message.error === "string") {
+                lastAssistantErrorKind = message.error;
+              }
+              const supersedesPriorMessages = applySupersede(message, evictLive, this.logger);
               if (!message.message?.content) {
                 this.logger.warn(
                   `[claude-code] Unexpected assistant message structure: missing content field. Message type: ${message.type}. This may indicate an SDK protocol violation.`
@@ -2040,19 +3213,24 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                 const toolId = tool3.id;
                 let state = toolStates.get(toolId);
                 if (!state) {
-                  const currentParentId = tool3.name === "Task" ? null : sdkParentToolUseId ?? tool3.parentToolUseId ?? getFallbackParentId();
+                  const currentParentId = isSubagentToolName(tool3.name) ? null : resolveToolParentId(
+                    sdkParentToolUseId,
+                    tool3.parentToolUseId,
+                    getFallbackParentId
+                  );
                   state = {
                     name: tool3.name,
                     inputStarted: false,
                     inputClosed: false,
                     callEmitted: false,
-                    parentToolCallId: currentParentId
+                    parentToolCallId: currentParentId,
+                    ...typeof message.uuid === "string" && { messageUuid: message.uuid }
                   };
                   toolStates.set(toolId, state);
                   this.logger.debug(
                     `[claude-code] New tool use detected - Tool: ${tool3.name}, ID: ${toolId}, SDK parent: ${sdkParentToolUseId}, resolved parent: ${currentParentId}`
                   );
-                } else if (!state.parentToolCallId && sdkParentToolUseId && tool3.name !== "Task") {
+                } else if (!state.parentToolCallId && sdkParentToolUseId && !isSubagentToolName(tool3.name)) {
                   state.parentToolCallId = sdkParentToolUseId;
                   this.logger.debug(
                     `[claude-code] Retroactive parent context - Tool: ${tool3.name}, ID: ${toolId}, parent: ${sdkParentToolUseId}`
@@ -2076,7 +3254,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                       }
                     }
                   });
-                  if (tool3.name === "Task") {
+                  if (isSubagentToolName(tool3.name)) {
                     activeTaskTools.set(toolId, { startTime: Date.now() });
                   }
                   state.inputStarted = true;
@@ -2105,10 +3283,76 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
               }
               const text = content.map((c) => c.type === "text" ? c.text : "").join("");
               if (text) {
-                if (hasReceivedStreamEvents) {
+                if (supersedesPriorMessages) {
+                  textSegments.push({
+                    ...typeof message.uuid === "string" && { uuid: message.uuid },
+                    text
+                  });
+                  accumulatedText = textSegments.map((segment) => segment.text).join("");
+                  if (emittedTextSinceLastAssistant === text) {
+                    streamedTextLength = Math.max(streamedTextLength, text.length);
+                    this.logger.debug(
+                      "[claude-code] Skipping text emission for superseding assistant message (replacement already streamed)"
+                    );
+                  } else if (emittedTextSinceLastAssistant.length > 0 && text.startsWith(emittedTextSinceLastAssistant)) {
+                    if (options.responseFormat?.type !== "json") {
+                      const suffix = text.slice(emittedTextSinceLastAssistant.length);
+                      if (suffix) {
+                        if (!textPartId) {
+                          textPartId = (0, import_provider_utils.generateId)();
+                          controller.enqueue({ type: "text-start", id: textPartId });
+                        }
+                        controller.enqueue({
+                          type: "text-delta",
+                          id: textPartId,
+                          delta: suffix
+                        });
+                        emittedTextSinceLastAssistant = text;
+                      }
+                    }
+                    streamedTextLength = Math.max(streamedTextLength, text.length);
+                    this.logger.debug(
+                      "[claude-code] Emitted unstreamed suffix of superseding assistant message"
+                    );
+                  } else if (options.responseFormat?.type !== "json") {
+                    if (textPartId) {
+                      const closedTextId = textPartId;
+                      controller.enqueue({
+                        type: "text-end",
+                        id: closedTextId
+                      });
+                      textPartId = void 0;
+                      for (const [idx, blockTextId] of textBlocksByIndex) {
+                        if (blockTextId === closedTextId) {
+                          textBlocksByIndex.delete(idx);
+                          break;
+                        }
+                      }
+                    }
+                    textPartId = (0, import_provider_utils.generateId)();
+                    controller.enqueue({
+                      type: "text-start",
+                      id: textPartId
+                    });
+                    controller.enqueue({
+                      type: "text-delta",
+                      id: textPartId,
+                      delta: text
+                    });
+                    streamedTextLength = Math.max(streamedTextLength, text.length);
+                    this.logger.debug(
+                      "[claude-code] Emitted superseding assistant message as a new text part (canonical replacement)"
+                    );
+                  }
+                } else if (hasReceivedStreamEvents) {
                   const newTextStart = streamedTextLength;
                   const deltaText = text.length > newTextStart ? text.slice(newTextStart) : "";
                   accumulatedText = text;
+                  textSegments.length = 0;
+                  textSegments.push({
+                    ...typeof message.uuid === "string" && { uuid: message.uuid },
+                    text
+                  });
                   if (options.responseFormat?.type !== "json" && deltaText) {
                     if (!textPartId) {
                       textPartId = (0, import_provider_utils.generateId)();
@@ -2126,6 +3370,10 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                   streamedTextLength = text.length;
                 } else {
                   accumulatedText += text;
+                  textSegments.push({
+                    ...typeof message.uuid === "string" && { uuid: message.uuid },
+                    text
+                  });
                   if (options.responseFormat?.type !== "json") {
                     if (!textPartId) {
                       textPartId = (0, import_provider_utils.generateId)();
@@ -2142,6 +3390,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                   }
                 }
               }
+              emittedTextSinceLastAssistant = "";
             } else if (message.type === "user") {
               if (!message.message?.content) {
                 this.logger.warn(
@@ -2162,13 +3411,18 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                     break;
                   }
                 }
-                accumulatedText = "";
-                streamedTextLength = 0;
                 this.logger.debug("[claude-code] Closed text part due to user message");
               }
+              accumulatedText = "";
+              textSegments.length = 0;
+              streamedTextLength = 0;
+              emittedTextSinceLastAssistant = "";
               const sdkParentToolUseIdForResults = message.parent_tool_use_id;
               const content = message.message.content;
               for (const result of this.extractToolResults(content)) {
+                if (this.isRetractedToolFrame(result.id, retractedStreamToolIds, "result")) {
+                  continue;
+                }
                 let state = toolStates.get(result.id);
                 const toolName = result.name ?? state?.name ?? _ClaudeCodeLanguageModel.UNKNOWN_TOOL_NAME;
                 this.logger.debug(
@@ -2178,7 +3432,11 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                   this.logger.warn(
                     `[claude-code] Received tool result for unknown tool ID: ${result.id}`
                   );
-                  const resolvedParentId = toolName === "Task" ? null : sdkParentToolUseIdForResults ?? getFallbackParentId();
+                  const resolvedParentId = isSubagentToolName(toolName) ? null : resolveToolParentId(
+                    sdkParentToolUseIdForResults,
+                    void 0,
+                    getFallbackParentId
+                  );
                   state = {
                     name: toolName,
                     inputStarted: false,
@@ -2212,50 +3470,24 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                   }
                 }
                 state.name = toolName;
-                const normalizedResult = this.normalizeToolResult(result.result);
-                const rawResult = typeof result.result === "string" ? result.result : (() => {
-                  try {
-                    return JSON.stringify(result.result);
-                  } catch {
-                    return String(result.result);
-                  }
-                })();
-                const maxToolResultSize = this.settings.maxToolResultSize;
-                const truncatedResult = truncateToolResultForStream(
-                  normalizedResult,
-                  maxToolResultSize
-                );
-                const truncatedRawResult = truncateToolResultForStream(
-                  rawResult,
-                  maxToolResultSize
-                );
-                const rawResultTruncated = truncatedRawResult !== rawResult;
                 emitToolCall(result.id, state);
-                if (toolName === "Task") {
+                if (isSubagentToolName(toolName)) {
                   activeTaskTools.delete(result.id);
                 }
-                controller.enqueue({
-                  type: "tool-result",
-                  toolCallId: result.id,
-                  toolName,
-                  result: truncatedResult,
-                  isError: result.isError,
-                  providerExecuted: true,
-                  dynamic: true,
-                  // V3 field: indicates tool is provider-defined
-                  providerMetadata: {
-                    "claude-code": {
-                      // rawResult preserves the original CLI output string before JSON parsing.
-                      // Use this when you need the exact string returned by the tool, especially
-                      // if the `result` field has been parsed/normalized and you need the original format.
-                      rawResult: truncatedRawResult,
-                      rawResultTruncated,
-                      parentToolCallId: state.parentToolCallId ?? null
-                    }
-                  }
-                });
+                controller.enqueue(
+                  this.buildToolResultPart(
+                    result.id,
+                    toolName,
+                    result.result,
+                    result.isError,
+                    state.parentToolCallId
+                  )
+                );
               }
               for (const error of this.extractToolErrors(content)) {
+                if (this.isRetractedToolFrame(error.id, retractedStreamToolIds, "error")) {
+                  continue;
+                }
                 let state = toolStates.get(error.id);
                 const toolName = error.name ?? state?.name ?? _ClaudeCodeLanguageModel.UNKNOWN_TOOL_NAME;
                 this.logger.debug(
@@ -2265,7 +3497,11 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                   this.logger.warn(
                     `[claude-code] Received tool error for unknown tool ID: ${error.id}`
                   );
-                  const errorResolvedParentId = toolName === "Task" ? null : sdkParentToolUseIdForResults ?? getFallbackParentId();
+                  const errorResolvedParentId = isSubagentToolName(toolName) ? null : resolveToolParentId(
+                    sdkParentToolUseIdForResults,
+                    void 0,
+                    getFallbackParentId
+                  );
                   state = {
                     name: toolName,
                     inputStarted: true,
@@ -2276,37 +3512,24 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                   toolStates.set(error.id, state);
                 }
                 emitToolCall(error.id, state);
-                if (toolName === "Task") {
+                if (isSubagentToolName(toolName)) {
                   activeTaskTools.delete(error.id);
                 }
-                const rawError = typeof error.error === "string" ? error.error : typeof error.error === "object" && error.error !== null ? (() => {
-                  try {
-                    return JSON.stringify(error.error);
-                  } catch {
-                    return String(error.error);
-                  }
-                })() : String(error.error);
-                controller.enqueue({
-                  type: "tool-error",
-                  toolCallId: error.id,
-                  toolName,
-                  error: rawError,
-                  providerExecuted: true,
-                  dynamic: true,
-                  // V3 field: indicates tool is provider-defined
-                  providerMetadata: {
-                    "claude-code": {
-                      rawError,
-                      parentToolCallId: state.parentToolCallId ?? null
-                    }
-                  }
-                });
+                controller.enqueue(
+                  this.buildToolErrorPart(error.id, toolName, error.error, state.parentToolCallId)
+                );
               }
             } else if (message.type === "result") {
               done();
+              this.mergeResultPermissionDenials(message, metadataTracking);
               if ("is_error" in message && message.is_error === true) {
-                const errorMessage = "result" in message && typeof message.result === "string" ? message.result : "Claude Code CLI returned an error";
-                throw Object.assign(new Error(errorMessage), { exitCode: 1 });
+                const resultText = "result" in message && typeof message.result === "string" ? message.result : void 0;
+                const errorsText = "errors" in message && Array.isArray(message.errors) ? message.errors.filter((e) => typeof e === "string").join("; ") : "";
+                const errorMessage = resultText ?? (errorsText || "Claude Code CLI returned an error");
+                throw Object.assign(new Error(errorMessage), {
+                  exitCode: 1,
+                  errorKind: lastAssistantErrorKind
+                });
               }
               if (message.subtype === "error_max_structured_output_retries") {
                 throw new Error(
@@ -2354,6 +3577,38 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                   type: "text-end",
                   id: jsonTextId
                 });
+              } else if (options.responseFormat?.type === "json" && options.responseFormat.schema !== void 0 && finishReason.unified === "stop") {
+                const recoveredJsonText = extractJsonObjectText(accumulatedText);
+                if (recoveredJsonText === void 0) {
+                  throw createAPICallError({
+                    message: MISSING_STRUCTURED_OUTPUT_ERROR_MESSAGE,
+                    promptExcerpt: messagesPrompt.substring(0, 200),
+                    isRetryable: false
+                  });
+                }
+                this.logger.warn(
+                  "[claude-code] outputFormat was requested but the CLI returned no structured_output; recovered JSON by parsing the prose response. The schema likely contains constructs the CLI cannot enforce - see the README structured-output limitations."
+                );
+                if (textPartId) {
+                  controller.enqueue({
+                    type: "text-end",
+                    id: textPartId
+                  });
+                }
+                const recoveredTextId = (0, import_provider_utils.generateId)();
+                controller.enqueue({
+                  type: "text-start",
+                  id: recoveredTextId
+                });
+                controller.enqueue({
+                  type: "text-delta",
+                  id: recoveredTextId,
+                  delta: recoveredJsonText
+                });
+                controller.enqueue({
+                  type: "text-end",
+                  id: recoveredTextId
+                });
               } else if (textPartId) {
                 controller.enqueue({
                   type: "text-end",
@@ -2391,6 +3646,32 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                     ...message.modelUsage !== void 0 && {
                       modelUsage: message.modelUsage
                     },
+                    // SDK 0.3.x timing metadata (ttft_* only present on SDKResultSuccess)
+                    ..."ttft_ms" in message && message.ttft_ms !== void 0 && { ttftMs: message.ttft_ms },
+                    ..."ttft_stream_ms" in message && message.ttft_stream_ms !== void 0 && {
+                      ttftStreamMs: message.ttft_stream_ms
+                    },
+                    ..."time_to_request_ms" in message && message.time_to_request_ms !== void 0 && {
+                      timeToRequestMs: message.time_to_request_ms
+                    },
+                    ..."warm_spare_claimed" in message && message.warm_spare_claimed !== void 0 && {
+                      warmSpareClaimed: message.warm_spare_claimed
+                    },
+                    ...message.terminal_reason !== void 0 && {
+                      terminalReason: message.terminal_reason
+                    },
+                    ...metadataTracking.apiRetries > 0 && {
+                      apiRetries: metadataTracking.apiRetries
+                    },
+                    ...metadataTracking.permissionDenials.length > 0 && {
+                      permissionDenials: metadataTracking.permissionDenials
+                    },
+                    ...metadataTracking.mirrorErrors.length > 0 && {
+                      mirrorErrors: metadataTracking.mirrorErrors
+                    },
+                    ...metadataTracking.estimatedThinkingTokens > 0 && {
+                      estimatedThinkingTokens: metadataTracking.estimatedThinkingTokens
+                    },
                     // JSON validation warnings are collected during streaming and included
                     // in providerMetadata since the AI SDK's finish event doesn't support
                     // a top-level warnings field (unlike stream-start which was already emitted)
@@ -2401,6 +3682,10 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                 }
               });
               controller.close();
+              const effectivePromptSuggestions = sdkOptions?.promptSuggestions ?? this.settings.promptSuggestions;
+              if (this.settings.onPromptSuggestion && effectivePromptSuggestions !== false) {
+                await this.drainPromptSuggestion(response, this.settings.onPromptSuggestion);
+              }
               return;
             } else if (message.type === "system" && message.subtype === "init") {
               this.logMcpConnectionIssues(message.mcp_servers);
@@ -2412,6 +3697,15 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                 timestamp: /* @__PURE__ */ new Date(),
                 modelId: this.modelId
               });
+            } else if (message.type === "system") {
+              this.handleSystemMessage(
+                message,
+                metadataTracking,
+                buildRetractionEvictor(evictLive)
+              );
+            } else if (message.type === "prompt_suggestion") {
+              this.logger.debug("[claude-code] Received prompt suggestion");
+              this.settings.onPromptSuggestion?.(message.suggestion);
             }
           }
           finalizeToolCalls();
@@ -2462,6 +3756,18 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                 "claude-code": {
                   ...this.sessionId !== void 0 && { sessionId: this.sessionId },
                   truncated: true,
+                  ...metadataTracking.apiRetries > 0 && {
+                    apiRetries: metadataTracking.apiRetries
+                  },
+                  ...metadataTracking.permissionDenials.length > 0 && {
+                    permissionDenials: metadataTracking.permissionDenials
+                  },
+                  ...metadataTracking.mirrorErrors.length > 0 && {
+                    mirrorErrors: metadataTracking.mirrorErrors
+                  },
+                  ...metadataTracking.estimatedThinkingTokens > 0 && {
+                    estimatedThinkingTokens: metadataTracking.estimatedThinkingTokens
+                  },
                   ...streamWarnings.length > 0 && {
                     warnings: warningsJson
                   }
@@ -2577,10 +3883,40 @@ var claudeCode = createClaudeCode();
 
 // src/index.ts
 var import_claude_agent_sdk3 = require("@anthropic-ai/claude-agent-sdk");
+var import_claude_agent_sdk4 = require("@anthropic-ai/claude-agent-sdk");
+var import_claude_agent_sdk5 = require("@anthropic-ai/claude-agent-sdk");
 
 // src/mcp-helpers.ts
 var import_claude_agent_sdk2 = require("@anthropic-ai/claude-agent-sdk");
 var import_zod2 = require("zod");
+function buildIsErrorResult(text) {
+  return {
+    isError: true,
+    content: [{ type: "text", text }]
+  };
+}
+async function normalizeToolResultToText(toolName, result) {
+  if (result != null && typeof result[Symbol.asyncIterator] === "function") {
+    let last;
+    for await (const chunk of result) {
+      last = chunk;
+    }
+    result = last;
+  }
+  if (typeof result === "string") {
+    return { text: result };
+  }
+  try {
+    return { text: JSON.stringify(result) ?? "undefined" };
+  } catch (serializationError) {
+    const reason = serializationError instanceof Error ? serializationError.message : String(serializationError);
+    return {
+      isError: buildIsErrorResult(
+        `Tool "${toolName}" succeeded but its result could not be serialized to JSON: ${reason}`
+      )
+    };
+  }
+}
 function createCustomMcpServer(config) {
   const defs = Object.entries(config.tools).map(
     ([name, def]) => (0, import_claude_agent_sdk2.tool)(
@@ -2593,19 +3929,97 @@ function createCustomMcpServer(config) {
   );
   return (0, import_claude_agent_sdk2.createSdkMcpServer)({ name: config.name, version: config.version, tools: defs });
 }
+var AI_SDK_SCHEMA_SYMBOL = Symbol.for("vercel.ai.schema");
+function isAiSdkJsonSchema(schema) {
+  return typeof schema === "object" && schema !== null && AI_SDK_SCHEMA_SYMBOL in schema;
+}
+function isZodObjectSchema(schema) {
+  if (typeof schema !== "object" || schema === null) {
+    return false;
+  }
+  const candidate = schema;
+  if (!("_zod" in candidate) && !("_def" in candidate)) {
+    return false;
+  }
+  const typeTag = candidate._zod?.def?.type ?? candidate._def?.typeName;
+  if (typeTag !== "object" && typeTag !== "ZodObject") {
+    return false;
+  }
+  return typeof candidate.shape === "object" && candidate.shape !== null;
+}
+function createAiSdkMcpServer(name, tools) {
+  const defs = Object.entries(tools).map(([toolName, def]) => {
+    const execute = def.execute;
+    if (typeof execute !== "function") {
+      throw new Error(
+        `createAiSdkMcpServer: tool "${toolName}" has no execute function. Only tools that execute locally can be bridged to the Claude Code CLI.`
+      );
+    }
+    if (isAiSdkJsonSchema(def.inputSchema)) {
+      throw new Error(
+        `createAiSdkMcpServer: tool "${toolName}" uses a JSON Schema-based inputSchema (e.g. the AI SDK's jsonSchema() helper). Only Zod object schemas are supported because the Agent SDK's tool() requires a Zod shape. Define inputSchema with z.object({...}) instead.`
+      );
+    }
+    if (!isZodObjectSchema(def.inputSchema)) {
+      throw new Error(
+        `createAiSdkMcpServer: tool "${toolName}" has an inputSchema that is not a Zod object schema. Pass the same z.object({...}) schema you would give to the AI SDK tool() helper.`
+      );
+    }
+    const zodSchema = def.inputSchema;
+    return (0, import_claude_agent_sdk2.tool)(
+      toolName,
+      def.description ?? "",
+      zodSchema.shape,
+      async (args, extra) => {
+        try {
+          const extraInfo = extra ?? {};
+          const result = await execute.call(def, args, {
+            toolCallId: extraInfo.requestId !== void 0 ? String(extraInfo.requestId) : void 0,
+            abortSignal: extraInfo.signal
+          });
+          const normalized = await normalizeToolResultToText(toolName, result);
+          if ("isError" in normalized) {
+            return normalized.isError;
+          }
+          return { content: [{ type: "text", text: normalized.text }] };
+        } catch (error) {
+          return buildIsErrorResult(error instanceof Error ? error.message : String(error));
+        }
+      }
+    );
+  });
+  return (0, import_claude_agent_sdk2.createSdkMcpServer)({ name, tools: defs });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AbortError,
   ClaudeCodeLanguageModel,
+  HOOK_EVENTS,
+  InMemorySessionStore,
+  SYSTEM_PROMPT_DYNAMIC_BOUNDARY,
   claudeCode,
   createAPICallError,
+  createAiSdkMcpServer,
   createAuthenticationError,
   createClaudeCode,
   createCustomMcpServer,
   createSdkMcpServer,
   createTimeoutError,
+  deleteSession,
+  foldSessionSummary,
+  forkSession,
   getErrorMetadata,
+  getSessionInfo,
+  getSessionMessages,
+  getSubagentMessages,
+  importSessionToStore,
   isAuthenticationError,
   isTimeoutError,
+  listSessions,
+  listSubagents,
+  renameSession,
+  startup,
+  tagSession,
   tool
 });
 //# sourceMappingURL=index.cjs.map