gsd-pi 2.34.0-dev.ed0bfbf → 2.35.0-dev.30eec3f

package/packages/pi-ai/src/providers/openai-responses.ts

@@ -1,12 +1,9 @@
 // Lazy-loaded: OpenAI SDK is imported on first use, not at startup.
 // This avoids penalizing users who don't use OpenAI models.
-import type OpenAI from "openai";
 import type { ResponseCreateParamsStreaming } from "openai/resources/responses/responses.js";
 import { getEnvApiKey } from "../env-api-keys.js";
 import { supportsXhigh } from "../models.js";
 import type {
-	Api,
-	AssistantMessage,
 	CacheRetention,
 	Context,
 	Model,
@@ -16,29 +13,17 @@ import type {
 	Usage,
 } from "../types.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
-import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
 import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.js";
+import {
+	assertStreamSuccess,
+	buildInitialOutput,
+	clampReasoningForModel,
+	createOpenAIClient,
+	finalizeStream,
+	handleStreamError,
+} from "./openai-shared.js";
 import { buildBaseOptions, clampReasoning } from "./simple-options.js";
 
-let _OpenAIResponsesClass: typeof OpenAI | undefined;
-async function getOpenAIResponsesClass(): Promise<typeof OpenAI> {
-	if (!_OpenAIResponsesClass) {
-		const mod = await import("openai");
-		_OpenAIResponsesClass = mod.default;
-	}
-	return _OpenAIResponsesClass;
-}
-
-/**
- * Clamp reasoning effort for models that don't support all levels.
- * gpt-5.x models don't support "minimal" — map to "low".
- */
-function clampReasoningForModel(modelName: string, effort: string): string {
-	const name = modelName.includes("/") ? modelName.split("/").pop()! : modelName;
-	if (name.startsWith("gpt-5") && effort === "minimal") return "low";
-	return effort;
-}
-
 const OPENAI_TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode"]);
 
 /**
@@ -88,28 +73,14 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses", OpenAIRes
 
 	// Start async processing
 	(async () => {
-		const output: AssistantMessage = {
-			role: "assistant",
-			content: [],
-			api: model.api as Api,
-			provider: model.provider,
-			model: model.id,
-			usage: {
-				input: 0,
-				output: 0,
-				cacheRead: 0,
-				cacheWrite: 0,
-				totalTokens: 0,
-				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-			},
-			stopReason: "stop",
-			timestamp: Date.now(),
-		};
+		const output = buildInitialOutput(model);
 
 		try {
 			// Create OpenAI client
 			const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
-			const client = await createClient(model, context, apiKey, options?.headers);
+			const client = await createOpenAIClient(model, context, apiKey, {
+				optionsHeaders: options?.headers,
+			});
 			let params = buildParams(model, context, options);
 			const nextParams = await options?.onPayload?.(params, model);
 			if (nextParams !== undefined) {
@@ -126,22 +97,10 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses", OpenAIRes
 				applyServiceTierPricing,
 			});
 
-			if (options?.signal?.aborted) {
-				throw new Error("Request was aborted");
-			}
-
-			if (output.stopReason === "aborted" || output.stopReason === "error") {
-				throw new Error("An unknown error occurred");
-			}
-
-			stream.push({ type: "done", reason: output.stopReason, message: output });
-			stream.end();
+			assertStreamSuccess(output, options?.signal);
+			finalizeStream(stream, output);
 		} catch (error) {
-			for (const block of output.content) delete (block as { index?: number }).index;
-			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-			output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
-			stream.push({ type: "error", reason: output.stopReason, error: output });
-			stream.end();
+			handleStreamError(stream, output, error, options?.signal);
 		}
 	})();
 
@@ -167,45 +126,6 @@ export const streamSimpleOpenAIResponses: StreamFunction<"openai-responses", Sim
 	} satisfies OpenAIResponsesOptions);
 };
 
-async function createClient(
-	model: Model<"openai-responses">,
-	context: Context,
-	apiKey?: string,
-	optionsHeaders?: Record<string, string>,
-) {
-	if (!apiKey) {
-		if (!process.env.OPENAI_API_KEY) {
-			throw new Error(
-				"OpenAI API key is required. Set OPENAI_API_KEY environment variable or pass it as an argument.",
-			);
-		}
-		apiKey = process.env.OPENAI_API_KEY;
-	}
-
-	const headers = { ...model.headers };
-	if (model.provider === "github-copilot") {
-		const hasImages = hasCopilotVisionInput(context.messages);
-		const copilotHeaders = buildCopilotDynamicHeaders({
-			messages: context.messages,
-			hasImages,
-		});
-		Object.assign(headers, copilotHeaders);
-	}
-
-	// Merge options headers last so they can override defaults
-	if (optionsHeaders) {
-		Object.assign(headers, optionsHeaders);
-	}
-
-	const OpenAIClass = await getOpenAIResponsesClass();
-	return new OpenAIClass({
-		apiKey,
-		baseURL: model.baseUrl,
-		dangerouslyAllowBrowser: true,
-		defaultHeaders: headers,
-	});
-}
-
 function buildParams(model: Model<"openai-responses">, context: Context, options?: OpenAIResponsesOptions) {
 	const messages = convertResponsesMessages(model, context, OPENAI_TOOL_CALL_PROVIDERS);
 
@@ -236,13 +156,13 @@ function buildParams(model: Model<"openai-responses">, context: Context, options
 	}
 
 	if (model.reasoning) {
+		params.include = ["reasoning.encrypted_content"];
 		if (options?.reasoningEffort || options?.reasoningSummary) {
 			const effort = clampReasoningForModel(model.name, options?.reasoningEffort || "medium") as typeof options.reasoningEffort;
 			params.reasoning = {
 				effort: effort || "medium",
 				summary: options?.reasoningSummary || "auto",
 			};
-			params.include = ["reasoning.encrypted_content"];
 		} else {
 			if (model.name.startsWith("gpt-5")) {
 				// Jesus Christ, see https://community.openai.com/t/need-reasoning-false-option-for-gpt-5/1351588/7

package/packages/pi-ai/src/providers/openai-shared.ts

@@ -0,0 +1,193 @@
+/**
+ * Shared utilities for OpenAI Completions and Responses providers.
+ *
+ * This module consolidates code that is identical (or near-identical) across
+ * openai-completions.ts and openai-responses.ts to reduce duplication while
+ * preserving the subtle behavioural differences of each provider.
+ */
+
+import type OpenAI from "openai";
+import type {
+	Api,
+	AssistantMessage,
+	Context,
+	Model,
+	StopReason,
+} from "../types.js";
+import type { AssistantMessageEventStream } from "../utils/event-stream.js";
+import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
+
+// =============================================================================
+// Lazy SDK loading
+// =============================================================================
+
+let _openAIClass: typeof OpenAI | undefined;
+
+/**
+ * Lazy-load the OpenAI SDK default export.
+ * Shared between Completions and Responses providers so the module is only
+ * imported once regardless of which provider is used first.
+ */
+export async function getOpenAIClass(): Promise<typeof OpenAI> {
+	if (!_openAIClass) {
+		const mod = await import("openai");
+		_openAIClass = mod.default;
+	}
+	return _openAIClass;
+}
+
+// =============================================================================
+// Client creation
+// =============================================================================
+
+export interface CreateClientOptions {
+	/** Extra headers from the options bag (merged last, can override defaults). */
+	optionsHeaders?: Record<string, string>;
+	/** Provider-specific client constructor options (e.g. timeout, maxRetries for Z.ai). */
+	extraClientOptions?: Record<string, unknown>;
+}
+
+/**
+ * Create an OpenAI SDK client instance.
+ *
+ * Handles:
+ * - API key resolution (explicit > env)
+ * - GitHub Copilot dynamic headers
+ * - Options header merging
+ * - Lazy SDK loading
+ */
+export async function createOpenAIClient<TApi extends Api>(
+	model: Model<TApi>,
+	context: Context,
+	apiKey: string | undefined,
+	options?: CreateClientOptions,
+): Promise<OpenAI> {
+	if (!apiKey) {
+		if (!process.env.OPENAI_API_KEY) {
+			throw new Error(
+				"OpenAI API key is required. Set OPENAI_API_KEY environment variable or pass it as an argument.",
+			);
+		}
+		apiKey = process.env.OPENAI_API_KEY;
+	}
+
+	const headers = { ...model.headers };
+	if (model.provider === "github-copilot") {
+		const hasImages = hasCopilotVisionInput(context.messages);
+		const copilotHeaders = buildCopilotDynamicHeaders({
+			messages: context.messages,
+			hasImages,
+		});
+		Object.assign(headers, copilotHeaders);
+	}
+
+	// Merge options headers last so they can override defaults
+	if (options?.optionsHeaders) {
+		Object.assign(headers, options.optionsHeaders);
+	}
+
+	const OpenAIClass = await getOpenAIClass();
+	return new OpenAIClass({
+		apiKey,
+		baseURL: model.baseUrl,
+		dangerouslyAllowBrowser: true,
+		defaultHeaders: headers,
+		...options?.extraClientOptions,
+	});
+}
+
+// =============================================================================
+// Initial output construction
+// =============================================================================
+
+/**
+ * Build the initial AssistantMessage output object used by all OpenAI stream
+ * handlers.  Every field is initialised to its zero/default value.
+ */
+export function buildInitialOutput<TApi extends Api>(model: Model<TApi>): AssistantMessage {
+	return {
+		role: "assistant",
+		content: [],
+		api: model.api as Api,
+		provider: model.provider,
+		model: model.id,
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		},
+		stopReason: "stop",
+		timestamp: Date.now(),
+	};
+}
+
+// =============================================================================
+// Stream lifecycle helpers
+// =============================================================================
+
+/**
+ * Shared post-stream checks.  Call after the provider-specific stream loop
+ * finishes successfully (before pushing the "done" event).
+ *
+ * Throws if the request was aborted or the output indicates an error.
+ */
+export function assertStreamSuccess(output: AssistantMessage, signal?: AbortSignal): void {
+	if (signal?.aborted) {
+		throw new Error("Request was aborted");
+	}
+	if (output.stopReason === "aborted" || output.stopReason === "error") {
+		throw new Error("An unknown error occurred");
+	}
+}
+
+/**
+ * Emit the "done" event and close the stream.
+ */
+export function finalizeStream(
+	stream: AssistantMessageEventStream,
+	output: AssistantMessage,
+): void {
+	stream.push({ type: "done", reason: output.stopReason as Extract<StopReason, "stop" | "length" | "toolUse">, message: output });
+	stream.end();
+}
+
+/**
+ * Handle an error during streaming.
+ *
+ * Cleans up any leftover `index` properties on content blocks, sets the
+ * appropriate stop reason and error message, then emits the "error" event.
+ */
+export function handleStreamError(
+	stream: AssistantMessageEventStream,
+	output: AssistantMessage,
+	error: unknown,
+	signal?: AbortSignal,
+	/** Extra error metadata to append (e.g. OpenRouter raw metadata). */
+	extraMessage?: string,
+): void {
+	for (const block of output.content) delete (block as { index?: number }).index;
+	output.stopReason = signal?.aborted ? "aborted" : "error";
+	output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+	if (extraMessage) output.errorMessage += `\n${extraMessage}`;
+	stream.push({ type: "error", reason: output.stopReason, error: output });
+	stream.end();
+}
+
+// =============================================================================
+// Reasoning helpers
+// =============================================================================
+
+/**
+ * Clamp reasoning effort for models that don't support all levels.
+ * gpt-5.x models don't support "minimal" -- map to "low".
+ *
+ * Used by both openai-responses.ts and azure-openai-responses.ts.
+ */
+export function clampReasoningForModel(modelName: string, effort: string): string {
+	const name = modelName.includes("/") ? modelName.split("/").pop()! : modelName;
+	if (name.startsWith("gpt-5") && effort === "minimal") return "low";
+	return effort;
+}

