@mastra/code-sdk 1.0.3-alpha.0 → 1.1.0-alpha.2

package/dist/providers/openai-codex.js

@@ -1,291 +1,302 @@
+import { AuthStorage } from "../auth/storage.js";
 import { createOpenAI } from "@ai-sdk/openai";
 import { wrapLanguageModel } from "ai";
-import { AuthStorage } from "../auth/storage.js";
+//#region src/providers/openai-codex.ts
+/**
+* OpenAI Codex OAuth Provider
+*
+* Uses OAuth tokens from AuthStorage to authenticate with ChatGPT Plus/Pro subscription.
+* This allows access to OpenAI models through the ChatGPT OAuth flow.
+*
+* Inspired by opencode's Codex plugin implementation:
+* https://github.com/sst/opencode/blob/main/packages/opencode/src/plugin/codex.ts
+*/
 const CODEX_API_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
 const CODEX_ORIGINATOR = "mastracode";
 const CODEX_USER_AGENT = "mastracode";
 let authStorageInstance = null;
+/**
+* Get or create the shared AuthStorage instance
+*/
 function getAuthStorage() {
-  if (!authStorageInstance) {
-    authStorageInstance = new AuthStorage();
-  }
-  return authStorageInstance;
+	if (!authStorageInstance) authStorageInstance = new AuthStorage();
+	return authStorageInstance;
 }
+/**
+* Set a custom AuthStorage instance (useful for TUI integration)
+*/
 function setAuthStorage(storage) {
-  authStorageInstance = storage ?? null;
+	authStorageInstance = storage ?? null;
 }
 const CODEX_INSTRUCTIONS = `You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
 
 IMPORTANT: You should be concise, direct, and helpful. Focus on solving the user's problem efficiently.`;
 const GPT5_MODEL_RE = /^gpt-5(?:\.|-|$)/;
 function getEffectiveThinkingLevel(modelId, level) {
-  if (GPT5_MODEL_RE.test(modelId) && level === "off") {
-    return "low";
-  }
-  return level;
+	if (GPT5_MODEL_RE.test(modelId) && level === "off") return "low";
+	return level;
 }
 const THINKING_LEVEL_TO_REASONING_EFFORT = {
-  off: void 0,
-  low: "low",
-  medium: "medium",
-  high: "high",
-  xhigh: "xhigh"
+	off: void 0,
+	low: "low",
+	medium: "medium",
+	high: "high",
+	xhigh: "xhigh"
 };
+/**
+* Create Codex middleware with the given reasoning effort level.
+*/
 function createCodexMiddleware(reasoningEffort) {
-  return {
-    specificationVersion: "v3",
-    transformParams: async ({ params }) => {
-      if (params.temperature !== void 0 && params.temperature !== null) {
-        delete params.topP;
-      }
-      params.providerOptions = {
-        ...params.providerOptions,
-        openai: {
-          ...params.providerOptions?.openai ?? {},
-          instructions: CODEX_INSTRUCTIONS,
-          // Codex API requires store to be false
-          store: false,
-          // Enable reasoning for Codex models — without this, the model
-          // skips the reasoning/action phase and goes straight to final_answer,
-          // resulting in narration instead of tool calls.
-          ...reasoningEffort ? { reasoningEffort } : {}
-        }
-      };
-      return params;
-    }
-  };
+	return {
+		specificationVersion: "v3",
+		transformParams: async ({ params }) => {
+			if (params.temperature !== void 0 && params.temperature !== null) delete params.topP;
+			params.providerOptions = {
+				...params.providerOptions,
+				openai: {
+					...params.providerOptions?.openai ?? {},
+					instructions: CODEX_INSTRUCTIONS,
+					store: false,
+					...reasoningEffort ? { reasoningEffort } : {}
+				}
+			};
+			return params;
+		}
+	};
 }
