ai-sdk-provider-claude-code 3.5.2 → 4.0.0

package/dist/index.js

@@ -3,11 +3,21 @@ import { NoSuchModelError as NoSuchModelError2 } from "@ai-sdk/provider";
 
 // src/claude-code-language-model.ts
 import { NoSuchModelError, APICallError as APICallError2, LoadAPIKeyError as LoadAPIKeyError2 } from "@ai-sdk/provider";
-import { generateId } from "@ai-sdk/provider-utils";
+import {
+  generateId,
+  isCustomReasoning,
+  mapReasoningToProviderEffort
+} from "@ai-sdk/provider-utils";
 
 // src/convert-to-claude-code-messages.ts
+import { detectMediaType } from "@ai-sdk/provider-utils";
 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 FILE_REFERENCE_WARNING = "Provider file references are not supported by this provider; supply inline file data.";
+function createUnsupportedFilePartWarning(mediaType) {
+  const mediaTypeLabel = mediaType && mediaType.trim() ? mediaType : "unknown";
+  return `Unsupported file part (${mediaTypeLabel}) was ignored; this provider forwards only image file parts inline.`;
+}
 var MAX_TOOL_CALL_INPUT_LENGTH = 1e3;
 function serializeToolCallInput(input) {
   let serialized;
@@ -25,42 +35,75 @@ function serializeToolCallInput(input) {
   }
   return serialized;
 }
