@mastra/code-sdk 0.0.0-aggregate-trace-20261015182851

package/dist/providers/model-ids.js

@@ -0,0 +1,79 @@
+//#region src/providers/model-ids.ts
+/**
+* Model-id helpers shared by the model gateway and the browser settings
+* module. Kept dependency-free so neither side has to import the other.
+*/
+const OPENAI_PREFIX = "openai/";
+const ANTHROPIC_PREFIX = "anthropic/";
+const MASTRA_GATEWAY_PREFIX = "mastra/";
+/** Anthropic's API only accepts dashed ids (`claude-opus-4-6`), but catalogs may list dotted ones. */
+function normalizeAnthropicModelId(modelId) {
+	return modelId.replace(/\.(?=\d)/g, "-");
+}
+/**
+* The Codex ChatGPT-account endpoint serves some OpenAI models only under a
+* `-codex` id. Applied wherever a model id is sent over Codex OAuth (chat
+* agents and Stagehand alike) so both paths hit the same upstream model.
+*/
+const CODEX_OPENAI_MODEL_REMAPS = {
+	"gpt-5.3": "gpt-5.3-codex",
+	"gpt-5.2": "gpt-5.2-codex",
+	"gpt-5.1": "gpt-5.1-codex",
+	"gpt-5.1-mini": "gpt-5.1-codex-mini",
+	"gpt-5": "gpt-5-codex"
+};
+function stripMastraGatewayPrefix(modelId) {
+	return modelId.startsWith("mastra/") ? modelId.substring(7) : modelId;
+}
+/**
+* Kimi For Coding subscriptions are served from `api.kimi.com`, which models.dev
+* lists as `kimi-code-plan-cn`. Mastra Code augments that provider with the
+* Kimi OAuth/API-key credential instead of defining its own.
+*/
+const KIMI_CODING_PROVIDER_ID = "kimi-code-plan-cn";
+/** Credential id the Kimi login stores accounts under. */
+const KIMI_CODING_CREDENTIAL_ID = "kimi-for-coding";
+/** Providers Mastra Code used to catalog as `mastracode/<provider>/<model>`. */
+const LEGACY_MASTRACODE_NAMESPACED_PROVIDERS = /* @__PURE__ */ new Set([
+	"amazon-bedrock",
+	"github-copilot",
+	KIMI_CODING_CREDENTIAL_ID
+]);
+/** Provider ids Mastra Code defined itself before augmenting the models.dev provider. */
+const LEGACY_PROVIDER_IDS = { [KIMI_CODING_CREDENTIAL_ID]: KIMI_CODING_PROVIDER_ID };
+/**
+* Map model ids saved by older Mastra Code versions (packs, OM settings,
+* thread metadata) to the current catalog id:
+* `mastracode/kimi-for-coding/k3` and `kimi-for-coding/k3` → `kimi-code-plan-cn/k3`,
+* `mastracode/github-copilot/<m>` → `github-copilot/<m>`,
+* `mastracode/amazon-bedrock/<m>` → `amazon-bedrock/<m>`.
+*/
+function normalizeLegacyModelId(modelId) {
+	let normalized = modelId;
+	const namespacedProvider = normalized.startsWith("mastracode/") ? normalized.split("/", 3)[1] : void 0;
+	if (namespacedProvider && LEGACY_MASTRACODE_NAMESPACED_PROVIDERS.has(namespacedProvider)) normalized = normalized.slice(11);
+	const slash = normalized.indexOf("/");
+	const providerId = slash > 0 ? normalized.slice(0, slash) : void 0;
+	const replacement = providerId ? LEGACY_PROVIDER_IDS[providerId] : void 0;
+	return replacement ? `${replacement}${normalized.slice(slash)}` : normalized;
+}
+/** Credential-store id that authenticates a catalog provider id. */
+function getCredentialProviderId(providerId) {
+	if (providerId === "openai") return "openai-codex";
+	if (providerId === "kimi-code-plan-cn") return KIMI_CODING_CREDENTIAL_ID;
+	return providerId;
+}
+function remapOpenAIModelForCodexOAuth(modelId) {
+	const normalizedModelId = stripMastraGatewayPrefix(modelId);
+	if (!normalizedModelId.startsWith("openai/")) return modelId;
+	const openaiModelId = normalizedModelId.substring(7);
+	if (openaiModelId.includes("-codex")) return modelId;
+	const codexModelId = CODEX_OPENAI_MODEL_REMAPS[openaiModelId];
+	if (!codexModelId) return modelId;
+	const remappedModelId = `${OPENAI_PREFIX}${codexModelId}`;
+	return modelId.startsWith("mastra/") ? `${MASTRA_GATEWAY_PREFIX}${remappedModelId}` : remappedModelId;
+}
+//#endregion
+export { ANTHROPIC_PREFIX, KIMI_CODING_CREDENTIAL_ID, KIMI_CODING_PROVIDER_ID, MASTRA_GATEWAY_PREFIX, OPENAI_PREFIX, getCredentialProviderId, normalizeAnthropicModelId, normalizeLegacyModelId, remapOpenAIModelForCodexOAuth, stripMastraGatewayPrefix };
+
+//# sourceMappingURL=model-ids.js.map