+/**
+* Get a live OAuth bearer token for the Codex OAuth credential.
+*
+* Refreshes the token if it's expired, and returns the credential's
+* accountId alongside the access token. Throws if the user isn't logged in
+* or if the refresh fails.
+*
+* This is the only piece of Codex auth that is genuinely shared between
+* the main agent's fetch (`buildOpenAICodexOAuthFetch`) and the Stagehand
+* fetch (`buildCodexStagehandFetch`).
+*/
 async function getCodexBearer(authStorage) {
-  const storage = authStorage ?? getAuthStorage();
-  storage.reload();
-  const cred = storage.get("openai-codex");
-  if (!cred || cred.type !== "oauth") {
-    throw new Error("Not logged in to OpenAI Codex. Run /login first.");
-  }
-  let accessToken = cred.access;
-  if (Date.now() >= cred.expires) {
-    const refreshedToken = await storage.getApiKey("openai-codex");
-    if (!refreshedToken) {
-      throw new Error("Failed to refresh OpenAI Codex token. Please /login again.");
-    }
-    accessToken = refreshedToken;
-    storage.reload();
-  }
-  return { accessToken, accountId: cred.accountId };
+	const storage = authStorage ?? getAuthStorage();
+	storage.reload();
+	const cred = storage.get("openai-codex");
+	if (!cred || cred.type !== "oauth") throw new Error("Not logged in to OpenAI Codex. Run /login first.");
+	let accessToken = cred.access;
+	if (Date.now() >= cred.expires) {
+		const refreshedToken = await storage.getApiKey("openai-codex");
+		if (!refreshedToken) throw new Error("Failed to refresh OpenAI Codex token. Please /login again.");
+		accessToken = refreshedToken;
+		storage.reload();
+	}
+	return {
+		accessToken,
+		accountId: cred.accountId
+	};
 }
+/**
+* Build a fetch function that handles OpenAI Codex OAuth.
+* Preserves non-authorization headers from init.
+* When rewriteUrl is true (default), rewrites /v1/responses and /chat/completions
+* to the Codex API endpoint. Set rewriteUrl: false for gateway usage where the
+* SDK already targets the correct URL.
+*/
 function buildOpenAICodexOAuthFetch(opts = {}) {
-  return (async (url, init) => {
-    const { accessToken, accountId } = await getCodexBearer(opts.authStorage);
-    const headers = new Headers();
-    if (init?.headers) {
-      if (init.headers instanceof Headers) {
-        init.headers.forEach((value, key) => {
-          if (key.toLowerCase() !== "authorization") {
-            headers.set(key, value);
-          }
-        });
-      } else if (Array.isArray(init.headers)) {
-        for (const [key, value] of init.headers) {
-          if (key.toLowerCase() !== "authorization" && value !== void 0) {
-            headers.set(key, String(value));
-          }
-        }
-      } else {
-        for (const [key, value] of Object.entries(init.headers)) {
-          if (key.toLowerCase() !== "authorization" && value !== void 0) {
-            headers.set(key, String(value));
-          }
-        }
-      }
-    }
-    headers.set("Authorization", `Bearer ${accessToken}`);
-    if (!headers.has("originator")) {
-      headers.set("originator", CODEX_ORIGINATOR);
-    }
-    if (!headers.has("User-Agent")) {
-      headers.set("User-Agent", CODEX_USER_AGENT);
-    }
-    if (accountId) {
-      headers.set("ChatGPT-Account-ID", accountId);
-    }
-    const parsed = url instanceof URL ? url : new URL(typeof url === "string" ? url : url.url);
-    const shouldRewrite = opts.rewriteUrl !== false && (parsed.pathname.includes("/v1/responses") || parsed.pathname.includes("/chat/completions"));
-    const finalUrl = shouldRewrite ? new URL(CODEX_API_ENDPOINT) : parsed;
-    try {
-      return await fetch(finalUrl, { ...init, headers });
-    } catch (error) {
-      if (error && typeof error === "object") {
-        Object.assign(error, {
-          requestUrl: finalUrl.toString()
-        });
-      }
-      throw error;
-    }
-  });
+	return (async (url, init) => {
+		const { accessToken, accountId } = await getCodexBearer(opts.authStorage);
+		const headers = new Headers();
+		if (init?.headers) {
+			if (init.headers instanceof Headers) init.headers.forEach((value, key) => {
+				if (key.toLowerCase() !== "authorization") headers.set(key, value);
+			});
+			else if (Array.isArray(init.headers)) {
+				for (const [key, value] of init.headers) if (key.toLowerCase() !== "authorization" && value !== void 0) headers.set(key, String(value));
+			} else for (const [key, value] of Object.entries(init.headers)) if (key.toLowerCase() !== "authorization" && value !== void 0) headers.set(key, String(value));
+		}
+		headers.set("Authorization", `Bearer ${accessToken}`);
+		if (!headers.has("originator")) headers.set("originator", CODEX_ORIGINATOR);
+		if (!headers.has("User-Agent")) headers.set("User-Agent", CODEX_USER_AGENT);
+		if (accountId) headers.set("ChatGPT-Account-ID", accountId);
+		const parsed = url instanceof URL ? url : new URL(typeof url === "string" ? url : url.url);
+		const finalUrl = opts.rewriteUrl !== false && (parsed.pathname.includes("/v1/responses") || parsed.pathname.includes("/chat/completions")) ? new URL(CODEX_API_ENDPOINT) : parsed;
+		try {
+			return await fetch(finalUrl, {
+				...init,
+				headers
+			});
+		} catch (error) {
+			if (error && typeof error === "object") Object.assign(error, { requestUrl: finalUrl.toString() });
+			throw error;
+		}
+	});
 }
