@mastra/claude 0.3.0 → 0.3.1-alpha.0

package/dist/index.js

@@ -1,1159 +1,949 @@
-import { randomUUID } from 'crypto';
-import { ReadableStream, TransformStream } from 'stream/web';
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { Agent } from '@mastra/core/agent';
-import { RequestContext } from '@mastra/core/request-context';
-import { ChunkFrom, MastraModelOutput } from '@mastra/core/stream';
-import { MessageList } from '@mastra/core/agent/message-list';
-import { getOrCreateSpan, EntityType, SpanType, executeWithContext } from '@mastra/core/observability';
-import { toStandardSchema, standardSchemaToJSONSchema } from '@mastra/core/schema';
-
-// src/index.ts
+import { randomUUID } from "crypto";
+import { ReadableStream, TransformStream } from "stream/web";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { Agent } from "@mastra/core/agent";
+import { RequestContext } from "@mastra/core/request-context";
+import { ChunkFrom, MastraModelOutput } from "@mastra/core/stream";
+import { MessageList } from "@mastra/core/agent/message-list";
+import { EntityType, SpanType, executeWithContext, getOrCreateSpan } from "@mastra/core/observability";
+import { standardSchemaToJSONSchema, toStandardSchema } from "@mastra/core/schema";
+//#region src/utils.ts
 function createNoopModel({ modelId, provider }) {
-  return {
-    modelId,
-    provider,
-    specificationVersion: "v3",
-    supportedUrls: {},
-    doGenerate: async () => createNoopStreamResult(),
-    doStream: async () => createNoopStreamResult()
-  };
+	return {
+		modelId,
+		provider,
+		specificationVersion: "v3",
+		supportedUrls: {},
+		doGenerate: async () => createNoopStreamResult(),
+		doStream: async () => createNoopStreamResult()
+	};
 }
 function createNoopStreamResult() {
-  return {
-    stream: new ReadableStream({
-      start: (controller) => controller.close()
-    })
-  };
-}
-function createCompletedMastraStream({
-  runId,
-  prompt,
-  text,
-  responseId,
-  modelId,
-  usage,
-  providerMetadata,
-  costContext,
-  object
-}) {
-  return new ReadableStream({
-    start(controller) {
-      const textId = randomUUID();
-      enqueueStartChunks(controller, {
-        runId,
-        prompt,
-        textId,
-        responseId,
-        modelId,
-        providerMetadata
-      });
-      if (text) {
-        enqueueTextDelta(controller, runId, textId, text);
-      }
-      enqueueFinishChunks(controller, {
-        runId,
-        prompt,
-        textId,
-        text,
-        responseId,
-        modelId,
-        usage,
-        providerMetadata,
-        costContext,
-        object
-      });
-      controller.close();
-    }
-  });
-}
-function createMastraOutput({
-  messages,
-  runId,
-  modelId,
-  provider,
-  stream,
-  responseText = "",
-  options
-}) {
-  const messageList = new MessageList();
-  messageList.add(messages, "input");
-  messageList.add([{ role: "assistant", content: responseText }], "response");
-  return new MastraModelOutput({
-    model: {
-      modelId,
-      provider,
-      version: "v3"
-    },
-    stream,
-    messageList,
-    messageId: randomUUID(),
-    options: {
-      ...options,
-      runId
-    }
-  });
-}
-function toFullOutput({
-  messages,
-  runId,
-  provider,
-  result,
-  options
-}) {
-  const text = result.content.map((part) => part.text).join("");
-  const stream = createCompletedMastraStream({
-    runId,
-    prompt: promptToText(messages),
-    text,
-    responseId: result.response.id,
-    modelId: result.response.modelId,
-    usage: toLanguageModelUsage(result.usage),
-    providerMetadata: result.providerMetadata,
-    costContext: result.costContext,
-    object: result.object
-  });
-  return createMastraOutput({
-    messages,
-    runId,
-    modelId: result.response.modelId,
-    provider,
-    stream,
-    responseText: text,
-    options
-  }).getFullOutput();
-}
-function createSDKAgentTelemetry({
-  agentId,
-  agentName,
-  provider,
-  modelId,
-  messages,
-  prompt,
-  runId,
-  streaming,
-  method,
-  requestContext,
-  instructions,
-  maxSteps,
-  tracingOptions,
-  tracingContext,
-  onFinish,
-  onStepFinish,
-  mastra
-}) {
-  const agentSpan = getOrCreateSpan({
-    type: SpanType.AGENT_RUN,
-    name: `agent run: '${agentId}'`,
-    entityType: EntityType.AGENT,
-    entityId: agentId,
-    entityName: agentName,
-    input: messages,
-    attributes: {
-      prompt,
-      instructions,
-      maxSteps
-    },
-    metadata: {
-      runId,
-      sdkAgent: true,
-      sdkProvider: provider,
-      sdkMethod: method
-    },
-    tracingOptions,
-    tracingContext,
-    requestContext,
-    mastra
-  });
-  const modelSpan = agentSpan?.createChildSpan({
-    type: SpanType.MODEL_GENERATION,
-    name: `llm: '${modelId}'`,
-    input: {
-      messages
-    },
-    attributes: {
-      model: modelId,
-      provider,
-      streaming
-    },
-    metadata: {
-      runId,
-      sdkAgent: true,
-      sdkProvider: provider,
-      sdkMethod: method
-    },
-    requestContext
-  });
-  const modelSpanTracker = getModelSpanTracker(modelSpan);
-  const toolSpans = /* @__PURE__ */ new Map();
-  let ended = false;
-  const startToolCall = ({ toolCallId, toolName, input }) => {
-    if (toolSpans.has(toolCallId)) {
-      return;
-    }
-    const parentSpan = agentSpan ?? modelSpan;
-    if (!parentSpan) {
-      return;
-    }
-    const mcp = parseMcpToolName(toolName);
-    const span = mcp ? parentSpan.createChildSpan({
-      type: SpanType.MCP_TOOL_CALL,
-      name: `mcp_tool: '${toolName}' on '${mcp.serverName}'`,
-      input,
-      entityType: EntityType.TOOL,
-      entityId: toolName,
-      entityName: toolName,
-      attributes: {
-        mcpServer: mcp.serverName
-      },
-      metadata: {
-        runId,
-        sdkAgent: true,
-        sdkProvider: provider,
-        sdkMethod: method,
-        toolCallId
-      },
-      requestContext
-    }) : parentSpan.createChildSpan({
-      type: SpanType.TOOL_CALL,
-      name: `tool: '${toolName}'`,
-      input,
-      entityType: EntityType.TOOL,
-      entityId: toolName,
-      entityName: toolName,
-      attributes: {
-        toolType: "tool"
-      },
-      metadata: {
-        runId,
-        sdkAgent: true,
-        sdkProvider: provider,
-        sdkMethod: method,
-        toolCallId
-      },
-      requestContext
-    });
-    toolSpans.set(toolCallId, span);
-  };
-  const endToolCall = ({ toolCallId, output, isError }) => {
-    const span = toolSpans.get(toolCallId);
-    if (!span) {
-      return;
-    }
-    toolSpans.delete(toolCallId);
-    if (isError) {
-      span.error({
-        error: output instanceof Error ? output : new Error(typeof output === "string" ? output : "SDK tool call failed"),
-        attributes: { success: false }
-      });
-      return;
-    }
-    span.end({
-      output,
-      attributes: { success: true }
-    });
-  };
-  const closeOpenToolSpans = (success, error) => {
-    for (const [toolCallId, span] of toolSpans) {
-      toolSpans.delete(toolCallId);
-      if (success) {
-        span.end({ attributes: { success: true } });
-        continue;
-      }
-      const normalized = error instanceof Error ? error : new Error(String(error ?? "SDK agent run failed"));
-      span.error({ error: normalized, attributes: { success: false } });
-    }
-  };
-  const endModel = ({
-    text,
-    usage,
-    providerMetadata,
-    finishReason = "stop",
-    responseId,
-    responseModel,
-    costContext
-  }) => {
-    if (modelSpanTracker) {
-      modelSpanTracker.endGeneration({
-        output: {
-          text
-        },
-        attributes: {
-          finishReason,
-          responseId,
-          responseModel,
-          costContext
-        },
-        usage,
-        providerMetadata
-      });
-      return;
-    }
-    modelSpan?.end({
-      output: {
-        text
-      },
-      attributes: {
-        finishReason,
-        responseId,
-        responseModel,
-        usage: usage ? toUsageStats(usage) : void 0,
-        costContext
-      }
-    });
-  };
-  const end = (result) => {
-    if (ended) {
-      return;
-    }
-    ended = true;
-    closeOpenToolSpans(true);
-    endModel(result);
-    agentSpan?.end({
-      output: {
-        text: result.text
-      }
-    });
-  };
-  const fail = (error) => {
-    if (ended) {
-      return;
-    }
-    ended = true;
-    const normalized = error instanceof Error ? error : new Error(String(error));
-    closeOpenToolSpans(false, normalized);
-    if (modelSpanTracker) {
-      modelSpanTracker.reportGenerationError({ error: normalized });
-    } else {
-      modelSpan?.error({ error: normalized });
-    }
-    agentSpan?.error({ error: normalized });
-  };
-  return {
-    execute: (fn) => executeWithContext({ span: modelSpan ?? agentSpan, fn }),
-    endGenerate(result) {
-      end({
-        text: result.content.map((part) => part.text).join(""),
-        usage: toLanguageModelUsage(result.usage),
-        providerMetadata: result.providerMetadata,
-        finishReason: result.finishReason.unified,
-        responseId: result.response.id,
-        responseModel: result.response.modelId,
-        costContext: result.costContext
-      });
-    },
-    fail,
-    startToolCall,
-    endToolCall,
-    wrapStream(stream) {
-      const trackedStream = modelSpanTracker?.wrapStream(stream) ?? stream;
-      return wrapStreamForAgentSpan(trackedStream, {
-        end,
-        fail
-      });
-    },
-    outputOptions() {
-      return {
-        onFinish,
-        onStepFinish,
-        requestContext,
-        tracingContext: agentSpan ? { currentSpan: agentSpan } : tracingContext
-      };
-    }
-  };
+	return { stream: new ReadableStream({ start: (controller) => controller.close() }) };
+}
+function createCompletedMastraStream({ runId, prompt, text, responseId, modelId, usage, providerMetadata, costContext, object }) {
+	return new ReadableStream({ start(controller) {
+		const textId = randomUUID();
+		enqueueStartChunks(controller, {
+			runId,
+			prompt,
+			textId,
+			responseId,
+			modelId,
+			providerMetadata
+		});
+		if (text) enqueueTextDelta(controller, runId, textId, text);
+		enqueueFinishChunks(controller, {
+			runId,
+			prompt,
+			textId,
+			text,
+			responseId,
+			modelId,
+			usage,
+			providerMetadata,
+			costContext,
+			object
+		});
+		controller.close();
+	} });
+}
+function createMastraOutput({ messages, runId, modelId, provider, stream, responseText = "", options }) {
+	const messageList = new MessageList();
+	messageList.add(messages, "input");
+	messageList.add([{
+		role: "assistant",
+		content: responseText
+	}], "response");
+	return new MastraModelOutput({
+		model: {
+			modelId,
+			provider,
+			version: "v3"
+		},
+		stream,
+		messageList,
+		messageId: randomUUID(),
+		options: {
+			...options,
+			runId
+		}
+	});
+}
+function toFullOutput({ messages, runId, provider, result, options }) {
+	const text = result.content.map((part) => part.text).join("");
+	const stream = createCompletedMastraStream({
+		runId,
+		prompt: promptToText(messages),
+		text,
+		responseId: result.response.id,
+		modelId: result.response.modelId,
+		usage: toLanguageModelUsage(result.usage),
+		providerMetadata: result.providerMetadata,
+		costContext: result.costContext,
+		object: result.object
+	});
+	return createMastraOutput({
+		messages,
+		runId,
+		modelId: result.response.modelId,
+		provider,
+		stream,
+		responseText: text,
+		options
+	}).getFullOutput();
+}
+function createSDKAgentTelemetry({ agentId, agentName, provider, modelId, messages, prompt, runId, streaming, method, requestContext, instructions, maxSteps, tracingOptions, tracingContext, onFinish, onStepFinish, mastra }) {
+	const agentSpan = getOrCreateSpan({
+		type: SpanType.AGENT_RUN,
+		name: `agent run: '${agentId}'`,
+		entityType: EntityType.AGENT,
+		entityId: agentId,
+		entityName: agentName,
+		input: messages,
+		attributes: {
+			prompt,
+			instructions,
+			maxSteps
+		},
+		metadata: {
+			runId,
+			sdkAgent: true,
+			sdkProvider: provider,
+			sdkMethod: method
+		},
+		tracingOptions,
+		tracingContext,
+		requestContext,
+		mastra
+	});
+	const modelSpan = agentSpan?.createChildSpan({
+		type: SpanType.MODEL_GENERATION,
+		name: `llm: '${modelId}'`,
+		input: { messages },
+		attributes: {
+			model: modelId,
+			provider,
+			streaming
+		},
+		metadata: {
+			runId,
+			sdkAgent: true,
+			sdkProvider: provider,
+			sdkMethod: method
+		},
+		requestContext
+	});
+	const modelSpanTracker = getModelSpanTracker(modelSpan);
+	const toolSpans = /* @__PURE__ */ new Map();
+	let ended = false;
+	const startToolCall = ({ toolCallId, toolName, input }) => {
+		if (toolSpans.has(toolCallId)) return;
+		const parentSpan = agentSpan ?? modelSpan;
+		if (!parentSpan) return;
+		const mcp = parseMcpToolName(toolName);
+		const span = mcp ? parentSpan.createChildSpan({
+			type: SpanType.MCP_TOOL_CALL,
+			name: `mcp_tool: '${toolName}' on '${mcp.serverName}'`,
+			input,
+			entityType: EntityType.TOOL,
+			entityId: toolName,
+			entityName: toolName,
+			attributes: { mcpServer: mcp.serverName },
+			metadata: {
+				runId,
+				sdkAgent: true,
+				sdkProvider: provider,
+				sdkMethod: method,
+				toolCallId
+			},
+			requestContext
+		}) : parentSpan.createChildSpan({
+			type: SpanType.TOOL_CALL,
+			name: `tool: '${toolName}'`,
+			input,
+			entityType: EntityType.TOOL,
+			entityId: toolName,
+			entityName: toolName,
+			attributes: { toolType: "tool" },
+			metadata: {
+				runId,
+				sdkAgent: true,
+				sdkProvider: provider,
+				sdkMethod: method,
+				toolCallId
+			},
+			requestContext
+		});
+		toolSpans.set(toolCallId, span);
+	};
+	const endToolCall = ({ toolCallId, output, isError }) => {
+		const span = toolSpans.get(toolCallId);
+		if (!span) return;
+		toolSpans.delete(toolCallId);
+		if (isError) {
+			span.error({
+				error: output instanceof Error ? output : new Error(typeof output === "string" ? output : "SDK tool call failed"),
+				attributes: { success: false }
+			});
+			return;
+		}
+		span.end({
+			output,
+			attributes: { success: true }
+		});
+	};
+	const closeOpenToolSpans = (success, error) => {
+		for (const [toolCallId, span] of toolSpans) {
+			toolSpans.delete(toolCallId);
+			if (success) {
+				span.end({ attributes: { success: true } });
+				continue;
+			}
+			const normalized = error instanceof Error ? error : new Error(String(error ?? "SDK agent run failed"));
+			span.error({
+				error: normalized,
+				attributes: { success: false }
+			});
+		}
+	};
+	const endModel = ({ text, usage, providerMetadata, finishReason = "stop", responseId, responseModel, costContext }) => {
+		if (modelSpanTracker) {
+			modelSpanTracker.endGeneration({
+				output: { text },
+				attributes: {
+					finishReason,
+					responseId,
+					responseModel,
+					costContext
+				},
+				usage,
+				providerMetadata
+			});
+			return;
+		}
+		modelSpan?.end({
+			output: { text },
+			attributes: {
+				finishReason,
+				responseId,
+				responseModel,
+				usage: usage ? toUsageStats(usage) : void 0,
+				costContext
+			}
+		});
+	};
+	const end = (result) => {
+		if (ended) return;
+		ended = true;
+		closeOpenToolSpans(true);
+		endModel(result);
+		agentSpan?.end({ output: { text: result.text } });
+	};
+	const fail = (error) => {
+		if (ended) return;
+		ended = true;
+		const normalized = error instanceof Error ? error : new Error(String(error));
+		closeOpenToolSpans(false, normalized);
+		if (modelSpanTracker) modelSpanTracker.reportGenerationError({ error: normalized });
+		else modelSpan?.error({ error: normalized });
+		agentSpan?.error({ error: normalized });
+	};
+	return {
+		execute: (fn) => executeWithContext({
+			span: modelSpan ?? agentSpan,
+			fn
+		}),
+		endGenerate(result) {
+			end({
+				text: result.content.map((part) => part.text).join(""),
+				usage: toLanguageModelUsage(result.usage),
+				providerMetadata: result.providerMetadata,
+				finishReason: result.finishReason.unified,
+				responseId: result.response.id,
+				responseModel: result.response.modelId,
+				costContext: result.costContext
+			});
+		},
+		fail,
+		startToolCall,
+		endToolCall,
+		wrapStream(stream) {
+			return wrapStreamForAgentSpan(modelSpanTracker?.wrapStream(stream) ?? stream, {
+				end,
+				fail
+			});
+		},
+		outputOptions() {
+			return {
+				onFinish,
+				onStepFinish,
+				requestContext,
+				tracingContext: agentSpan ? { currentSpan: agentSpan } : tracingContext
+			};
+		}
+	};
 }
 function parseMcpToolName(toolName) {
-  const match = /^mcp__([^_].*?)__(.+)$/.exec(toolName);
-  if (!match?.[1] || !match[2]) {
-    return void 0;
-  }
-  return {
-    serverName: match[1],
-    toolName: match[2]
-  };
+	const match = /^mcp__([^_].*?)__(.+)$/.exec(toolName);
+	if (!match?.[1] || !match[2]) return;
+	return {
+		serverName: match[1],
+		toolName: match[2]
+	};
 }
 function getModelSpanTracker(modelSpan) {
-  if (!modelSpan || !("createTracker" in modelSpan)) {
-    return void 0;
-  }
-  return modelSpan.createTracker();
+	if (!modelSpan || !("createTracker" in modelSpan)) return;
+	return modelSpan.createTracker();
 }
 function wrapStreamForAgentSpan(stream, telemetry) {
-  let text = "";
-  return stream.pipeThrough(
-    new TransformStream({
-      transform(chunk, controller) {
-        if (chunk.type === "text-delta") {
-          text += chunk.payload.text;
-        }
-        if (chunk.type === "finish") {
-          telemetry.end({
-            text,
-            usage: chunk.payload.output.usage,
-            providerMetadata: chunk.payload.providerMetadata,
-            finishReason: chunk.payload.stepResult.reason,
-            responseId: chunk.payload.response?.id,
-            responseModel: chunk.payload.response?.modelId,
-            costContext: getCostContext(chunk.payload.metadata?.costContext)
-          });
-        }
-        if (chunk.type === "error") {
-          telemetry.fail(chunk.payload.error);
-        }
-        controller.enqueue(chunk);
-      },
-      flush() {
-        telemetry.end({ text });
-      }
-    })
-  );
+	let text = "";
+	return stream.pipeThrough(new TransformStream({
+		transform(chunk, controller) {
+			if (chunk.type === "text-delta") text += chunk.payload.text;
+			if (chunk.type === "finish") telemetry.end({
+				text,
+				usage: chunk.payload.output.usage,
+				providerMetadata: chunk.payload.providerMetadata,
+				finishReason: chunk.payload.stepResult.reason,
+				responseId: chunk.payload.response?.id,
+				responseModel: chunk.payload.response?.modelId,
+				costContext: getCostContext(chunk.payload.metadata?.costContext)
+			});
+			if (chunk.type === "error") telemetry.fail(chunk.payload.error);
+			controller.enqueue(chunk);
+		},
+		flush() {
+			telemetry.end({ text });
+		}
+	}));
 }
 function toUsageStats(usage) {
-  return {
-    inputTokens: usage.inputTokens,
-    outputTokens: usage.outputTokens,
-    inputDetails: {
-      cacheRead: usage.cachedInputTokens,
-      cacheWrite: usage.cacheCreationInputTokens
-    },
-    outputDetails: {
-      text: usage.outputTokens,
-      reasoning: usage.reasoningTokens
-    }
-  };
+	return {
+		inputTokens: usage.inputTokens,
+		outputTokens: usage.outputTokens,
+		inputDetails: {
+			cacheRead: usage.cachedInputTokens,
+			cacheWrite: usage.cacheCreationInputTokens
+		},
+		outputDetails: {
+			text: usage.outputTokens,
+			reasoning: usage.reasoningTokens
+		}
+	};
 }
 function getCostContext(value) {
-  if (!value || typeof value !== "object") {
-    return void 0;
-  }
-  return value;
-}
-function enqueueStartChunks(controller, {
-  runId,
-  prompt,
-  textId,
-  responseId,
-  modelId,
-  providerMetadata
-}) {
-  controller.enqueue({
-    type: "start",
-    runId,
-    from: ChunkFrom.AGENT,
-    payload: {}
-  });
-  controller.enqueue({
-    type: "step-start",
-    runId,
-    from: ChunkFrom.AGENT,
-    payload: {
-      request: { body: prompt }
-    }
-  });
-  controller.enqueue({
-    type: "response-metadata",
-    runId,
-    from: ChunkFrom.AGENT,
-    payload: {
-      id: responseId,
-      modelId,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    }
-  });
-  controller.enqueue({
-    type: "text-start",
-    runId,
-    from: ChunkFrom.AGENT,
-    payload: {
-      id: textId,
-      providerMetadata
-    }
-  });
+	if (!value || typeof value !== "object") return;
+	return value;
+}
+function enqueueStartChunks(controller, { runId, prompt, textId, responseId, modelId, providerMetadata }) {
+	controller.enqueue({
+		type: "start",
+		runId,
+		from: ChunkFrom.AGENT,
+		payload: {}
+	});
+	controller.enqueue({
+		type: "step-start",
+		runId,
+		from: ChunkFrom.AGENT,
+		payload: { request: { body: prompt } }
+	});
+	controller.enqueue({
+		type: "response-metadata",
+		runId,
+		from: ChunkFrom.AGENT,
+		payload: {
+			id: responseId,
+			modelId,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		}
+	});
+	controller.enqueue({
+		type: "text-start",
+		runId,
+		from: ChunkFrom.AGENT,
+		payload: {
+			id: textId,
+			providerMetadata
+		}
+	});
 }
 function enqueueTextDelta(controller, runId, textId, text) {
-  controller.enqueue({
-    type: "text-delta",
-    runId,
-    from: ChunkFrom.AGENT,
-    payload: {
-      id: textId,
-      text
-    }
-  });
-}
-function enqueueFinishChunks(controller, {
-  runId,
-  prompt,
-  textId,
-  text,
-  responseId,
-  modelId,
-  usage,
-  providerMetadata,
-  costContext,
-  object
-}) {
-  const timestamp = /* @__PURE__ */ new Date();
-  const response = {
-    id: responseId,
-    modelId,
-    timestamp
-  };
-  const metadata = {
-    providerMetadata,
-    costContext,
-    request: { body: prompt },
-    modelId,
-    timestamp
-  };
-  controller.enqueue({
-    type: "text-end",
-    runId,
-    from: ChunkFrom.AGENT,
-    payload: {
-      id: textId,
-      providerMetadata
-    }
-  });
-  if (object !== void 0) {
-    controller.enqueue({
-      type: "object-result",
-      runId,
-      from: ChunkFrom.AGENT,
-      object
-    });
-  }
-  controller.enqueue({
-    type: "step-finish",
-    runId,
-    from: ChunkFrom.AGENT,
-    payload: {
-      id: responseId,
-      providerMetadata,
-      totalUsage: usage,
-      response,
-      stepResult: {
-        reason: "stop",
-        warnings: []
-      },
-      output: {
-        text,
-        usage,
-        steps: []
-      },
-      metadata
-    }
-  });
-  controller.enqueue({
-    type: "finish",
-    runId,
-    from: ChunkFrom.AGENT,
-    payload: {
-      stepResult: {
-        reason: "stop",
-        warnings: []
-      },
-      output: {
-        usage,
-        steps: []
-      },
-      metadata,
-      providerMetadata,
-      messages: {
-        all: [],
-        user: [],
-        nonUser: []
-      },
-      response
-    }
-  });
+	controller.enqueue({
+		type: "text-delta",
+		runId,
+		from: ChunkFrom.AGENT,
+		payload: {
+			id: textId,
+			text
+		}
+	});
+}
+function enqueueFinishChunks(controller, { runId, prompt, textId, text, responseId, modelId, usage, providerMetadata, costContext, object }) {
+	const timestamp = /* @__PURE__ */ new Date();
+	const response = {
+		id: responseId,
+		modelId,
+		timestamp
+	};
+	const metadata = {
+		providerMetadata,
+		costContext,
+		request: { body: prompt },
+		modelId,
+		timestamp
+	};
+	controller.enqueue({
+		type: "text-end",
+		runId,
+		from: ChunkFrom.AGENT,
+		payload: {
+			id: textId,
+			providerMetadata
+		}
+	});
+	if (object !== void 0) controller.enqueue({
+		type: "object-result",
+		runId,
+		from: ChunkFrom.AGENT,
+		object
+	});
+	controller.enqueue({
+		type: "step-finish",
+		runId,
+		from: ChunkFrom.AGENT,
+		payload: {
+			id: responseId,
+			providerMetadata,
+			totalUsage: usage,
+			response,
+			stepResult: {
+				reason: "stop",
+				warnings: []
+			},
+			output: {
+				text,
+				usage,
+				steps: []
+			},
+			metadata
+		}
+	});
+	controller.enqueue({
+		type: "finish",
+		runId,
+		from: ChunkFrom.AGENT,
+		payload: {
+			stepResult: {
+				reason: "stop",
+				warnings: []
+			},
+			output: {
+				usage,
+				steps: []
+			},
+			metadata,
+			providerMetadata,
+			messages: {
+				all: [],
+				user: [],
+				nonUser: []
+			},
+			response
+		}
+	});
 }
 function toLanguageModelUsage(usage) {
-  const inputTokens = usage.inputTokens.total ?? 0;
-  const outputTokens = usage.outputTokens.total ?? 0;
-  return {
-    inputTokens,
-    outputTokens,
-    totalTokens: inputTokens + outputTokens,
-    cachedInputTokens: usage.inputTokens.cacheRead,
-    cacheCreationInputTokens: usage.inputTokens.cacheWrite,
-    raw: usage
-  };
+	const inputTokens = usage.inputTokens.total ?? 0;
+	const outputTokens = usage.outputTokens.total ?? 0;
+	return {
+		inputTokens,
+		outputTokens,
+		totalTokens: inputTokens + outputTokens,
+		cachedInputTokens: usage.inputTokens.cacheRead,
+		cacheCreationInputTokens: usage.inputTokens.cacheWrite,
+		raw: usage
+	};
 }
 function createProviderMetadata(provider, metadata) {
-  return {
-    [provider]: toJsonRecord(metadata)
-  };
+	return { [provider]: toJsonRecord(metadata) };
 }
 function toJsonRecord(record) {
-  return Object.fromEntries(
-    Object.entries(record).filter((entry) => entry[1] !== void 0).map(([key, value]) => [key, toJsonValue(value)])
-  );
+	return Object.fromEntries(Object.entries(record).filter((entry) => entry[1] !== void 0).map(([key, value]) => [key, toJsonValue(value)]));
 }
 function toJsonValue(value) {
-  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.filter((item) => item !== void 0).map(toJsonValue);
-  }
-  if (value instanceof Date) {
-    return value.toISOString();
-  }
-  if (typeof value === "object") {
-    return toJsonRecord(value);
-  }
-  return String(value);
+	if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (Array.isArray(value)) return value.filter((item) => item !== void 0).map(toJsonValue);
+	if (value instanceof Date) return value.toISOString();
+	if (typeof value === "object") return toJsonRecord(value);
+	return String(value);
 }
 function promptToText(prompt) {
-  if (typeof prompt === "string") {
-    return prompt;
-  }
-  if (Array.isArray(prompt)) {
-    return prompt.map(promptToText).filter(Boolean).join("\n");
-  }
-  if (!prompt || typeof prompt !== "object") {
-    return "";
-  }
-  const record = prompt;
-  if (typeof record.text === "string") {
-    return record.text;
-  }
-  if (typeof record.content === "string") {
-    return record.content;
-  }
-  if (record.content) {
-    return promptToText(record.content);
-  }
-  return "";
+	if (typeof prompt === "string") return prompt;
+	if (Array.isArray(prompt)) return prompt.map(promptToText).filter(Boolean).join("\n");
+	if (!prompt || typeof prompt !== "object") return "";
+	const record = prompt;
+	if (typeof record.text === "string") return record.text;
+	if (typeof record.content === "string") return record.content;
+	if (record.content) return promptToText(record.content);
+	return "";
 }
 function getStructuredOutputSchema(structuredOutput) {
-  if (!structuredOutput?.schema) {
-    return void 0;
-  }
-  return standardSchemaToJSONSchema(toStandardSchema(structuredOutput.schema));
+	if (!structuredOutput?.schema) return;
+	return standardSchemaToJSONSchema(toStandardSchema(structuredOutput.schema));
 }
 async function getStructuredOutputFromValue(value, structuredOutput) {
-  if (!structuredOutput?.schema) {
-    return void 0;
-  }
-  let parsed;
-  if (typeof value === "string") {
-    try {
-      parsed = JSON.parse(value);
-    } catch (error) {
-      return handleStructuredOutputError(
-        new Error("Structured output must be valid JSON.", { cause: error }),
-        structuredOutput
-      );
-    }
-  } else {
-    parsed = value;
-  }
-  const schema = toStandardSchema(structuredOutput.schema);
-  const result = await schema["~standard"].validate(parsed);
-  if (!result.issues) {
-    return result.value;
-  }
-  const message = result.issues.map((issue) => `- ${issue.path?.join(".") || "root"}: ${issue.message}`).join("\n");
-  return handleStructuredOutputError(new Error(`Structured output validation failed:
-${message}`), structuredOutput);
+	if (!structuredOutput?.schema) return;
+	let parsed;
+	if (typeof value === "string") try {
+		parsed = JSON.parse(value);
+	} catch (error) {
+		return handleStructuredOutputError(new Error("Structured output must be valid JSON.", { cause: error }), structuredOutput);
+	}
+	else parsed = value;
+	const result = await toStandardSchema(structuredOutput.schema)["~standard"].validate(parsed);
+	if (!result.issues) return result.value;
+	const message = result.issues.map((issue) => `- ${issue.path?.join(".") || "root"}: ${issue.message}`).join("\n");
+	return handleStructuredOutputError(/* @__PURE__ */ new Error(`Structured output validation failed:\n${message}`), structuredOutput);
 }
 function handleStructuredOutputError(error, structuredOutput) {
-  if (structuredOutput.errorStrategy === "fallback") {
-    return structuredOutput.fallbackValue;
-  }
-  if (structuredOutput.errorStrategy === "warn") {
-    structuredOutput.logger?.warn(error.message);
-    return void 0;
-  }
-  throw error;
+	if (structuredOutput.errorStrategy === "fallback") return structuredOutput.fallbackValue;
+	if (structuredOutput.errorStrategy === "warn") {
+		structuredOutput.logger?.warn(error.message);
+		return;
+	}
+	throw error;
 }
 function sumDefined(...values) {
-  const defined = values.filter((value) => typeof value === "number");
-  if (defined.length === 0) {
-    return void 0;
-  }
-  return defined.reduce((sum, value) => sum + value, 0);
-}
-
-// src/index.ts
-var PROVIDER = "@anthropic-ai/claude-agent-sdk";
-var MODEL_ID = "claude-agent-sdk";
+	const defined = values.filter((value) => typeof value === "number");
+	if (defined.length === 0) return;
+	return defined.reduce((sum, value) => sum + value, 0);
+}
+//#endregion
+//#region src/index.ts
+const PROVIDER = "@anthropic-ai/claude-agent-sdk";
+const MODEL_ID = "claude-agent-sdk";
 var ClaudeSDKAgent = class extends Agent {
-  options;
-  #mastra;
-  constructor(options) {
-    super({
-      id: options.id,
-      name: options.name ?? options.id,
-      description: options.description,
-      instructions: "",
-      model: createNoopModel({
-        modelId: getModelId(options),
-        provider: PROVIDER
-      })
-    });
-    this.options = options;
-  }
-  __registerMastra(mastra) {
-    super.__registerMastra(mastra);
-    this.#mastra = mastra;
-  }
-  supportsMemory() {
-    return false;
-  }
-  async generate(messages, options) {
-    const prompt = promptToText(messages);
-    const runId = options?.runId ?? randomUUID();
-    const requestContext = options?.requestContext ?? new RequestContext();
-    const instructions = options?.instructions ? promptToText(options.instructions) : void 0;
-    const telemetry = createSDKAgentTelemetry({
-      agentId: this.id,
-      agentName: this.name,
-      provider: PROVIDER,
-      modelId: getModelId(this.options),
-      messages,
-      prompt,
-      runId,
-      streaming: false,
-      method: "generate",
-      requestContext,
-      instructions,
-      maxSteps: options?.maxSteps,
-      tracingOptions: options?.tracingOptions,
-      tracingContext: options?.tracingContext,
-      onFinish: options?.onFinish,
-      onStepFinish: options?.onStepFinish,
-      mastra: this.#mastra
-    });
-    let result;
-    try {
-      result = await telemetry.execute(() => runClaudeGenerate(prompt, this.options, telemetry, options));
-      telemetry.endGenerate(result);
-    } catch (error) {
-      telemetry.fail(error);
-      throw error;
-    }
-    return toFullOutput({
-      messages,
-      runId,
-      provider: PROVIDER,
-      result,
-      options: { ...telemetry.outputOptions(), structuredOutput: options?.structuredOutput }
-    });
-  }
-  async stream(messages, options) {
-    const runId = options?.runId ?? randomUUID();
-    const prompt = promptToText(messages);
-    const modelId = getModelId(this.options);
-    const requestContext = options?.requestContext ?? new RequestContext();
-    const instructions = options?.instructions ? promptToText(options.instructions) : void 0;
-    const telemetry = createSDKAgentTelemetry({
-      agentId: this.id,
-      agentName: this.name,
-      provider: PROVIDER,
-      modelId,
-      messages,
-      prompt,
-      runId,
-      streaming: true,
-      method: "stream",
-      requestContext,
-      instructions,
-      maxSteps: options?.maxSteps,
-      tracingOptions: options?.tracingOptions,
-      tracingContext: options?.tracingContext,
-      onFinish: options?.onFinish,
-      onStepFinish: options?.onStepFinish,
-      mastra: this.#mastra
-    });
-    return createMastraOutput({
-      messages,
-      runId,
-      modelId,
-      provider: PROVIDER,
-      stream: telemetry.wrapStream(runClaudeAsMastraStream(prompt, this.options, runId, telemetry, options)),
-      options: { ...telemetry.outputOptions(), structuredOutput: options?.structuredOutput }
-    });
-  }
-  async resumeGenerate(resumeData, options) {
-    const data = validateClaudeResumeData(resumeData);
-    return this.generate(data.message, createClaudeResumeRunOptions(data, options));
-  }
-  async resumeStream(resumeData, options) {
-    const data = validateClaudeResumeData(resumeData);
-    return this.stream(data.message, createClaudeResumeRunOptions(data, options));
-  }
+	options;
+	#mastra;
+	constructor(options) {
+		super({
+			id: options.id,
+			name: options.name ?? options.id,
+			description: options.description,
+			instructions: "",
+			model: createNoopModel({
+				modelId: getModelId(options),
+				provider: PROVIDER
+			})
+		});
+		this.options = options;
+	}
+	__registerMastra(mastra) {
+		super.__registerMastra(mastra);
+		this.#mastra = mastra;
+	}
+	supportsMemory() {
+		return false;
+	}
+	async generate(messages, options) {
+		const prompt = promptToText(messages);
+		const runId = options?.runId ?? randomUUID();
+		const requestContext = options?.requestContext ?? new RequestContext();
+		const instructions = options?.instructions ? promptToText(options.instructions) : void 0;
+		const telemetry = createSDKAgentTelemetry({
+			agentId: this.id,
+			agentName: this.name,
+			provider: PROVIDER,
+			modelId: getModelId(this.options),
+			messages,
+			prompt,
+			runId,
+			streaming: false,
+			method: "generate",
+			requestContext,
+			instructions,
+			maxSteps: options?.maxSteps,
+			tracingOptions: options?.tracingOptions,
+			tracingContext: options?.tracingContext,
+			onFinish: options?.onFinish,
+			onStepFinish: options?.onStepFinish,
+			mastra: this.#mastra
+		});
+		let result;
+		try {
+			result = await telemetry.execute(() => runClaudeGenerate(prompt, this.options, telemetry, options));
+			telemetry.endGenerate(result);
+		} catch (error) {
+			telemetry.fail(error);
+			throw error;
+		}
+		return toFullOutput({
+			messages,
+			runId,
+			provider: PROVIDER,
+			result,
+			options: {
+				...telemetry.outputOptions(),
+				structuredOutput: options?.structuredOutput
+			}
+		});
+	}
+	async stream(messages, options) {
+		const runId = options?.runId ?? randomUUID();
+		const prompt = promptToText(messages);
+		const modelId = getModelId(this.options);
+		const requestContext = options?.requestContext ?? new RequestContext();
+		const instructions = options?.instructions ? promptToText(options.instructions) : void 0;
+		const telemetry = createSDKAgentTelemetry({
+			agentId: this.id,
+			agentName: this.name,
+			provider: PROVIDER,
+			modelId,
+			messages,
+			prompt,
+			runId,
+			streaming: true,
+			method: "stream",
+			requestContext,
+			instructions,
+			maxSteps: options?.maxSteps,
+			tracingOptions: options?.tracingOptions,
+			tracingContext: options?.tracingContext,
+			onFinish: options?.onFinish,
+			onStepFinish: options?.onStepFinish,
+			mastra: this.#mastra
+		});
+		return createMastraOutput({
+			messages,
+			runId,
+			modelId,
+			provider: PROVIDER,
+			stream: telemetry.wrapStream(runClaudeAsMastraStream(prompt, this.options, runId, telemetry, options)),
+			options: {
+				...telemetry.outputOptions(),
+				structuredOutput: options?.structuredOutput
+			}
+		});
+	}
+	async resumeGenerate(resumeData, options) {
+		const data = validateClaudeResumeData(resumeData);
+		return this.generate(data.message, createClaudeResumeRunOptions(data, options));
+	}
+	async resumeStream(resumeData, options) {
+		const data = validateClaudeResumeData(resumeData);
+		return this.stream(data.message, createClaudeResumeRunOptions(data, options));
+	}
 };
 function validateClaudeResumeData(resumeData) {
-  if (!isRecord(resumeData) || !("message" in resumeData)) {
-    throw new Error("ClaudeSDKAgent resumeData must include a message.");
-  }
-  const hasSessionId = "sessionId" in resumeData;
-  const hasContinue = "continue" in resumeData;
-  if (hasSessionId && hasContinue) {
-    throw new Error("ClaudeSDKAgent resumeData must include either sessionId or continue: true, not both.");
-  }
-  if (hasSessionId) {
-    if (typeof resumeData.sessionId !== "string") {
-      throw new Error("ClaudeSDKAgent resumeData.sessionId must be a string.");
-    }
-    return resumeData;
-  }
-  if (hasContinue) {
-    if (resumeData.continue !== true) {
-      throw new Error("ClaudeSDKAgent resumeData.continue must be true when provided.");
-    }
-    return resumeData;
-  }
-  throw new Error("ClaudeSDKAgent resumeData must include sessionId or continue: true.");
+	if (!isRecord(resumeData) || !("message" in resumeData)) throw new Error("ClaudeSDKAgent resumeData must include a message.");
+	const hasSessionId = "sessionId" in resumeData;
+	const hasContinue = "continue" in resumeData;
+	if (hasSessionId && hasContinue) throw new Error("ClaudeSDKAgent resumeData must include either sessionId or continue: true, not both.");
+	if (hasSessionId) {
+		if (typeof resumeData.sessionId !== "string") throw new Error("ClaudeSDKAgent resumeData.sessionId must be a string.");
+		return resumeData;
+	}
+	if (hasContinue) {
+		if (resumeData.continue !== true) throw new Error("ClaudeSDKAgent resumeData.continue must be true when provided.");
+		return resumeData;
+	}
+	throw new Error("ClaudeSDKAgent resumeData must include sessionId or continue: true.");
 }
 function createClaudeResumeRunOptions(resumeData, options) {
-  const sdkOptions = { ...options?.sdkOptions };
-  if ("sessionId" in resumeData && typeof resumeData.sessionId === "string") {
-    sdkOptions.resume = resumeData.sessionId;
-    if (resumeData.forkSession !== void 0) {
-      sdkOptions.forkSession = resumeData.forkSession;
-    }
-    if (resumeData.resumeSessionAt !== void 0) {
-      sdkOptions.resumeSessionAt = resumeData.resumeSessionAt;
-    }
-  } else {
-    sdkOptions.continue = true;
-  }
-  return {
-    ...options,
-    sdkOptions
-  };
+	const sdkOptions = { ...options?.sdkOptions };
+	if ("sessionId" in resumeData && typeof resumeData.sessionId === "string") {
+		sdkOptions.resume = resumeData.sessionId;
+		if (resumeData.forkSession !== void 0) sdkOptions.forkSession = resumeData.forkSession;
+		if (resumeData.resumeSessionAt !== void 0) sdkOptions.resumeSessionAt = resumeData.resumeSessionAt;
+	} else sdkOptions.continue = true;
+	return {
+		...options,
+		sdkOptions
+	};
 }
 async function runClaudeGenerate(prompt, options, telemetry, runOptions) {
-  let text = "";
-  let structuredOutputValue;
-  const usage = createClaudeUsageCollector();
-  for await (const message of observeClaudeMessages(
-    runClaude(prompt, options, runOptions?.abortSignal ?? runOptions?.signal, runOptions),
-    telemetry
-  )) {
-    usage.record(message);
-    if (message.type === "result") {
-      if (message.subtype !== "success") {
-        throw new Error(message.errors.join("\n") || `Claude Agent SDK failed with ${message.subtype}`);
-      }
-      text = message.result;
-      structuredOutputValue = getClaudeStructuredOutput(message);
-    }
-  }
-  const totals = usage.totals();
-  const object = await getStructuredOutputFromValue(
-    structuredOutputValue === void 0 ? text : structuredOutputValue,
-    runOptions?.structuredOutput
-  );
-  return {
-    content: [{ type: "text", text }],
-    finishReason: { unified: "stop", raw: "stop" },
-    usage: usage.toV3Usage(),
-    response: {
-      id: randomUUID(),
-      modelId: getModelId(options),
-      timestamp: /* @__PURE__ */ new Date()
-    },
-    providerMetadata: getClaudeProviderMetadata(options, totals),
-    costContext: getClaudeCostContext(options, totals),
-    object
-  };
+	let text = "";
+	let structuredOutputValue;
+	const usage = createClaudeUsageCollector();
+	for await (const message of observeClaudeMessages(runClaude(prompt, options, runOptions?.abortSignal ?? runOptions?.signal, runOptions), telemetry)) {
+		usage.record(message);
+		if (message.type === "result") {
+			if (message.subtype !== "success") throw new Error(message.errors.join("\n") || `Claude Agent SDK failed with ${message.subtype}`);
+			text = message.result;
+			structuredOutputValue = getClaudeStructuredOutput(message);
+		}
+	}
+	const totals = usage.totals();
+	const object = await getStructuredOutputFromValue(structuredOutputValue === void 0 ? text : structuredOutputValue, runOptions?.structuredOutput);
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		finishReason: {
+			unified: "stop",
+			raw: "stop"
+		},
+		usage: usage.toV3Usage(),
+		response: {
+			id: randomUUID(),
+			modelId: getModelId(options),
+			timestamp: /* @__PURE__ */ new Date()
+		},
+		providerMetadata: getClaudeProviderMetadata(options, totals),
+		costContext: getClaudeCostContext(options, totals),
+		object
+	};
 }
 function runClaudeAsMastraStream(prompt, options, runId, telemetry, runOptions) {
-  return new ReadableStream({
-    start: async (controller) => {
-      const textId = randomUUID();
-      const responseId = randomUUID();
-      const modelId = getModelId(options);
-      const usage = createClaudeUsageCollector();
-      let text = "";
-      let structuredOutputValue;
-      let sawDelta = false;
-      try {
-        enqueueStartChunks(controller, {
-          runId,
-          prompt,
-          textId,
-          responseId,
-          modelId,
-          providerMetadata: getClaudeProviderMetadata(options, usage.totals())
-        });
-        for await (const message of observeClaudeMessages(
-          runClaude(prompt, options, runOptions?.abortSignal ?? runOptions?.signal, runOptions),
-          telemetry
-        )) {
-          usage.record(message);
-          const delta = getTextDelta(message);
-          if (delta) {
-            sawDelta = true;
-            text += delta;
-            enqueueTextDelta(controller, runId, textId, delta);
-          }
-          if (message.type === "result") {
-            if (message.subtype !== "success") {
-              throw new Error(message.errors.join("\n") || `Claude Agent SDK failed with ${message.subtype}`);
-            }
-            if (!sawDelta && message.result) {
-              text += message.result;
-              enqueueTextDelta(controller, runId, textId, message.result);
-            }
-            structuredOutputValue = getClaudeStructuredOutput(message);
-          }
-        }
-        const totals = usage.totals();
-        const providerMetadata = getClaudeProviderMetadata(options, totals);
-        enqueueFinishChunks(controller, {
-          runId,
-          prompt,
-          textId,
-          text,
-          responseId,
-          modelId,
-          usage: usage.toLanguageModelUsage(),
-          providerMetadata,
-          costContext: getClaudeCostContext(options, totals),
-          object: await getStructuredOutputFromValue(
-            structuredOutputValue === void 0 ? text : structuredOutputValue,
-            runOptions?.structuredOutput
-          )
-        });
-        controller.close();
-      } catch (error) {
-        controller.enqueue({
-          type: "error",
-          runId,
-          from: ChunkFrom.AGENT,
-          payload: { error }
-        });
-        controller.close();
-      }
-    }
-  });
+	return new ReadableStream({ start: async (controller) => {
+		const textId = randomUUID();
+		const responseId = randomUUID();
+		const modelId = getModelId(options);
+		const usage = createClaudeUsageCollector();
+		let text = "";
+		let structuredOutputValue;
+		let sawDelta = false;
+		try {
+			enqueueStartChunks(controller, {
+				runId,
+				prompt,
+				textId,
+				responseId,
+				modelId,
+				providerMetadata: getClaudeProviderMetadata(options, usage.totals())
+			});
+			for await (const message of observeClaudeMessages(runClaude(prompt, options, runOptions?.abortSignal ?? runOptions?.signal, runOptions), telemetry)) {
+				usage.record(message);
+				const delta = getTextDelta(message);
+				if (delta) {
+					sawDelta = true;
+					text += delta;
+					enqueueTextDelta(controller, runId, textId, delta);
+				}
+				if (message.type === "result") {
+					if (message.subtype !== "success") throw new Error(message.errors.join("\n") || `Claude Agent SDK failed with ${message.subtype}`);
+					if (!sawDelta && message.result) {
+						text += message.result;
+						enqueueTextDelta(controller, runId, textId, message.result);
+					}
+					structuredOutputValue = getClaudeStructuredOutput(message);
+				}
+			}
+			const totals = usage.totals();
+			const providerMetadata = getClaudeProviderMetadata(options, totals);
+			enqueueFinishChunks(controller, {
+				runId,
+				prompt,
+				textId,
+				text,
+				responseId,
+				modelId,
+				usage: usage.toLanguageModelUsage(),
+				providerMetadata,
+				costContext: getClaudeCostContext(options, totals),
+				object: await getStructuredOutputFromValue(structuredOutputValue === void 0 ? text : structuredOutputValue, runOptions?.structuredOutput)
+			});
+			controller.close();
+		} catch (error) {
+			controller.enqueue({
+				type: "error",
+				runId,
+				from: ChunkFrom.AGENT,
+				payload: { error }
+			});
+			controller.close();
+		}
+	} });
 }
 function runClaude(prompt, options, signal, runOptions) {
-  const abortController = createAbortController(signal);
-  const queryOptions = {
-    ...options.sdkOptions,
-    ...runOptions?.sdkOptions
-  };
-  const outputSchema = getStructuredOutputSchema(runOptions?.structuredOutput);
-  if (outputSchema) {
-    queryOptions.outputFormat = {
-      type: "json_schema",
-      schema: outputSchema
-    };
-  }
-  if (abortController) {
-    queryOptions.abortController = abortController;
-  }
-  return query({
-    prompt,
-    options: queryOptions
-  });
+	const abortController = createAbortController(signal);
+	const queryOptions = {
+		...options.sdkOptions,
+		...runOptions?.sdkOptions
+	};
+	const outputSchema = getStructuredOutputSchema(runOptions?.structuredOutput);
+	if (outputSchema) queryOptions.outputFormat = {
+		type: "json_schema",
+		schema: outputSchema
+	};
+	if (abortController) queryOptions.abortController = abortController;
+	return query({
+		prompt,
+		options: queryOptions
+	});
 }
 function getClaudeStructuredOutput(message) {
-  if (message.type !== "result") {
-    return void 0;
-  }
-  return message.structured_output;
+	if (message.type !== "result") return;
+	return message.structured_output;
 }
 async function* observeClaudeMessages(messages, telemetry) {
-  for await (const message of messages) {
-    recordClaudeToolTelemetry(message, telemetry);
-    yield message;
-  }
+	for await (const message of messages) {
+		recordClaudeToolTelemetry(message, telemetry);
+		yield message;
+	}
 }
 function recordClaudeToolTelemetry(message, telemetry) {
-  for (const toolCall of getClaudeToolCalls(message)) {
-    telemetry.startToolCall(toolCall);
-  }
-  for (const toolResult of getClaudeToolResults(message)) {
-    telemetry.endToolCall(toolResult);
-  }
+	for (const toolCall of getClaudeToolCalls(message)) telemetry.startToolCall(toolCall);
+	for (const toolResult of getClaudeToolResults(message)) telemetry.endToolCall(toolResult);
 }
 function getClaudeToolCalls(message) {
-  if (message.type !== "assistant") {
-    return [];
-  }
-  return getContentBlocks(message.message).filter(isRecord).filter((block) => block.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string").map((block) => ({
-    toolCallId: block.id,
-    toolName: block.name,
-    input: block.input
-  }));
+	if (message.type !== "assistant") return [];
+	return getContentBlocks(message.message).filter(isRecord).filter((block) => block.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string").map((block) => ({
+		toolCallId: block.id,
+		toolName: block.name,
+		input: block.input
+	}));
 }
 function getClaudeToolResults(message) {
-  if (message.type !== "user") {
-    return [];
-  }
-  return getContentBlocks(message.message).filter(isRecord).filter((block) => block.type === "tool_result" && typeof block.tool_use_id === "string").map((block) => ({
-    toolCallId: block.tool_use_id,
-    output: block.content,
-    isError: block.is_error === true
-  }));
+	if (message.type !== "user") return [];
+	return getContentBlocks(message.message).filter(isRecord).filter((block) => block.type === "tool_result" && typeof block.tool_use_id === "string").map((block) => ({
+		toolCallId: block.tool_use_id,
+		output: block.content,
+		isError: block.is_error === true
+	}));
 }
 function getContentBlocks(message) {
-  if (!isRecord(message)) {
-    return [];
-  }
-  return Array.isArray(message.content) ? message.content : [];
+	if (!isRecord(message)) return [];
+	return Array.isArray(message.content) ? message.content : [];
 }
 function isRecord(value) {
-  return value !== null && typeof value === "object";
+	return value !== null && typeof value === "object";
 }
 function createAbortController(signal) {
-  if (!signal) {
-    return void 0;
-  }
-  const controller = new AbortController();
-  if (signal.aborted) {
-    controller.abort(signal.reason);
-    return controller;
-  }
-  signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
-  return controller;
+	if (!signal) return;
+	const controller = new AbortController();
+	if (signal.aborted) {
+		controller.abort(signal.reason);
+		return controller;
+	}
+	signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
+	return controller;
 }
 function getModelId(options) {
-  return options.sdkOptions?.model ?? MODEL_ID;
+	return options.sdkOptions?.model ?? MODEL_ID;
 }
 function createClaudeUsageCollector() {
-  const assistantUsageById = /* @__PURE__ */ new Map();
-  let resultUsage = {};
-  return {
-    record(message) {
-      if (message.type === "assistant") {
-        assistantUsageById.set(message.message.id, usageFromClaudeMessage(message.message.usage));
-        return;
-      }
-      if (message.type === "result") {
-        resultUsage = {
-          ...usageFromClaudeMessage(message.usage),
-          totalCostUsd: message.total_cost_usd,
-          modelUsage: message.modelUsage
-        };
-      }
-    },
-    totals() {
-      const assistantUsage = getAssistantUsageTotals(assistantUsageById);
-      if (hasAnyUsage(resultUsage)) {
-        return {
-          ...resultUsage,
-          inputTokens: resultUsage.inputTokens ?? assistantUsage.inputTokens,
-          outputTokens: resultUsage.outputTokens ?? assistantUsage.outputTokens,
-          cacheReadInputTokens: resultUsage.cacheReadInputTokens ?? assistantUsage.cacheReadInputTokens,
-          cacheCreationInputTokens: resultUsage.cacheCreationInputTokens ?? assistantUsage.cacheCreationInputTokens
-        };
-      }
-      return assistantUsage;
-    },
-    toV3Usage() {
-      return toV3Usage(this.totals());
-    },
-    toLanguageModelUsage() {
-      return toLanguageModelUsage(toV3Usage(this.totals()));
-    }
-  };
+	const assistantUsageById = /* @__PURE__ */ new Map();
+	let resultUsage = {};
+	return {
+		record(message) {
+			if (message.type === "assistant") {
+				assistantUsageById.set(message.message.id, usageFromClaudeMessage(message.message.usage));
+				return;
+			}
+			if (message.type === "result") resultUsage = {
+				...usageFromClaudeMessage(message.usage),
+				totalCostUsd: message.total_cost_usd,
+				modelUsage: message.modelUsage
+			};
+		},
+		totals() {
+			const assistantUsage = getAssistantUsageTotals(assistantUsageById);
+			if (hasAnyUsage(resultUsage)) return {
+				...resultUsage,
+				inputTokens: resultUsage.inputTokens ?? assistantUsage.inputTokens,
+				outputTokens: resultUsage.outputTokens ?? assistantUsage.outputTokens,
+				cacheReadInputTokens: resultUsage.cacheReadInputTokens ?? assistantUsage.cacheReadInputTokens,
+				cacheCreationInputTokens: resultUsage.cacheCreationInputTokens ?? assistantUsage.cacheCreationInputTokens
+			};
+			return assistantUsage;
+		},
+		toV3Usage() {
+			return toV3Usage(this.totals());
+		},
+		toLanguageModelUsage() {
+			return toLanguageModelUsage(toV3Usage(this.totals()));
+		}
+	};
 }
 function getAssistantUsageTotals(assistantUsageById) {
-  return [...assistantUsageById.values()].reduce((totals, item) => {
-    totals.inputTokens = addOptional(totals.inputTokens, item.inputTokens);
-    totals.outputTokens = addOptional(totals.outputTokens, item.outputTokens);
-    totals.cacheReadInputTokens = addOptional(totals.cacheReadInputTokens, item.cacheReadInputTokens);
-    totals.cacheCreationInputTokens = addOptional(totals.cacheCreationInputTokens, item.cacheCreationInputTokens);
-    return totals;
-  }, {});
+	return [...assistantUsageById.values()].reduce((totals, item) => {
+		totals.inputTokens = addOptional(totals.inputTokens, item.inputTokens);
+		totals.outputTokens = addOptional(totals.outputTokens, item.outputTokens);
+		totals.cacheReadInputTokens = addOptional(totals.cacheReadInputTokens, item.cacheReadInputTokens);
+		totals.cacheCreationInputTokens = addOptional(totals.cacheCreationInputTokens, item.cacheCreationInputTokens);
+		return totals;
+	}, {});
 }
 function usageFromClaudeMessage(usage) {
-  if (!usage || typeof usage !== "object") {
-    return {};
-  }
-  const record = usage;
-  return {
-    inputTokens: getTokenTotal(record.input_tokens),
-    outputTokens: getTokenTotal(record.output_tokens),
-    cacheReadInputTokens: getTokenTotal(record.cache_read_input_tokens),
-    cacheCreationInputTokens: getTokenTotal(record.cache_creation_input_tokens)
-  };
+	if (!usage || typeof usage !== "object") return {};
+	const record = usage;
+	return {
+		inputTokens: getTokenTotal(record.input_tokens),
+		outputTokens: getTokenTotal(record.output_tokens),
+		cacheReadInputTokens: getTokenTotal(record.cache_read_input_tokens),
+		cacheCreationInputTokens: getTokenTotal(record.cache_creation_input_tokens)
+	};
 }
 function hasAnyUsage(usage) {
-  return usage.inputTokens !== void 0 || usage.outputTokens !== void 0 || usage.cacheReadInputTokens !== void 0 || usage.cacheCreationInputTokens !== void 0 || usage.totalCostUsd !== void 0;
+	return usage.inputTokens !== void 0 || usage.outputTokens !== void 0 || usage.cacheReadInputTokens !== void 0 || usage.cacheCreationInputTokens !== void 0 || usage.totalCostUsd !== void 0;
 }
 function addOptional(left, right) {
-  if (left === void 0) {
-    return right;
-  }
-  if (right === void 0) {
-    return left;
-  }
-  return left + right;
+	if (left === void 0) return right;
+	if (right === void 0) return left;
+	return left + right;
 }
 function toV3Usage(usage) {
-  const noCache = usage.inputTokens;
-  const cacheRead = usage.cacheReadInputTokens;
-  const cacheWrite = usage.cacheCreationInputTokens;
-  const totalInputTokens = sumDefined(noCache, cacheRead, cacheWrite);
-  const outputTokens = usage.outputTokens;
-  return {
-    inputTokens: {
-      total: totalInputTokens,
-      noCache,
-      cacheRead,
-      cacheWrite
-    },
-    outputTokens: {
-      total: outputTokens,
-      text: outputTokens
-    }
-  };
+	const noCache = usage.inputTokens;
+	const cacheRead = usage.cacheReadInputTokens;
+	const cacheWrite = usage.cacheCreationInputTokens;
+	const totalInputTokens = sumDefined(noCache, cacheRead, cacheWrite);
+	const outputTokens = usage.outputTokens;
+	return {
+		inputTokens: {
+			total: totalInputTokens,
+			noCache,
+			cacheRead,
+			cacheWrite
+		},
+		outputTokens: {
+			total: outputTokens,
+			text: outputTokens
+		}
+	};
 }
 function getClaudeProviderMetadata(options, usage) {
-  const queryOptions = options.sdkOptions;
-  return createProviderMetadata("claude", {
-    totalCostUsd: usage?.totalCostUsd,
-    model: getModelId(options),
-    cwd: queryOptions?.cwd,
-    permissionMode: queryOptions?.permissionMode,
-    maxTurns: queryOptions?.maxTurns,
-    allowedTools: queryOptions?.allowedTools,
-    disallowedTools: queryOptions?.disallowedTools,
-    usage
-  });
+	const queryOptions = options.sdkOptions;
+	return createProviderMetadata("claude", {
+		totalCostUsd: usage?.totalCostUsd,
+		model: getModelId(options),
+		cwd: queryOptions?.cwd,
+		permissionMode: queryOptions?.permissionMode,
+		maxTurns: queryOptions?.maxTurns,
+		allowedTools: queryOptions?.allowedTools,
+		disallowedTools: queryOptions?.disallowedTools,
+		usage
+	});
 }
 function getClaudeCostContext(options, usage) {
-  if (typeof usage?.totalCostUsd !== "number") {
-    return void 0;
-  }
-  return {
-    provider: "anthropic",
-    model: getModelId(options),
-    estimatedCost: usage.totalCostUsd,
-    costUnit: "USD",
-    costMetadata: {
-      source: "sdk_estimate",
-      sdkProvider: PROVIDER,
-      sdkCostField: "total_cost_usd",
-      scope: "query_total",
-      modelUsage: usage.modelUsage
-    }
-  };
+	if (typeof usage?.totalCostUsd !== "number") return;
+	return {
+		provider: "anthropic",
+		model: getModelId(options),
+		estimatedCost: usage.totalCostUsd,
+		costUnit: "USD",
+		costMetadata: {
+			source: "sdk_estimate",
+			sdkProvider: PROVIDER,
+			sdkCostField: "total_cost_usd",
+			scope: "query_total",
+			modelUsage: usage.modelUsage
+		}
+	};
 }
 function getTextDelta(message) {
-  if (message.type !== "stream_event") {
-    return "";
-  }
-  const event = message.event;
-  if (event.type === "content_block_delta" && event.delta?.type === "text_delta") {
-    return event.delta.text ?? "";
-  }
-  return "";
+	if (message.type !== "stream_event") return "";
+	const event = message.event;
+	if (event.type === "content_block_delta" && event.delta?.type === "text_delta") return event.delta.text ?? "";
+	return "";
 }
 function getTokenTotal(value) {
-  return typeof value === "number" ? value : void 0;
+	return typeof value === "number" ? value : void 0;
 }
-
+//#endregion
 export { ClaudeSDKAgent };
-//# sourceMappingURL=index.js.map
+
 //# sourceMappingURL=index.js.map