package/dist/providers/model-ids.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-ids.js","names":[],"sources":["../../src/providers/model-ids.ts"],"sourcesContent":["/**\n * Model-id helpers shared by the model gateway and the browser settings\n * module. Kept dependency-free so neither side has to import the other.\n */\n\nexport const OPENAI_PREFIX = 'openai/';\nexport const ANTHROPIC_PREFIX = 'anthropic/';\nexport const MASTRA_GATEWAY_PREFIX = 'mastra/';\n\n/** Anthropic's API only accepts dashed ids (`claude-opus-4-6`), but catalogs may list dotted ones. */\nexport function normalizeAnthropicModelId(modelId: string): string {\n  return modelId.replace(/\\.(?=\\d)/g, '-');\n}\n\n/**\n * The Codex ChatGPT-account endpoint serves some OpenAI models only under a\n * `-codex` id. Applied wherever a model id is sent over Codex OAuth (chat\n * agents and Stagehand alike) so both paths hit the same upstream model.\n */\nconst CODEX_OPENAI_MODEL_REMAPS: Record<string, string> = {\n  'gpt-5.3': 'gpt-5.3-codex',\n  'gpt-5.2': 'gpt-5.2-codex',\n  'gpt-5.1': 'gpt-5.1-codex',\n  'gpt-5.1-mini': 'gpt-5.1-codex-mini',\n  'gpt-5': 'gpt-5-codex',\n};\n\nexport function stripMastraGatewayPrefix(modelId: string): string {\n  return modelId.startsWith(MASTRA_GATEWAY_PREFIX) ? modelId.substring(MASTRA_GATEWAY_PREFIX.length) : modelId;\n}\n\n/**\n * Kimi For Coding subscriptions are served from `api.kimi.com`, which models.dev\n * lists as `kimi-code-plan-cn`. Mastra Code augments that provider with the\n * Kimi OAuth/API-key credential instead of defining its own.\n */\nexport const KIMI_CODING_PROVIDER_ID = 'kimi-code-plan-cn';\n/** Credential id the Kimi login stores accounts under. */\nexport const KIMI_CODING_CREDENTIAL_ID = 'kimi-for-coding';\n\n/** Providers Mastra Code used to catalog as `mastracode/<provider>/<model>`. */\nconst LEGACY_MASTRACODE_NAMESPACED_PROVIDERS = new Set(['amazon-bedrock', 'github-copilot', KIMI_CODING_CREDENTIAL_ID]);\n/** Provider ids Mastra Code defined itself before augmenting the models.dev provider. */\nconst LEGACY_PROVIDER_IDS: Record<string, string> = {\n  [KIMI_CODING_CREDENTIAL_ID]: KIMI_CODING_PROVIDER_ID,\n};\n\n/**\n * Map model ids saved by older Mastra Code versions (packs, OM settings,\n * thread metadata) to the current catalog id:\n * `mastracode/kimi-for-coding/k3` and `kimi-for-coding/k3` → `kimi-code-plan-cn/k3`,\n * `mastracode/github-copilot/<m>` → `github-copilot/<m>`,\n * `mastracode/amazon-bedrock/<m>` → `amazon-bedrock/<m>`.\n */\nexport function normalizeLegacyModelId(modelId: string): string {\n  let normalized = modelId;\n  const namespacedProvider = normalized.startsWith('mastracode/') ? normalized.split('/', 3)[1] : undefined;\n  if (namespacedProvider && LEGACY_MASTRACODE_NAMESPACED_PROVIDERS.has(namespacedProvider)) {\n    normalized = normalized.slice('mastracode/'.length);\n  }\n  const slash = normalized.indexOf('/');\n  const providerId = slash > 0 ? normalized.slice(0, slash) : undefined;\n  const replacement = providerId ? LEGACY_PROVIDER_IDS[providerId] : undefined;\n  return replacement ? `${replacement}${normalized.slice(slash)}` : normalized;\n}\n\n/** Credential-store id that authenticates a catalog provider id. */\nexport function getCredentialProviderId(providerId: string): string {\n  if (providerId === 'openai') return 'openai-codex';\n  if (providerId === KIMI_CODING_PROVIDER_ID) return KIMI_CODING_CREDENTIAL_ID;\n  return providerId;\n}\n\nexport function remapOpenAIModelForCodexOAuth(modelId: string): string {\n  const normalizedModelId = stripMastraGatewayPrefix(modelId);\n\n  if (!normalizedModelId.startsWith(OPENAI_PREFIX)) {\n    return modelId;\n  }\n\n  const openaiModelId = normalizedModelId.substring(OPENAI_PREFIX.length);\n\n  if (openaiModelId.includes('-codex')) {\n    return modelId;\n  }\n\n  const codexModelId = CODEX_OPENAI_MODEL_REMAPS[openaiModelId];\n  if (!codexModelId) {\n    return modelId;\n  }\n\n  const remappedModelId = `${OPENAI_PREFIX}${codexModelId}`;\n  return modelId.startsWith(MASTRA_GATEWAY_PREFIX) ? `${MASTRA_GATEWAY_PREFIX}${remappedModelId}` : remappedModelId;\n}\n"],"mappings":";;;;;AAKA,MAAa,gBAAgB;AAC7B,MAAa,mBAAmB;AAChC,MAAa,wBAAwB;;AAGrC,SAAgB,0BAA0B,SAAyB;CACjE,OAAO,QAAQ,QAAQ,aAAa,GAAG;AACzC;;;;;;AAOA,MAAM,4BAAoD;CACxD,WAAW;CACX,WAAW;CACX,WAAW;CACX,gBAAgB;CAChB,SAAS;AACX;AAEA,SAAgB,yBAAyB,SAAyB;CAChE,OAAO,QAAQ,WAAA,SAAgC,IAAI,QAAQ,UAAU,CAA4B,IAAI;AACvG;;;;;;AAOA,MAAa,0BAA0B;;AAEvC,MAAa,4BAA4B;;AAGzC,MAAM,yDAAyC,IAAI,IAAI;CAAC;CAAkB;CAAkB;AAAyB,CAAC;;AAEtH,MAAM,sBAA8C,GACjD,4BAA4B,wBAC/B;;;;;;;;AASA,SAAgB,uBAAuB,SAAyB;CAC9D,IAAI,aAAa;CACjB,MAAM,qBAAqB,WAAW,WAAW,aAAa,IAAI,WAAW,MAAM,KAAK,CAAC,CAAC,CAAC,KAAK,KAAA;CAChG,IAAI,sBAAsB,uCAAuC,IAAI,kBAAkB,GACrF,aAAa,WAAW,MAAM,EAAoB;CAEpD,MAAM,QAAQ,WAAW,QAAQ,GAAG;CACpC,MAAM,aAAa,QAAQ,IAAI,WAAW,MAAM,GAAG,KAAK,IAAI,KAAA;CAC5D,MAAM,cAAc,aAAa,oBAAoB,cAAc,KAAA;CACnE,OAAO,cAAc,GAAG,cAAc,WAAW,MAAM,KAAK,MAAM;AACpE;;AAGA,SAAgB,wBAAwB,YAA4B;CAClE,IAAI,eAAe,UAAU,OAAO;CACpC,IAAI,eAAA,qBAAwC,OAAO;CACnD,OAAO;AACT;AAEA,SAAgB,8BAA8B,SAAyB;CACrE,MAAM,oBAAoB,yBAAyB,OAAO;CAE1D,IAAI,CAAC,kBAAkB,WAAA,SAAwB,GAC7C,OAAO;CAGT,MAAM,gBAAgB,kBAAkB,UAAU,CAAoB;CAEtE,IAAI,cAAc,SAAS,QAAQ,GACjC,OAAO;CAGT,MAAM,eAAe,0BAA0B;CAC/C,IAAI,CAAC,cACH,OAAO;CAGT,MAAM,kBAAkB,GAAG,gBAAgB;CAC3C,OAAO,QAAQ,WAAA,SAAgC,IAAI,GAAG,wBAAwB,oBAAoB;AACpG"}