+/**
+* Build a fetch function for Stagehand-on-Codex.
+*
+* The Codex backend has two requirements that AI SDK's non-streaming
+* `generateText` path doesn't naturally satisfy:
+*
+*   1. `stream: true` must be set on every request body.
+*   2. The response is delivered as Server-Sent Events; AI SDK's
+*      non-streaming code path expects a single JSON body.
+*
+* This fetch forces streaming on the outgoing request, collects the SSE
+* events, and synthesizes the non-streaming JSON shape that
+* `@ai-sdk/openai`'s Responses API parser expects.
+*
+* Headers, OAuth refresh, and URL targeting are handled by the caller via
+* `baseURL` / `headers` on the AI SDK provider; this fetch only injects the
+* live OAuth bearer per call.
+*/
 function buildCodexStagehandFetch(authStorage) {
-  return (async (url, init) => {
-    const { accessToken } = await getCodexBearer(authStorage);
-    const headers = new Headers(init?.headers);
-    headers.set("Authorization", `Bearer ${accessToken}`);
-    headers.set("Accept", "text/event-stream");
-    let body = init?.body;
-    if (typeof init?.body === "string") {
-      try {
-        const parsed = JSON.parse(init.body);
-        parsed.stream = true;
-        body = JSON.stringify(parsed);
-        if (!headers.has("content-type")) headers.set("content-type", "application/json");
-      } catch {
-      }
-    }
-    const upstream = await fetch(url, { ...init, headers, body });
-    if (!upstream.ok) return upstream;
-    const aggregated = await aggregateCodexStream(upstream);
-    return new Response(aggregated, {
-      status: 200,
-      headers: { "content-type": "application/json" }
-    });
-  });
+	return (async (url, init) => {
+		const { accessToken } = await getCodexBearer(authStorage);
+		const headers = new Headers(init?.headers);
+		headers.set("Authorization", `Bearer ${accessToken}`);
+		headers.set("Accept", "text/event-stream");
+		let body = init?.body;
+		if (typeof init?.body === "string") try {
+			const parsed = JSON.parse(init.body);
+			parsed.stream = true;
+			body = JSON.stringify(parsed);
+			if (!headers.has("content-type")) headers.set("content-type", "application/json");
+		} catch {}
+		const upstream = await fetch(url, {
+			...init,
+			headers,
+			body
+		});
+		if (!upstream.ok) return upstream;
+		const aggregated = await aggregateCodexStream(upstream);
+		return new Response(aggregated, {
+			status: 200,
+			headers: { "content-type": "application/json" }
+		});
+	});
 }
