@mastra/cursor 0.0.0

package/dist/index.js

@@ -0,0 +1,1039 @@
+import { randomUUID } from 'crypto';
+import { ReadableStream, TransformStream } from 'stream/web';
+import { Agent as Agent$1 } from '@cursor/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';
+
+// src/index.ts
+function createNoopModel({ modelId, provider }) {
+  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
+}) {
+  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
+      });
+      controller.close();
+    }
+  });
+}
+function createMastraOutput({
+  messages,
+  runId,
+  modelId,
+  provider,
+  stream,
+  options
+}) {
+  const messageList = new MessageList();
+  messageList.add(messages, "input");
+  messageList.add([{ role: "assistant", content: "" }], "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
+  });
+  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 = 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
+      };
+    }
+  };
+}
+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 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: 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
+}) {
+  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
+    }
+  });
+  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
+  };
+}
+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 = "@cursor/sdk";
+var MODEL_ID = "cursor-agent-sdk";
+var CursorSDKAgent = class extends Agent {
+  options;
+  #mastra;
+  #createdAgent;
+  constructor(options) {
+    super({
+      id: options.id,
+      name: options.name ?? options.id,
+      description: options.description,
+      instructions: "",
+      model: createNoopModel({
+        modelId: getModelId(getRequestedModel(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 sdkAgent = await this.resolveCursorAgent();
+    const modelId = getCursorModelId(this.options, sdkAgent);
+    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: 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(() => runCursorGenerate(prompt, this.options, sdkAgent, telemetry));
+      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 ?? randomUUID();
+    const prompt = promptToText(messages);
+    const sdkAgent = await this.resolveCursorAgent();
+    const modelId = getCursorModelId(this.options, sdkAgent);
+    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(runCursorAsMastraStream(prompt, this.options, sdkAgent, runId, telemetry)),
+      options: telemetry.outputOptions()
+    });
+  }
+  resolveCursorAgent() {
+    this.#createdAgent ??= resolveCursorAgent(this.options.agent, this.options).catch((error) => {
+      this.#createdAgent = void 0;
+      throw error;
+    });
+    return this.#createdAgent;
+  }
+};
+async function runCursorGenerate(prompt, options, agent, telemetry) {
+  const usage = createCursorUsageCollector();
+  const run = await agent.send(prompt, createCursorSendOptions(options, usage, telemetry));
+  const result = await run.wait();
+  if (result.status === "error" || result.status === "cancelled") {
+    throw new Error(`Cursor run ${result.id} ended with status ${result.status}`);
+  }
+  const responseModel = getModelId(result.model ?? run.model ?? getRequestedModel(options) ?? agent.model);
+  const providerMetadata = getCursorProviderMetadata(
+    options,
+    agent.agentId,
+    result.id,
+    result.status,
+    result.durationMs,
+    usage.totals(),
+    responseModel
+  );
+  return {
+    content: [{ type: "text", text: result.result ?? "" }],
+    finishReason: { unified: "stop", raw: "stop" },
+    usage: usage.toV3Usage(),
+    response: {
+      id: result.id,
+      modelId: responseModel,
+      timestamp: /* @__PURE__ */ new Date()
+    },
+    providerMetadata
+  };
+}
+function runCursorAsMastraStream(prompt, options, agent, runId, telemetry) {
+  return new ReadableStream({
+    start: async (controller) => {
+      const textId = randomUUID();
+      const usage = createCursorUsageCollector();
+      let text = "";
+      try {
+        const run = await agent.send(prompt, createCursorSendOptions(options, usage, telemetry));
+        const responseId = run.id;
+        const responseModel = getModelId(run.model ?? getRequestedModel(options) ?? agent.model);
+        enqueueStartChunks(controller, {
+          runId,
+          prompt,
+          textId,
+          responseId,
+          modelId: responseModel,
+          providerMetadata: getCursorProviderMetadata(
+            options,
+            agent.agentId,
+            run.id,
+            run.status,
+            run.durationMs,
+            usage.totals(),
+            responseModel
+          )
+        });
+        let result;
+        if (run.supports("stream")) {
+          for await (const message of run.stream()) {
+            const delta = getTextFromCursorMessage(message);
+            if (delta) {
+              text += delta;
+              enqueueTextDelta(controller, runId, textId, delta);
+            }
+          }
+          result = await run.wait();
+        } else {
+          result = await run.wait();
+          if (result.status === "error" || result.status === "cancelled") {
+            throw new Error(`Cursor run ${result.id} ended with status ${result.status}`);
+          }
+          if (result.result) {
+            text += result.result;
+            enqueueTextDelta(controller, runId, textId, result.result);
+          }
+        }
+        if (result.status === "error" || result.status === "cancelled") {
+          throw new Error(`Cursor run ${result.id} ended with status ${result.status}`);
+        }
+        if (!text && result.result) {
+          text = result.result;
+          enqueueTextDelta(controller, runId, textId, result.result);
+        }
+        const providerMetadata = getCursorProviderMetadata(
+          options,
+          agent.agentId,
+          run.id,
+          result.status,
+          result.durationMs,
+          usage.totals(),
+          getModelId(result.model ?? run.model ?? getRequestedModel(options) ?? agent.model)
+        );
+        enqueueFinishChunks(controller, {
+          runId,
+          prompt,
+          textId,
+          text,
+          responseId,
+          modelId: getModelId(result.model ?? run.model ?? getRequestedModel(options) ?? agent.model),
+          usage: usage.toLanguageModelUsage(),
+          providerMetadata
+        });
+        controller.close();
+      } catch (error) {
+        controller.enqueue({
+          type: "error",
+          runId,
+          from: ChunkFrom.AGENT,
+          payload: { error }
+        });
+        controller.close();
+      }
+    }
+  });
+}
+async function resolveCursorAgent(agent, options) {
+  if (!agent) {
+    return Agent$1.create(toCursorCreateOptions(options));
+  }
+  return typeof agent === "function" ? agent(toCursorCreateOptions(options)) : agent;
+}
+function toCursorCreateOptions(options) {
+  const createOptions = { ...options.sdkOptions };
+  const apiKey = createOptions.apiKey ?? process.env["CURSOR_API_KEY"];
+  if (apiKey) createOptions.apiKey = apiKey;
+  if (options.name && !createOptions.name) createOptions.name = options.name;
+  return createOptions;
+}
+function createCursorSendOptions(options, usage, telemetry) {
+  return {
+    mcpServers: options.sdkOptions?.mcpServers,
+    onDelta: async (args) => {
+      usage.record(args.update);
+      recordCursorToolTelemetry(args.update, telemetry);
+    }
+  };
+}
+function createCursorUsageCollector() {
+  const totals = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0
+  };
+  return {
+    record(update) {
+      if (update.type !== "turn-ended" || !update.usage) {
+        return;
+      }
+      totals.inputTokens += update.usage.inputTokens;
+      totals.outputTokens += update.usage.outputTokens;
+      totals.cacheReadTokens += update.usage.cacheReadTokens;
+      totals.cacheWriteTokens += update.usage.cacheWriteTokens;
+    },
+    totals() {
+      return {
+        inputTokens: totals.inputTokens || void 0,
+        outputTokens: totals.outputTokens || void 0,
+        cacheReadTokens: totals.cacheReadTokens || void 0,
+        cacheWriteTokens: totals.cacheWriteTokens || void 0
+      };
+    },
+    toV3Usage() {
+      return toV3Usage(totals);
+    },
+    toLanguageModelUsage() {
+      return toLanguageModelUsage(toV3Usage(totals));
+    }
+  };
+}
+function toV3Usage(usage) {
+  const noCache = usage.inputTokens;
+  const cacheRead = usage.cacheReadTokens;
+  const cacheWrite = usage.cacheWriteTokens;
+  const totalInputTokens = sumDefined(noCache, cacheRead, cacheWrite);
+  const outputTokens = usage.outputTokens;
+  return {
+    inputTokens: {
+      total: totalInputTokens,
+      noCache,
+      cacheRead,
+      cacheWrite
+    },
+    outputTokens: {
+      total: outputTokens,
+      text: outputTokens
+    }
+  };
+}
+function getRequestedModel(options) {
+  return options.sdkOptions?.model;
+}
+function getModelId(model) {
+  if (!model) {
+    return MODEL_ID;
+  }
+  return typeof model === "string" ? model : model.id;
+}
+function getCursorModelId(options, agent) {
+  return getModelId(getRequestedModel(options) ?? agent.model);
+}
+function getCursorProviderMetadata(options, agentId, runId, status, durationMs, usage, requestedModel) {
+  return createProviderMetadata("cursor", {
+    agentId,
+    runId,
+    status,
+    requestedModel: requestedModel ?? getModelId(getRequestedModel(options)),
+    durationMs,
+    mcpServerNames: getMcpServerNames(options),
+    usage
+  });
+}
+function getMcpServerNames(options) {
+  const servers = options.sdkOptions?.mcpServers;
+  return servers ? Object.keys(servers) : void 0;
+}
+function getTextFromCursorMessage(message) {
+  if (message.type === "assistant") {
+    return message.message.content.map((block) => {
+      if (block.type === "text") {
+        return block.text;
+      }
+      return "";
+    }).filter(Boolean).join("");
+  }
+  if (message.type === "task") {
+    return message.text ?? "";
+  }
+  return "";
+}
+function recordCursorToolTelemetry(update, telemetry) {
+  const updateRecord = toRecord(update);
+  if (!updateRecord) {
+    return;
+  }
+  const updateType = typeof updateRecord?.type === "string" ? updateRecord.type : void 0;
+  if (updateType !== "tool-call-started" && updateType !== "partial-tool-call" && updateType !== "tool-call-completed") {
+    return;
+  }
+  const toolCall = getCursorToolCall(updateRecord);
+  if (!toolCall) {
+    return;
+  }
+  if (updateType === "tool-call-started" || updateType === "partial-tool-call") {
+    telemetry.startToolCall({
+      toolCallId: toolCall.toolCallId,
+      toolName: toolCall.toolName,
+      input: toolCall.input
+    });
+    return;
+  }
+  telemetry.startToolCall({
+    toolCallId: toolCall.toolCallId,
+    toolName: toolCall.toolName,
+    input: toolCall.input
+  });
+  telemetry.endToolCall({
+    toolCallId: toolCall.toolCallId,
+    output: toolCall.output,
+    isError: toolCall.isError
+  });
+}
+function getCursorToolCall(update) {
+  const toolCallId = typeof update.callId === "string" ? update.callId : void 0;
+  const toolCall = toRecord(update.toolCall);
+  if (!toolCallId || !toolCall) {
+    return void 0;
+  }
+  if (toolCall.type === "mcp") {
+    const args = toRecord(toolCall.args);
+    if (!args) {
+      return void 0;
+    }
+    const providerIdentifier = typeof args?.providerIdentifier === "string" ? args.providerIdentifier : void 0;
+    const toolName2 = typeof args?.toolName === "string" ? args.toolName : void 0;
+    if (!providerIdentifier || !toolName2) {
+      return void 0;
+    }
+    const result = toRecord(toolCall.result);
+    return {
+      toolCallId,
+      toolName: `mcp__${providerIdentifier}__${toolName2}`,
+      input: args.args,
+      output: result?.value ?? toolCall.result,
+      isError: result?.status === "error" || result?.status === "failed"
+    };
+  }
+  const toolName = typeof toolCall.name === "string" ? toolCall.name : typeof toolCall.type === "string" ? toolCall.type : void 0;
+  if (!toolName) {
+    return void 0;
+  }
+  return {
+    toolCallId,
+    toolName,
+    input: "args" in toolCall ? toolCall.args : void 0,
+    output: "result" in toolCall ? toolCall.result : void 0,
+    isError: toolCall.status === "error"
+  };
+}
+function toRecord(value) {
+  return value !== null && typeof value === "object" ? value : void 0;
+}
+
+export { CursorSDKAgent };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map