package/dist/providers/openai-codex.d.ts

@@ -0,0 +1,84 @@
+/**
+ * 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
+ */
+import type { MastraModelConfig } from '@mastra/core/llm';
+import type { LanguageModelMiddleware } from 'ai';
+import { AuthStorage } from '../auth/storage.js';
+import type { CredentialStore } from '../auth/types.js';
+import type { ThinkingLevelSetting } from '../thinking.js';
+export { supportsMaxReasoningEffort } from '../thinking.js';
+/**
+ * Get or create the shared AuthStorage instance
+ */
+export declare function getAuthStorage(): AuthStorage;
+/**
+ * Set a custom AuthStorage instance (useful for TUI integration)
+ */
+export declare function setAuthStorage(storage: AuthStorage | undefined): void;
+export type ThinkingLevel = ThinkingLevelSetting;
+export declare function getEffectiveThinkingLevel(modelId: string, level: ThinkingLevel): ThinkingLevel;
+export declare const THINKING_LEVEL_TO_REASONING_EFFORT: Record<ThinkingLevel, string | undefined>;
+/**
+ * Create Codex middleware with the given reasoning effort level.
+ */
+export declare function createCodexMiddleware(reasoningEffort?: string): LanguageModelMiddleware;
+/**
+ * Create middleware that forwards a resolved reasoning effort to an
+ * OpenAI-compatible provider as `providerOptions[providerKey].reasoningEffort`.
+ *
+ * Returns `undefined` when `reasoningEffort` is unset so callers wrap nothing
+ * (e.g. thinking level `off`), leaving the wire request without a
+ * `reasoning_effort` field. Unlike {@link createCodexMiddleware}, it does not
+ * inject Codex-only options (instructions/store); it only sets reasoning
+ * effort, keyed by the caller-supplied provider id.
+ */
+export declare function createReasoningEffortMiddleware(providerKey: string, reasoningEffort?: string): LanguageModelMiddleware | undefined;
+/**
+ * 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.
+ */
+export declare function buildOpenAICodexOAuthFetch(opts?: {
+    authStorage?: CredentialStore;
+    rewriteUrl?: boolean;
+}): typeof fetch;
+/**
+ * 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.
+ */
+export declare function buildCodexStagehandFetch(authStorage: AuthStorage): typeof fetch;
+/**
+ * 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.
+ */
+export declare function openaiCodexProvider(modelId?: string, options?: {
+    thinkingLevel?: ThinkingLevel;
+    headers?: Record<string, string>;
+    authStorage?: CredentialStore;
+}): MastraModelConfig;
+//# sourceMappingURL=openai-codex.d.ts.map

package/dist/providers/openai-codex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-codex.d.ts","sourceRoot":"","sources":["../../src/providers/openai-codex.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE1D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,IAAI,CAAC;AAElD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AAU5D;;GAEG;AACH,wBAAgB,cAAc,IAAI,WAAW,CAK5C;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,WAAW,GAAG,SAAS,GAAG,IAAI,CAErE;AAOD,MAAM,MAAM,aAAa,GAAG,oBAAoB,CAAC;AAIjD,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,aAAa,CAI9F;AAKD,eAAO,MAAM,kCAAkC,EAAE,MAAM,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,CAOxF,CAAC;AAEF;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG,uBAAuB,CA4BvF;AAED;;;;;;;;;GASG;AACH,wBAAgB,+BAA+B,CAC7C,WAAW,EAAE,MAAM,EACnB,eAAe,CAAC,EAAE,MAAM,GACvB,uBAAuB,GAAG,SAAS,CAgBrC;AA2CD;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,GAAE;IAAE,WAAW,CAAC,EAAE,eAAe,CAAC;IAAC,UAAU,CAAC,EAAE,OAAO,CAAA;CAAO,GACjE,OAAO,KAAK,CAkDd;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,wBAAwB,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,KAAK,CAuC/E;AAwID;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,GAAE,MAA4B,EACrC,OAAO,CAAC,EAAE;IAAE,aAAa,CAAC,EAAE,aAAa,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,WAAW,CAAC,EAAE,eAAe,CAAA;CAAE,GAC3G,iBAAiB,CAmCnB"}

