@mastra/cursor 0.3.0 → 0.3.1-alpha.1

package/dist/index.js

@@ -1,1097 +1,896 @@
-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
+import { randomUUID } from "crypto";
+import { ReadableStream, TransformStream } from "stream/web";
+import { Agent } from "@cursor/sdk";
+import { Agent as Agent$1 } 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";
+//#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,
-  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,
-    object: result.object
-  });
-  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
-      };
-    }
-  };
+	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, 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,
+		object: result.object
+	});
+	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) {
+			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 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) {
-    assertStructuredOutputUnsupported(options);
-    const sdkAgent = await this.resolveCursorAgent();
-    return this.generateWithAgent(messages, sdkAgent, options);
-  }
-  async generateWithAgent(messages, sdkAgent, options) {
-    const prompt = promptToText(messages);
-    const runId = options?.runId ?? randomUUID();
-    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) {
-    assertStructuredOutputUnsupported(options);
-    const sdkAgent = await this.resolveCursorAgent();
-    return this.streamWithAgent(messages, sdkAgent, options);
-  }
-  async streamWithAgent(messages, sdkAgent, options) {
-    const runId = options?.runId ?? randomUUID();
-    const prompt = promptToText(messages);
-    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()
-    });
-  }
-  async resumeGenerate(resumeData, options) {
-    assertStructuredOutputUnsupported(options);
-    const data = validateCursorResumeData(resumeData);
-    const sdkAgent = await this.resolveResumeCursorAgent(data);
-    return this.generateWithAgent(data.message, sdkAgent, options);
-  }
-  async resumeStream(resumeData, options) {
-    assertStructuredOutputUnsupported(options);
-    const data = validateCursorResumeData(resumeData);
-    const sdkAgent = await this.resolveResumeCursorAgent(data);
-    return this.streamWithAgent(data.message, sdkAgent, options);
-  }
-  resolveCursorAgent() {
-    this.#createdAgent ??= resolveCursorAgent(this.options.agent, this.options).catch((error) => {
-      this.#createdAgent = void 0;
-      throw error;
-    });
-    return this.#createdAgent;
-  }
-  async resolveResumeCursorAgent(resumeData) {
-    if (!resumeData.agentId) {
-      return this.resolveCursorAgent();
-    }
-    return Agent$1.resume(resumeData.agentId, {
-      ...toCursorCreateOptions(this.options),
-      ...resumeData.sdkOptions
-    });
-  }
+	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 = "@cursor/sdk";
+const MODEL_ID = "cursor-agent-sdk";
+var CursorSDKAgent = class extends Agent$1 {
+	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) {
+		assertStructuredOutputUnsupported(options);
+		const sdkAgent = await this.resolveCursorAgent();
+		return this.generateWithAgent(messages, sdkAgent, options);
+	}
+	async generateWithAgent(messages, sdkAgent, options) {
+		const prompt = promptToText(messages);
+		const runId = options?.runId ?? randomUUID();
+		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) {
+		assertStructuredOutputUnsupported(options);
+		const sdkAgent = await this.resolveCursorAgent();
+		return this.streamWithAgent(messages, sdkAgent, options);
+	}
+	async streamWithAgent(messages, sdkAgent, options) {
+		const runId = options?.runId ?? randomUUID();
+		const prompt = promptToText(messages);
+		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()
+		});
+	}
+	async resumeGenerate(resumeData, options) {
+		assertStructuredOutputUnsupported(options);
+		const data = validateCursorResumeData(resumeData);
+		const sdkAgent = await this.resolveResumeCursorAgent(data);
+		return this.generateWithAgent(data.message, sdkAgent, options);
+	}
+	async resumeStream(resumeData, options) {
+		assertStructuredOutputUnsupported(options);
+		const data = validateCursorResumeData(resumeData);
+		const sdkAgent = await this.resolveResumeCursorAgent(data);
+		return this.streamWithAgent(data.message, sdkAgent, options);
+	}
+	resolveCursorAgent() {
+		this.#createdAgent ??= resolveCursorAgent(this.options.agent, this.options).catch((error) => {
+			this.#createdAgent = void 0;
+			throw error;
+		});
+		return this.#createdAgent;
+	}
+	async resolveResumeCursorAgent(resumeData) {
+		if (!resumeData.agentId) return this.resolveCursorAgent();
+		return Agent.resume(resumeData.agentId, {
+			...toCursorCreateOptions(this.options),
+			...resumeData.sdkOptions
+		});
+	}
 };
 function validateCursorResumeData(resumeData) {
-  if (!toRecord(resumeData) || !("message" in resumeData)) {
-    throw new Error("CursorSDKAgent resumeData must include a message.");
-  }
-  if (resumeData.agentId !== void 0 && typeof resumeData.agentId !== "string") {
-    throw new Error("CursorSDKAgent resumeData.agentId must be a string when provided.");
-  }
-  return resumeData;
+	if (!toRecord(resumeData) || !("message" in resumeData)) throw new Error("CursorSDKAgent resumeData must include a message.");
+	if (resumeData.agentId !== void 0 && typeof resumeData.agentId !== "string") throw new Error("CursorSDKAgent resumeData.agentId must be a string when provided.");
+	return resumeData;
 }
 function assertStructuredOutputUnsupported(options) {
-  const structuredOutput = toRecord(toRecord(options)?.structuredOutput);
-  if (structuredOutput && "schema" in structuredOutput) {
-    throw new Error(
-      "CursorSDKAgent does not support structuredOutput because the Cursor TypeScript SDK does not expose a schema-constrained output API."
-    );
-  }
+	const structuredOutput = toRecord(toRecord(options)?.structuredOutput);
+	if (structuredOutput && "schema" in structuredOutput) throw new Error("CursorSDKAgent does not support structuredOutput because the Cursor TypeScript SDK does not expose a schema-constrained output API.");
 }
 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
-  };
+	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();
-      }
-    }
-  });
+	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;
+	if (!agent) return Agent.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;
+	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);
-    }
-  };
+	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));
-    }
-  };
+	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
-    }
-  };
+	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;
+	return options.sdkOptions?.model;
 }
 function getModelId(model) {
-  if (!model) {
-    return MODEL_ID;
-  }
-  return typeof model === "string" ? model : model.id;
+	if (!model) return MODEL_ID;
+	return typeof model === "string" ? model : model.id;
 }
 function getCursorModelId(options, agent) {
-  return getModelId(getRequestedModel(options) ?? agent.model);
+	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
-  });
+	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;
+	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 "";
+	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
-  });
+	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"
-  };
+	const toolCallId = typeof update.callId === "string" ? update.callId : void 0;
+	const toolCall = toRecord(update.toolCall);
+	if (!toolCallId || !toolCall) return;
+	if (toolCall.type === "mcp") {
+		const args = toRecord(toolCall.args);
+		if (!args) return;
+		const providerIdentifier = typeof args?.providerIdentifier === "string" ? args.providerIdentifier : void 0;
+		const toolName = typeof args?.toolName === "string" ? args.toolName : void 0;
+		if (!providerIdentifier || !toolName) return;
+		const result = toRecord(toolCall.result);
+		return {
+			toolCallId,
+			toolName: `mcp__${providerIdentifier}__${toolName}`,
+			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;
+	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;
+	return value !== null && typeof value === "object" ? value : void 0;
 }
-
+//#endregion
 export { CursorSDKAgent };
-//# sourceMappingURL=index.js.map
+
 //# sourceMappingURL=index.js.map