package/packages/pi-ai/src/utils/oauth/google-antigravity.ts

@@ -6,7 +6,13 @@
  * It is only intended for CLI use, not browser environments.
  */
 
-import type { Server } from "node:http";
+import {
+	type CallbackServerInfo,
+	getGoogleUserEmail,
+	parseRedirectUrl,
+	refreshGoogleOAuthToken,
+	startCallbackServer,
+} from "./google-oauth-utils.js";
 import { generatePKCE } from "./pkce.js";
 import type { OAuthCredentials, OAuthLoginCallbacks, OAuthProviderInterface } from "./types.js";
 
@@ -14,14 +20,6 @@ type AntigravityCredentials = OAuthCredentials & {
 	projectId: string;
 };
 
-let _createServer: typeof import("node:http").createServer | null = null;
-let _httpImportPromise: Promise<void> | null = null;
-if (typeof process !== "undefined" && (process.versions?.node || process.versions?.bun)) {
-	_httpImportPromise = import("node:http").then((m) => {
-		_createServer = m.createServer;
-	});
-}
-
 // Antigravity OAuth credentials (different from Gemini CLI)
 const decode = (s: string) => atob(s);
 const CLIENT_ID = decode(
@@ -42,109 +40,13 @@ const SCOPES = [
 const AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
 const TOKEN_URL = "https://oauth2.googleapis.com/token";
 
+// Callback server configuration
+const CALLBACK_PORT = 51121;
+const CALLBACK_PATH = "/oauth-callback";
+
 // Fallback project ID when discovery fails
 const DEFAULT_PROJECT_ID = "rising-fact-p41fc";
 
-type CallbackServerInfo = {
-	server: Server;
-	cancelWait: () => void;
-	waitForCode: () => Promise<{ code: string; state: string } | null>;
-};
-
-/**
- * Start a local HTTP server to receive the OAuth callback
- */
-async function getNodeCreateServer(): Promise<typeof import("node:http").createServer> {
-	if (_createServer) return _createServer;
-	if (_httpImportPromise) {
-		await _httpImportPromise;
-	}
-	if (_createServer) return _createServer;
-	throw new Error("Antigravity OAuth is only available in Node.js environments");
-}
-
-async function startCallbackServer(): Promise<CallbackServerInfo> {
-	const createServer = await getNodeCreateServer();
-
-	return new Promise((resolve, reject) => {
-		let result: { code: string; state: string } | null = null;
-		let cancelled = false;
-
-		const server = createServer((req, res) => {
-			const url = new URL(req.url || "", `http://localhost:51121`);
-
-			if (url.pathname === "/oauth-callback") {
-				const code = url.searchParams.get("code");
-				const state = url.searchParams.get("state");
-				const error = url.searchParams.get("error");
-
-				if (error) {
-					res.writeHead(400, { "Content-Type": "text/html" });
-					res.end(
-						`<html><body><h1>Authentication Failed</h1><p>Error: ${error}</p><p>You can close this window.</p></body></html>`,
-					);
-					return;
-				}
-
-				if (code && state) {
-					res.writeHead(200, { "Content-Type": "text/html" });
-					res.end(
-						`<html><body><h1>Authentication Successful</h1><p>You can close this window and return to the terminal.</p></body></html>`,
-					);
-					result = { code, state };
-				} else {
-					res.writeHead(400, { "Content-Type": "text/html" });
-					res.end(
-						`<html><body><h1>Authentication Failed</h1><p>Missing code or state parameter.</p></body></html>`,
-					);
-				}
-			} else {
-				res.writeHead(404);
-				res.end();
-			}
-		});
-
-		server.on("error", (err) => {
-			reject(err);
-		});
-
-		server.listen(51121, "127.0.0.1", () => {
-			resolve({
-				server,
-				cancelWait: () => {
-					cancelled = true;
-				},
-				waitForCode: async () => {
-					const sleep = () => new Promise((r) => setTimeout(r, 100));
-					while (!result && !cancelled) {
-						await sleep();
-					}
-					return result;
-				},
-			});
-		});
-	});
-}
-
-/**
- * Parse redirect URL to extract code and state
- */
-function parseRedirectUrl(input: string): { code?: string; state?: string } {
-	const value = input.trim();
-	if (!value) return {};
-
-	try {
-		const url = new URL(value);
-		return {
-			code: url.searchParams.get("code") ?? undefined,
-			state: url.searchParams.get("state") ?? undefined,
-		};
-	} catch {
-		// Not a URL, return empty
-		return {};
-	}
-}
-
 interface LoadCodeAssistPayload {
 	cloudaicompanionProject?: string | { id?: string };
 	currentTier?: { id?: string };
@@ -212,61 +114,11 @@ async function discoverProject(accessToken: string, onProgress?: (message: strin
 	return DEFAULT_PROJECT_ID;
 }
 
-/**
- * Get user email from the access token
- */
-async function getUserEmail(accessToken: string): Promise<string | undefined> {
-	try {
-		const response = await fetch("https://www.googleapis.com/oauth2/v1/userinfo?alt=json", {
-			headers: {
-				Authorization: `Bearer ${accessToken}`,
-			},
-			signal: AbortSignal.timeout(30_000),
-		});
-
-		if (response.ok) {
-			const data = (await response.json()) as { email?: string };
-			return data.email;
-		}
-	} catch {
-		// Ignore errors, email is optional
-	}
-	return undefined;
-}
-
 /**
  * Refresh Antigravity token
  */
 export async function refreshAntigravityToken(refreshToken: string, projectId: string): Promise<OAuthCredentials> {
-	const response = await fetch(TOKEN_URL, {
-		method: "POST",
-		headers: { "Content-Type": "application/x-www-form-urlencoded" },
-		body: new URLSearchParams({
-			client_id: CLIENT_ID,
-			client_secret: CLIENT_SECRET,
-			refresh_token: refreshToken,
-			grant_type: "refresh_token",
-		}),
-		signal: AbortSignal.timeout(30_000),
-	});
-
-	if (!response.ok) {
-		const error = await response.text();
-		throw new Error(`Antigravity token refresh failed: ${error}`);
-	}
-
-	const data = (await response.json()) as {
-		access_token: string;
-		expires_in: number;
-		refresh_token?: string;
-	};
-
-	return {
-		refresh: data.refresh_token || refreshToken,
-		access: data.access_token,
-		expires: Date.now() + data.expires_in * 1000 - 5 * 60 * 1000,
-		projectId,
-	};
+	return refreshGoogleOAuthToken(refreshToken, CLIENT_ID, CLIENT_SECRET, "Antigravity", { projectId });
 }
 
 /**
@@ -286,7 +138,7 @@ export async function loginAntigravity(
 
 	// Start local server for callback
 	onProgress?.("Starting local server for OAuth callback...");
-	const server = await startCallbackServer();
+	const server: CallbackServerInfo = await startCallbackServer(CALLBACK_PORT, CALLBACK_PATH, "Antigravity");
 
 	let code: string | undefined;
 
@@ -415,7 +267,7 @@ export async function loginAntigravity(
 
 		// Get user email
 		onProgress?.("Getting user info...");
-		const email = await getUserEmail(tokenData.access_token);
+		const email = await getGoogleUserEmail(tokenData.access_token);
 
 		// Discover project
 		const projectId = await discoverProject(tokenData.access_token, onProgress);