@oh-my-pi/pi-ai 18.2.6 → 18.2.7

package/src/providers/register-builtins.ts

@@ -1,27 +1,10 @@
 /**
- * Lazy provider module loading.
- *
- * Each provider module is loaded only when its stream function is first called.
- * This avoids eagerly importing heavy SDK dependencies (e.g., openai) at
- * startup. The loaded module promise is cached so subsequent calls
- * reuse the same import.
- *
- * NOTE: stream.ts currently imports providers directly, so this file is not yet
- * wired into the main streaming path. It provides the infrastructure for lazy
- * loading that can be integrated when stream.ts is refactored.
+ * Built-in provider stream dispatch with shared error, cancellation, and timeout handling.
  */
 
 import type { CompatOf } from "@oh-my-pi/pi-catalog/types";
 import * as AIError from "../error";
-import type {
-	Api,
-	AssistantMessage,
-	AssistantMessageEvent,
-	AssistantMessageEventStream,
-	Context,
-	Model,
-	OptionsForApi,
-} from "../types";
+import type { Api, AssistantMessage, AssistantMessageEvent, Context, Model, OptionsForApi } from "../types";
 import { type AbortSourceTracker, createAbortSourceTracker } from "../utils/abort";
 import { AssistantMessageEventStream as EventStreamImpl } from "../utils/event-stream";
 import {
@@ -31,156 +14,44 @@ import {
 	getStreamIdleTimeoutMs,
 	iterateWithIdleTimeout,
 } from "../utils/idle-iterator";
-import type { BedrockOptions } from "./amazon-bedrock";
-import type { AnthropicOptions } from "./anthropic";
-import type { AzureOpenAIResponsesOptions } from "./azure-openai-responses";
-import type { CursorOptions } from "./cursor";
-import type { DevinOptions } from "./devin";
-import type { GoogleOptions } from "./google";
-import type { GoogleGeminiCliOptions } from "./google-gemini-cli";
-import type { GoogleVertexOptions } from "./google-vertex";
-import type { OllamaChatOptions } from "./ollama";
-import type { OpenAICodexResponsesOptions } from "./openai-codex-responses";
-import type { OpenAICompletionsOptions } from "./openai-completions";
-import type { OpenAIResponsesOptions } from "./openai-responses";
-
-// ---------------------------------------------------------------------------
-// Lazy provider module shape
-// ---------------------------------------------------------------------------
-
-interface LazyProviderModule<TApi extends Api> {
-	stream: (model: Model<TApi>, context: Context, options: OptionsForApi<TApi>) => AsyncIterable<AssistantMessageEvent>;
-}
-
-interface AnthropicProviderModule {
-	streamAnthropic: (
-		model: Model<"anthropic-messages">,
-		context: Context,
-		options: AnthropicOptions,
-	) => AssistantMessageEventStream;
-}
-
-interface AzureOpenAIResponsesProviderModule {
-	streamAzureOpenAIResponses: (
-		model: Model<"azure-openai-responses">,
-		context: Context,
-		options: AzureOpenAIResponsesOptions,
-	) => AssistantMessageEventStream;
-}
-
-interface GoogleProviderModule {
-	streamGoogle: (
-		model: Model<"google-generative-ai">,
-		context: Context,
-		options: GoogleOptions,
-	) => AssistantMessageEventStream;
-}
-
-interface GoogleGeminiCliProviderModule {
-	streamGoogleGeminiCli: (
-		model: Model<"google-gemini-cli">,
-		context: Context,
-		options: GoogleGeminiCliOptions,
-	) => AssistantMessageEventStream;
-}
-
-interface GoogleVertexProviderModule {
-	streamGoogleVertex: (
-		model: Model<"google-vertex">,
-		context: Context,
-		options: GoogleVertexOptions,
-	) => AssistantMessageEventStream;
-}
-
-interface OpenAICodexResponsesProviderModule {
-	streamOpenAICodexResponses: (
-		model: Model<"openai-codex-responses">,
-		context: Context,
-		options: OpenAICodexResponsesOptions,
-	) => AssistantMessageEventStream;
-}
-
-interface OpenAICompletionsProviderModule {
-	streamOpenAICompletions: (
-		model: Model<"openai-completions">,
-		context: Context,
-		options: OpenAICompletionsOptions,
-	) => AssistantMessageEventStream;
-}
-
-interface OpenAIResponsesProviderModule {
-	streamOpenAIResponses: (
-		model: Model<"openai-responses">,
-		context: Context,
-		options: OpenAIResponsesOptions,
-	) => AssistantMessageEventStream;
-}
-
-interface OllamaProviderModule {
-	streamOllama: (
-		model: Model<"ollama-chat">,
-		context: Context,
-		options: OllamaChatOptions,
-	) => AssistantMessageEventStream;
-}
-
-interface CursorProviderModule {
-	streamCursor: (
-		model: Model<"cursor-agent">,
-		context: Context,
-		options: CursorOptions,
-	) => AssistantMessageEventStream;
-}
-
-interface DevinProviderModule {
-	streamDevin: (model: Model<"devin-agent">, context: Context, options: DevinOptions) => AssistantMessageEventStream;
-}
-
-interface BedrockProviderModule {
-	streamBedrock: (
-		model: Model<"bedrock-converse-stream">,
-		context: Context,
-		options: BedrockOptions,
-	) => AssistantMessageEventStream;
-}
-
-// ---------------------------------------------------------------------------
-// Module-level lazy promise caches
-// ---------------------------------------------------------------------------
+import * as AnthropicProvider from "./anthropic";
+import * as AzureOpenAIResponsesProvider from "./azure-openai-responses";
+import * as BedrockProvider from "./amazon-bedrock";
+import * as CursorProvider from "./cursor";
+import * as DevinProvider from "./devin";
+import * as GoogleProvider from "./google";
+import * as GoogleGeminiCliProvider from "./google-gemini-cli";
+import * as GoogleVertexProvider from "./google-vertex";
+import * as OllamaProvider from "./ollama";
+import * as OpenAICodexResponsesProvider from "./openai-codex-responses";
+import * as OpenAICompletionsProvider from "./openai-completions";
+import * as OpenAIResponsesProvider from "./openai-responses";
+
+type ProviderStream<TApi extends Api> = (
+	model: Model<TApi>,
+	context: Context,
+	options: OptionsForApi<TApi>,
+) => AsyncIterable<AssistantMessageEvent>;
 
-let anthropicProviderModulePromise: Promise<LazyProviderModule<"anthropic-messages">> | undefined;
-let azureOpenAIResponsesProviderModulePromise: Promise<LazyProviderModule<"azure-openai-responses">> | undefined;
-let googleProviderModulePromise: Promise<LazyProviderModule<"google-generative-ai">> | undefined;
-let googleGeminiCliProviderModulePromise: Promise<LazyProviderModule<"google-gemini-cli">> | undefined;
-let googleVertexProviderModulePromise: Promise<LazyProviderModule<"google-vertex">> | undefined;
-let openAICodexResponsesProviderModulePromise: Promise<LazyProviderModule<"openai-codex-responses">> | undefined;
-let openAICompletionsProviderModulePromise: Promise<LazyProviderModule<"openai-completions">> | undefined;
-let openAIResponsesProviderModulePromise: Promise<LazyProviderModule<"openai-responses">> | undefined;
-let ollamaProviderModulePromise: Promise<LazyProviderModule<"ollama-chat">> | undefined;
-let cursorProviderModulePromise: Promise<LazyProviderModule<"cursor-agent">> | undefined;
-let cursorProviderModuleOverride: LazyProviderModule<"cursor-agent"> | undefined;
-let devinProviderModulePromise: Promise<LazyProviderModule<"devin-agent">> | undefined;
-let bedrockProviderModuleOverride: LazyProviderModule<"bedrock-converse-stream"> | undefined;
-let bedrockProviderModulePromise: Promise<LazyProviderModule<"bedrock-converse-stream">> | undefined;
+let cursorStreamOverride: typeof CursorProvider.streamCursor | undefined;
+let bedrockStreamOverride: typeof BedrockProvider.streamBedrock | undefined;
 
-export function setBedrockProviderModule(module: BedrockProviderModule): void {
-	bedrockProviderModuleOverride = {
-		stream: module.streamBedrock,
-	};
+/** Install a host-supplied Bedrock transport in place of the built-in provider. */
+export function setBedrockProviderModule(module: Pick<typeof BedrockProvider, "streamBedrock">): void {
+	bedrockStreamOverride = module.streamBedrock;
 }
 
-export function setCursorProviderModule(module: CursorProviderModule): void {
-	cursorProviderModuleOverride = {
-		stream: module.streamCursor,
-	};
+/** Install a host-supplied Cursor transport in place of the built-in provider. */
+export function setCursorProviderModule(module: Pick<typeof CursorProvider, "streamCursor">): void {
+	cursorStreamOverride = module.streamCursor;
 }
 
 // ---------------------------------------------------------------------------
 // Stream forwarding / error helpers
 // ---------------------------------------------------------------------------
 
-const LAZY_STREAM_IDLE_TIMEOUT_ERROR = "Provider stream stalled while waiting for the next event";
-const LAZY_STREAM_FIRST_EVENT_TIMEOUT_ERROR = "Provider stream timed out while waiting for the first event";
+const STREAM_IDLE_TIMEOUT_ERROR = "Provider stream stalled while waiting for the next event";
+const STREAM_FIRST_EVENT_TIMEOUT_ERROR = "Provider stream timed out while waiting for the first event";
 
 function hasFinalResult(
 	source: AsyncIterable<AssistantMessageEvent>,
@@ -194,21 +65,21 @@ function hasFinalResult(
  * take precedence unless a provider opts into OpenAI-family idle flooring for
  * local backends that users historically tuned with `PI_OPENAI_STREAM_IDLE_TIMEOUT_MS`.
  */
-interface LazyStreamLimits {
+interface StreamLimits {
 	defaultFirstEventTimeoutMs?: number;
 	defaultIdleTimeoutMs?: number;
 	/**
 	 * The provider implementation already wraps its upstream transport with
-	 * stream timeouts. Keep the lazy loader from racing it with generic errors.
+	 * stream timeouts. Keep the shared watchdog from racing it with generic errors.
 	 */
 	providerHandlesStreamTimeouts?: boolean;
 	/**
 	 * The provider retries or fails over when no first event arrives, while the
-	 * lazy wrapper continues to own steady-state idle detection.
+	 * shared wrapper continues to own steady-state idle detection.
 	 */
 	providerHandlesFirstEventTimeouts?: boolean;
 	/**
-	 * Apply OpenAI-family idle timeout precedence in the lazy wrapper. Used by
+	 * Apply OpenAI-family idle timeout precedence in the shared wrapper. Used by
 	 * local backends whose users historically tune slow prompt-processing gaps
 	 * with `PI_OPENAI_STREAM_IDLE_TIMEOUT_MS`.
 	 */
@@ -217,18 +88,18 @@ interface LazyStreamLimits {
 /**
  * Cloud Code Assist owns first-event detection because Antigravity can return
  * successful headers and then never emit an SSE event. Keeping the watchdog in
- * the provider lets it fail over before surfacing an error; the lazy wrapper
+ * the provider lets it fail over before surfacing an error; the shared wrapper
  * still catches post-first-event stalls.
  */
-const GOOGLE_GEMINI_CLI_LAZY_STREAM_LIMITS: LazyStreamLimits = {
+const GOOGLE_GEMINI_CLI_STREAM_LIMITS: StreamLimits = {
 	providerHandlesFirstEventTimeouts: true,
 };
 
-const PROVIDER_HANDLED_STREAM_TIMEOUTS: LazyStreamLimits = {
+const PROVIDER_HANDLED_STREAM_TIMEOUTS: StreamLimits = {
 	providerHandlesStreamTimeouts: true,
 };
 
-const OPENAI_IDLE_FLOORED_LAZY_STREAM_LIMITS: LazyStreamLimits = {
+const OPENAI_IDLE_FLOORED_STREAM_LIMITS: StreamLimits = {
 	openAIIdleEnvFloorsFirstEvent: true,
 };
 
@@ -238,7 +109,7 @@ function forwardStream<TApi extends Api>(
 	model: Model<TApi>,
 	options: OptionsForApi<TApi>,
 	abortTracker: AbortSourceTracker,
-	limits?: LazyStreamLimits,
+	limits?: StreamLimits,
 ): void {
 	(async () => {
 		try {
@@ -275,11 +146,11 @@ function forwardStream<TApi extends Api>(
 			const watchedSource = iterateWithIdleTimeout(source, {
 				idleTimeoutMs,
 				firstItemTimeoutMs,
-				errorMessage: LAZY_STREAM_IDLE_TIMEOUT_ERROR,
-				firstItemErrorMessage: LAZY_STREAM_FIRST_EVENT_TIMEOUT_ERROR,
-				onIdle: () => abortTracker.abortLocally(new AIError.StreamTimeoutError(LAZY_STREAM_IDLE_TIMEOUT_ERROR)),
+				errorMessage: STREAM_IDLE_TIMEOUT_ERROR,
+				firstItemErrorMessage: STREAM_FIRST_EVENT_TIMEOUT_ERROR,
+				onIdle: () => abortTracker.abortLocally(new AIError.StreamTimeoutError(STREAM_IDLE_TIMEOUT_ERROR)),
 				onFirstItemTimeout: () =>
-					abortTracker.abortLocally(new AIError.StreamTimeoutError(LAZY_STREAM_FIRST_EVENT_TIMEOUT_ERROR)),
+					abortTracker.abortLocally(new AIError.StreamTimeoutError(STREAM_FIRST_EVENT_TIMEOUT_ERROR)),
 				abortSignal: options.signal,
 				// The synthetic `start` event is yielded immediately by every provider before
 				// the upstream model has emitted any tokens. Treating it as the first "real"
@@ -300,14 +171,14 @@ function forwardStream<TApi extends Api>(
 			}
 		} catch (error) {
 			const stopReason = abortTracker.wasCallerAbort() ? "aborted" : "error";
-			const message = createLazyLoadErrorMessage(model, error, stopReason);
+			const message = createProviderStreamError(model, error, stopReason);
 			target.push({ type: "error", reason: stopReason, error: message });
 			target.end(message);
 		}
 	})();
 }
 
-function createLazyLoadErrorMessage<TApi extends Api>(
+function createProviderStreamError<TApi extends Api>(
 	model: Model<TApi>,
 	error: unknown,
 	stopReason: Extract<AssistantMessage["stopReason"], "aborted" | "error"> = "error",
@@ -335,173 +206,95 @@ function createLazyLoadErrorMessage<TApi extends Api>(
 }
 
 // ---------------------------------------------------------------------------
-// Generic lazy stream factory
+// Provider stream wrapper
 // ---------------------------------------------------------------------------
 
-function createLazyStream<TApi extends Api>(
-	loadModule: () => Promise<LazyProviderModule<TApi>>,
-	limits?: LazyStreamLimits,
+function createProviderStream<TApi extends Api>(
+	stream: ProviderStream<TApi>,
+	limits?: StreamLimits,
 ): (model: Model<TApi>, context: Context, options: OptionsForApi<TApi>) => EventStreamImpl {
 	return (model, context, options) => {
 		const outer = new EventStreamImpl();
-		const streamOptions = (options ?? {}) as OptionsForApi<TApi>;
+		const streamOptions: OptionsForApi<TApi> = options ?? {};
 
-		loadModule()
-			.then(module => {
-				const abortTracker = createAbortSourceTracker(streamOptions.signal);
-				const providerOptions = { ...streamOptions, signal: abortTracker.requestSignal } as OptionsForApi<TApi>;
-				const inner = module.stream(model, context, providerOptions);
-				forwardStream(outer, inner, model, streamOptions, abortTracker, limits);
-			})
-			.catch(error => {
-				const message = createLazyLoadErrorMessage(model, error);
-				outer.push({ type: "error", reason: "error", error: message });
-				outer.end(message);
-			});
+		try {
+			const abortTracker = createAbortSourceTracker(streamOptions.signal);
+			const providerOptions: OptionsForApi<TApi> = { ...streamOptions, signal: abortTracker.requestSignal };
+			const inner = stream(model, context, providerOptions);
+			forwardStream(outer, inner, model, streamOptions, abortTracker, limits);
+		} catch (error) {
+			const message = createProviderStreamError(model, error);
+			outer.push({ type: "error", reason: "error", error: message });
+			outer.end(message);
+		}
 
 		return outer;
 	};
 }
 
-// ---------------------------------------------------------------------------
-// Module loaders (one per provider, cached via ||=)
-// ---------------------------------------------------------------------------
-
-function loadAnthropicProviderModule(): Promise<LazyProviderModule<"anthropic-messages">> {
-	anthropicProviderModulePromise ||= import("./anthropic").then(module => {
-		const provider = module as AnthropicProviderModule;
-		return { stream: provider.streamAnthropic };
-	});
-	return anthropicProviderModulePromise;
-}
-
-function loadAzureOpenAIResponsesProviderModule(): Promise<LazyProviderModule<"azure-openai-responses">> {
-	azureOpenAIResponsesProviderModulePromise ||= import("./azure-openai-responses").then(module => {
-		const provider = module as AzureOpenAIResponsesProviderModule;
-		return { stream: provider.streamAzureOpenAIResponses };
-	});
-	return azureOpenAIResponsesProviderModulePromise;
-}
-
-function loadGoogleProviderModule(): Promise<LazyProviderModule<"google-generative-ai">> {
-	googleProviderModulePromise ||= import("./google").then(module => {
-		const provider = module as GoogleProviderModule;
-		return { stream: provider.streamGoogle };
-	});
-	return googleProviderModulePromise;
-}
-
-function loadGoogleGeminiCliProviderModule(): Promise<LazyProviderModule<"google-gemini-cli">> {
-	googleGeminiCliProviderModulePromise ||= import("./google-gemini-cli").then(module => {
-		const provider = module as GoogleGeminiCliProviderModule;
-		return { stream: provider.streamGoogleGeminiCli };
-	});
-	return googleGeminiCliProviderModulePromise;
-}
-
-function loadGoogleVertexProviderModule(): Promise<LazyProviderModule<"google-vertex">> {
-	googleVertexProviderModulePromise ||= import("./google-vertex").then(module => {
-		const provider = module as GoogleVertexProviderModule;
-		return { stream: provider.streamGoogleVertex };
-	});
-	return googleVertexProviderModulePromise;
-}
-
-function loadOpenAICodexResponsesProviderModule(): Promise<LazyProviderModule<"openai-codex-responses">> {
-	openAICodexResponsesProviderModulePromise ||= import("./openai-codex-responses").then(module => {
-		const provider = module as OpenAICodexResponsesProviderModule;
-		return { stream: provider.streamOpenAICodexResponses };
-	});
-	return openAICodexResponsesProviderModulePromise;
-}
-
-function loadOpenAICompletionsProviderModule(): Promise<LazyProviderModule<"openai-completions">> {
-	openAICompletionsProviderModulePromise ||= import("./openai-completions").then(module => {
-		const provider = module as OpenAICompletionsProviderModule;
-		return { stream: provider.streamOpenAICompletions };
-	});
-	return openAICompletionsProviderModulePromise;
-}
-
-function loadOpenAIResponsesProviderModule(): Promise<LazyProviderModule<"openai-responses">> {
-	openAIResponsesProviderModulePromise ||= import("./openai-responses").then(module => {
-		const provider = module as OpenAIResponsesProviderModule;
-		return { stream: provider.streamOpenAIResponses };
-	});
-	return openAIResponsesProviderModulePromise;
-}
-
-function loadOllamaProviderModule(): Promise<LazyProviderModule<"ollama-chat">> {
-	ollamaProviderModulePromise ||= import("./ollama").then(module => {
-		const provider = module as OllamaProviderModule;
-		return { stream: provider.streamOllama };
-	});
-	return ollamaProviderModulePromise;
-}
+/** Stream Anthropic responses with provider-owned timeout handling. */
+export const streamAnthropic = createProviderStream<"anthropic-messages">(
+	(model, context, options) => AnthropicProvider.streamAnthropic(model, context, options),
+	PROVIDER_HANDLED_STREAM_TIMEOUTS,
+);
 
-function loadCursorProviderModule(): Promise<LazyProviderModule<"cursor-agent">> {
-	if (cursorProviderModuleOverride) {
-		return Promise.resolve(cursorProviderModuleOverride);
-	}
-	cursorProviderModulePromise ||= import("./cursor").then(module => {
-		const provider = module as CursorProviderModule;
-		return { stream: provider.streamCursor };
-	});
-	return cursorProviderModulePromise;
-}
+/** Stream Azure Responses with provider-owned timeout handling. */
+export const streamAzureOpenAIResponses = createProviderStream<"azure-openai-responses">(
+	(model, context, options) => AzureOpenAIResponsesProvider.streamAzureOpenAIResponses(model, context, options),
+	PROVIDER_HANDLED_STREAM_TIMEOUTS,
+);
 
-function loadDevinProviderModule(): Promise<LazyProviderModule<"devin-agent">> {
-	devinProviderModulePromise ||= import("./devin").then(module => {
-		const provider = module as DevinProviderModule;
-		return { stream: provider.streamDevin };
-	});
-	return devinProviderModulePromise;
-}
+/** Stream Google's direct API through the shared watchdog. */
+export const streamGoogle = createProviderStream<"google-generative-ai">((model, context, options) =>
+	GoogleProvider.streamGoogle(model, context, options),
+);
 
-function loadBedrockProviderModule(): Promise<LazyProviderModule<"bedrock-converse-stream">> {
-	if (bedrockProviderModuleOverride) {
-		return Promise.resolve(bedrockProviderModuleOverride);
-	}
-	bedrockProviderModulePromise ||= import("./amazon-bedrock").then(module => {
-		const provider = module as BedrockProviderModule;
-		return { stream: provider.streamBedrock };
-	});
-	return bedrockProviderModulePromise;
-}
+/** Stream Cloud Code Assist while retaining its first-event watchdog. */
+export const streamGoogleGeminiCli = createProviderStream<"google-gemini-cli">(
+	(model, context, options) => GoogleGeminiCliProvider.streamGoogleGeminiCli(model, context, options),
+	GOOGLE_GEMINI_CLI_STREAM_LIMITS,
+);
 
-// ---------------------------------------------------------------------------
-// Lazy stream function exports
-//
-// These use the same names as the direct provider stream functions. When
-// stream.ts is updated to import from this module instead of individual
-// providers, the lazy loading will take effect on the main code path.
-// ---------------------------------------------------------------------------
+/** Stream the Vertex API through the shared watchdog. */
+export const streamGoogleVertex = createProviderStream<"google-vertex">((model, context, options) =>
+	GoogleVertexProvider.streamGoogleVertex(model, context, options),
+);
 
-export const streamAnthropic = createLazyStream(loadAnthropicProviderModule, PROVIDER_HANDLED_STREAM_TIMEOUTS);
-export const streamAzureOpenAIResponses = createLazyStream(
-	loadAzureOpenAIResponsesProviderModule,
+/** Stream Codex with provider-owned timeout handling. */
+export const streamOpenAICodexResponses = createProviderStream<"openai-codex-responses">(
+	(model, context, options) => OpenAICodexResponsesProvider.streamOpenAICodexResponses(model, context, options),
 	PROVIDER_HANDLED_STREAM_TIMEOUTS,
 );
-export const streamGoogle = createLazyStream(loadGoogleProviderModule);
-export const streamGoogleGeminiCli = createLazyStream(
-	loadGoogleGeminiCliProviderModule,
-	GOOGLE_GEMINI_CLI_LAZY_STREAM_LIMITS,
-);
-export const streamGoogleVertex = createLazyStream(loadGoogleVertexProviderModule);
-export const streamOpenAICodexResponses = createLazyStream(
-	loadOpenAICodexResponsesProviderModule,
+
+/** Stream Chat Completions with provider-owned timeout handling. */
+export const streamOpenAICompletions = createProviderStream<"openai-completions">(
+	(model, context, options) => OpenAICompletionsProvider.streamOpenAICompletions(model, context, options),
 	PROVIDER_HANDLED_STREAM_TIMEOUTS,
 );
-export const streamOpenAICompletions = createLazyStream(
-	loadOpenAICompletionsProviderModule,
+
+/** Stream Responses with provider-owned timeout handling. */
+export const streamOpenAIResponses = createProviderStream<"openai-responses">(
+	(model, context, options) => OpenAIResponsesProvider.streamOpenAIResponses(model, context, options),
 	PROVIDER_HANDLED_STREAM_TIMEOUTS,
 );
-export const streamOpenAIResponses = createLazyStream(
-	loadOpenAIResponsesProviderModule,
-	PROVIDER_HANDLED_STREAM_TIMEOUTS,
+
+/** Stream through the host Cursor transport when installed, otherwise the built-in transport. */
+export const streamCursor = createProviderStream<"cursor-agent">((model, context, options) =>
+	(cursorStreamOverride ?? CursorProvider.streamCursor)(model, context, options),
 );
-export const streamCursor = createLazyStream(loadCursorProviderModule);
-export const streamDevin = createLazyStream(loadDevinProviderModule);
-export const streamOllama = createLazyStream(loadOllamaProviderModule, OPENAI_IDLE_FLOORED_LAZY_STREAM_LIMITS);
 
-export const streamBedrock = createLazyStream(loadBedrockProviderModule);
+/** Stream Devin through the shared watchdog. */
+export const streamDevin = createProviderStream<"devin-agent">((model, context, options) =>
+	DevinProvider.streamDevin(model, context, options),
+);
+
+/** Stream Ollama with OpenAI-compatible idle timeout precedence. */
+export const streamOllama = createProviderStream<"ollama-chat">(
+	(model, context, options) => OllamaProvider.streamOllama(model, context, options),
+	OPENAI_IDLE_FLOORED_STREAM_LIMITS,
+);
+
+/** Stream through the host Bedrock transport when installed, otherwise the built-in transport. */
+export const streamBedrock = createProviderStream<"bedrock-converse-stream">((model, context, options) =>
+	(bedrockStreamOverride ?? BedrockProvider.streamBedrock)(model, context, options),
+);

package/src/providers/synthetic.ts

@@ -8,7 +8,7 @@
  * @see https://dev.synthetic.new/docs/api/overview
  */
 
-import type { Api, Context, Model } from "../types";
+import type { Context, Model } from "../types";
 import type { AssistantMessageEventStream } from "../utils/event-stream";
 import {
 	type OpenAIAnthropicApiFormat,
@@ -41,10 +41,3 @@ export function streamSynthetic(
 		defaultFormat: "openai",
 	});
 }
-
-/**
- * Check if a model is a Synthetic model.
- */
-export function isSyntheticModel(model: Model<Api>): boolean {
-	return model.provider === "synthetic";
-}

package/src/registry/cloudflare-ai-gateway.ts

@@ -8,8 +8,8 @@ import {
 	parseCloudflareAiGatewayCredential,
 } from "@oh-my-pi/pi-catalog/wire/cloudflare-ai-gateway";
 import { $env } from "@oh-my-pi/pi-utils";
+import { NO_AUTH_SENTINEL } from "../auth-retry";
 import * as AIError from "../error";
-import { NO_AUTH_SENTINEL } from "../providers/openai-shared";
 import type { ProviderTransport } from "./build";
 
 /** Cloudflare AI Gateway model/request shaping; login lives in `oauth/cloudflare-ai-gateway.ts` + its auth rule. */

package/src/stream.ts

@@ -26,24 +26,17 @@ import type { AnthropicOptions } from "./providers/anthropic";
 import type { MessageCreateParamsStreaming } from "./providers/anthropic-wire";
 import type { CursorOptions } from "./providers/cursor";
 import type { DevinOptions } from "./providers/devin";
-import { isGitLabDuoModel, streamGitLabDuo } from "./providers/gitlab-duo";
+import { streamGitLabDuo } from "./providers/gitlab-duo";
 import { type GitLabDuoWorkflowOptions, streamGitLabDuoWorkflow } from "./providers/gitlab-duo-workflow";
 import type { GoogleOptions } from "./providers/google";
 import { getVertexAccessToken } from "./providers/google-auth";
 import type { GoogleGeminiCliOptions } from "./providers/google-gemini-cli";
 import type { GoogleVertexOptions } from "./providers/google-vertex";
-import { isKimiModel, streamKimi } from "./providers/kimi";
+import { streamKimi } from "./providers/kimi";
 import type { OllamaChatOptions } from "./providers/ollama";
 import type { OpenAICompletionsOptions } from "./providers/openai-completions";
 import { streamPiNative } from "./providers/pi-native-client";
-// Heavy provider stream functions are imported lazily via register-builtins,
-// which wraps each provider module in a dynamic import. This keeps the
-// AWS SDK, google-auth-library, @google/genai, and
-// other provider SDKs out of the CLI startup parse graph. The
-// gitlab-duo / kimi / synthetic providers stay eager because their modules
-// export routing predicates (isGitLabDuoModel, isKimiModel, isSyntheticModel)
-// that must be callable synchronously before streaming begins, and their
-// modules are thin wrappers with no heavy SDK dependencies.
+import { streamSynthetic } from "./providers/synthetic";
 import {
 	streamAnthropic,
 	streamAzureOpenAIResponses,
@@ -58,7 +51,6 @@ import {
 	streamOpenAICompletions,
 	streamOpenAIResponses,
 } from "./providers/register-builtins";
-import { isSyntheticModel, streamSynthetic } from "./providers/synthetic";
 import { getProviderDefinition, PROVIDER_REGISTRY } from "./registry";
 import type {
 	Api,
@@ -953,7 +945,7 @@ function streamDispatch<TApi extends Api>(
 		return customApiProvider.stream(model, context, requestOptions as StreamOptions);
 	}
 
-	if (isGitLabDuoModel(model)) {
+	if (model.provider === "gitlab-duo") {
 		const apiKey = requestOptions.apiKey || getEnvApiKey(model.provider);
 		if (!apiKey) {
 			throw new AIError.MissingApiKeyError(model.provider);
@@ -1725,7 +1717,7 @@ function streamSimpleRequest<TApi extends Api>(
 	}
 
 	// GitLab Duo - wraps Anthropic/OpenAI behind GitLab AI Gateway direct access tokens
-	if (isGitLabDuoModel(model)) {
+	if (model.provider === "gitlab-duo") {
 		return withThinkingLoopGuard(model, requestOptions, opts =>
 			withProviderInFlightLimit(model, opts, () =>
 				streamGitLabDuo(model, context, {
@@ -1751,7 +1743,7 @@ function streamSimpleRequest<TApi extends Api>(
 	}
 
 	// Kimi Code - route to dedicated handler that wraps OpenAI or Anthropic API
-	if (isKimiModel(model)) {
+	if (model.provider === "kimi-code") {
 		// streamKimi handles openai/anthropic format mapping internally, but the
 		// mandatory-reasoning clamp is a request-shaping concern owned here: K3's
 		// `supports_thinking_type: "only"` endpoint rejects disabled/omitted
@@ -1770,7 +1762,7 @@ function streamSimpleRequest<TApi extends Api>(
 	}
 
 	// Synthetic - route to dedicated handler that wraps OpenAI or Anthropic API
-	if (isSyntheticModel(model)) {
+	if (model.provider === "synthetic") {
 		// Pass raw SimpleStreamOptions - streamSynthetic handles mapping internally.
 		return withThinkingLoopGuard(model, requestOptions, opts =>
 			withProviderInFlightLimit(model, opts, () =>