@mastra/openai 1.0.1-alpha.8 → 1.0.3

package/dist/index.js

@@ -0,0 +1,1175 @@
+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
+function createNoopModel({ modelId, provider }) {
+  return {
+    modelId,
+    provider,
+    specificationVersion: "v3",
+    supportedUrls: {},
+    doGenerate: async () => createNoopStreamResult(),
+    doStream: async () => createNoopStreamResult()
+  };
+}
+function createNoopStreamResult() {
+  return {
+    stream: new ReadableStream({
+      start: (controller) => controller.close()
+    })
+  };
+}
+function createCompletedMastraStream({
+  runId,
+  prompt,
+  text,
+  responseId,
+  modelId,
+  usage,
+  providerMetadata,
+  costContext,
+  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
+      };
+    }
+  };
+}
+function parseMcpToolName(toolName) {
+  const match = /^mcp__([^_].*?)__(.+)$/.exec(toolName);
+  if (!match?.[1] || !match[2]) {
+    return void 0;
+  }
+  return {
+    serverName: match[1],
+    toolName: match[2]
+  };
+}
+function getModelSpanTracker(modelSpan) {
+  if (!modelSpan || !("createTracker" in modelSpan)) {
+    return void 0;
+  }
+  return modelSpan.createTracker();
+}
+function wrapStreamForAgentSpan(stream, telemetry) {
+  let text = "";
+  return stream.pipeThrough(
+    new TransformStream({
+      transform(chunk, controller) {
+        if (chunk.type === "text-delta") {
+          text += chunk.payload.text;
+        }
+        if (chunk.type === "finish") {
+          telemetry.end({
+            text,
+            usage: chunk.payload.output.usage,
+            providerMetadata: chunk.payload.providerMetadata,
+            finishReason: chunk.payload.stepResult.reason,
+            responseId: chunk.payload.response?.id,
+            responseModel: chunk.payload.response?.modelId,
+            costContext: getCostContext(chunk.payload.metadata?.costContext)
+          });
+        }
+        if (chunk.type === "error") {
+          telemetry.fail(chunk.payload.error);
+        }
+        controller.enqueue(chunk);
+      },
+      flush() {
+        telemetry.end({ text });
+      }
+    })
+  );
+}
+function toUsageStats(usage) {
+  return {
+    inputTokens: usage.inputTokens,
+    outputTokens: usage.outputTokens,
+    inputDetails: {
+      cacheRead: usage.cachedInputTokens,
+      cacheWrite: usage.cacheCreationInputTokens
+    },
+    outputDetails: {
+      text: usage.outputTokens,
+      reasoning: usage.reasoningTokens
+    }
+  };
+}
+function getCostContext(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  return value;
+}
+function enqueueStartChunks(controller, {
+  runId,
+  prompt,
+  textId,
+  responseId,
+  modelId,
+  providerMetadata
+}) {
+  controller.enqueue({
+    type: "start",
+    runId,
+    from: ChunkFrom.AGENT,
+    payload: {}
+  });
+  controller.enqueue({
+    type: "step-start",
+    runId,
+    from: ChunkFrom.AGENT,
+    payload: {
+      request: { body: prompt }
+    }
+  });
+  controller.enqueue({
+    type: "response-metadata",
+    runId,
+    from: ChunkFrom.AGENT,
+    payload: {
+      ...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
+    }
+  });
+}
+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
+  };
+}
+function createProviderMetadata(provider, metadata) {
+  return {
+    [provider]: toJsonRecord(metadata)
+  };
+}
+function toJsonRecord(record) {
+  return Object.fromEntries(
+    Object.entries(record).filter((entry) => entry[1] !== void 0).map(([key, value]) => [key, toJsonValue(value)])
+  );
+}
+function toJsonValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.filter((item) => item !== void 0).map(toJsonValue);
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (typeof value === "object") {
+    return toJsonRecord(value);
+  }
+  return String(value);
+}
+function promptToText(prompt) {
+  if (typeof prompt === "string") {
+    return prompt;
+  }
+  if (Array.isArray(prompt)) {
+    return prompt.map(promptToText).filter(Boolean).join("\n");
+  }
+  if (!prompt || typeof prompt !== "object") {
+    return "";
+  }
+  const record = prompt;
+  if (typeof record.text === "string") {
+    return record.text;
+  }
+  if (typeof record.content === "string") {
+    return record.content;
+  }
+  if (record.content) {
+    return promptToText(record.content);
+  }
+  return "";
+}
+function getStructuredOutputSchema(structuredOutput) {
+  if (!structuredOutput?.schema) {
+    return void 0;
+  }
+  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);
+}
+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;
+}
+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";
+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;
+  }
+};
+function getStructuredOutputOption(options) {
+  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.");
+}
+function createOpenAIResumeRunOptions(resumeData, options) {
+  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)
+  };
+}
+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();
+      }
+    }
+  });
+}
+function toOpenAIAgentOptions(options) {
+  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 });
+}
+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;
+}
+function addDefined(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;
+}
+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");
+}
+function getTextFromFinalOutput(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
+  };
+}
+function getDetailRecords(value) {
+  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;
+}
+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
+  });
+}
+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);
+      }
+    }
+  }
+}
+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);
+    }
+  }
+}
+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;
+}
+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"
+  };
+}
+function getNamespacedToolName(record) {
+  const name = getString(record, "name");
+  const namespace = getString(record, "namespace");
+  if (!name) {
+    return void 0;
+  }
+  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 : "";
+}
+function parseJsonString(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;
+}
+function getString(record, key) {
+  const value = record?.[key];
+  return typeof value === "string" ? value : void 0;
+}
+function getObjectValue(value, key) {
+  return toRecord(value)?.[key];
+}
+function toRecord(value) {
+  return isRecord(value) ? value : void 0;
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object";
+}
+
+export { OpenAISDKAgent };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map