@mastra/claude 0.0.0

package/dist/index.cjs

@@ -0,0 +1,1026 @@
+'use strict';
+
+var crypto = require('crypto');
+var web = require('stream/web');
+var claudeAgentSdk = require('@anthropic-ai/claude-agent-sdk');
+var agent = require('@mastra/core/agent');
+var requestContext = require('@mastra/core/request-context');
+var stream = require('@mastra/core/stream');
+var messageList = require('@mastra/core/agent/message-list');
+var observability = require('@mastra/core/observability');
+
+// src/index.ts
+function createNoopModel({ modelId, provider }) {
+  return {
+    modelId,
+    provider,
+    specificationVersion: "v3",
+    supportedUrls: {},
+    doGenerate: async () => createNoopStreamResult(),
+    doStream: async () => createNoopStreamResult()
+  };
+}
+function createNoopStreamResult() {
+  return {
+    stream: new web.ReadableStream({
+      start: (controller) => controller.close()
+    })
+  };
+}
+function createCompletedMastraStream({
+  runId,
+  prompt,
+  text,
+  responseId,
+  modelId,
+  usage,
+  providerMetadata,
+  costContext
+}) {
+  return new web.ReadableStream({
+    start(controller) {
+      const textId = crypto.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
+      });
+      controller.close();
+    }
+  });
+}
+function createMastraOutput({
+  messages,
+  runId,
+  modelId,
+  provider,
+  stream: stream$1,
+  options
+}) {
+  const messageList$1 = new messageList.MessageList();
+  messageList$1.add(messages, "input");
+  messageList$1.add([{ role: "assistant", content: "" }], "response");
+  return new stream.MastraModelOutput({
+    model: {
+      modelId,
+      provider,
+      version: "v3"
+    },
+    stream: stream$1,
+    messageList: messageList$1,
+    messageId: crypto.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
+  });
+  return createMastraOutput({
+    messages,
+    runId,
+    modelId: result.response.modelId,
+    provider,
+    stream,
+    options
+  }).getFullOutput();
+}
+function createSDKAgentTelemetry({
+  agentId,
+  agentName,
+  provider,
+  modelId,
+  messages,
+  prompt,
+  runId,
+  streaming,
+  method,
+  requestContext,
+  instructions,
+  maxSteps,
+  tracingOptions,
+  tracingContext,
+  onFinish,
+  onStepFinish,
+  mastra
+}) {
+  const agentSpan = observability.getOrCreateSpan({
+    type: observability.SpanType.AGENT_RUN,
+    name: `agent run: '${agentId}'`,
+    entityType: observability.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: observability.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: observability.SpanType.MCP_TOOL_CALL,
+      name: `mcp_tool: '${toolName}' on '${mcp.serverName}'`,
+      input,
+      entityType: observability.EntityType.TOOL,
+      entityId: toolName,
+      entityName: toolName,
+      attributes: {
+        mcpServer: mcp.serverName
+      },
+      metadata: {
+        runId,
+        sdkAgent: true,
+        sdkProvider: provider,
+        sdkMethod: method,
+        toolCallId
+      },
+      requestContext
+    }) : parentSpan.createChildSpan({
+      type: observability.SpanType.TOOL_CALL,
+      name: `tool: '${toolName}'`,
+      input,
+      entityType: observability.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) => observability.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
+      };
+    }
+  };
+}
+function parseMcpToolName(toolName) {
+  const match = /^mcp__([^_].*?)__(.+)$/.exec(toolName);
+  if (!match?.[1] || !match[2]) {
+    return void 0;
+  }
+  return {
+    serverName: match[1],
+    toolName: match[2]
+  };
+}
+function getModelSpanTracker(modelSpan) {
+  if (!modelSpan || !("createTracker" in modelSpan)) {
+    return void 0;
+  }
+  return modelSpan.createTracker();
+}
+function wrapStreamForAgentSpan(stream, telemetry) {
+  let text = "";
+  return stream.pipeThrough(
+    new web.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
+    }
+  };
+}
+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: stream.ChunkFrom.AGENT,
+    payload: {}
+  });
+  controller.enqueue({
+    type: "step-start",
+    runId,
+    from: stream.ChunkFrom.AGENT,
+    payload: {
+      request: { body: prompt }
+    }
+  });
+  controller.enqueue({
+    type: "response-metadata",
+    runId,
+    from: stream.ChunkFrom.AGENT,
+    payload: {
+      id: responseId,
+      modelId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  });
+  controller.enqueue({
+    type: "text-start",
+    runId,
+    from: stream.ChunkFrom.AGENT,
+    payload: {
+      id: textId,
+      providerMetadata
+    }
+  });
+}
+function enqueueTextDelta(controller, runId, textId, text) {
+  controller.enqueue({
+    type: "text-delta",
+    runId,
+    from: stream.ChunkFrom.AGENT,
+    payload: {
+      id: textId,
+      text
+    }
+  });
+}
+function enqueueFinishChunks(controller, {
+  runId,
+  prompt,
+  textId,
+  text,
+  responseId,
+  modelId,
+  usage,
+  providerMetadata,
+  costContext
+}) {
+  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: stream.ChunkFrom.AGENT,
+    payload: {
+      id: textId,
+      providerMetadata
+    }
+  });
+  controller.enqueue({
+    type: "step-finish",
+    runId,
+    from: stream.ChunkFrom.AGENT,
+    payload: {
+      id: responseId,
+      providerMetadata,
+      totalUsage: usage,
+      response,
+      stepResult: {
+        reason: "stop",
+        warnings: []
+      },
+      output: {
+        text,
+        usage,
+        steps: []
+      },
+      metadata
+    }
+  });
+  controller.enqueue({
+    type: "finish",
+    runId,
+    from: stream.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
+  };
+}
+function createProviderMetadata(provider, 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)])
+  );
+}
+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);
+}
+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 "";
+}
+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";
+var ClaudeSDKAgent = class extends agent.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 ?? crypto.randomUUID();
+    const requestContext$1 = options?.requestContext ?? new requestContext.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: requestContext$1,
+      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?.abortSignal ?? options?.signal)
+      );
+      telemetry.endGenerate(result);
+    } catch (error) {
+      telemetry.fail(error);
+      throw error;
+    }
+    return toFullOutput({
+      messages,
+      runId,
+      provider: PROVIDER,
+      result,
+      options: telemetry.outputOptions()
+    });
+  }
+  async stream(messages, options) {
+    const runId = options?.runId ?? crypto.randomUUID();
+    const prompt = promptToText(messages);
+    const modelId = getModelId(this.options);
+    const requestContext$1 = options?.requestContext ?? new requestContext.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: requestContext$1,
+      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?.abortSignal ?? options?.signal)
+      ),
+      options: telemetry.outputOptions()
+    });
+  }
+};
+async function runClaudeGenerate(prompt, options, telemetry, signal) {
+  let text = "";
+  const usage = createClaudeUsageCollector();
+  for await (const message of observeClaudeMessages(runClaude(prompt, options, signal), 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;
+    }
+  }
+  const totals = usage.totals();
+  return {
+    content: [{ type: "text", text }],
+    finishReason: { unified: "stop", raw: "stop" },
+    usage: usage.toV3Usage(),
+    response: {
+      id: crypto.randomUUID(),
+      modelId: getModelId(options),
+      timestamp: /* @__PURE__ */ new Date()
+    },
+    providerMetadata: getClaudeProviderMetadata(options, totals),
+    costContext: getClaudeCostContext(options, totals)
+  };
+}
+function runClaudeAsMastraStream(prompt, options, runId, telemetry, signal) {
+  return new web.ReadableStream({
+    start: async (controller) => {
+      const textId = crypto.randomUUID();
+      const responseId = crypto.randomUUID();
+      const modelId = getModelId(options);
+      const usage = createClaudeUsageCollector();
+      let text = "";
+      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, signal), 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);
+            }
+          }
+        }
+        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)
+        });
+        controller.close();
+      } catch (error) {
+        controller.enqueue({
+          type: "error",
+          runId,
+          from: stream.ChunkFrom.AGENT,
+          payload: { error }
+        });
+        controller.close();
+      }
+    }
+  });
+}
+function runClaude(prompt, options, signal) {
+  const abortController = createAbortController(signal);
+  const queryOptions = {
+    ...options.sdkOptions
+  };
+  if (abortController) {
+    queryOptions.abortController = abortController;
+  }
+  return claudeAgentSdk.query({
+    prompt,
+    options: queryOptions
+  });
+}
+async function* observeClaudeMessages(messages, telemetry) {
+  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);
+  }
+}
+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
+  }));
+}
+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
+  }));
+}
+function getContentBlocks(message) {
+  if (!isRecord(message)) {
+    return [];
+  }
+  return Array.isArray(message.content) ? message.content : [];
+}
+function isRecord(value) {
+  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;
+}
+function getModelId(options) {
+  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()));
+    }
+  };
+}
+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;
+  }, {});
+}
+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)
+  };
+}
+function hasAnyUsage(usage) {
+  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;
+}
+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
+    }
+  };
+}
+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
+  });
+}
+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
+    }
+  };
+}
+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 "";
+}
+function getTokenTotal(value) {
+  return typeof value === "number" ? value : void 0;
+}
+
+exports.ClaudeSDKAgent = ClaudeSDKAgent;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map