package/dist/providers/openai-codex.js

@@ -0,0 +1,347 @@
+import { AuthStorage } from "../auth/storage.js";
+import { supportsMaxReasoningEffort } from "../thinking.js";
+import { runCatalogThinkingLevel } from "../thinking-catalog.js";
+import { ProviderAuthRequiredError } from "../auth/provider-auth-error.js";
+import { createOpenAI } from "@ai-sdk/openai";
+import { wrapLanguageModel } from "ai";
+//#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;
+}
+/**
+* Set a custom AuthStorage instance (useful for TUI integration)
+*/
+function setAuthStorage(storage) {
+	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) {
+	const requestedLevel = GPT5_MODEL_RE.test(modelId) && level === "off" ? "low" : level;
+	return runCatalogThinkingLevel(`openai/${modelId}`, requestedLevel);
+}
+const THINKING_LEVEL_TO_REASONING_EFFORT = {
+	off: void 0,
+	low: "low",
+	medium: "medium",
+	high: "high",
+	xhigh: "xhigh",
+	max: "max"
+};
+/**
+* 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,
+					store: false,
+					...reasoningEffort ? { reasoningEffort } : {}
+				}
+			};
+			return params;
+		}
+	};
+}
+/**
+* Create middleware that forwards a resolved reasoning effort to an
+* OpenAI-compatible provider as `providerOptions[providerKey].reasoningEffort`.
+*
+* Returns `undefined` when `reasoningEffort` is unset so callers wrap nothing
+* (e.g. thinking level `off`), leaving the wire request without a
+* `reasoning_effort` field. Unlike {@link createCodexMiddleware}, it does not
+* inject Codex-only options (instructions/store); it only sets reasoning
+* effort, keyed by the caller-supplied provider id.
+*/
+function createReasoningEffortMiddleware(providerKey, reasoningEffort) {
+	if (!reasoningEffort) return void 0;
+	return {
+		specificationVersion: "v3",
+		transformParams: async ({ params }) => {
+			params.providerOptions = {
+				...params.providerOptions,
+				[providerKey]: {
+					...params.providerOptions?.[providerKey] ?? {},
+					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();
+	let cred = storage.get("openai-codex");
+	if (!cred || cred.type !== "oauth") throw new ProviderAuthRequiredError("Not logged in to OpenAI Codex.");
+	if (storage.getOAuthCredential) {
+		cred = await storage.getOAuthCredential("openai-codex");
+		if (!cred) throw new ProviderAuthRequiredError("Failed to refresh the OpenAI Codex token.");
+	} else if (Date.now() >= cred.expires) {
+		const refreshedToken = await storage.getApiKey("openai-codex");
+		if (!refreshedToken) throw new ProviderAuthRequiredError("Failed to refresh the OpenAI Codex token.");
+		storage.reload();
+		const reloaded = storage.get("openai-codex");
+		if (!reloaded || reloaded.type !== "oauth") throw new ProviderAuthRequiredError("Not logged in to OpenAI Codex.");
+		cred = {
+			...reloaded,
+			access: refreshedToken
+		};
+	}
+	return {
+		accessToken: cred.access,
+		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: initHeaders, ...requestInit } = init ?? {};
+		const request = new Request(url, requestInit);
+		const headers = new Headers(url instanceof Request ? url.headers : void 0);
+		if (initHeaders) new Headers(initHeaders).forEach((value, key) => headers.set(key, value));
+		headers.delete("authorization");
+		headers.delete("x-api-key");
+		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 = new URL(request.url);
+		const finalUrl = opts.rewriteUrl !== false && (parsed.pathname.includes("/v1/responses") || parsed.pathname.includes("/chat/completions")) ? new URL(CODEX_API_ENDPOINT) : parsed;
+		const body = request.method === "GET" || request.method === "HEAD" ? void 0 : request.body;
+		const finalRequest = new Request(finalUrl, {
+			method: request.method,
+			headers,
+			body,
+			signal: request.signal,
+			redirect: request.redirect,
+			integrity: request.integrity,
+			...body ? { duplex: "half" } : {}
+		});
+		try {
+			return await fetch(finalRequest);
+		} 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: initHeaders, ...requestInit } = init ?? {};
+		const request = new Request(url, requestInit);
+		const headers = new Headers(url instanceof Request ? url.headers : void 0);
+		if (initHeaders) new Headers(initHeaders).forEach((value, key) => headers.set(key, value));
+		headers.delete("authorization");
+		headers.delete("x-api-key");
+		headers.set("Authorization", `Bearer ${accessToken}`);
+		headers.set("Accept", "text/event-stream");
+		let body = await request.clone().text();
+		try {
+			const parsed = JSON.parse(body);
+			parsed.stream = true;
+			body = JSON.stringify(parsed);
+			if (!headers.has("content-type")) headers.set("content-type", "application/json");
+		} catch {}
+		const upstream = await fetch(new Request(request, {
+			headers,
+			...request.method === "GET" || request.method === "HEAD" ? {} : { 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;
+		}
+		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 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]
+	});
+}
+//#endregion
+export { THINKING_LEVEL_TO_REASONING_EFFORT, buildCodexStagehandFetch, buildOpenAICodexOAuthFetch, createCodexMiddleware, createReasoningEffortMiddleware, getAuthStorage, getEffectiveThinkingLevel, openaiCodexProvider, setAuthStorage, supportsMaxReasoningEffort };
+
+//# sourceMappingURL=openai-codex.js.map

package/dist/providers/openai-codex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-codex.js","names":[],"sources":["../../src/providers/openai-codex.ts"],"sourcesContent":["/**\n * OpenAI Codex OAuth Provider\n *\n * Uses OAuth tokens from AuthStorage to authenticate with ChatGPT Plus/Pro subscription.\n * This allows access to OpenAI models through the ChatGPT OAuth flow.\n *\n * Inspired by opencode's Codex plugin implementation:\n * https://github.com/sst/opencode/blob/main/packages/opencode/src/plugin/codex.ts\n */\n\nimport { createOpenAI } from '@ai-sdk/openai';\nimport type { MastraModelConfig } from '@mastra/core/llm';\nimport { wrapLanguageModel } from 'ai';\nimport type { LanguageModelMiddleware } from 'ai';\nimport { ProviderAuthRequiredError } from '../auth/provider-auth-error.js';\nimport { AuthStorage } from '../auth/storage.js';\nimport type { CredentialStore } from '../auth/types.js';\nimport { runCatalogThinkingLevel } from '../thinking-catalog.js';\nimport type { ThinkingLevelSetting } from '../thinking.js';\nexport { supportsMaxReasoningEffort } from '../thinking.js';\n\n// Codex API endpoint (not standard OpenAI API)\nconst CODEX_API_ENDPOINT = 'https://chatgpt.com/backend-api/codex/responses';\nconst CODEX_ORIGINATOR = 'mastracode';\nconst CODEX_USER_AGENT = 'mastracode';\n\n// Singleton auth storage instance (shared with claude-max.ts)\nlet authStorageInstance: AuthStorage | null = null;\n\n/**\n * Get or create the shared AuthStorage instance\n */\nexport function getAuthStorage(): AuthStorage {\n  if (!authStorageInstance) {\n    authStorageInstance = new AuthStorage();\n  }\n  return authStorageInstance;\n}\n\n/**\n * Set a custom AuthStorage instance (useful for TUI integration)\n */\nexport function setAuthStorage(storage: AuthStorage | undefined): void {\n  authStorageInstance = storage ?? null;\n}\n\n// Default instructions for Codex API (required)\nconst 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.\n\nIMPORTANT: You should be concise, direct, and helpful. Focus on solving the user's problem efficiently.`;\n\nexport type ThinkingLevel = ThinkingLevelSetting;\n\nconst GPT5_MODEL_RE = /^gpt-5(?:\\.|-|$)/;\n\nexport function getEffectiveThinkingLevel(modelId: string, level: ThinkingLevel): ThinkingLevel {\n  // GPT-5.* models on Codex require at least low reasoning.\n  const requestedLevel = GPT5_MODEL_RE.test(modelId) && level === 'off' ? 'low' : level;\n  return runCatalogThinkingLevel(`openai/${modelId}`, requestedLevel);\n}\n\n// Map thinkingLevel state values to OpenAI reasoningEffort values.\n// undefined means omit the parameter (no reasoning). Model-dependent fitting\n// happens in getEffectiveThinkingLevel before this lookup.\nexport const THINKING_LEVEL_TO_REASONING_EFFORT: Record<ThinkingLevel, string | undefined> = {\n  off: undefined,\n  low: 'low',\n  medium: 'medium',\n  high: 'high',\n  xhigh: 'xhigh',\n  max: 'max',\n};\n\n/**\n * Create Codex middleware with the given reasoning effort level.\n */\nexport function createCodexMiddleware(reasoningEffort?: string): LanguageModelMiddleware {\n  return {\n    specificationVersion: 'v3',\n    transformParams: async ({ params }) => {\n      // Remove topP if temperature is set (OpenAI doesn't like both)\n      if (params.temperature !== undefined && params.temperature !== null) {\n        delete params.topP;\n      }\n\n      // Codex API requires specific settings via providerOptions\n      // Use type assertion to satisfy JSONValue constraints\n      params.providerOptions = {\n        ...params.providerOptions,\n        openai: {\n          ...(params.providerOptions?.openai ?? {}),\n          instructions: CODEX_INSTRUCTIONS,\n          // Codex API requires store to be false\n          store: false,\n          // Enable reasoning for Codex models — without this, the model\n          // skips the reasoning/action phase and goes straight to final_answer,\n          // resulting in narration instead of tool calls.\n          ...(reasoningEffort ? { reasoningEffort } : {}),\n        },\n      } as typeof params.providerOptions;\n\n      return params;\n    },\n  };\n}\n\n/**\n * Create middleware that forwards a resolved reasoning effort to an\n * OpenAI-compatible provider as `providerOptions[providerKey].reasoningEffort`.\n *\n * Returns `undefined` when `reasoningEffort` is unset so callers wrap nothing\n * (e.g. thinking level `off`), leaving the wire request without a\n * `reasoning_effort` field. Unlike {@link createCodexMiddleware}, it does not\n * inject Codex-only options (instructions/store); it only sets reasoning\n * effort, keyed by the caller-supplied provider id.\n */\nexport function createReasoningEffortMiddleware(\n  providerKey: string,\n  reasoningEffort?: string,\n): LanguageModelMiddleware | undefined {\n  if (!reasoningEffort) return undefined;\n  return {\n    specificationVersion: 'v3',\n    transformParams: async ({ params }) => {\n      params.providerOptions = {\n        ...params.providerOptions,\n        [providerKey]: {\n          ...(params.providerOptions?.[providerKey] ?? {}),\n          reasoningEffort,\n        },\n      } as typeof params.providerOptions;\n\n      return params;\n    },\n  };\n}\n\n/**\n * Get a live OAuth bearer token for the Codex OAuth credential.\n *\n * Refreshes the token if it's expired, and returns the credential's\n * accountId alongside the access token. Throws if the user isn't logged in\n * or if the refresh fails.\n *\n * This is the only piece of Codex auth that is genuinely shared between\n * the main agent's fetch (`buildOpenAICodexOAuthFetch`) and the Stagehand\n * fetch (`buildCodexStagehandFetch`).\n */\nasync function getCodexBearer(\n  authStorage?: CredentialStore,\n): Promise<{ accessToken: string; accountId: string | undefined }> {\n  const storage = authStorage ?? getAuthStorage();\n  storage.reload();\n\n  let cred = storage.get('openai-codex');\n  if (!cred || cred.type !== 'oauth') {\n    throw new ProviderAuthRequiredError('Not logged in to OpenAI Codex.');\n  }\n\n  if (storage.getOAuthCredential) {\n    cred = await storage.getOAuthCredential('openai-codex');\n    if (!cred) throw new ProviderAuthRequiredError('Failed to refresh the OpenAI Codex token.');\n  } else if (Date.now() >= cred.expires) {\n    const refreshedToken = await storage.getApiKey('openai-codex');\n    if (!refreshedToken) {\n      throw new ProviderAuthRequiredError('Failed to refresh the OpenAI Codex token.');\n    }\n    storage.reload();\n    const reloaded = storage.get('openai-codex');\n    if (!reloaded || reloaded.type !== 'oauth') {\n      throw new ProviderAuthRequiredError('Not logged in to OpenAI Codex.');\n    }\n    cred = { ...reloaded, access: refreshedToken };\n  }\n\n  return { accessToken: cred.access, accountId: (cred as any).accountId as string | undefined };\n}\n\n/**\n * Build a fetch function that handles OpenAI Codex OAuth.\n * Preserves non-authorization headers from init.\n * When rewriteUrl is true (default), rewrites /v1/responses and /chat/completions\n * to the Codex API endpoint. Set rewriteUrl: false for gateway usage where the\n * SDK already targets the correct URL.\n */\nexport function buildOpenAICodexOAuthFetch(\n  opts: { authStorage?: CredentialStore; rewriteUrl?: boolean } = {},\n): typeof fetch {\n  return (async (url: string | URL | Request, init?: Parameters<typeof fetch>[1]) => {\n    const { accessToken, accountId } = await getCodexBearer(opts.authStorage);\n    const { headers: initHeaders, ...requestInit } = init ?? {};\n    const request = new Request(url, requestInit);\n\n    // Preserve Request headers and let explicit init headers override them.\n    const headers = new Headers(url instanceof Request ? url.headers : undefined);\n    if (initHeaders) new Headers(initHeaders).forEach((value, key) => headers.set(key, value));\n    headers.delete('authorization');\n    headers.delete('x-api-key');\n    headers.set('Authorization', `Bearer ${accessToken}`);\n    if (!headers.has('originator')) {\n      headers.set('originator', CODEX_ORIGINATOR);\n    }\n    if (!headers.has('User-Agent')) {\n      headers.set('User-Agent', CODEX_USER_AGENT);\n    }\n    if (accountId) {\n      headers.set('ChatGPT-Account-ID', accountId);\n    }\n\n    // URL rewriting — only when rewriteUrl !== false\n    const parsed = new URL(request.url);\n    const shouldRewrite =\n      opts.rewriteUrl !== false &&\n      (parsed.pathname.includes('/v1/responses') || parsed.pathname.includes('/chat/completions'));\n    const finalUrl = shouldRewrite ? new URL(CODEX_API_ENDPOINT) : parsed;\n\n    const body = request.method === 'GET' || request.method === 'HEAD' ? undefined : request.body;\n    const finalRequest = new Request(finalUrl, {\n      method: request.method,\n      headers,\n      body,\n      signal: request.signal,\n      redirect: request.redirect,\n      integrity: request.integrity,\n      ...(body ? ({ duplex: 'half' } as RequestInit) : {}),\n    });\n    try {\n      return await fetch(finalRequest);\n    } catch (error) {\n      if (error && typeof error === 'object') {\n        Object.assign(error as Record<string, unknown>, {\n          requestUrl: finalUrl.toString(),\n        });\n      }\n      throw error;\n    }\n  }) as typeof fetch;\n}\n\n/**\n * Build a fetch function for Stagehand-on-Codex.\n *\n * The Codex backend has two requirements that AI SDK's non-streaming\n * `generateText` path doesn't naturally satisfy:\n *\n *   1. `stream: true` must be set on every request body.\n *   2. The response is delivered as Server-Sent Events; AI SDK's\n *      non-streaming code path expects a single JSON body.\n *\n * This fetch forces streaming on the outgoing request, collects the SSE\n * events, and synthesizes the non-streaming JSON shape that\n * `@ai-sdk/openai`'s Responses API parser expects.\n *\n * Headers, OAuth refresh, and URL targeting are handled by the caller via\n * `baseURL` / `headers` on the AI SDK provider; this fetch only injects the\n * live OAuth bearer per call.\n */\nexport function buildCodexStagehandFetch(authStorage: AuthStorage): typeof fetch {\n  return (async (url: string | URL | Request, init?: Parameters<typeof fetch>[1]) => {\n    // Refresh + inject the OAuth bearer per call.\n    const { accessToken } = await getCodexBearer(authStorage);\n    const { headers: initHeaders, ...requestInit } = init ?? {};\n    const request = new Request(url, requestInit);\n    const headers = new Headers(url instanceof Request ? url.headers : undefined);\n    if (initHeaders) new Headers(initHeaders).forEach((value, key) => headers.set(key, value));\n    headers.delete('authorization');\n    headers.delete('x-api-key');\n    headers.set('Authorization', `Bearer ${accessToken}`);\n    headers.set('Accept', 'text/event-stream');\n\n    // Stagehand sends JSON; force stream: true while preserving Request bodies.\n    let body = await request.clone().text();\n    try {\n      const parsed = JSON.parse(body) as Record<string, unknown>;\n      parsed.stream = true;\n      body = JSON.stringify(parsed);\n      if (!headers.has('content-type')) headers.set('content-type', 'application/json');\n    } catch {\n      // Not JSON; leave as-is.\n    }\n\n    const upstream = await fetch(\n      new Request(request, {\n        headers,\n        ...(request.method === 'GET' || request.method === 'HEAD' ? {} : { body }),\n      }),\n    );\n    if (!upstream.ok) return upstream;\n\n    // Aggregate SSE -> synthesized non-streaming Response\n    const aggregated = await aggregateCodexStream(upstream);\n    return new Response(aggregated, {\n      status: 200,\n      headers: { 'content-type': 'application/json' },\n    });\n  }) as typeof fetch;\n}\n\n/**\n * Read an SSE Response and reduce it to a single JSON string matching the\n * non-streaming OpenAI Responses-API shape.\n *\n * Event vocabulary we care about (per OpenAI Responses API streaming):\n *   - response.created         → carries `response` object (id, model, usage stub)\n *   - response.output_item.added/done → output items (message, reasoning, etc.)\n *   - response.output_text.delta → text chunks\n *   - response.completed       → final `response` snapshot incl. usage\n *   - response.error / error   → bubble up as a thrown body\n *\n * Reasoning events (`response.reasoning_summary.*`) are intentionally ignored\n * for the non-streaming text response.\n */\nasync function aggregateCodexStream(response: Response): Promise<string> {\n  if (!response.body) {\n    throw new Error('Codex streaming response had no body');\n  }\n\n  const reader = response.body.getReader();\n  const decoder = new TextDecoder('utf-8');\n  let buffer = '';\n\n  let finalResponse: any = null;\n  let createdResponse: any = null;\n  // Track output_items by index so we can rebuild the final array\n  const items = new Map<number, any>();\n  // Accumulate output_text deltas keyed by item_index + content_index\n  const textBuffers = new Map<string, string>();\n\n  const handleEvent = (event: { event?: string; data?: string }) => {\n    if (!event.data || event.data === '[DONE]') return;\n    let payload: any;\n    try {\n      payload = JSON.parse(event.data);\n    } catch {\n      return;\n    }\n    const type: string = payload.type ?? event.event ?? '';\n\n    switch (type) {\n      case 'response.created': {\n        createdResponse = payload.response ?? createdResponse;\n        break;\n      }\n      case 'response.output_item.added': {\n        if (typeof payload.output_index === 'number' && payload.item) {\n          items.set(payload.output_index, payload.item);\n        }\n        break;\n      }\n      case 'response.output_item.done': {\n        if (typeof payload.output_index === 'number' && payload.item) {\n          items.set(payload.output_index, payload.item);\n        }\n        break;\n      }\n      case 'response.output_text.delta': {\n        const key = `${payload.output_index}:${payload.content_index ?? 0}`;\n        textBuffers.set(key, (textBuffers.get(key) ?? '') + (payload.delta ?? ''));\n        break;\n      }\n      case 'response.completed': {\n        finalResponse = payload.response ?? finalResponse;\n        break;\n      }\n      case 'response.error':\n      case 'error': {\n        throw new Error(`Codex stream error: ${JSON.stringify(payload.error ?? payload)}`);\n      }\n      default:\n        // Ignore reasoning / unknown events\n        break;\n    }\n  };\n\n  // SSE parser: events separated by blank line; lines like \"event: x\" / \"data: y\"\n  // Normalize CRLF→LF so \\r\\n\\r\\n event boundaries parse correctly (SSE spec allows CRLF).\n  const processChunk = (chunk: string) => {\n    buffer += chunk.replace(/\\r\\n/g, '\\n');\n    let sepIdx: number;\n    while ((sepIdx = buffer.indexOf('\\n\\n')) !== -1) {\n      const raw = buffer.slice(0, sepIdx);\n      buffer = buffer.slice(sepIdx + 2);\n      const event: { event?: string; data?: string } = {};\n      const dataLines: string[] = [];\n      for (const line of raw.split('\\n')) {\n        if (line.startsWith('event:')) {\n          event.event = line.slice(6).trim();\n        } else if (line.startsWith('data:')) {\n          dataLines.push(line.slice(5).trimStart());\n        }\n      }\n      if (dataLines.length > 0) {\n        event.data = dataLines.join('\\n');\n      }\n      handleEvent(event);\n    }\n  };\n\n  try {\n    while (true) {\n      const { value, done } = await reader.read();\n      if (done) break;\n      processChunk(decoder.decode(value, { stream: true }));\n    }\n    processChunk(decoder.decode());\n  } finally {\n    reader.releaseLock();\n  }\n\n  // Stitch accumulated text deltas back into their items\n  const base = finalResponse ?? createdResponse ?? { output: [] };\n  const finalItems = Array.from(items.entries())\n    .sort(([a], [b]) => a - b)\n    .map(([index, item]) => {\n      // Patch message-type items' content text using buffered deltas\n      if (item?.type === 'message' && Array.isArray(item.content)) {\n        item.content = item.content.map((c: any, ci: number) => {\n          const key = `${index}:${ci}`;\n          if (textBuffers.has(key)) {\n            return { ...c, text: textBuffers.get(key) };\n          }\n          return c;\n        });\n      }\n      return item;\n    });\n\n  base.output = finalItems.length > 0 ? finalItems : (base.output ?? []);\n\n  return JSON.stringify(base);\n}\n\n/**\n * Creates an OpenAI model using ChatGPT OAuth authentication\n * Uses OAuth tokens from AuthStorage (auto-refreshes when needed)\n *\n * IMPORTANT: This uses the Codex API endpoint, not the standard OpenAI API.\n * URLs are rewritten from /v1/responses or /chat/completions to the Codex endpoint.\n */\nexport function openaiCodexProvider(\n  modelId: string = 'codex-mini-latest',\n  options?: { thinkingLevel?: ThinkingLevel; headers?: Record<string, string>; authStorage?: CredentialStore },\n): MastraModelConfig {\n  const requestedLevel: ThinkingLevel = options?.thinkingLevel ?? 'medium';\n  const effectiveLevel = getEffectiveThinkingLevel(modelId, requestedLevel);\n  const reasoningEffort = THINKING_LEVEL_TO_REASONING_EFFORT[effectiveLevel];\n  const middleware = createCodexMiddleware(reasoningEffort);\n  const headers = options?.headers;\n\n  const baseURL = process.env.OPENAI_BASE_URL;\n\n  // Test environment: use API key\n  if (process.env.NODE_ENV === 'test' || process.env.VITEST) {\n    const openai = createOpenAI({\n      apiKey: 'test-api-key',\n      baseURL,\n      headers,\n    });\n    return wrapLanguageModel({\n      model: openai.responses(modelId),\n      middleware: [middleware],\n    });\n  }\n\n  const openai = createOpenAI({\n    apiKey: 'oauth-dummy-key',\n    baseURL,\n    headers,\n    fetch: buildOpenAICodexOAuthFetch({ authStorage: options?.authStorage }) as any,\n  });\n\n  // Use the responses API for Codex models\n  // Wrap with middleware\n  return wrapLanguageModel({\n    model: openai.responses(modelId),\n    middleware: [middleware],\n  });\n}\n"],"mappings":"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"}

package/dist/providers/provider-thinking.d.ts

@@ -0,0 +1,23 @@
+import { ModelRouterLanguageModel } from '@mastra/core/llm';
+import { wrapLanguageModel } from 'ai';
+import type { JSONValue } from 'ai';
+import type { ThinkingLevelSetting } from '../thinking.js';
+export interface ProviderThinkingOptions {
+    optionsKey: string;
+    options: Record<string, JSONValue>;
+    controlKeys: ReadonlySet<string>;
+}
+export declare function providerThinkingOptions(routedModelId: string, level: ThinkingLevelSetting | undefined): ProviderThinkingOptions | undefined;
+type AiSdkLanguageModel = Parameters<typeof wrapLanguageModel>[0]['model'];
+export declare function withThinkingOptionsModel(model: AiSdkLanguageModel, thinking: ProviderThinkingOptions | undefined): AiSdkLanguageModel;
+type RouterConfig = ConstructorParameters<typeof ModelRouterLanguageModel>[0];
+type RouterCallOptions = Parameters<ModelRouterLanguageModel['doStream']>[0];
+type RouterCallResult = ReturnType<ModelRouterLanguageModel['doStream']>;
+export declare class ModelRouterLanguageModelWithThinking extends ModelRouterLanguageModel {
+    #private;
+    constructor(config: RouterConfig, thinking: ProviderThinkingOptions | undefined);
+    doGenerate(options: RouterCallOptions): RouterCallResult;
+    doStream(options: RouterCallOptions): RouterCallResult;
+}
+export {};
+//# sourceMappingURL=provider-thinking.d.ts.map

package/dist/providers/provider-thinking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-thinking.d.ts","sourceRoot":"","sources":["../../src/providers/provider-thinking.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,wBAAwB,EAAE,MAAM,kBAAkB,CAAC;AACtF,OAAO,EAAE,iBAAiB,EAAE,MAAM,IAAI,CAAC;AACvC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AAEpC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAK3D,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACnC,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAClC;AAED,wBAAgB,uBAAuB,CACrC,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,oBAAoB,GAAG,SAAS,GACtC,uBAAuB,GAAG,SAAS,CAarC;AAmBD,KAAK,kBAAkB,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;AAE3E,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,kBAAkB,EACzB,QAAQ,EAAE,uBAAuB,GAAG,SAAS,GAC5C,kBAAkB,CASpB;AAED,KAAK,YAAY,GAAG,qBAAqB,CAAC,OAAO,wBAAwB,CAAC,CAAC,CAAC,CAAC,CAAC;AAC9E,KAAK,iBAAiB,GAAG,UAAU,CAAC,wBAAwB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAC7E,KAAK,gBAAgB,GAAG,UAAU,CAAC,wBAAwB,CAAC,UAAU,CAAC,CAAC,CAAC;AAEzE,qBAAa,oCAAqC,SAAQ,wBAAwB;;gBAGpE,MAAM,EAAE,YAAY,EAAE,QAAQ,EAAE,uBAAuB,GAAG,SAAS;IAKtE,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,gBAAgB;IAIxD,QAAQ,CAAC,OAAO,EAAE,iBAAiB,GAAG,gBAAgB;CAGhE"}