+/**
+* Read an SSE Response and reduce it to a single JSON string matching the
+* non-streaming OpenAI Responses-API shape.
+*
+* Event vocabulary we care about (per OpenAI Responses API streaming):
+*   - response.created         → carries `response` object (id, model, usage stub)
+*   - response.output_item.added/done → output items (message, reasoning, etc.)
+*   - response.output_text.delta → text chunks
+*   - response.completed       → final `response` snapshot incl. usage
+*   - response.error / error   → bubble up as a thrown body
+*
+* Reasoning events (`response.reasoning_summary.*`) are intentionally ignored
+* for the non-streaming text response.
+*/
 async function aggregateCodexStream(response) {
-  if (!response.body) {
-    throw new Error("Codex streaming response had no body");
-  }
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder("utf-8");
-  let buffer = "";
-  let finalResponse = null;
-  let createdResponse = null;
-  const items = /* @__PURE__ */ new Map();
-  const textBuffers = /* @__PURE__ */ new Map();
-  const handleEvent = (event) => {
-    if (!event.data || event.data === "[DONE]") return;
-    let payload;
-    try {
-      payload = JSON.parse(event.data);
-    } catch {
-      return;
-    }
-    const type = payload.type ?? event.event ?? "";
-    switch (type) {
-      case "response.created": {
-        createdResponse = payload.response ?? createdResponse;
-        break;
-      }
-      case "response.output_item.added": {
-        if (typeof payload.output_index === "number" && payload.item) {
-          items.set(payload.output_index, payload.item);
-        }
-        break;
-      }
-      case "response.output_item.done": {
-        if (typeof payload.output_index === "number" && payload.item) {
-          items.set(payload.output_index, payload.item);
-        }
-        break;
-      }
-      case "response.output_text.delta": {
-        const key = `${payload.output_index}:${payload.content_index ?? 0}`;
-        textBuffers.set(key, (textBuffers.get(key) ?? "") + (payload.delta ?? ""));
-        break;
-      }
-      case "response.completed": {
-        finalResponse = payload.response ?? finalResponse;
-        break;
-      }
-      case "response.error":
-      case "error": {
-        throw new Error(`Codex stream error: ${JSON.stringify(payload.error ?? payload)}`);
-      }
-      default:
-        break;
-    }
-  };
-  const processChunk = (chunk) => {
-    buffer += chunk.replace(/\r\n/g, "\n");
-    let sepIdx;
-    while ((sepIdx = buffer.indexOf("\n\n")) !== -1) {
-      const raw = buffer.slice(0, sepIdx);
-      buffer = buffer.slice(sepIdx + 2);
-      const event = {};
-      const dataLines = [];
-      for (const line of raw.split("\n")) {
-        if (line.startsWith("event:")) {
-          event.event = line.slice(6).trim();
-        } else if (line.startsWith("data:")) {
-          dataLines.push(line.slice(5).trimStart());
-        }
-      }
-      if (dataLines.length > 0) {
-        event.data = dataLines.join("\n");
-      }
-      handleEvent(event);
-    }
-  };
-  try {
-    while (true) {
-      const { value, done } = await reader.read();
-      if (done) break;
-      processChunk(decoder.decode(value, { stream: true }));
-    }
-    processChunk(decoder.decode());
-  } finally {
-    reader.releaseLock();
-  }
-  const base = finalResponse ?? createdResponse ?? { output: [] };
-  const finalItems = Array.from(items.entries()).sort(([a], [b]) => a - b).map(([index, item]) => {
-    if (item?.type === "message" && Array.isArray(item.content)) {
-      item.content = item.content.map((c, ci) => {
-        const key = `${index}:${ci}`;
-        if (textBuffers.has(key)) {
-          return { ...c, text: textBuffers.get(key) };
-        }
-        return c;
-      });
-    }
-    return item;
-  });
-  base.output = finalItems.length > 0 ? finalItems : base.output ?? [];
-  return JSON.stringify(base);
+	if (!response.body) throw new Error("Codex streaming response had no body");
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder("utf-8");
+	let buffer = "";
+	let finalResponse = null;
+	let createdResponse = null;
+	const items = /* @__PURE__ */ new Map();
+	const textBuffers = /* @__PURE__ */ new Map();
+	const handleEvent = (event) => {
+		if (!event.data || event.data === "[DONE]") return;
+		let payload;
+		try {
+			payload = JSON.parse(event.data);
+		} catch {
+			return;
+		}
+		switch (payload.type ?? event.event ?? "") {
+			case "response.created":
+				createdResponse = payload.response ?? createdResponse;
+				break;
+			case "response.output_item.added":
+				if (typeof payload.output_index === "number" && payload.item) items.set(payload.output_index, payload.item);
+				break;
+			case "response.output_item.done":
+				if (typeof payload.output_index === "number" && payload.item) items.set(payload.output_index, payload.item);
+				break;
+			case "response.output_text.delta": {
+				const key = `${payload.output_index}:${payload.content_index ?? 0}`;
+				textBuffers.set(key, (textBuffers.get(key) ?? "") + (payload.delta ?? ""));
+				break;
+			}
+			case "response.completed":
+				finalResponse = payload.response ?? finalResponse;
+				break;
+			case "response.error":
+			case "error": throw new Error(`Codex stream error: ${JSON.stringify(payload.error ?? payload)}`);
+			default: break;
+		}
+	};
+	const processChunk = (chunk) => {
+		buffer += chunk.replace(/\r\n/g, "\n");
+		let sepIdx;
+		while ((sepIdx = buffer.indexOf("\n\n")) !== -1) {
+			const raw = buffer.slice(0, sepIdx);
+			buffer = buffer.slice(sepIdx + 2);
+			const event = {};
+			const dataLines = [];
+			for (const line of raw.split("\n")) if (line.startsWith("event:")) event.event = line.slice(6).trim();
+			else if (line.startsWith("data:")) dataLines.push(line.slice(5).trimStart());
+			if (dataLines.length > 0) event.data = dataLines.join("\n");
+			handleEvent(event);
+		}
+	};
+	try {
+		while (true) {
+			const { value, done } = await reader.read();
+			if (done) break;
+			processChunk(decoder.decode(value, { stream: true }));
+		}
+		processChunk(decoder.decode());
+	} finally {
+		reader.releaseLock();
+	}
+	const base = finalResponse ?? createdResponse ?? { output: [] };
+	const finalItems = Array.from(items.entries()).sort(([a], [b]) => a - b).map(([index, item]) => {
+		if (item?.type === "message" && Array.isArray(item.content)) item.content = item.content.map((c, ci) => {
+			const key = `${index}:${ci}`;
+			if (textBuffers.has(key)) return {
+				...c,
+				text: textBuffers.get(key)
+			};
+			return c;
+		});
+		return item;
+	});
+	base.output = finalItems.length > 0 ? finalItems : base.output ?? [];
+	return JSON.stringify(base);
 }
