@mastra/openai 1.1.0 → 1.1.1-alpha.1

package/dist/index.js

@@ -1,1175 +1,972 @@
-import { randomUUID } from 'crypto';
-import { ReadableStream, TransformStream } from 'stream/web';
-import { Agent } from '@mastra/core/agent';
-import { RequestContext } from '@mastra/core/request-context';
-import { ChunkFrom, MastraModelOutput } from '@mastra/core/stream';
-import { Agent as Agent$1, run } from '@openai/agents';
-import { MessageList } from '@mastra/core/agent/message-list';
-import { getOrCreateSpan, EntityType, SpanType, executeWithContext } from '@mastra/core/observability';
-import { toStandardSchema, standardSchemaToJSONSchema } from '@mastra/core/schema';
-
-// src/index.ts
+import { randomUUID } from "crypto";
+import { ReadableStream, TransformStream } from "stream/web";
+import { Agent } from "@mastra/core/agent";
+import { RequestContext } from "@mastra/core/request-context";
+import { ChunkFrom, MastraModelOutput } from "@mastra/core/stream";
+import { Agent as Agent$1, run } from "@openai/agents";
+import { MessageList } from "@mastra/core/agent/message-list";
+import { EntityType, SpanType, executeWithContext, getOrCreateSpan } from "@mastra/core/observability";
+import { standardSchemaToJSONSchema, toStandardSchema } from "@mastra/core/schema";
+//#region src/utils.ts
 function createNoopModel({ modelId, provider }) {
-  return {
-    modelId,
-    provider,
-    specificationVersion: "v3",
-    supportedUrls: {},
-    doGenerate: async () => createNoopStreamResult(),
-    doStream: async () => createNoopStreamResult()
-  };
+	return {
+		modelId,
+		provider,
+		specificationVersion: "v3",
+		supportedUrls: {},
+		doGenerate: async () => createNoopStreamResult(),
+		doStream: async () => createNoopStreamResult()
+	};
 }
 function createNoopStreamResult() {
-  return {
-    stream: new ReadableStream({
-      start: (controller) => controller.close()
-    })
-  };
-}
-function createCompletedMastraStream({
-  runId,
-  prompt,
-  text,
-  responseId,
-  modelId,
-  usage,
-  providerMetadata,
-  costContext,
-  object
-}) {
-  return new ReadableStream({
-    start(controller) {
-      const textId = randomUUID();
-      enqueueStartChunks(controller, {
-        runId,
-        prompt,
-        textId,
-        responseId,
-        modelId,
-        providerMetadata
-      });
-      if (text) {
-        enqueueTextDelta(controller, runId, textId, text);
-      }
-      enqueueFinishChunks(controller, {
-        runId,
-        prompt,
-        textId,
-        text,
-        responseId,
-        modelId,
-        usage,
-        providerMetadata,
-        costContext,
-        object
-      });
-      controller.close();
-    }
-  });
-}
-function createMastraOutput({
-  messages,
-  runId,
-  modelId,
-  provider,
-  stream,
-  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: {
-      ...responseId ? { 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: {
+			...responseId ? { 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 = {
-    ...responseId ? { 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: {
-      ...responseId ? { 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 = {
+		...responseId ? { 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: {
+			...responseId ? { 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,
-    reasoningTokens: usage.outputTokens.reasoning,
-    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,
+		reasoningTokens: usage.outputTokens.reasoning,
+		raw: usage
+	};
 }
 function createProviderMetadata(provider, metadata) {
-  return {
-    [provider]: toJsonRecord(metadata)
-  };
+	return { [provider]: toJsonRecord(metadata) };
 }
 function toJsonRecord(record) {
-  return Object.fromEntries(
-    Object.entries(record).filter((entry) => entry[1] !== void 0).map(([key, value]) => [key, toJsonValue(value)])
-  );
+	return Object.fromEntries(Object.entries(record).filter((entry) => entry[1] !== void 0).map(([key, value]) => [key, toJsonValue(value)]));
 }
 function toJsonValue(value) {
-  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.filter((item) => item !== void 0).map(toJsonValue);
-  }
-  if (value instanceof Date) {
-    return value.toISOString();
-  }
-  if (typeof value === "object") {
-    return toJsonRecord(value);
-  }
-  return String(value);
+	if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (Array.isArray(value)) return value.filter((item) => item !== void 0).map(toJsonValue);
+	if (value instanceof Date) return value.toISOString();
+	if (typeof value === "object") return toJsonRecord(value);
+	return String(value);
 }
 function promptToText(prompt) {
-  if (typeof prompt === "string") {
-    return prompt;
-  }
-  if (Array.isArray(prompt)) {
-    return prompt.map(promptToText).filter(Boolean).join("\n");
-  }
-  if (!prompt || typeof prompt !== "object") {
-    return "";
-  }
-  const record = prompt;
-  if (typeof record.text === "string") {
-    return record.text;
-  }
-  if (typeof record.content === "string") {
-    return record.content;
-  }
-  if (record.content) {
-    return promptToText(record.content);
-  }
-  return "";
+	if (typeof prompt === "string") return prompt;
+	if (Array.isArray(prompt)) return prompt.map(promptToText).filter(Boolean).join("\n");
+	if (!prompt || typeof prompt !== "object") return "";
+	const record = prompt;
+	if (typeof record.text === "string") return record.text;
+	if (typeof record.content === "string") return record.content;
+	if (record.content) return promptToText(record.content);
+	return "";
 }
 function getStructuredOutputSchema(structuredOutput) {
-  if (!structuredOutput?.schema) {
-    return void 0;
-  }
-  return {
-    type: "json_schema",
-    name: "mastra_output",
-    strict: false,
-    schema: standardSchemaToJSONSchema(toStandardSchema(structuredOutput.schema))
-  };
+	if (!structuredOutput?.schema) return;
+	return {
+		type: "json_schema",
+		name: "mastra_output",
+		strict: false,
+		schema: standardSchemaToJSONSchema(toStandardSchema(structuredOutput.schema))
+	};
 }
 async function getStructuredOutputFromValue(value, structuredOutput) {
-  if (!structuredOutput?.schema) {
-    return void 0;
-  }
-  let parsed;
-  if (typeof value === "string") {
-    try {
-      parsed = JSON.parse(value);
-    } catch (error) {
-      return handleStructuredOutputError(
-        new Error("Structured output must be valid JSON.", { cause: error }),
-        structuredOutput
-      );
-    }
-  } else {
-    parsed = value;
-  }
-  const schema = toStandardSchema(structuredOutput.schema);
-  const result = await schema["~standard"].validate(parsed);
-  if (!result.issues) {
-    return result.value;
-  }
-  const message = result.issues.map((issue) => `- ${issue.path?.join(".") || "root"}: ${issue.message}`).join("\n");
-  return handleStructuredOutputError(new Error(`Structured output validation failed:
-${message}`), structuredOutput);
+	if (!structuredOutput?.schema) return;
+	let parsed;
+	if (typeof value === "string") try {
+		parsed = JSON.parse(value);
+	} catch (error) {
+		return handleStructuredOutputError(new Error("Structured output must be valid JSON.", { cause: error }), structuredOutput);
+	}
+	else parsed = value;
+	const result = await toStandardSchema(structuredOutput.schema)["~standard"].validate(parsed);
+	if (!result.issues) return result.value;
+	const message = result.issues.map((issue) => `- ${issue.path?.join(".") || "root"}: ${issue.message}`).join("\n");
+	return handleStructuredOutputError(/* @__PURE__ */ new Error(`Structured output validation failed:\n${message}`), structuredOutput);
 }
 function handleStructuredOutputError(error, structuredOutput) {
-  if (structuredOutput.errorStrategy === "fallback") {
-    return structuredOutput.fallbackValue;
-  }
-  if (structuredOutput.errorStrategy === "warn") {
-    structuredOutput.logger?.warn(error.message);
-    return void 0;
-  }
-  throw error;
+	if (structuredOutput.errorStrategy === "fallback") return structuredOutput.fallbackValue;
+	if (structuredOutput.errorStrategy === "warn") {
+		structuredOutput.logger?.warn(error.message);
+		return;
+	}
+	throw error;
 }
 function sumDefined(...values) {
-  const defined = values.filter((value) => typeof value === "number");
-  if (defined.length === 0) {
-    return void 0;
-  }
-  return defined.reduce((sum, value) => sum + value, 0);
-}
-
-// src/index.ts
-var PROVIDER = "@openai/agents";
-var MODEL_ID = "openai-agents-sdk";
+	const defined = values.filter((value) => typeof value === "number");
+	if (defined.length === 0) return;
+	return defined.reduce((sum, value) => sum + value, 0);
+}
+//#endregion
+//#region src/index.ts
+const PROVIDER = "@openai/agents";
+const MODEL_ID = "openai-agents-sdk";
 var OpenAISDKAgent = 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(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 = getRunOpenAIAgent(this.resolveOpenAIAgent(), options);
-    const modelId = getModelId(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(() => runOpenAIGenerate(prompt, sdkAgent, runId, telemetry, options));
-      telemetry.endGenerate(result);
-    } catch (error) {
-      telemetry.fail(error);
-      throw error;
-    }
-    return toFullOutput({
-      messages,
-      runId,
-      provider: PROVIDER,
-      result,
-      options: { ...telemetry.outputOptions(), structuredOutput: getStructuredOutputOption(options) }
-    });
-  }
-  async stream(messages, options) {
-    const prompt = promptToText(messages);
-    const runId = options?.runId ?? randomUUID();
-    const sdkAgent = getRunOpenAIAgent(this.resolveOpenAIAgent(), options);
-    const modelId = getModelId(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(runOpenAIAsMastraStream(prompt, sdkAgent, runId, modelId, telemetry, options)),
-      options: { ...telemetry.outputOptions(), structuredOutput: getStructuredOutputOption(options) }
-    });
-  }
-  async resumeGenerate(resumeData, options) {
-    const data = validateOpenAIResumeData(resumeData);
-    return this.generate(data.message, createOpenAIResumeRunOptions(data, options));
-  }
-  async resumeStream(resumeData, options) {
-    const data = validateOpenAIResumeData(resumeData);
-    return this.stream(data.message, createOpenAIResumeRunOptions(data, options));
-  }
-  resolveOpenAIAgent() {
-    this.#createdAgent ??= this.options.agent ?? new Agent$1(toOpenAIAgentOptions(this.options));
-    return this.#createdAgent;
-  }
+	options;
+	#mastra;
+	#createdAgent;
+	constructor(options) {
+		super({
+			id: options.id,
+			name: options.name ?? options.id,
+			description: options.description,
+			instructions: "",
+			model: createNoopModel({
+				modelId: getModelId(options),
+				provider: PROVIDER
+			})
+		});
+		this.options = options;
+	}
+	__registerMastra(mastra) {
+		super.__registerMastra(mastra);
+		this.#mastra = mastra;
+	}
+	supportsMemory() {
+		return false;
+	}
+	async generate(messages, options) {
+		const prompt = promptToText(messages);
+		const runId = options?.runId ?? randomUUID();
+		const sdkAgent = getRunOpenAIAgent(this.resolveOpenAIAgent(), options);
+		const modelId = getModelId(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(() => runOpenAIGenerate(prompt, sdkAgent, runId, telemetry, options));
+			telemetry.endGenerate(result);
+		} catch (error) {
+			telemetry.fail(error);
+			throw error;
+		}
+		return toFullOutput({
+			messages,
+			runId,
+			provider: PROVIDER,
+			result,
+			options: {
+				...telemetry.outputOptions(),
+				structuredOutput: getStructuredOutputOption(options)
+			}
+		});
+	}
+	async stream(messages, options) {
+		const prompt = promptToText(messages);
+		const runId = options?.runId ?? randomUUID();
+		const sdkAgent = getRunOpenAIAgent(this.resolveOpenAIAgent(), options);
+		const modelId = getModelId(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(runOpenAIAsMastraStream(prompt, sdkAgent, runId, modelId, telemetry, options)),
+			options: {
+				...telemetry.outputOptions(),
+				structuredOutput: getStructuredOutputOption(options)
+			}
+		});
+	}
+	async resumeGenerate(resumeData, options) {
+		const data = validateOpenAIResumeData(resumeData);
+		return this.generate(data.message, createOpenAIResumeRunOptions(data, options));
+	}
+	async resumeStream(resumeData, options) {
+		const data = validateOpenAIResumeData(resumeData);
+		return this.stream(data.message, createOpenAIResumeRunOptions(data, options));
+	}
+	resolveOpenAIAgent() {
+		this.#createdAgent ??= this.options.agent ?? new Agent$1(toOpenAIAgentOptions(this.options));
+		return this.#createdAgent;
+	}
 };
 function getStructuredOutputOption(options) {
-  return options?.structuredOutput;
+	return options?.structuredOutput;
 }
 function validateOpenAIResumeData(resumeData) {
-  const record = toRecord(resumeData);
-  if (!record || !("message" in record)) {
-    throw new Error("OpenAISDKAgent resumeData must include a message.");
-  }
-  if (typeof resumeData.previousResponseId === "string" || typeof resumeData.conversationId === "string" || resumeData.session !== void 0) {
-    return resumeData;
-  }
-  throw new Error("OpenAISDKAgent resumeData must include previousResponseId, conversationId, or session.");
+	const record = toRecord(resumeData);
+	if (!record || !("message" in record)) throw new Error("OpenAISDKAgent resumeData must include a message.");
+	if (typeof resumeData.previousResponseId === "string" || typeof resumeData.conversationId === "string" || resumeData.session !== void 0) return resumeData;
+	throw new Error("OpenAISDKAgent resumeData must include previousResponseId, conversationId, or session.");
 }
 function createOpenAIResumeRunOptions(resumeData, options) {
-  return {
-    ...options,
-    previousResponseId: resumeData.previousResponseId ?? options?.previousResponseId,
-    conversationId: resumeData.conversationId ?? options?.conversationId,
-    session: resumeData.session ?? options?.session
-  };
+	return {
+		...options,
+		previousResponseId: resumeData.previousResponseId ?? options?.previousResponseId,
+		conversationId: resumeData.conversationId ?? options?.conversationId,
+		session: resumeData.session ?? options?.session
+	};
 }
 async function runOpenAIGenerate(prompt, agent, runId, telemetry, options) {
-  const result = await run(agent, prompt, createOpenAIRunOptions(options, false));
-  recordOpenAIToolTelemetry(result.newItems, telemetry);
-  const text = getTextFromFinalOutput(result.finalOutput);
-  const responseId = result.lastResponseId;
-  const modelId = getModelId(void 0, result.lastAgent ?? agent, result.rawResponses.at(-1));
-  const usage = createOpenAIUsageTotals(result.state.usage);
-  const providerMetadata = getOpenAIProviderMetadata({
-    modelId,
-    responseId,
-    lastResponseId: result.lastResponseId,
-    rawResponseCount: result.rawResponses.length,
-    itemCount: result.newItems.length,
-    usage
-  });
-  return {
-    content: [{ type: "text", text }],
-    finishReason: { unified: "stop", raw: "stop" },
-    usage: toV3Usage(usage),
-    response: {
-      id: responseId,
-      modelId,
-      timestamp: /* @__PURE__ */ new Date()
-    },
-    providerMetadata,
-    object: await getStructuredOutputFromValue(result.finalOutput, options?.structuredOutput)
-  };
+	const result = await run(agent, prompt, createOpenAIRunOptions(options, false));
+	recordOpenAIToolTelemetry(result.newItems, telemetry);
+	const text = getTextFromFinalOutput(result.finalOutput);
+	const responseId = result.lastResponseId;
+	const modelId = getModelId(void 0, result.lastAgent ?? agent, result.rawResponses.at(-1));
+	const usage = createOpenAIUsageTotals(result.state.usage);
+	const providerMetadata = getOpenAIProviderMetadata({
+		modelId,
+		responseId,
+		lastResponseId: result.lastResponseId,
+		rawResponseCount: result.rawResponses.length,
+		itemCount: result.newItems.length,
+		usage
+	});
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		finishReason: {
+			unified: "stop",
+			raw: "stop"
+		},
+		usage: toV3Usage(usage),
+		response: {
+			id: responseId,
+			modelId,
+			timestamp: /* @__PURE__ */ new Date()
+		},
+		providerMetadata,
+		object: await getStructuredOutputFromValue(result.finalOutput, options?.structuredOutput)
+	};
 }
 function runOpenAIAsMastraStream(prompt, agent, runId, requestedModelId, telemetry, options) {
-  return new ReadableStream({
-    start: async (controller) => {
-      const textId = randomUUID();
-      let text = "";
-      let responseId;
-      let modelId = requestedModelId;
-      try {
-        const result = await run(agent, prompt, createOpenAIRunOptions(options, true));
-        enqueueStartChunks(controller, {
-          runId,
-          prompt,
-          textId,
-          responseId,
-          modelId
-        });
-        for await (const event of result) {
-          const delta = getTextDelta(event);
-          if (delta) {
-            text += delta;
-            enqueueTextDelta(controller, runId, textId, delta);
-          }
-          recordOpenAIStreamToolTelemetry(event, telemetry);
-        }
-        await result.completed;
-        responseId = result.lastResponseId ?? responseId;
-        modelId = getModelId(void 0, result.lastAgent ?? agent, result.rawResponses.at(-1));
-        if (!text) {
-          text = getTextFromFinalOutput(result.finalOutput);
-          if (text) {
-            enqueueTextDelta(controller, runId, textId, text);
-          }
-        }
-        const usage = createOpenAIUsageTotals(result.state.usage);
-        const providerMetadata = getOpenAIProviderMetadata({
-          modelId,
-          responseId,
-          lastResponseId: result.lastResponseId,
-          rawResponseCount: result.rawResponses.length,
-          itemCount: result.newItems.length,
-          usage
-        });
-        enqueueFinishChunks(controller, {
-          runId,
-          prompt,
-          textId,
-          text,
-          responseId,
-          modelId,
-          usage: toLanguageModelUsage(toV3Usage(usage)),
-          providerMetadata,
-          object: await getStructuredOutputFromValue(result.finalOutput, options?.structuredOutput)
-        });
-        controller.close();
-      } catch (error) {
-        controller.enqueue({
-          type: "error",
-          runId,
-          from: ChunkFrom.AGENT,
-          payload: { error }
-        });
-        controller.close();
-      }
-    }
-  });
+	return new ReadableStream({ start: async (controller) => {
+		const textId = randomUUID();
+		let text = "";
+		let responseId;
+		let modelId = requestedModelId;
+		try {
+			const result = await run(agent, prompt, createOpenAIRunOptions(options, true));
+			enqueueStartChunks(controller, {
+				runId,
+				prompt,
+				textId,
+				responseId,
+				modelId
+			});
+			for await (const event of result) {
+				const delta = getTextDelta(event);
+				if (delta) {
+					text += delta;
+					enqueueTextDelta(controller, runId, textId, delta);
+				}
+				recordOpenAIStreamToolTelemetry(event, telemetry);
+			}
+			await result.completed;
+			responseId = result.lastResponseId ?? responseId;
+			modelId = getModelId(void 0, result.lastAgent ?? agent, result.rawResponses.at(-1));
+			if (!text) {
+				text = getTextFromFinalOutput(result.finalOutput);
+				if (text) enqueueTextDelta(controller, runId, textId, text);
+			}
+			const usage = createOpenAIUsageTotals(result.state.usage);
+			const providerMetadata = getOpenAIProviderMetadata({
+				modelId,
+				responseId,
+				lastResponseId: result.lastResponseId,
+				rawResponseCount: result.rawResponses.length,
+				itemCount: result.newItems.length,
+				usage
+			});
+			enqueueFinishChunks(controller, {
+				runId,
+				prompt,
+				textId,
+				text,
+				responseId,
+				modelId,
+				usage: toLanguageModelUsage(toV3Usage(usage)),
+				providerMetadata,
+				object: await getStructuredOutputFromValue(result.finalOutput, options?.structuredOutput)
+			});
+			controller.close();
+		} catch (error) {
+			controller.enqueue({
+				type: "error",
+				runId,
+				from: ChunkFrom.AGENT,
+				payload: { error }
+			});
+			controller.close();
+		}
+	} });
 }
 function toOpenAIAgentOptions(options) {
-  return {
-    name: options.name ?? options.id,
-    ...options.sdkOptions
-  };
+	return {
+		name: options.name ?? options.id,
+		...options.sdkOptions
+	};
 }
 function getRunOpenAIAgent(agent, options) {
-  const outputType = getStructuredOutputSchema(options?.structuredOutput);
-  if (!outputType) {
-    return agent;
-  }
-  return agent.clone({ outputType });
+	const outputType = getStructuredOutputSchema(options?.structuredOutput);
+	if (!outputType) return agent;
+	return agent.clone({ outputType });
 }
 function createOpenAIRunOptions(options, stream) {
-  const runOptions = { stream };
-  addDefined(runOptions, "maxTurns", options?.maxSteps);
-  addDefined(runOptions, "signal", options?.abortSignal ?? options?.signal);
-  addDefined(runOptions, "conversationId", options?.conversationId);
-  addDefined(runOptions, "previousResponseId", options?.previousResponseId);
-  addDefined(runOptions, "session", options?.session);
-  return runOptions;
+	const runOptions = { stream };
+	addDefined(runOptions, "maxTurns", options?.maxSteps);
+	addDefined(runOptions, "signal", options?.abortSignal ?? options?.signal);
+	addDefined(runOptions, "conversationId", options?.conversationId);
+	addDefined(runOptions, "previousResponseId", options?.previousResponseId);
+	addDefined(runOptions, "session", options?.session);
+	return runOptions;
 }
 function addDefined(target, key, value) {
-  if (value !== void 0) {
-    target[key] = value;
-  }
+	if (value !== void 0) target[key] = value;
 }
 function getModelId(options, agent, rawResponse) {
-  return getModelNameFromUnknown(rawResponse) ?? getModelNameFromUnknown(agent?.model) ?? getModelNameFromUnknown(options?.sdkOptions?.model) ?? MODEL_ID;
+	return getModelNameFromUnknown(rawResponse) ?? getModelNameFromUnknown(agent?.model) ?? getModelNameFromUnknown(options?.sdkOptions?.model) ?? MODEL_ID;
 }
 function getModelNameFromUnknown(value) {
-  if (typeof value === "string") {
-    return value;
-  }
-  const record = toRecord(value);
-  return getString(record, "model") ?? getString(record, "modelId") ?? getString(record, "modelName") ?? getString(toRecord(record?.providerData), "model");
+	if (typeof value === "string") return value;
+	const record = toRecord(value);
+	return getString(record, "model") ?? getString(record, "modelId") ?? getString(record, "modelName") ?? getString(toRecord(record?.providerData), "model");
 }
 function getTextFromFinalOutput(output) {
-  if (typeof output === "string") {
-    return output;
-  }
-  if (output === void 0 || output === null) {
-    return "";
-  }
-  return JSON.stringify(output);
+	if (typeof output === "string") return output;
+	if (output === void 0 || output === null) return "";
+	return JSON.stringify(output);
 }
 function createOpenAIUsageTotals(usage) {
-  const record = toRecord(usage);
-  if (!record) {
-    return {};
-  }
-  const inputDetails = getDetailRecords(record.inputTokensDetails);
-  const outputDetails = getDetailRecords(record.outputTokensDetails);
-  const requestUsageEntries = Array.isArray(record.requestUsageEntries) ? record.requestUsageEntries : void 0;
-  return {
-    inputTokens: getNumber(record.inputTokens),
-    outputTokens: getNumber(record.outputTokens),
-    cacheReadInputTokens: sumDetails(inputDetails, "cachedTokens", "cached_tokens", "cacheReadInputTokens"),
-    cacheCreationInputTokens: sumDetails(inputDetails, "cacheCreationInputTokens", "cache_creation_input_tokens"),
-    reasoningTokens: sumDetails(outputDetails, "reasoningTokens", "reasoning_tokens"),
-    requests: getNumber(record.requests),
-    requestUsageEntries
-  };
+	const record = toRecord(usage);
+	if (!record) return {};
+	const inputDetails = getDetailRecords(record.inputTokensDetails);
+	const outputDetails = getDetailRecords(record.outputTokensDetails);
+	const requestUsageEntries = Array.isArray(record.requestUsageEntries) ? record.requestUsageEntries : void 0;
+	return {
+		inputTokens: getNumber(record.inputTokens),
+		outputTokens: getNumber(record.outputTokens),
+		cacheReadInputTokens: sumDetails(inputDetails, "cachedTokens", "cached_tokens", "cacheReadInputTokens"),
+		cacheCreationInputTokens: sumDetails(inputDetails, "cacheCreationInputTokens", "cache_creation_input_tokens"),
+		reasoningTokens: sumDetails(outputDetails, "reasoningTokens", "reasoning_tokens"),
+		requests: getNumber(record.requests),
+		requestUsageEntries
+	};
 }
 function getDetailRecords(value) {
-  if (Array.isArray(value)) {
-    return value.filter(isRecord);
-  }
-  const record = toRecord(value);
-  return record ? [record] : [];
+	if (Array.isArray(value)) return value.filter(isRecord);
+	const record = toRecord(value);
+	return record ? [record] : [];
 }
 function sumDetails(records, ...keys) {
-  let total = 0;
-  let found = false;
-  for (const record of records) {
-    for (const key of keys) {
-      const value = getNumber(record[key]);
-      if (value !== void 0) {
-        total += value;
-        found = true;
-      }
-    }
-  }
-  return found ? total : void 0;
+	let total = 0;
+	let found = false;
+	for (const record of records) for (const key of keys) {
+		const value = getNumber(record[key]);
+		if (value !== void 0) {
+			total += value;
+			found = true;
+		}
+	}
+	return found ? total : void 0;
 }
 function toV3Usage(usage) {
-  const totalInputTokens = usage.inputTokens;
-  const cacheRead = usage.cacheReadInputTokens;
-  const cacheWrite = usage.cacheCreationInputTokens;
-  const noCache = totalInputTokens === void 0 ? void 0 : Math.max(totalInputTokens - (sumDefined(cacheRead, cacheWrite) ?? 0), 0);
-  const outputTokens = usage.outputTokens;
-  const reasoningTokens = usage.reasoningTokens;
-  return {
-    inputTokens: {
-      total: totalInputTokens,
-      noCache,
-      cacheRead,
-      cacheWrite
-    },
-    outputTokens: {
-      total: outputTokens,
-      text: outputTokens,
-      reasoning: reasoningTokens
-    }
-  };
-}
-function getOpenAIProviderMetadata({
-  modelId,
-  responseId,
-  lastResponseId,
-  rawResponseCount,
-  itemCount,
-  usage
-}) {
-  return createProviderMetadata("openai", {
-    model: modelId,
-    responseId,
-    lastResponseId,
-    rawResponseCount,
-    itemCount,
-    usage
-  });
+	const totalInputTokens = usage.inputTokens;
+	const cacheRead = usage.cacheReadInputTokens;
+	const cacheWrite = usage.cacheCreationInputTokens;
+	const noCache = totalInputTokens === void 0 ? void 0 : Math.max(totalInputTokens - (sumDefined(cacheRead, cacheWrite) ?? 0), 0);
+	const outputTokens = usage.outputTokens;
+	const reasoningTokens = usage.reasoningTokens;
+	return {
+		inputTokens: {
+			total: totalInputTokens,
+			noCache,
+			cacheRead,
+			cacheWrite
+		},
+		outputTokens: {
+			total: outputTokens,
+			text: outputTokens,
+			reasoning: reasoningTokens
+		}
+	};
+}
+function getOpenAIProviderMetadata({ modelId, responseId, lastResponseId, rawResponseCount, itemCount, usage }) {
+	return createProviderMetadata("openai", {
+		model: modelId,
+		responseId,
+		lastResponseId,
+		rawResponseCount,
+		itemCount,
+		usage
+	});
 }
 function recordOpenAIToolTelemetry(items, telemetry) {
-  for (const item of items) {
-    if (item.type === "tool_call_item") {
-      const toolCall = getOpenAIToolCall(item.rawItem);
-      if (toolCall) {
-        telemetry.startToolCall(toolCall);
-      }
-      continue;
-    }
-    if (item.type === "tool_call_output_item") {
-      const toolOutput = getOpenAIToolOutput(item.rawItem, item.output);
-      if (toolOutput) {
-        telemetry.endToolCall(toolOutput);
-      }
-    }
-  }
+	for (const item of items) {
+		if (item.type === "tool_call_item") {
+			const toolCall = getOpenAIToolCall(item.rawItem);
+			if (toolCall) telemetry.startToolCall(toolCall);
+			continue;
+		}
+		if (item.type === "tool_call_output_item") {
+			const toolOutput = getOpenAIToolOutput(item.rawItem, item.output);
+			if (toolOutput) telemetry.endToolCall(toolOutput);
+		}
+	}
 }
 function recordOpenAIStreamToolTelemetry(event, telemetry) {
-  if (event.type !== "run_item_stream_event") {
-    return;
-  }
-  if (event.name === "tool_called") {
-    const toolCall = getOpenAIToolCall(event.item.rawItem);
-    if (toolCall) {
-      telemetry.startToolCall(toolCall);
-    }
-    return;
-  }
-  if (event.name === "tool_output") {
-    const toolOutput = getOpenAIToolOutput(event.item.rawItem, getObjectValue(event.item, "output"));
-    if (toolOutput) {
-      telemetry.endToolCall(toolOutput);
-    }
-  }
+	if (event.type !== "run_item_stream_event") return;
+	if (event.name === "tool_called") {
+		const toolCall = getOpenAIToolCall(event.item.rawItem);
+		if (toolCall) telemetry.startToolCall(toolCall);
+		return;
+	}
+	if (event.name === "tool_output") {
+		const toolOutput = getOpenAIToolOutput(event.item.rawItem, getObjectValue(event.item, "output"));
+		if (toolOutput) telemetry.endToolCall(toolOutput);
+	}
 }
 function getOpenAIToolCall(rawItem) {
-  const record = toRecord(rawItem);
-  if (!record) {
-    return void 0;
-  }
-  if (record.type === "function_call") {
-    const toolCallId = getString(record, "callId") ?? getString(record, "id");
-    const toolName = getNamespacedToolName(record);
-    if (!toolCallId || !toolName) {
-      return void 0;
-    }
-    return {
-      toolCallId,
-      toolName,
-      input: parseJsonString(record.arguments)
-    };
-  }
-  if (record.type === "hosted_tool_call") {
-    const toolCallId = getString(record, "id") ?? getString(record, "name");
-    const toolName = getString(record, "name");
-    if (!toolCallId || !toolName) {
-      return void 0;
-    }
-    return {
-      toolCallId,
-      toolName,
-      input: parseJsonString(record.arguments)
-    };
-  }
-  if (record.type === "shell_call" || record.type === "apply_patch_call") {
-    const toolCallId = getString(record, "callId");
-    if (!toolCallId) {
-      return void 0;
-    }
-    return {
-      toolCallId,
-      toolName: String(record.type),
-      input: record.action ?? record.operation
-    };
-  }
-  return void 0;
+	const record = toRecord(rawItem);
+	if (!record) return;
+	if (record.type === "function_call") {
+		const toolCallId = getString(record, "callId") ?? getString(record, "id");
+		const toolName = getNamespacedToolName(record);
+		if (!toolCallId || !toolName) return;
+		return {
+			toolCallId,
+			toolName,
+			input: parseJsonString(record.arguments)
+		};
+	}
+	if (record.type === "hosted_tool_call") {
+		const toolCallId = getString(record, "id") ?? getString(record, "name");
+		const toolName = getString(record, "name");
+		if (!toolCallId || !toolName) return;
+		return {
+			toolCallId,
+			toolName,
+			input: parseJsonString(record.arguments)
+		};
+	}
+	if (record.type === "shell_call" || record.type === "apply_patch_call") {
+		const toolCallId = getString(record, "callId");
+		if (!toolCallId) return;
+		return {
+			toolCallId,
+			toolName: String(record.type),
+			input: record.action ?? record.operation
+		};
+	}
 }
 function getOpenAIToolOutput(rawItem, fallbackOutput) {
-  const record = toRecord(rawItem);
-  if (!record) {
-    return void 0;
-  }
-  const toolCallId = getString(record, "callId") ?? getString(record, "id");
-  if (!toolCallId) {
-    return void 0;
-  }
-  return {
-    toolCallId,
-    output: record.output ?? fallbackOutput,
-    isError: record.status === "failed" || record.status === "incomplete"
-  };
+	const record = toRecord(rawItem);
+	if (!record) return;
+	const toolCallId = getString(record, "callId") ?? getString(record, "id");
+	if (!toolCallId) return;
+	return {
+		toolCallId,
+		output: record.output ?? fallbackOutput,
+		isError: record.status === "failed" || record.status === "incomplete"
+	};
 }
 function getNamespacedToolName(record) {
-  const name = getString(record, "name");
-  const namespace = getString(record, "namespace");
-  if (!name) {
-    return void 0;
-  }
-  return namespace ? `${namespace}.${name}` : name;
+	const name = getString(record, "name");
+	const namespace = getString(record, "namespace");
+	if (!name) return;
+	return namespace ? `${namespace}.${name}` : name;
 }
 function getTextDelta(event) {
-  if (event.type !== "raw_model_stream_event") {
-    return "";
-  }
-  const data = toRecord(event.data);
-  return data?.type === "output_text_delta" && typeof data.delta === "string" ? data.delta : "";
+	if (event.type !== "raw_model_stream_event") return "";
+	const data = toRecord(event.data);
+	return data?.type === "output_text_delta" && typeof data.delta === "string" ? data.delta : "";
 }
 function parseJsonString(value) {
-  if (typeof value !== "string") {
-    return value;
-  }
-  try {
-    return JSON.parse(value);
-  } catch {
-    return value;
-  }
+	if (typeof value !== "string") return value;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
 }
 function getNumber(value) {
-  return typeof value === "number" ? value : void 0;
+	return typeof value === "number" ? value : void 0;
 }
 function getString(record, key) {
-  const value = record?.[key];
-  return typeof value === "string" ? value : void 0;
+	const value = record?.[key];
+	return typeof value === "string" ? value : void 0;
 }
 function getObjectValue(value, key) {
-  return toRecord(value)?.[key];
+	return toRecord(value)?.[key];
 }
 function toRecord(value) {
-  return isRecord(value) ? value : void 0;
+	return isRecord(value) ? value : void 0;
 }
 function isRecord(value) {
-  return value !== null && typeof value === "object";
+	return value !== null && typeof value === "object";
 }
-
+//#endregion
 export { OpenAISDKAgent };
-//# sourceMappingURL=index.js.map
+
 //# sourceMappingURL=index.js.map