-function normalizeBase64(base64) {
-  return base64.replace(/\s+/g, "");
+function getVariantName(value, discriminator) {
+  if (typeof value === "object" && value !== null) {
+    const candidate = value[discriminator];
+    if (typeof candidate === "string" && candidate) {
+      return candidate;
+    }
+  }
+  return String(value);
+}
+function createUnknownPromptVariantWarning(value, context, discriminator = "type") {
+  return `Unsupported ${context} ${discriminator} '${getVariantName(
+    value,
+    discriminator
+  )}' was skipped.`;
+}
+function extractMimeType(candidate) {
+  if (typeof candidate === "string" && candidate.trim()) {
+    return candidate.trim();
+  }
+  return void 0;
+}
+function normalizeMediaType(mediaType) {
+  return mediaType.trim().toLowerCase();
+}
+function isImageMimeType(mediaType) {
+  if (!mediaType) {
+    return false;
+  }
+  const normalized = normalizeMediaType(mediaType);
+  return normalized === "image" || normalized === "image/*" || normalized.startsWith("image/");
+}
+function isConcreteImageMimeType(mediaType) {
+  const normalized = normalizeMediaType(mediaType);
+  return normalized.startsWith("image/") && !normalized.endsWith("/*");
 }
-function isImageMimeType(mimeType) {
-  return typeof mimeType === "string" && mimeType.trim().toLowerCase().startsWith("image/");
+function resolveImageMediaType(mediaType, data) {
+  const normalizedMediaType = normalizeMediaType(mediaType);
+  if (isConcreteImageMimeType(normalizedMediaType)) {
+    return normalizedMediaType;
+  }
+  if ((normalizedMediaType === "image" || normalizedMediaType === "image/*") && data) {
+    try {
+      const detectedMediaType = detectMediaType({ data, topLevelType: "image" });
+      if (detectedMediaType && isConcreteImageMimeType(detectedMediaType)) {
+        return detectedMediaType;
+      }
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
 }
 function createImageContent(mediaType, data) {
-  const trimmedType = mediaType.trim();
-  const trimmedData = normalizeBase64(data.trim());
-  if (!trimmedType || !trimmedData) {
+  const normalizedType = normalizeMediaType(mediaType);
+  const trimmedData = data.trim().replace(/\s+/g, "");
+  if (!isConcreteImageMimeType(normalizedType) || !trimmedData) {
     return void 0;
   }
   return {
     type: "image",
     source: {
       type: "base64",
-      media_type: trimmedType,
+      media_type: normalizedType,
       data: trimmedData
     }
   };
 }
-function extractMimeType(candidate) {
-  if (typeof candidate === "string" && candidate.trim()) {
-    return candidate.trim();
-  }
-  return void 0;
-}
-function parseObjectImage(imageObj, fallbackMimeType) {
-  const data = typeof imageObj.data === "string" ? imageObj.data : void 0;
-  const mimeType = extractMimeType(
-    imageObj.mimeType ?? imageObj.mediaType ?? imageObj.media_type ?? fallbackMimeType
-  );
-  if (!data || !mimeType) {
-    return void 0;
-  }
-  return createImageContent(mimeType, data);
+function resolveStringImageMediaType(mediaType, data, fallbackMimeType) {
+  return resolveImageMediaType(mediaType, data) ?? (fallbackMimeType ? resolveImageMediaType(fallbackMimeType, data) : void 0);
 }
 function parseStringImage(value, fallbackMimeType) {
   const trimmed = value.trim();
@@ -70,41 +113,31 @@ function parseStringImage(value, fallbackMimeType) {
   const dataUrlMatch = trimmed.match(/^data:([^;]+);base64,(.+)$/i);
   if (dataUrlMatch) {
     const [, mediaType, data] = dataUrlMatch;
-    const content = createImageContent(mediaType, data);
+    const resolvedMediaType = resolveStringImageMediaType(mediaType, data, fallbackMimeType);
+    const content = resolvedMediaType ? createImageContent(resolvedMediaType, data) : void 0;
     return content ? { content } : { warning: IMAGE_CONVERSION_WARNING };
   }
   const base64Match = trimmed.match(/^base64:([^,]+),(.+)$/i);
   if (base64Match) {
     const [, explicitMimeType, data] = base64Match;
-    const content = createImageContent(explicitMimeType, data);
+    const resolvedMediaType = resolveStringImageMediaType(explicitMimeType, data, fallbackMimeType);
+    const content = resolvedMediaType ? createImageContent(resolvedMediaType, data) : void 0;
     return content ? { content } : { warning: IMAGE_CONVERSION_WARNING };
   }
   if (fallbackMimeType) {
-    const content = createImageContent(fallbackMimeType, trimmed);
-    if (content) {
-      return { content };
+    const resolvedMediaType = resolveImageMediaType(fallbackMimeType, trimmed);
+    if (resolvedMediaType) {
+      const content = createImageContent(resolvedMediaType, trimmed);
+      if (content) {
+        return { content };
+      }
     }
   }
   return { warning: IMAGE_CONVERSION_WARNING };
 }
-function parseImagePart(part) {
-  if (!part || typeof part !== "object") {
-    return { warning: IMAGE_CONVERSION_WARNING };
-  }
-  const imageValue = part.image;
-  const mimeType = extractMimeType(part.mimeType);
-  if (typeof imageValue === "string") {
-    return parseStringImage(imageValue, mimeType);
-  }
-  if (imageValue && typeof imageValue === "object") {
-    const content = parseObjectImage(imageValue, mimeType);
-    return content ? { content } : { warning: IMAGE_CONVERSION_WARNING };
-  }
-  return { warning: IMAGE_CONVERSION_WARNING };
-}
 function convertBinaryToBase64(data) {
   if (typeof Buffer !== "undefined") {
-    const buffer = data instanceof Uint8Array ? Buffer.from(data) : Buffer.from(new Uint8Array(data));
+    const buffer = data instanceof Uint8Array ? Buffer.from(data.buffer, data.byteOffset, data.byteLength) : Buffer.from(data);
     return buffer.toString("base64");
   }
   if (typeof btoa === "function") {
@@ -120,24 +153,102 @@ function convertBinaryToBase64(data) {
   return void 0;
 }
 function parseFilePart(part) {
-  const mimeType = extractMimeType(part.mediaType ?? part.mimeType);
-  if (!mimeType || !isImageMimeType(mimeType)) {
-    return {};
+  const mediaType = extractMimeType(part.mediaType);
+  const fileData = part.data;
+  switch (fileData.type) {
+    case "data": {
+      if (!mediaType || !isImageMimeType(mediaType)) {
+        return { warning: createUnsupportedFilePartWarning(mediaType) };
+      }
+      if (typeof fileData.data === "string") {
+        return parseStringImage(fileData.data, mediaType);
+      }
+      const resolvedMediaType = resolveImageMediaType(mediaType, fileData.data);
+      if (!resolvedMediaType) {
+        return { warning: IMAGE_CONVERSION_WARNING };
+      }
+      const base64 = convertBinaryToBase64(fileData.data);
+      if (!base64) {
+        return { warning: IMAGE_CONVERSION_WARNING };
+      }
+      const content = createImageContent(resolvedMediaType, base64);
+      return content ? { content } : { warning: IMAGE_CONVERSION_WARNING };
+    }
+    case "url": {
+      if (!mediaType || !isImageMimeType(mediaType)) {
+        return { warning: createUnsupportedFilePartWarning(mediaType) };
+      }
+      const url = fileData.url.toString();
+      if (!/^data:/i.test(url.trim())) {
+        return { warning: IMAGE_URL_WARNING };
+      }
+      return parseStringImage(url, mediaType);
+    }
+    case "text":
+      return fileData.text ? { text: fileData.text } : {};
+    case "reference":
+      return { warning: FILE_REFERENCE_WARNING };
+    default: {
+      const unknownFileData = fileData;
+      return {
+        warning: createUnknownPromptVariantWarning(unknownFileData, "prompt file data")
+      };
+    }
   }
-  const data = part.data;
-  if (typeof data === "string") {
-    const content = createImageContent(mimeType, data);
-    return content ? { content } : { warning: IMAGE_CONVERSION_WARNING };
+}
+function serializeToolResultFilePart(part, warnings) {
+  const fileData = part.data;
+  const fileLabel = part.filename ? `File ${part.filename}` : "File";
+  switch (fileData.type) {
+    case "data":
+      return `[${fileLabel}: ${part.mediaType}]`;
+    case "url":
+      return `[${fileLabel}: ${part.mediaType}: ${fileData.url.toString()}]`;
+    case "text":
+      return fileData.text;
+    case "reference":
+      warnings.push(FILE_REFERENCE_WARNING);
+      return void 0;
+    default: {
+      const unknownFileData = fileData;
+      warnings.push(createUnknownPromptVariantWarning(unknownFileData, "tool result file data"));
+      return void 0;
+    }
   }
-  if (data instanceof Uint8Array || typeof ArrayBuffer !== "undefined" && data instanceof ArrayBuffer) {
-    const base64 = convertBinaryToBase64(data);
-    if (!base64) {
-      return { warning: IMAGE_CONVERSION_WARNING };
+}
+function serializeToolResultContentPart(part, warnings) {
+  switch (part.type) {
+    case "text":
+      return part.text;
+    case "file":
+      return serializeToolResultFilePart(part, warnings);
+    case "custom":
+      return void 0;
+    default: {
+      const unknownPart = part;
+      warnings.push(createUnknownPromptVariantWarning(unknownPart, "tool result content part"));
+      return void 0;
+    }
+  }
+}
+function serializeToolResultOutput(output, warnings) {
+  switch (output.type) {
+    case "text":
+    case "error-text":
+      return output.value;
+    case "json":
+    case "error-json":
+      return JSON.stringify(output.value) ?? String(output.value);
+    case "execution-denied":
+      return `[Execution denied${output.reason ? `: ${output.reason}` : ""}]`;
+    case "content":
+      return output.value.map((part) => serializeToolResultContentPart(part, warnings)).filter((text) => typeof text === "string" && text.length > 0).join("\n");
+    default: {
+      const unknownOutput = output;
+      warnings.push(createUnknownPromptVariantWarning(unknownOutput, "tool result output"));
+      return void 0;
     }
-    const content = createImageContent(mimeType, base64);
-    return content ? { content } : { warning: IMAGE_CONVERSION_WARNING };
   }
-  return { warning: IMAGE_CONVERSION_WARNING };
 }
 function convertToClaudeCodeMessages(prompt) {
   const messages = [];
@@ -157,89 +268,149 @@ function convertToClaudeCodeMessages(prompt) {
     }
     imageMap.get(segmentIndex)?.push(content);
   };
+  const addWarning = (warning) => {
+    if (warning) {
+      warnings.push(warning);
+    }
+  };
   for (const message of prompt) {
     switch (message.role) {
       case "system":
-        systemPrompt = message.content;
-        if (typeof message.content === "string" && message.content.trim().length > 0) {
+        systemPrompt = systemPrompt === void 0 ? message.content : `${systemPrompt}
+
+${message.content}`;
+        if (message.content.trim().length > 0) {
           addSegment(message.content);
         } else {
           addSegment("");
         }
         break;
-      case "user":
-        if (typeof message.content === "string") {
-          messages.push(message.content);
-          addSegment(`Human: ${message.content}`);
-        } else {
-          const textParts = message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
-          const segmentIndex = addSegment(textParts ? `Human: ${textParts}` : "");
-          if (textParts) {
-            messages.push(textParts);
-          }
-          for (const part of message.content) {
-            if (part.type === "image") {
-              const { content, warning } = parseImagePart(part);
-              if (content) {
-                addImageForSegment(segmentIndex, content);
-              } else if (warning) {
-                warnings.push(warning);
+      case "user": {
+        const textParts = [];
+        const imageParts = [];
+        for (const part of message.content) {
+          switch (part.type) {
+            case "text":
+              if (typeof part.text === "string") {
+                textParts.push(part.text);
+              }
+              break;
+            case "file": {
+              const { content, text, warning } = parseFilePart(part);
+              if (typeof text === "string") {
+                textParts.push(text);
               }
-            } else if (part.type === "file") {
-              const { content, warning } = parseFilePart(part);
               if (content) {
-                addImageForSegment(segmentIndex, content);
-              } else if (warning) {
-                warnings.push(warning);
+                imageParts.push(content);
               }
+              addWarning(warning);
+              break;
+            }
+            default: {
+              const unknownPart = part;
+              addWarning(
+                createUnknownPromptVariantWarning(unknownPart, "prompt user content part")
+              );
+              break;
             }
           }
         }
+        const textContent = textParts.join("\n");
+        const segmentIndex = addSegment(textContent ? `Human: ${textContent}` : "");
+        if (textContent) {
+          messages.push(`Human: ${textContent}`);
+        }
+        for (const imagePart of imageParts) {
+          addImageForSegment(segmentIndex, imagePart);
+        }
         break;
+      }
       case "assistant": {
-        let assistantContent = "";
-        if (typeof message.content === "string") {
-          assistantContent = message.content;
-        } else {
-          const textParts = message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
-          if (textParts) {
-            assistantContent = textParts;
-          }
-          const toolCalls = message.content.filter((part) => part.type === "tool-call");
-          if (toolCalls.length > 0) {
-            const serializedCalls = toolCalls.map((call) => `[Tool call: ${call.toolName}(${serializeToolCallInput(call.input)})]`).join("\n");
-            assistantContent += assistantContent ? `
-${serializedCalls}` : serializedCalls;
+        const assistantParts = [];
+        const imageParts = [];
+        for (const part of message.content) {
+          switch (part.type) {
+            case "text":
+              if (typeof part.text === "string") {
+                assistantParts.push(part.text);
+              }
+              break;
+            case "tool-call":
+              assistantParts.push(
+                `[Tool call: ${part.toolName}(${serializeToolCallInput(part.input)})]`
+              );
+              break;
+            case "tool-result": {
+              const output = serializeToolResultOutput(part.output, warnings);
+              if (output !== void 0) {
+                assistantParts.push(`Tool Result (${part.toolName}): ${output}`);
+              }
+              break;
+            }
+            case "file": {
+              const { content, text, warning } = parseFilePart(part);
+              if (typeof text === "string") {
+                assistantParts.push(text);
+              }
+              if (content) {
+                imageParts.push(content);
+              }
+              addWarning(warning);
+              break;
+            }
+            case "reasoning":
+              break;
+            case "reasoning-file":
+              break;
+            case "custom":
+              break;
+            default: {
+              const unknownPart = part;
+              addWarning(
+                createUnknownPromptVariantWarning(unknownPart, "prompt assistant content part")
+              );
+              break;
+            }
           }
         }
+        const assistantContent = assistantParts.join("\n");
         const formattedAssistant = `Assistant: ${assistantContent}`;
         messages.push(formattedAssistant);
-        addSegment(formattedAssistant);
+        const segmentIndex = addSegment(formattedAssistant);
+        for (const imagePart of imageParts) {
+          addImageForSegment(segmentIndex, imagePart);
+        }
         break;
       }
       case "tool":
         for (const tool3 of message.content) {
-          if (tool3.type === "tool-approval-response") {
-            continue;
-          }
-          let resultText;
-          const output = tool3.output;
-          if (output.type === "text" || output.type === "error-text") {
-            resultText = output.value;
-          } else if (output.type === "json" || output.type === "error-json") {
-            resultText = JSON.stringify(output.value);
-          } else if (output.type === "execution-denied") {
-            resultText = `[Execution denied${output.reason ? `: ${output.reason}` : ""}]`;
-          } else if (output.type === "content") {
-            resultText = output.value.filter((part) => part.type === "text").map((part) => part.text).join("\n");
-          } else {
-            resultText = "[Unknown output type]";
+          switch (tool3.type) {
+            case "tool-result": {
+              const output = serializeToolResultOutput(tool3.output, warnings);
+              if (output !== void 0) {
+                const formattedToolResult = `Tool Result (${tool3.toolName}): ${output}`;
+                messages.push(formattedToolResult);
+                addSegment(formattedToolResult);
+              }
+              break;
+            }
+            case "tool-approval-response":
+              break;
+            default: {
+              const unknownPart = tool3;
+              addWarning(
+                createUnknownPromptVariantWarning(unknownPart, "prompt tool content part")
+              );
+              break;
+            }
           }
-          const formattedToolResult = `Tool Result (${tool3.toolName}): ${resultText}`;
-          messages.push(formattedToolResult);
-          addSegment(formattedToolResult);
         }
         break;
+      default: {
+        const unknownMessage = message;
+        addWarning(createUnknownPromptVariantWarning(unknownMessage, "prompt message", "role"));
+        break;
+      }
     }
   }
   let finalPrompt = "";
@@ -249,12 +420,7 @@ ${serializedCalls}` : serializedCalls;
   if (messages.length > 0) {
     const formattedMessages = [];
     for (let i = 0; i < messages.length; i++) {
-      const msg = messages[i];
-      if (msg.startsWith("Assistant:") || msg.startsWith("Tool Result")) {
-        formattedMessages.push(msg);
-      } else {
-        formattedMessages.push(`Human: ${msg}`);
-      }
+      formattedMessages.push(messages[i]);
     }
     if (finalPrompt) {
       const joinedMessages = formattedMessages.join("\n\n");
@@ -532,6 +698,18 @@ var claudeCodeSettingsSchema = z.object({
   forwardSubagentText: z.boolean().optional(),
   agentProgressSummaries: z.boolean().optional(),
   includeHookEvents: z.boolean().optional(),
+  onSdkMessage: z.any().refine((v) => v === void 0 || typeof v === "function", {
+    message: "onSdkMessage must be a function"
+  }).optional(),
+  onTaskEvent: z.any().refine((v) => v === void 0 || typeof v === "function", {
+    message: "onTaskEvent must be a function"
+  }).optional(),
+  onHookEvent: z.any().refine((v) => v === void 0 || typeof v === "function", {
+    message: "onHookEvent must be a function"
+  }).optional(),
+  onMcpStatusChange: z.any().refine((v) => v === void 0 || typeof v === "function", {
+    message: "onMcpStatusChange must be a function"
+  }).optional(),
   taskBudget: z.object({ total: z.number().positive() }).strict().optional(),
   sessionStore: z.any().refine(
     (val) => val === void 0 || typeof val === "object" && val !== null && typeof val.append === "function" && typeof val.load === "function",
@@ -548,6 +726,9 @@ var claudeCodeSettingsSchema = z.object({
   onUserDialog: z.any().refine((v) => v === void 0 || typeof v === "function", {
     message: "onUserDialog must be a function"
   }).optional(),
+  onElicitation: z.any().refine((v) => v === void 0 || typeof v === "function", {
+    message: "onElicitation must be a function"
+  }).optional(),
   supportedDialogKinds: z.array(z.string()).optional(),
   hooks: z.record(
     z.string(),
@@ -594,6 +775,7 @@ var claudeCodeSettingsSchema = z.object({
   logger: z.union([z.literal(false), loggerFunctionSchema]).optional(),
   env: z.record(z.string(), z.string().optional()).optional(),
   additionalDirectories: z.array(z.string()).optional(),
+  agent: z.string().optional(),
   agents: z.record(
     z.string(),
     z.object({
@@ -631,10 +813,13 @@ var claudeCodeSettingsSchema = z.object({
   onQueryCreated: z.any().refine((val) => val === void 0 || typeof val === "function", {
     message: "onQueryCreated must be a function"
   }).optional(),
+  onQueryControllerCreated: z.any().refine((val) => val === void 0 || typeof val === "function", {
+    message: "onQueryControllerCreated must be a function"
+  }).optional(),
   onStreamStart: 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)
+  // Callback invoked with the predicted next user prompt (requires promptSuggestions: true)
   onPromptSuggestion: z.any().refine((val) => val === void 0 || typeof val === "function", {
     message: "onPromptSuggestion must be a function"
   }).optional()
@@ -719,6 +904,11 @@ function validateSettings(settings) {
         `Very high maxThinkingTokens (${validSettings.maxThinkingTokens}) may increase response time`
       );
     }
+    if (validSettings.onPromptSuggestion !== void 0 && effective("promptSuggestions") !== true) {
+      warnings.push(
+        "onPromptSuggestion is registered but promptSuggestions is not enabled. The CLI only emits prompt_suggestion messages when promptSuggestions is true, so the callback will never fire. Set promptSuggestions: true."
+      );
+    }
     if (validSettings.allowedTools && validSettings.disallowedTools) {
       warnings.push(
         "Both allowedTools and disallowedTools are specified. Only allowedTools will be used."
@@ -956,9 +1146,38 @@ function createVerboseLogger(logger, verbose = false) {
   };
 }
 
+// src/query-controller.ts
+function createClaudeCodeQueryController(query2) {
+  const controller = {
+    rawQuery: query2,
+    // SDK 0.3.205 returns the control-protocol response; the public contract stays Promise<void>.
+    interrupt: async () => {
+      await query2.interrupt();
+    },
+    setPermissionMode: (mode) => query2.setPermissionMode(mode),
+    setMcpPermissionModeOverride: (serverName, mode) => query2.setMcpPermissionModeOverride(serverName, mode),
+    setModel: (model) => query2.setModel(model),
+    setMaxThinkingTokens: (maxThinkingTokens, thinkingDisplay) => query2.setMaxThinkingTokens(maxThinkingTokens, thinkingDisplay),
+    applyFlagSettings: (settings) => query2.applyFlagSettings(settings),
+    mcpServerStatus: () => query2.mcpServerStatus(),
+    reconnectMcpServer: (serverName) => query2.reconnectMcpServer(serverName),
+    toggleMcpServer: (serverName, enabled) => query2.toggleMcpServer(serverName, enabled),
+    setMcpServers: (servers) => query2.setMcpServers(servers),
+    getContextUsage: () => query2.getContextUsage(),
+    rewindFiles: (userMessageId, options) => query2.rewindFiles(userMessageId, options),
+    stopTask: (taskId) => query2.stopTask(taskId),
+    backgroundTasks: (toolUseId) => toolUseId === void 0 ? query2.backgroundTasks() : query2.backgroundTasks(toolUseId)
+  };
+  const streamInput = query2.streamInput;
+  if (typeof streamInput === "function") {
+    controller.streamInput = (stream) => streamInput.call(query2, stream);
+  }
+  return controller;
+}
+
 // src/claude-code-language-model.ts
 import { query } from "@anthropic-ai/claude-agent-sdk";
-var PROVIDER_VERSION = "3.5.2";
+var PROVIDER_VERSION = "4.0.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;
@@ -992,6 +1211,13 @@ 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.";
+var INTERNAL_STRUCTURED_OUTPUT_TOOL_NAME = "StructuredOutput";
+function isInternalStructuredOutputTool(toolName, options) {
+  return options.responseFormat?.type === "json" && toolName === INTERNAL_STRUCTURED_OUTPUT_TOOL_NAME;
+}
+function isNonTextToolUseContentBlockType(type) {
+  return type === "server_tool_use" || type === "mcp_tool_use";
+}
 function extractJsonObjectText(text) {
   const trimmed = text.trim();
   if (!trimmed) {
@@ -1085,7 +1311,7 @@ function getBaseProcessEnv() {
   }
   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 STREAMING_FEATURE_WARNING = "Claude Agent SDK image input requires streaming input. Set `streamingInput: 'auto'` or `streamingInput: 'always'`; `streamingInput: 'off'` disables streaming image input.";
 var SDK_OPTIONS_BLOCKLIST = /* @__PURE__ */ new Set(["model", "abortController", "prompt", "outputFormat"]);
 var SUBAGENT_TOOL_NAMES = /* @__PURE__ */ new Set(["Task", "Agent"]);
 function isSubagentToolName(name) {
@@ -1108,7 +1334,7 @@ function computeRetractedToolCallIds(retracted, descriptors) {
 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) {
+  if (!triggered || supersedes === void 0) {
     return false;
   }
   logger.debug(`[claude-code] Assistant message supersedes ${supersedes.length} prior message(s)`);
@@ -1121,12 +1347,126 @@ function buildRetractionEvictor(evict) {
 var INFORMATIONAL_SYSTEM_SUBTYPES = /* @__PURE__ */ new Set([
   "notification",
   "status",
-  "task_updated",
   "session_state_changed",
   "commands_changed",
   "memory_recall",
-  "plugin_install"
+  "plugin_install",
+  "informational"
 ]);
+var CLAUDE_REASONING_EFFORT_MAP = {
+  minimal: "low",
+  low: "low",
+  medium: "medium",
+  high: "high",
+  xhigh: "xhigh"
+};
+var CLAUDE_EFFORT_LEVELS = /* @__PURE__ */ new Set(["low", "medium", "high", "xhigh", "max"]);
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function toJsonSafeValue(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  try {
+    const serialized = JSON.stringify(value);
+    return serialized === void 0 ? void 0 : JSON.parse(serialized);
+  } catch {
+    return String(value);
+  }
+}
+function deepFreezeJsonValue(value) {
+  if (Array.isArray(value)) {
+    for (const nested of value) {
+      deepFreezeJsonValue(nested);
+    }
+    return Object.freeze(value);
+  }
+  if (!isObjectRecord(value)) {
+    return value;
+  }
+  const objectValue = value;
+  for (const nested of Object.values(objectValue)) {
+    if (nested !== void 0) {
+      deepFreezeJsonValue(nested);
+    }
+  }
+  return Object.freeze(objectValue);
+}
+function toJsonSafeClone(value) {
+  const clone = toJsonSafeValue(value);
+  if (clone === void 0) {
+    return void 0;
+  }
+  return clone;
+}
+function toImmutableJsonSafeClone(value) {
+  const clone = toJsonSafeValue(value);
+  if (clone === void 0) {
+    return void 0;
+  }
+  return deepFreezeJsonValue(clone);
+}
+function hasValidThinkingDisplay(value) {
+  return value === void 0 || value === "summarized" || value === "omitted";
+}
+function isClaudeEffortLevel(value) {
+  return typeof value === "string" && CLAUDE_EFFORT_LEVELS.has(value);
+}
+function isClaudeThinkingConfig(value) {
+  if (!isObjectRecord(value)) {
+    return false;
+  }
+  if (value.type === "disabled") {
+    return true;
+  }
+  if (value.type === "adaptive") {
+    return hasValidThinkingDisplay(value.display);
+  }
+  if (value.type === "enabled") {
+    const budgetTokens = value.budgetTokens;
+    return (budgetTokens === void 0 || typeof budgetTokens === "number") && hasValidThinkingDisplay(value.display);
+  }
+  return false;
+}
+function addInvalidClaudeReasoningProviderOptionWarning(warnings, key) {
+  warnings?.push({
+    type: "other",
+    message: `Invalid providerOptions['claude-code'].${key} value was ignored.`
+  });
+}
+function extractClaudeReasoningProviderOptions(providerOptions, warnings) {
+  const options = providerOptions?.["claude-code"];
+  if (options === void 0) {
+    return { hasClaudeReasoningSettings: false };
+  }
+  const result = { hasClaudeReasoningSettings: false };
+  if (options.thinking !== void 0) {
+    if (isClaudeThinkingConfig(options.thinking)) {
+      result.thinking = options.thinking;
+      result.hasClaudeReasoningSettings = true;
+    } else {
+      addInvalidClaudeReasoningProviderOptionWarning(warnings, "thinking");
+    }
+  }
+  if (options.effort !== void 0) {
+    if (isClaudeEffortLevel(options.effort)) {
+      result.effort = options.effort;
+      result.hasClaudeReasoningSettings = true;
+    } else {
+      addInvalidClaudeReasoningProviderOptionWarning(warnings, "effort");
+    }
+  }
+  if (options.maxThinkingTokens !== void 0) {
+    if (typeof options.maxThinkingTokens === "number") {
+      result.maxThinkingTokens = options.maxThinkingTokens;
+      result.hasClaudeReasoningSettings = true;
+    } else {
+      addInvalidClaudeReasoningProviderOptionWarning(warnings, "maxThinkingTokens");
+    }
+  }
+  return result;
+}
 function isContentBlock(item) {
   return typeof item === "object" && item !== null && "type" in item;
 }
@@ -1287,6 +1627,7 @@ function toAsyncIterablePrompt(messagesPrompt, outputStreamEnded, sessionId, con
   };
 }
 var modelMap = {
+  fable: "fable",
   opus: "opus",
   sonnet: "sonnet",
   haiku: "haiku"
@@ -1335,7 +1676,7 @@ function truncateToolResultForStream(result, maxSize = MAX_TOOL_RESULT_SIZE) {
   return result;
 }
 var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
-  specificationVersion = "v3";
+  specificationVersion = "v4";
   defaultObjectGenerationMode = "json";
   supportsImageUrls = false;
   supportedUrls = {};
@@ -1406,6 +1747,81 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     }
     return void 0;
   }
+  invokeObservabilityCallback(callbackName, callback, value) {
+    if (!callback) {
+      return;
+    }
+    const logError = (error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.warn(`[claude-code] ${callbackName} callback failed; ignoring error: ${message}`);
+      if (error instanceof Error && error.stack) {
+        this.logger.debug(`[claude-code] ${callbackName} callback stack: ${error.stack}`);
+      }
+    };
+    try {
+      const result = callback(value);
+      if (result && typeof result.then === "function") {
+        void Promise.resolve(result).catch(logError);
+      }
+    } catch (error) {
+      logError(error);
+    }
+  }
+  invokeSdkMessageCallback(message) {
+    const onSdkMessage = this.settings.onSdkMessage;
+    if (onSdkMessage === void 0) {
+      return;
+    }
+    this.invokeObservabilityCallback(
+      "onSdkMessage",
+      onSdkMessage,
+      toImmutableJsonSafeClone(message)
+    );
+  }
+  notifyQueryCreated(response) {
+    this.settings.onQueryCreated?.(response);
+    const onQueryControllerCreated = this.settings.onQueryControllerCreated;
+    if (onQueryControllerCreated !== void 0) {
+      this.invokeObservabilityCallback(
+        "onQueryControllerCreated",
+        onQueryControllerCreated,
+        createClaudeCodeQueryController(response)
+      );
+    }
+  }
+  trackTaskEvent(event, tracking) {
+    tracking.taskEvents.push(toJsonSafeClone(event));
+    const onTaskEvent = this.settings.onTaskEvent;
+    if (onTaskEvent !== void 0) {
+      this.invokeObservabilityCallback("onTaskEvent", onTaskEvent, toImmutableJsonSafeClone(event));
+    }
+  }
+  trackHookEvent(event, tracking) {
+    tracking.hookEvents.push(toJsonSafeClone(event));
+    const onHookEvent = this.settings.onHookEvent;
+    if (onHookEvent !== void 0) {
+      this.invokeObservabilityCallback("onHookEvent", onHookEvent, toImmutableJsonSafeClone(event));
+    }
+  }
+  trackMcpStatusFromInit(message, tracking) {
+    const servers = message.mcp_servers;
+    tracking.mcpServers = toJsonSafeClone(servers);
+    const statusEvent = {
+      subtype: "init",
+      sessionId: message.session_id,
+      uuid: message.uuid,
+      servers,
+      raw: message
+    };
+    const onMcpStatusChange = this.settings.onMcpStatusChange;
+    if (onMcpStatusChange !== void 0) {
+      this.invokeObservabilityCallback(
+        "onMcpStatusChange",
+        onMcpStatusChange,
+        toImmutableJsonSafeClone(statusEvent)
+      );
+    }
+  }
   /**
    * Single source of truth for the CLI's `--session-id` exclusivity rule.
    *
@@ -1570,7 +1986,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       input,
       providerExecuted: true,
       dynamic: true,
-      // V3 field: indicates tool is provider-defined (not in user's tools map)
+      // V4 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.
@@ -1610,12 +2026,11 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       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.
+      // NonNullable<JSONValue> contract of LanguageModelV4ToolResult.result.
       result: truncatedResult ?? "",
       isError,
-      providerExecuted: true,
       dynamic: true,
-      // V3 field: indicates tool is provider-defined
+      // V4 field: indicates tool is provider-defined
       providerMetadata: {
         "claude-code": {
           // rawResult preserves the original CLI output string before JSON parsing.
@@ -1638,37 +2053,12 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     })() : 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).
+   * Builds a V4 provider `tool-result` part with `isError: true` from a
+   * user-message `tool_error` block. V4 has no provider-level `tool-error`
+   * content or stream part; AI SDK core derives user-facing tool-error
+   * semantics from this result while preserving providerMetadata.
    */
-  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) {
+  buildErroredToolResultPart(toolCallId, toolName, error, parentToolCallId) {
     const rawError = this.serializeToolError(error);
     return {
       type: "tool-result",
@@ -1676,9 +2066,8 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       toolName,
       result: rawError,
       isError: true,
-      providerExecuted: true,
       dynamic: true,
-      // V3 field: indicates tool is provider-defined
+      // V4 field: indicates tool is provider-defined
       providerMetadata: {
         "claude-code": {
           rawError,
@@ -1704,7 +2093,33 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     );
     return true;
   }
-  generateAllWarnings(options, prompt) {
+  resolvePortableReasoningOptions(options, sdkOptions, claudeProviderOptions, warnings) {
+    const hasClaudeSpecificReasoning = this.settings.thinking !== void 0 || this.settings.effort !== void 0 || this.settings.maxThinkingTokens !== void 0 || sdkOptions?.thinking !== void 0 || sdkOptions?.effort !== void 0 || sdkOptions?.maxThinkingTokens !== void 0 || claudeProviderOptions.hasClaudeReasoningSettings;
+    if (hasClaudeSpecificReasoning || !isCustomReasoning(options.reasoning)) {
+      return {};
+    }
+    if (options.reasoning === "none") {
+      return { thinking: { type: "disabled" } };
+    }
+    const effort = mapReasoningToProviderEffort({
+      reasoning: options.reasoning,
+      effortMap: CLAUDE_REASONING_EFFORT_MAP,
+      warnings: warnings ?? []
+    });
+    return effort === void 0 ? {} : { effort };
+  }
+  applyClaudeReasoningProviderOptions(opts, claudeProviderOptions) {
+    if (claudeProviderOptions.thinking !== void 0) {
+      opts.thinking = claudeProviderOptions.thinking;
+    }
+    if (claudeProviderOptions.effort !== void 0) {
+      opts.effort = claudeProviderOptions.effort;
+    }
+    if (claudeProviderOptions.maxThinkingTokens !== void 0) {
+      opts.maxThinkingTokens = claudeProviderOptions.maxThinkingTokens;
+    }
+  }
+  generateAllWarnings(options, prompt, sdkOptions) {
     const warnings = [];
     const unsupportedParams = [];
     if (options.temperature !== void 0) unsupportedParams.push("temperature");
@@ -1771,9 +2186,18 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
         message: promptWarning
       });
     }
+    this.resolvePortableReasoningOptions(
+      options,
+      sdkOptions,
+      extractClaudeReasoningProviderOptions(options.providerOptions, warnings),
+      warnings
+    );
     return warnings;
   }
-  createQueryOptions(abortController, responseFormat, stderrCollector, sdkOptions, effectiveResume) {
+  createQueryOptions(abortController, options, stderrCollector, sdkOptions, effectiveResume) {
+    const claudeReasoningProviderOptions = extractClaudeReasoningProviderOptions(
+      options.providerOptions
+    );
     const opts = {
       model: this.getModel(),
       abortController,
@@ -1801,8 +2225,14 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       sandbox: this.settings.sandbox,
       tools: this.settings.tools,
       mcpServers: this.settings.mcpServers,
-      canUseTool: this.settings.canUseTool
+      canUseTool: this.settings.canUseTool,
+      onElicitation: this.settings.onElicitation,
+      agent: this.settings.agent
     };
+    Object.assign(
+      opts,
+      this.resolvePortableReasoningOptions(options, sdkOptions, claudeReasoningProviderOptions)
+    );
     if (this.settings.onUserDialog !== void 0) {
       opts.onUserDialog = this.settings.onUserDialog;
     }
@@ -1931,6 +2361,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
         }
       }
     }
+    this.applyClaudeReasoningProviderOptions(opts, claudeReasoningProviderOptions);
     this.applySessionResolution(opts, effectiveResume);
     if (typeof opts.fallbackModel === "string" && opts.fallbackModel === opts.model) {
       throw new Error(
@@ -1953,9 +2384,9 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       mergedEnv.CLAUDE_AGENT_SDK_CLIENT_APP = DEFAULT_CLIENT_APP;
     }
     opts.env = mergedEnv;
-    if (responseFormat?.type === "json" && responseFormat.schema) {
+    if (options.responseFormat?.type === "json" && options.responseFormat.schema) {
       const { schema: sanitizedSchema, strippedFormatPaths } = sanitizeJsonSchemaForOutputFormat(
-        responseFormat.schema
+        options.responseFormat.schema
       );
       if (strippedFormatPaths.length > 0) {
         this.logger.debug(
@@ -2029,7 +2460,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     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.`,
+        message: `${originalMessage}. The requested model was not found. Verify the model id passed to the provider (e.g. 'fable', 'opus', 'sonnet', 'haiku', or a full model name) and that your account has access to it.`,
         code: errorCode || void 0,
         exitCode,
         stderr,
@@ -2099,16 +2530,159 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
         break;
       case "permission_denied": {
         const reason = message.decision_reason ?? message.message;
+        const raw = toJsonSafeValue(message);
         tracking.permissionDenials.push({
           toolName: message.tool_name,
           toolUseId: message.tool_use_id,
-          ...reason !== void 0 && { reason }
+          ...message.agent_id !== void 0 && { agentId: message.agent_id },
+          ...message.decision_reason_type !== void 0 && {
+            decisionReasonType: message.decision_reason_type
+          },
+          ...reason !== void 0 && { reason },
+          ...raw !== void 0 && { raw }
         });
         this.logger.warn(
           `[claude-code] Permission denied - Tool: ${message.tool_name}${reason ? `, Reason: ${reason}` : ""}`
         );
         break;
       }
+      case "task_started":
+        this.trackTaskEvent(
+          {
+            subtype: "task_started",
+            taskId: message.task_id,
+            ...message.tool_use_id !== void 0 && { toolUseId: message.tool_use_id },
+            description: message.description,
+            ...message.subagent_type !== void 0 && { subagentType: message.subagent_type },
+            ...message.task_type !== void 0 && { taskType: message.task_type },
+            ...message.workflow_name !== void 0 && { workflowName: message.workflow_name },
+            ...message.prompt !== void 0 && { prompt: message.prompt },
+            ...message.skip_transcript !== void 0 && {
+              skipTranscript: message.skip_transcript
+            },
+            uuid: message.uuid,
+            sessionId: message.session_id,
+            raw: message
+          },
+          tracking
+        );
+        this.logger.debug(`[claude-code] Task started - ID: ${message.task_id}`);
+        break;
+      case "task_progress":
+        this.trackTaskEvent(
+          {
+            subtype: "task_progress",
+            taskId: message.task_id,
+            ...message.tool_use_id !== void 0 && { toolUseId: message.tool_use_id },
+            description: message.description,
+            ...message.subagent_type !== void 0 && { subagentType: message.subagent_type },
+            usage: message.usage,
+            ...message.last_tool_name !== void 0 && { lastToolName: message.last_tool_name },
+            ...message.summary !== void 0 && { summary: message.summary },
+            uuid: message.uuid,
+            sessionId: message.session_id,
+            raw: message
+          },
+          tracking
+        );
+        this.logger.debug(`[claude-code] Task progress - ID: ${message.task_id}`);
+        break;
+      case "task_updated":
+        this.trackTaskEvent(
+          {
+            subtype: "task_updated",
+            taskId: message.task_id,
+            patch: message.patch,
+            uuid: message.uuid,
+            sessionId: message.session_id,
+            raw: message
+          },
+          tracking
+        );
+        this.logger.debug(`[claude-code] Task updated - ID: ${message.task_id}`);
+        break;
+      case "task_notification":
+        this.trackTaskEvent(
+          {
+            subtype: "task_notification",
+            taskId: message.task_id,
+            ...message.tool_use_id !== void 0 && { toolUseId: message.tool_use_id },
+            status: message.status,
+            outputFile: message.output_file,
+            summary: message.summary,
+            ...message.usage !== void 0 && { usage: message.usage },
+            ...message.skip_transcript !== void 0 && {
+              skipTranscript: message.skip_transcript
+            },
+            uuid: message.uuid,
+            sessionId: message.session_id,
+            raw: message
+          },
+          tracking
+        );
+        this.logger.debug(
+          `[claude-code] Task notification - ID: ${message.task_id}, Status: ${message.status}`
+        );
+        break;
+      case "hook_started":
+        this.trackHookEvent(
+          {
+            subtype: "hook_started",
+            hookId: message.hook_id,
+            hookName: message.hook_name,
+            hookEvent: message.hook_event,
+            uuid: message.uuid,
+            sessionId: message.session_id,
+            raw: message
+          },
+          tracking
+        );
+        this.logger.debug(
+          `[claude-code] Hook started - ID: ${message.hook_id}, Event: ${message.hook_event}`
+        );
+        break;
+      case "hook_progress":
+        this.trackHookEvent(
+          {
+            subtype: "hook_progress",
+            hookId: message.hook_id,
+            hookName: message.hook_name,
+            hookEvent: message.hook_event,
+            stdout: message.stdout,
+            stderr: message.stderr,
+            output: message.output,
+            uuid: message.uuid,
+            sessionId: message.session_id,
+            raw: message
+          },
+          tracking
+        );
+        this.logger.debug(
+          `[claude-code] Hook progress - ID: ${message.hook_id}, Event: ${message.hook_event}`
+        );
+        break;
+      case "hook_response":
+        this.trackHookEvent(
+          {
+            subtype: "hook_response",
+            hookId: message.hook_id,
+            hookName: message.hook_name,
+            hookEvent: message.hook_event,
+            output: message.output,
+            stdout: message.stdout,
+            stderr: message.stderr,
+            ...message.exit_code !== void 0 && { exitCode: message.exit_code },
+            outcome: message.outcome,
+            uuid: message.uuid,
+            sessionId: message.session_id,
+            raw: message
+          },
+          tracking
+        );
+        this.logger.debug(
+          `[claude-code] Hook response - ID: ${message.hook_id}, Outcome: ${message.outcome}`
+        );
+        break;
       case "mirror_error": {
         const mirrorError = message.error ?? "unknown error";
         const mirrorSessionId = message.key?.sessionId ?? message.session_id ?? "unknown";
@@ -2161,12 +2735,21 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       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
-        });
+      if (alreadyTracked) {
+        continue;
       }
+      const agentId = typeof denial.agent_id === "string" ? denial.agent_id : typeof denial.agentId === "string" ? denial.agentId : void 0;
+      const decisionReasonType = typeof denial.decision_reason_type === "string" ? denial.decision_reason_type : typeof denial.decisionReasonType === "string" ? denial.decisionReasonType : void 0;
+      const reason = typeof denial.decision_reason === "string" ? denial.decision_reason : typeof denial.reason === "string" ? denial.reason : typeof denial.message === "string" ? denial.message : void 0;
+      const raw = toJsonSafeValue(denial);
+      tracking.permissionDenials.push({
+        toolName: denial.tool_name,
+        toolUseId: denial.tool_use_id,
+        ...agentId !== void 0 && { agentId },
+        ...decisionReasonType !== void 0 && { decisionReasonType },
+        ...reason !== void 0 && { reason },
+        ...raw !== void 0 && { raw }
+      });
     }
   }
   /**
@@ -2175,11 +2758,10 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
    * 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.
+   * result without emitting one. Drained messages still pass through the
+   * generic raw SDK callback before prompt-specific handling.
    */
-  async drainPromptSuggestion(response, onPromptSuggestion) {
-    const iterator = response[Symbol.asyncIterator]();
+  async drainPromptSuggestion(iterator, onPromptSuggestion) {
     let drainTimer;
     const drainTimeout = new Promise((resolve) => {
       drainTimer = setTimeout(
@@ -2202,8 +2784,9 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
         }
         const trailingMessage = winner.value;
         this.logger.debug(`[claude-code] Post-result message type: ${trailingMessage.type}`);
+        this.invokeSdkMessageCallback(trailingMessage);
         if (trailingMessage.type === "prompt_suggestion") {
-          onPromptSuggestion(trailingMessage.suggestion);
+          onPromptSuggestion?.(trailingMessage.suggestion);
           void iterator.return?.().catch(() => {
           });
           break;
@@ -2244,7 +2827,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     const effectiveResume = this.getEffectiveResume(sdkOptions);
     const queryOptions = this.createQueryOptions(
       abortController,
-      options.responseFormat,
+      options,
       stderrCollector,
       sdkOptions,
       effectiveResume
@@ -2318,9 +2901,15 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       apiRetries: 0,
       permissionDenials: [],
       mirrorErrors: [],
-      estimatedThinkingTokens: 0
+      estimatedThinkingTokens: 0,
+      taskEvents: [],
+      hookEvents: []
     };
-    const warnings = this.generateAllWarnings(options, messagesPrompt);
+    const warnings = this.generateAllWarnings(
+      options,
+      messagesPrompt,
+      sdkOptions
+    );
     if (messageWarnings) {
       messageWarnings.forEach((warning) => {
         warnings.push({
@@ -2332,7 +2921,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     const modeSetting = this.settings.streamingInput ?? "auto";
     const effectiveCanUseTool = sdkOptions?.canUseTool ?? this.settings.canUseTool;
     const effectivePermissionPromptToolName = sdkOptions?.permissionPromptToolName ?? this.settings.permissionPromptToolName;
-    const wantsStreamInput = modeSetting === "always" || modeSetting === "auto" && !!effectiveCanUseTool;
+    const wantsStreamInput = modeSetting === "always" || modeSetting === "auto" && (!!effectiveCanUseTool || hasImageParts);
     if (!wantsStreamInput && hasImageParts) {
       warnings.push({
         type: "other",
@@ -2364,7 +2953,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
         prompt: sdkPrompt,
         options: queryOptions
       });
-      this.settings.onQueryCreated?.(response);
+      this.notifyQueryCreated(response);
       let lastAssistantErrorKind;
       const sdkIterator = response[Symbol.asyncIterator]();
       const detachableResponse = {
@@ -2379,6 +2968,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       };
       for await (const message of detachableResponse) {
         this.logger.debug(`[claude-code] Received message type: ${message.type}`);
+        this.invokeSdkMessageCallback(message);
         if (message.type === "assistant") {
           if (typeof message.error === "string") {
             lastAssistantErrorKind = message.error;
@@ -2407,6 +2997,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
               } else if (block.type === "tool_use") {
                 const [tool3] = this.extractToolUses([block]);
                 if (!tool3) continue;
+                if (isInternalStructuredOutputTool(tool3.name, options)) continue;
                 const parentToolCallId = isSubagentToolName(tool3.name) ? null : resolveToolParentId(
                   sdkParentToolUseId,
                   tool3.parentToolUseId,
@@ -2517,7 +3108,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
               kind: "tool-error",
               ...resultMessageUuid !== void 0 && { uuid: resultMessageUuid },
               toolCallId: error.id,
-              part: this.buildToolErrorResultPart(
+              part: this.buildErroredToolResultPart(
                 error.id,
                 toolName,
                 error.error,
@@ -2575,14 +3166,19 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
           }
           const stopReason = "stop_reason" in message ? message.stop_reason : void 0;
           finishReason = mapClaudeCodeFinishReason(message.subtype, stopReason);
+          if (structuredOutput !== void 0 && finishReason.unified === "tool-calls") {
+            finishReason = { unified: "stop", raw: finishReason.raw };
+          }
           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);
+          const shouldDrainPromptSuggestion = effectivePromptSuggestions !== false && (this.settings.onPromptSuggestion !== void 0 || this.settings.onSdkMessage !== void 0);
+          if (shouldDrainPromptSuggestion) {
+            await this.drainPromptSuggestion(sdkIterator, this.settings.onPromptSuggestion);
           }
           break;
         } else if (message.type === "system" && message.subtype === "init") {
           this.logMcpConnectionIssues(message.mcp_servers);
+          this.trackMcpStatusFromInit(message, metadataTracking);
           this.setSessionId(message.session_id);
           this.logger.info(`[claude-code] Session initialized: ${message.session_id}`);
         } else if (message.type === "system") {
@@ -2685,6 +3281,15 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
           ...metadataTracking.permissionDenials.length > 0 && {
             permissionDenials: metadataTracking.permissionDenials
           },
+          ...metadataTracking.taskEvents.length > 0 && {
+            taskEvents: metadataTracking.taskEvents
+          },
+          ...metadataTracking.hookEvents.length > 0 && {
+            hookEvents: metadataTracking.hookEvents
+          },
+          ...metadataTracking.mcpServers !== void 0 && {
+            mcpServers: metadataTracking.mcpServers
+          },
           ...metadataTracking.mirrorErrors.length > 0 && {
             mirrorErrors: metadataTracking.mirrorErrors
           },
@@ -2722,7 +3327,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     const effectiveResume = this.getEffectiveResume(sdkOptions);
     const queryOptions = this.createQueryOptions(
       abortController,
-      options.responseFormat,
+      options,
       stderrCollector,
       sdkOptions,
       effectiveResume
@@ -2734,7 +3339,11 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     if (queryOptions.includePartialMessages === void 0) {
       queryOptions.includePartialMessages = true;
     }
-    const warnings = this.generateAllWarnings(options, messagesPrompt);
+    const warnings = this.generateAllWarnings(
+      options,
+      messagesPrompt,
+      sdkOptions
+    );
     if (messageWarnings) {
       messageWarnings.forEach((warning) => {
         warnings.push({
@@ -2746,7 +3355,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     const modeSetting = this.settings.streamingInput ?? "auto";
     const effectiveCanUseTool = sdkOptions?.canUseTool ?? this.settings.canUseTool;
     const effectivePermissionPromptToolName = sdkOptions?.permissionPromptToolName ?? this.settings.permissionPromptToolName;
-    const wantsStreamInput = modeSetting === "always" || modeSetting === "auto" && !!effectiveCanUseTool;
+    const wantsStreamInput = modeSetting === "always" || modeSetting === "auto" && (!!effectiveCanUseTool || hasImageParts);
     if (!wantsStreamInput && hasImageParts) {
       warnings.push({
         type: "other",
@@ -2813,9 +3422,13 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
           apiRetries: 0,
           permissionDenials: [],
           mirrorErrors: [],
-          estimatedThinkingTokens: 0
+          estimatedThinkingTokens: 0,
+          taskEvents: [],
+          hookEvents: []
         };
         const toolBlocksByIndex = /* @__PURE__ */ new Map();
+        const structuredOutputBlockIndexes = /* @__PURE__ */ new Set();
+        const nonTextToolBlockIndexes = /* @__PURE__ */ new Set();
         const toolInputAccumulators = /* @__PURE__ */ new Map();
         const textBlocksByIndex = /* @__PURE__ */ new Map();
         let textStreamedViaContentBlock = false;
@@ -2878,9 +3491,24 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
             prompt: sdkPrompt,
             options: queryOptions
           });
-          this.settings.onQueryCreated?.(response);
-          for await (const message of response) {
+          this.notifyQueryCreated(response);
+          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] Stream received message type: ${message.type}`);
+            this.invokeSdkMessageCallback(message);
+            if (options.includeRawChunks) {
+              controller.enqueue({ type: "raw", rawValue: message });
+            }
             if (message.type === "stream_event") {
               const streamEvent = message;
               const event = streamEvent.event;
@@ -2912,7 +3540,8 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                 const jsonDelta = event.delta.partial_json;
                 hasReceivedStreamEvents = true;
                 const blockIndex = "index" in event ? event.index : -1;
-                if (options.responseFormat?.type === "json") {
+                const isStructuredOutputDelta = structuredOutputBlockIndexes.has(blockIndex) || !toolBlocksByIndex.has(blockIndex) && !nonTextToolBlockIndexes.has(blockIndex);
+                if (options.responseFormat?.type === "json" && isStructuredOutputDelta) {
                   if (!textPartId) {
                     textPartId = generateId();
                     controller.enqueue({
@@ -2942,12 +3571,25 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                   continue;
                 }
               }
+              if (event.type === "content_block_start" && "content_block" in event && isNonTextToolUseContentBlockType(event.content_block?.type)) {
+                const blockIndex = "index" in event ? event.index : -1;
+                hasReceivedStreamEvents = true;
+                nonTextToolBlockIndexes.add(blockIndex);
+                structuredOutputBlockIndexes.delete(blockIndex);
+                continue;
+              }
               if (event.type === "content_block_start" && "content_block" in event && event.content_block?.type === "tool_use") {
                 const blockIndex = "index" in event ? event.index : -1;
                 const toolBlock = event.content_block;
                 const toolId = typeof toolBlock.id === "string" && toolBlock.id.length > 0 ? toolBlock.id : generateId();
                 const toolName = typeof toolBlock.name === "string" && toolBlock.name.length > 0 ? toolBlock.name : _ClaudeCodeLanguageModel.UNKNOWN_TOOL_NAME;
                 hasReceivedStreamEvents = true;
+                nonTextToolBlockIndexes.delete(blockIndex);
+                if (isInternalStructuredOutputTool(toolName, options)) {
+                  structuredOutputBlockIndexes.add(blockIndex);
+                  continue;
+                }
+                structuredOutputBlockIndexes.delete(blockIndex);
                 if (textPartId) {
                   const closedTextId = textPartId;
                   controller.enqueue({
@@ -3094,6 +3736,12 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                   toolInputAccumulators.delete(toolId);
                   continue;
                 }
+                if (structuredOutputBlockIndexes.delete(blockIndex)) {
+                  continue;
+                }
+                if (nonTextToolBlockIndexes.delete(blockIndex)) {
+                  continue;
+                }
                 const textId = textBlocksByIndex.get(blockIndex);
                 if (textId) {
                   this.logger.debug(
@@ -3140,7 +3788,9 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
               }
               const sdkParentToolUseId = message.parent_tool_use_id;
               const content = message.message.content;
-              const tools = this.extractToolUses(content);
+              const tools = this.extractToolUses(content).filter(
+                (tool3) => !isInternalStructuredOutputTool(tool3.name, options)
+              );
               if (textPartId && tools.length > 0) {
                 const closedTextId = textPartId;
                 controller.enqueue({
@@ -3193,7 +3843,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                     toolName: tool3.name,
                     providerExecuted: true,
                     dynamic: true,
-                    // V3 field: indicates tool is provider-defined
+                    // V4 field: indicates tool is provider-defined
                     providerMetadata: {
                       "claude-code": {
                         parentToolCallId: state.parentToolCallId ?? null
@@ -3398,7 +4048,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                       toolName,
                       providerExecuted: true,
                       dynamic: true,
-                      // V3 field: indicates tool is provider-defined
+                      // V4 field: indicates tool is provider-defined
                       providerMetadata: {
                         "claude-code": {
                           parentToolCallId: state.parentToolCallId ?? null
@@ -3450,19 +4100,47 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                   );
                   state = {
                     name: toolName,
-                    inputStarted: true,
-                    inputClosed: true,
+                    inputStarted: false,
+                    inputClosed: false,
                     callEmitted: false,
                     parentToolCallId: errorResolvedParentId
                   };
                   toolStates.set(error.id, state);
+                  if (!state.inputStarted) {
+                    controller.enqueue({
+                      type: "tool-input-start",
+                      id: error.id,
+                      toolName,
+                      providerExecuted: true,
+                      dynamic: true,
+                      // V4 field: indicates tool is provider-defined
+                      providerMetadata: {
+                        "claude-code": {
+                          parentToolCallId: state.parentToolCallId ?? null
+                        }
+                      }
+                    });
+                    state.inputStarted = true;
+                  }
+                  if (!state.inputClosed) {
+                    controller.enqueue({
+                      type: "tool-input-end",
+                      id: error.id
+                    });
+                    state.inputClosed = true;
+                  }
                 }
                 emitToolCall(error.id, state);
                 if (isSubagentToolName(toolName)) {
                   activeTaskTools.delete(error.id);
                 }
                 controller.enqueue(
-                  this.buildToolErrorPart(error.id, toolName, error.error, state.parentToolCallId)
+                  this.buildErroredToolResultPart(
+                    error.id,
+                    toolName,
+                    error.error,
+                    state.parentToolCallId
+                  )
                 );
               }
             } else if (message.type === "result") {
@@ -3492,13 +4170,16 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                 );
               }
               const stopReason = "stop_reason" in message ? message.stop_reason : void 0;
-              const finishReason = mapClaudeCodeFinishReason(
+              let finishReason = mapClaudeCodeFinishReason(
                 message.subtype,
                 stopReason
               );
-              this.logger.debug(`[claude-code] Stream finish reason: ${finishReason.unified}`);
               this.setSessionId(message.session_id);
               const structuredOutput = "structured_output" in message ? message.structured_output : void 0;
+              if (structuredOutput !== void 0 && finishReason.unified === "tool-calls") {
+                finishReason = { unified: "stop", raw: finishReason.raw };
+              }
+              this.logger.debug(`[claude-code] Stream finish reason: ${finishReason.unified}`);
               const alreadyStreamedJson = hasStreamedJson && options.responseFormat?.type === "json" && hasReceivedStreamEvents;
               if (alreadyStreamedJson) {
                 if (textPartId) {
@@ -3612,6 +4293,15 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                     ...metadataTracking.permissionDenials.length > 0 && {
                       permissionDenials: metadataTracking.permissionDenials
                     },
+                    ...metadataTracking.taskEvents.length > 0 && {
+                      taskEvents: metadataTracking.taskEvents
+                    },
+                    ...metadataTracking.hookEvents.length > 0 && {
+                      hookEvents: metadataTracking.hookEvents
+                    },
+                    ...metadataTracking.mcpServers !== void 0 && {
+                      mcpServers: metadataTracking.mcpServers
+                    },
                     ...metadataTracking.mirrorErrors.length > 0 && {
                       mirrorErrors: metadataTracking.mirrorErrors
                     },
@@ -3629,12 +4319,14 @@ 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);
+              const shouldDrainPromptSuggestion = effectivePromptSuggestions !== false && (this.settings.onPromptSuggestion !== void 0 || this.settings.onSdkMessage !== void 0);
+              if (shouldDrainPromptSuggestion) {
+                await this.drainPromptSuggestion(sdkIterator, this.settings.onPromptSuggestion);
               }
               return;
             } else if (message.type === "system" && message.subtype === "init") {
               this.logMcpConnectionIssues(message.mcp_servers);
+              this.trackMcpStatusFromInit(message, metadataTracking);
               this.setSessionId(message.session_id);
               this.logger.info(`[claude-code] Stream session initialized: ${message.session_id}`);
               controller.enqueue({
@@ -3708,6 +4400,15 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                   ...metadataTracking.permissionDenials.length > 0 && {
                     permissionDenials: metadataTracking.permissionDenials
                   },
+                  ...metadataTracking.taskEvents.length > 0 && {
+                    taskEvents: metadataTracking.taskEvents
+                  },
+                  ...metadataTracking.hookEvents.length > 0 && {
+                    hookEvents: metadataTracking.hookEvents
+                  },
+                  ...metadataTracking.mcpServers !== void 0 && {
+                    mcpServers: metadataTracking.mcpServers
+                  },
                   ...metadataTracking.mirrorErrors.length > 0 && {
                     mirrorErrors: metadataTracking.mirrorErrors
                   },
@@ -3755,19 +4456,23 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     };
   }
   serializeWarningsForMetadata(warnings) {
-    const result = warnings.map((w) => {
-      const base = { type: w.type };
-      if ("message" in w) {
-        const m = w.message;
-        if (m !== void 0) base.message = String(m);
-      }
-      if (w.type === "unsupported" || w.type === "compatibility") {
-        const feature = w.feature;
-        if (feature !== void 0) base.feature = String(feature);
-        if ("details" in w) {
-          const d = w.details;
-          if (d !== void 0) base.details = String(d);
-        }
+    const result = warnings.map((warning) => {
+      const base = { type: warning.type };
+      switch (warning.type) {
+        case "unsupported":
+        case "compatibility":
+          base.feature = warning.feature;
+          if (warning.details !== void 0) {
+            base.details = warning.details;
+          }
+          break;
+        case "deprecated":
+          base.setting = warning.setting;
+          base.message = warning.message;
+          break;
+        case "other":
+          base.message = warning.message;
+          break;
       }
       return base;
     });
@@ -3810,7 +4515,7 @@ function createClaudeCode(options = {}) {
   };
   provider.languageModel = createModel;
   provider.chat = createModel;
-  provider.specificationVersion = "v3";
+  provider.specificationVersion = "v4";
   provider.embeddingModel = (modelId) => {
     throw new NoSuchModelError2({
       modelId,
@@ -3834,7 +4539,9 @@ import {
   SYSTEM_PROMPT_DYNAMIC_BOUNDARY,
   InMemorySessionStore,
   HOOK_EVENTS,
-  AbortError
+  AbortError,
+  resolveSettings,
+  filterEscalatingDefaultMode
 } from "@anthropic-ai/claude-agent-sdk";
 import {
   listSessions,
@@ -3854,6 +4561,16 @@ import { startup } from "@anthropic-ai/claude-agent-sdk";
 // src/mcp-helpers.ts
 import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
 import "zod";
+var warnedDescriptionFunctionToolNames = /* @__PURE__ */ new Set();
+function warnDiscardedDescriptionFunction(toolName) {
+  if (warnedDescriptionFunctionToolNames.has(toolName)) {
+    return;
+  }
+  warnedDescriptionFunctionToolNames.add(toolName);
+  console.warn(
+    `[claude-code] AI SDK tool "${toolName}" has a function-valued description; createAiSdkMcpServer cannot evaluate it during MCP bridging, so the bridged tool description was omitted.`
+  );
+}
 function buildIsErrorResult(text) {
   return {
     isError: true,
@@ -3896,7 +4613,11 @@ function createCustomMcpServer(config) {
 }
 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;
+  if (typeof schema !== "object" || schema === null) {
+    return false;
+  }
+  const candidate = schema;
+  return candidate[AI_SDK_SCHEMA_SYMBOL] === true && "jsonSchema" in candidate && "validate" in candidate;
 }
 function isZodObjectSchema(schema) {
   if (typeof schema !== "object" || schema === null) {
@@ -3931,9 +4652,13 @@ function createAiSdkMcpServer(name, tools) {
       );
     }
     const zodSchema = def.inputSchema;
+    const description = typeof def.description === "string" ? def.description : "";
+    if (typeof def.description === "function") {
+      warnDiscardedDescriptionFunction(toolName);
+    }
     return tool(
       toolName,
-      def.description ?? "",
+      description,
       zodSchema.shape,
       async (args, extra) => {
         try {
@@ -3966,10 +4691,12 @@ export {
   createAiSdkMcpServer,
   createAuthenticationError,
   createClaudeCode,
+  createClaudeCodeQueryController,
   createCustomMcpServer,
   createSdkMcpServer2 as createSdkMcpServer,
   createTimeoutError,
   deleteSession,
+  filterEscalatingDefaultMode,
   foldSessionSummary,
   forkSession,
   getErrorMetadata,
@@ -3982,6 +4709,7 @@ export {
   listSessions,
   listSubagents,
   renameSession,
+  resolveSettings,
   startup,
   tagSession,
   tool2 as tool