+/**
+* Creates an OpenAI model using ChatGPT OAuth authentication
+* Uses OAuth tokens from AuthStorage (auto-refreshes when needed)
+*
+* IMPORTANT: This uses the Codex API endpoint, not the standard OpenAI API.
+* URLs are rewritten from /v1/responses or /chat/completions to the Codex endpoint.
+*/
 function openaiCodexProvider(modelId = "codex-mini-latest", options) {
-  const requestedLevel = options?.thinkingLevel ?? "medium";
-  const effectiveLevel = getEffectiveThinkingLevel(modelId, requestedLevel);
-  const reasoningEffort = THINKING_LEVEL_TO_REASONING_EFFORT[effectiveLevel];
-  const middleware = createCodexMiddleware(reasoningEffort);
-  const headers = options?.headers;
-  const baseURL = process.env.OPENAI_BASE_URL;
-  if (process.env.NODE_ENV === "test" || process.env.VITEST) {
-    const openai2 = createOpenAI({
-      apiKey: "test-api-key",
-      baseURL,
-      headers
-    });
-    return wrapLanguageModel({
-      model: openai2.responses(modelId),
-      middleware: [middleware]
-    });
-  }
-  const openai = createOpenAI({
-    apiKey: "oauth-dummy-key",
-    baseURL,
-    headers,
-    fetch: buildOpenAICodexOAuthFetch({ authStorage: options?.authStorage })
-  });
-  return wrapLanguageModel({
-    model: openai.responses(modelId),
-    middleware: [middleware]
-  });
+	const effectiveLevel = getEffectiveThinkingLevel(modelId, options?.thinkingLevel ?? "medium");
+	const reasoningEffort = THINKING_LEVEL_TO_REASONING_EFFORT[effectiveLevel];
+	const middleware = createCodexMiddleware(reasoningEffort);
+	const headers = options?.headers;
+	const baseURL = process.env.OPENAI_BASE_URL;
+	if (process.env.NODE_ENV === "test" || process.env.VITEST) return wrapLanguageModel({
+		model: createOpenAI({
+			apiKey: "test-api-key",
+			baseURL,
+			headers
+		}).responses(modelId),
+		middleware: [middleware]
+	});
+	return wrapLanguageModel({
+		model: createOpenAI({
+			apiKey: "oauth-dummy-key",
+			baseURL,
+			headers,
+			fetch: buildOpenAICodexOAuthFetch({ authStorage: options?.authStorage })
+		}).responses(modelId),
+		middleware: [middleware]
+	});
 }
-export {
-  THINKING_LEVEL_TO_REASONING_EFFORT,
-  buildCodexStagehandFetch,
-  buildOpenAICodexOAuthFetch,
-  createCodexMiddleware,
-  getAuthStorage,
-  getEffectiveThinkingLevel,
-  openaiCodexProvider,
-  setAuthStorage
-};
+//#endregion
+export { THINKING_LEVEL_TO_REASONING_EFFORT, buildCodexStagehandFetch, buildOpenAICodexOAuthFetch, createCodexMiddleware, getAuthStorage, getEffectiveThinkingLevel, openaiCodexProvider, setAuthStorage };
+
 //# sourceMappingURL=openai-codex.js.map