@steipete/summarize 0.7.1 → 0.8.1

package/dist/esm/llm/generate-text.js

@@ -1,9 +1,5 @@
+import { completeSimple, getModel, streamSimple } from '@mariozechner/pi-ai';
 import { parseGatewayStyleModelId } from './model-id.js';
-function assertNonEmptyText(text, modelId) {
-    if (text.trim().length > 0)
-        return;
-    throw new Error(`LLM returned an empty summary (model ${modelId}).`);
-}
 function parseAnthropicErrorPayload(responseBody) {
     try {
         const parsed = JSON.parse(responseBody);
@@ -48,25 +44,20 @@ function normalizeTokenUsage(raw) {
     if (!raw || typeof raw !== 'object')
         return null;
     const usage = raw;
-    const promptTokens = typeof usage.promptTokens === 'number' && Number.isFinite(usage.promptTokens)
-        ? usage.promptTokens
-        : typeof usage.inputTokens === 'number' && Number.isFinite(usage.inputTokens)
-            ? usage.inputTokens
-            : null;
-    const completionTokens = typeof usage.completionTokens === 'number' && Number.isFinite(usage.completionTokens)
-        ? usage.completionTokens
-        : typeof usage.outputTokens === 'number' && Number.isFinite(usage.outputTokens)
-            ? usage.outputTokens
-            : null;
+    const promptTokens = typeof usage.input === 'number' && Number.isFinite(usage.input) ? usage.input : null;
+    const completionTokens = typeof usage.output === 'number' && Number.isFinite(usage.output) ? usage.output : null;
     const totalTokens = typeof usage.totalTokens === 'number' && Number.isFinite(usage.totalTokens)
         ? usage.totalTokens
         : null;
-    if (promptTokens === null && completionTokens === null && totalTokens === null) {
+    if (promptTokens === null && completionTokens === null && totalTokens === null)
         return null;
-    }
     return { promptTokens, completionTokens, totalTokens };
 }
-function resolveOpenAiClientConfig({ apiKeys, fetchImpl, forceOpenRouter, openaiBaseUrlOverride, forceChatCompletions, }) {
+function resolveBaseUrlOverride(raw) {
+    const trimmed = typeof raw === 'string' ? raw.trim() : '';
+    return trimmed.length > 0 ? trimmed : null;
+}
+function resolveOpenAiClientConfig({ apiKeys, forceOpenRouter, openaiBaseUrlOverride, forceChatCompletions, }) {
     const baseUrlRaw = openaiBaseUrlOverride ??
         (typeof process !== 'undefined' ? process.env.OPENAI_BASE_URL : undefined);
     const baseUrl = typeof baseUrlRaw === 'string' && baseUrlRaw.trim().length > 0 ? baseUrlRaw.trim() : null;
@@ -84,53 +75,221 @@ function resolveOpenAiClientConfig({ apiKeys, fetchImpl, forceOpenRouter, openai
             ? 'Missing OPENROUTER_API_KEY (or OPENAI_API_KEY) for OpenRouter'
             : 'Missing OPENAI_API_KEY for openai/... model');
     }
-    const wrappedFetch = isOpenRouter
-        ? (url, init) => {
-            const headers = new Headers(init?.headers);
-            headers.set('HTTP-Referer', 'https://github.com/steipete/summarize');
-            headers.set('X-Title', 'summarize');
-            return fetchImpl(url, { ...init, headers });
-        }
-        : fetchImpl;
     const baseURL = forceOpenRouter
         ? 'https://openrouter.ai/api/v1'
         : (baseUrl ?? (isOpenRouter ? 'https://openrouter.ai/api/v1' : undefined));
-    const useChatCompletions = Boolean(forceChatCompletions) || isOpenRouter;
+    const isCustomBaseURL = (() => {
+        if (!baseURL)
+            return false;
+        try {
+            const url = new URL(baseURL);
+            return url.host !== 'api.openai.com' && url.host !== 'openrouter.ai';
+        }
+        catch {
+            return false;
+        }
+    })();
+    const useChatCompletions = Boolean(forceChatCompletions) || isOpenRouter || isCustomBaseURL;
     return {
         apiKey,
         baseURL: baseURL ?? undefined,
-        fetch: wrappedFetch,
         useChatCompletions,
         isOpenRouter,
     };
 }
-export async function generateTextWithModelId({ modelId, apiKeys, system, prompt, temperature, maxOutputTokens, timeoutMs, fetchImpl, forceOpenRouter, openaiBaseUrlOverride, forceChatCompletions, retries = 0, onRetry, }) {
+function promptToContext({ system, prompt }) {
+    const messages = typeof prompt === 'string'
+        ? [{ role: 'user', content: prompt, timestamp: Date.now() }]
+        : prompt.map((msg) => typeof msg.timestamp === 'number'
+            ? msg
+            : { ...msg, timestamp: Date.now() });
+    return { systemPrompt: system, messages };
+}
+function extractText(message) {
+    const text = message.content
+        .filter((c) => c.type === 'text')
+        .map((c) => c.text)
+        .join('');
+    return text.trim();
+}
+function wantsImages(context) {
+    for (const msg of context.messages) {
+        if (msg.role === 'user' || msg.role === 'toolResult') {
+            if (Array.isArray(msg.content) && msg.content.some((c) => c.type === 'image'))
+                return true;
+        }
+    }
+    return false;
+}
+function tryGetModel(provider, modelId) {
+    try {
+        return getModel(provider, modelId);
+    }
+    catch {
+        return null;
+    }
+}
+function createSyntheticModel({ provider, modelId, api, baseUrl, allowImages, headers, }) {
+    return {
+        id: modelId,
+        name: `${provider}/${modelId}`,
+        api,
+        provider,
+        baseUrl,
+        reasoning: false,
+        input: allowImages ? ['text', 'image'] : ['text'],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: 128_000,
+        maxTokens: 16_384,
+        ...(headers ? { headers } : {}),
+    };
+}
+function resolveModelForCall({ modelId, parsedProvider, openaiConfig, context, openaiBaseUrlOverride, anthropicBaseUrlOverride, googleBaseUrlOverride, xaiBaseUrlOverride, }) {
+    const allowImages = wantsImages(context);
+    if (parsedProvider === 'openai') {
+        const base = tryGetModel('openai', modelId);
+        const api = openaiConfig?.useChatCompletions ? 'openai-completions' : 'openai-responses';
+        const baseUrl = openaiConfig?.baseURL ?? base?.baseUrl ?? 'https://api.openai.com/v1';
+        const headers = openaiConfig?.isOpenRouter
+            ? {
+                ...(base?.headers ?? {}),
+                'HTTP-Referer': 'https://github.com/steipete/summarize',
+                'X-Title': 'summarize',
+            }
+            : base?.headers;
+        return {
+            ...(base ?? createSyntheticModel({ provider: 'openai', modelId, api, baseUrl, allowImages })),
+            api,
+            baseUrl,
+            ...(headers ? { headers } : {}),
+        };
+    }
+    if (parsedProvider === 'zai') {
+        const base = tryGetModel('zai', modelId);
+        const api = 'openai-completions';
+        const baseUrl = openaiBaseUrlOverride ??
+            base?.baseUrl ??
+            openaiConfig?.baseURL ??
+            'https://api.z.ai/api/paas/v4';
+        return {
+            ...(base ?? createSyntheticModel({ provider: 'zai', modelId, api, baseUrl, allowImages })),
+            api,
+            baseUrl,
+            input: allowImages ? ['text', 'image'] : ['text'],
+        };
+    }
+    if (parsedProvider === 'xai') {
+        const base = tryGetModel('xai', modelId);
+        const override = resolveBaseUrlOverride(xaiBaseUrlOverride);
+        if (override) {
+            return {
+                ...(base ??
+                    createSyntheticModel({
+                        provider: 'xai',
+                        modelId,
+                        api: 'openai-completions',
+                        baseUrl: override,
+                        allowImages,
+                    })),
+                baseUrl: override,
+            };
+        }
+        return (base ??
+            createSyntheticModel({
+                provider: 'xai',
+                modelId,
+                api: 'openai-completions',
+                baseUrl: 'https://api.x.ai/v1',
+                allowImages,
+            }));
+    }
+    if (parsedProvider === 'google') {
+        const base = tryGetModel('google', modelId);
+        const override = resolveBaseUrlOverride(googleBaseUrlOverride);
+        if (override) {
+            return {
+                ...(base ??
+                    createSyntheticModel({
+                        provider: 'google',
+                        modelId,
+                        api: 'google-generative-ai',
+                        baseUrl: override,
+                        allowImages,
+                    })),
+                baseUrl: override,
+            };
+        }
+        return (base ??
+            createSyntheticModel({
+                provider: 'google',
+                modelId,
+                api: 'google-generative-ai',
+                baseUrl: 'https://generativelanguage.googleapis.com/v1beta',
+                allowImages,
+            }));
+    }
+    const base = tryGetModel('anthropic', modelId);
+    const override = resolveBaseUrlOverride(anthropicBaseUrlOverride);
+    if (override) {
+        return {
+            ...(base ??
+                createSyntheticModel({
+                    provider: 'anthropic',
+                    modelId,
+                    api: 'anthropic-messages',
+                    baseUrl: override,
+                    allowImages,
+                })),
+            baseUrl: override,
+        };
+    }
+    return (base ??
+        createSyntheticModel({
+            provider: 'anthropic',
+            modelId,
+            api: 'anthropic-messages',
+            baseUrl: 'https://api.anthropic.com',
+            allowImages,
+        }));
+}
+export async function generateTextWithModelId({ modelId, apiKeys, system, prompt, temperature, maxOutputTokens, timeoutMs, fetchImpl: _fetchImpl, forceOpenRouter, openaiBaseUrlOverride, anthropicBaseUrlOverride, googleBaseUrlOverride, xaiBaseUrlOverride, forceChatCompletions, retries = 0, onRetry, }) {
+    void _fetchImpl;
     const parsed = parseGatewayStyleModelId(modelId);
+    const context = promptToContext({ system, prompt });
+    const isOpenaiGpt5 = parsed.provider === 'openai' && /^gpt-5([-.].+)?$/i.test(parsed.model);
+    const effectiveTemperature = typeof temperature === 'number' && !(isOpenaiGpt5 && temperature === 0)
+        ? temperature
+        : undefined;
     const maxRetries = Math.max(0, retries);
     let attempt = 0;
     while (attempt <= maxRetries) {
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), timeoutMs);
         try {
-            const { generateText } = await import('ai');
-            const shouldSendMaxOutputTokens = () => typeof maxOutputTokens === 'number';
             if (parsed.provider === 'xai') {
                 const apiKey = apiKeys.xaiApiKey;
                 if (!apiKey)
                     throw new Error('Missing XAI_API_KEY for xai/... model');
-                const { createXai } = await import('@ai-sdk/xai');
-                const xai = createXai({ apiKey, fetch: fetchImpl });
-                const result = await generateText({
-                    model: xai(parsed.model),
-                    system,
-                    ...(typeof prompt === 'string' ? { prompt } : { messages: prompt }),
-                    ...(typeof temperature === 'number' ? { temperature } : {}),
-                    ...(shouldSendMaxOutputTokens() ? { maxOutputTokens } : {}),
-                    abortSignal: controller.signal,
+                const model = resolveModelForCall({
+                    modelId: parsed.model,
+                    parsedProvider: parsed.provider,
+                    openaiConfig: null,
+                    context,
+                    xaiBaseUrlOverride,
+                });
+                const result = await completeSimple(model, context, {
+                    ...(typeof effectiveTemperature === 'number'
+                        ? { temperature: effectiveTemperature }
+                        : {}),
+                    ...(typeof maxOutputTokens === 'number' ? { maxTokens: maxOutputTokens } : {}),
+                    apiKey,
+                    signal: controller.signal,
                 });
-                assertNonEmptyText(result.text, parsed.canonical);
+                const text = extractText(result);
+                if (!text)
+                    throw new Error(`LLM returned an empty summary (model ${parsed.canonical}).`);
                 return {
-                    text: result.text,
+                    text,
                     canonicalModelId: parsed.canonical,
                     provider: parsed.provider,
                     usage: normalizeTokenUsage(result.usage),
@@ -140,19 +299,26 @@ export async function generateTextWithModelId({ modelId, apiKeys, system, prompt
                 const apiKey = apiKeys.googleApiKey;
                 if (!apiKey)
                     throw new Error('Missing GEMINI_API_KEY (or GOOGLE_GENERATIVE_AI_API_KEY / GOOGLE_API_KEY) for google/... model');
-                const { createGoogleGenerativeAI } = await import('@ai-sdk/google');
-                const google = createGoogleGenerativeAI({ apiKey, fetch: fetchImpl });
-                const result = await generateText({
-                    model: google(parsed.model),
-                    system,
-                    ...(typeof prompt === 'string' ? { prompt } : { messages: prompt }),
-                    ...(typeof temperature === 'number' ? { temperature } : {}),
-                    ...(shouldSendMaxOutputTokens() ? { maxOutputTokens } : {}),
-                    abortSignal: controller.signal,
+                const model = resolveModelForCall({
+                    modelId: parsed.model,
+                    parsedProvider: parsed.provider,
+                    openaiConfig: null,
+                    context,
+                    googleBaseUrlOverride,
+                });
+                const result = await completeSimple(model, context, {
+                    ...(typeof effectiveTemperature === 'number'
+                        ? { temperature: effectiveTemperature }
+                        : {}),
+                    ...(typeof maxOutputTokens === 'number' ? { maxTokens: maxOutputTokens } : {}),
+                    apiKey,
+                    signal: controller.signal,
                 });
-                assertNonEmptyText(result.text, parsed.canonical);
+                const text = extractText(result);
+                if (!text)
+                    throw new Error(`LLM returned an empty summary (model ${parsed.canonical}).`);
                 return {
-                    text: result.text,
+                    text,
                     canonicalModelId: parsed.canonical,
                     provider: parsed.provider,
                     usage: normalizeTokenUsage(result.usage),
@@ -162,52 +328,89 @@ export async function generateTextWithModelId({ modelId, apiKeys, system, prompt
                 const apiKey = apiKeys.anthropicApiKey;
                 if (!apiKey)
                     throw new Error('Missing ANTHROPIC_API_KEY for anthropic/... model');
-                const { createAnthropic } = await import('@ai-sdk/anthropic');
-                const anthropic = createAnthropic({ apiKey, fetch: fetchImpl });
-                const result = await generateText({
-                    model: anthropic(parsed.model),
-                    system,
-                    ...(typeof prompt === 'string' ? { prompt } : { messages: prompt }),
-                    ...(typeof temperature === 'number' ? { temperature } : {}),
-                    ...(shouldSendMaxOutputTokens() ? { maxOutputTokens } : {}),
-                    abortSignal: controller.signal,
+                const model = resolveModelForCall({
+                    modelId: parsed.model,
+                    parsedProvider: parsed.provider,
+                    openaiConfig: null,
+                    context,
+                    anthropicBaseUrlOverride,
                 });
-                assertNonEmptyText(result.text, parsed.canonical);
+                const result = await completeSimple(model, context, {
+                    ...(typeof effectiveTemperature === 'number'
+                        ? { temperature: effectiveTemperature }
+                        : {}),
+                    ...(typeof maxOutputTokens === 'number' ? { maxTokens: maxOutputTokens } : {}),
+                    apiKey,
+                    signal: controller.signal,
+                });
+                const text = extractText(result);
+                if (!text)
+                    throw new Error(`LLM returned an empty summary (model ${parsed.canonical}).`);
                 return {
-                    text: result.text,
+                    text,
                     canonicalModelId: parsed.canonical,
                     provider: parsed.provider,
                     usage: normalizeTokenUsage(result.usage),
                 };
             }
-            const { createOpenAI } = await import('@ai-sdk/openai');
-            const openaiConfig = resolveOpenAiClientConfig({
-                apiKeys,
-                fetchImpl,
-                forceOpenRouter,
+            const openaiConfig = parsed.provider === 'openai'
+                ? resolveOpenAiClientConfig({
+                    apiKeys,
+                    forceOpenRouter,
+                    openaiBaseUrlOverride,
+                    forceChatCompletions,
+                })
+                : null;
+            if (parsed.provider === 'zai') {
+                const apiKey = apiKeys.openaiApiKey;
+                if (!apiKey)
+                    throw new Error('Missing Z_AI_API_KEY for zai/... model');
+                const model = resolveModelForCall({
+                    modelId: parsed.model,
+                    parsedProvider: parsed.provider,
+                    openaiConfig: null,
+                    context,
+                    openaiBaseUrlOverride,
+                });
+                const result = await completeSimple(model, context, {
+                    ...(typeof effectiveTemperature === 'number'
+                        ? { temperature: effectiveTemperature }
+                        : {}),
+                    ...(typeof maxOutputTokens === 'number' ? { maxTokens: maxOutputTokens } : {}),
+                    apiKey,
+                    signal: controller.signal,
+                });
+                const text = extractText(result);
+                if (!text)
+                    throw new Error(`LLM returned an empty summary (model ${parsed.canonical}).`);
+                return {
+                    text,
+                    canonicalModelId: parsed.canonical,
+                    provider: parsed.provider,
+                    usage: normalizeTokenUsage(result.usage),
+                };
+            }
+            const model = resolveModelForCall({
+                modelId: parsed.model,
+                parsedProvider: parsed.provider,
+                openaiConfig,
+                context,
                 openaiBaseUrlOverride,
-                forceChatCompletions,
+                anthropicBaseUrlOverride,
+                googleBaseUrlOverride,
+                xaiBaseUrlOverride,
             });
-            const openai = createOpenAI({
-                apiKey: openaiConfig.apiKey,
-                ...(openaiConfig.baseURL ? { baseURL: openaiConfig.baseURL } : {}),
-                fetch: openaiConfig.fetch,
+            const result = await completeSimple(model, context, {
+                ...(typeof effectiveTemperature === 'number' ? { temperature: effectiveTemperature } : {}),
+                ...(typeof maxOutputTokens === 'number' ? { maxTokens: maxOutputTokens } : {}),
+                apiKey: openaiConfig?.apiKey ?? apiKeys.openaiApiKey ?? undefined,
+                signal: controller.signal,
             });
-            // OpenRouter requires chat completions endpoint
-            const useChatCompletions = openaiConfig.useChatCompletions;
-            const responsesModelId = parsed.model;
-            const chatModelId = parsed.model;
-            const result = await generateText({
-                model: useChatCompletions ? openai.chat(chatModelId) : openai(responsesModelId),
-                system,
-                ...(typeof prompt === 'string' ? { prompt } : { messages: prompt }),
-                ...(typeof temperature === 'number' ? { temperature } : {}),
-                ...(shouldSendMaxOutputTokens() ? { maxOutputTokens } : {}),
-                abortSignal: controller.signal,
-            });
-            assertNonEmptyText(result.text, parsed.canonical);
+            const text = extractText(result);
+            if (!text)
+                throw new Error(`LLM returned an empty summary (model ${parsed.canonical}).`);
             return {
-                text: result.text,
+                text,
                 canonicalModelId: parsed.canonical,
                 provider: parsed.provider,
                 usage: normalizeTokenUsage(result.usage),
@@ -257,8 +460,10 @@ function computeRetryDelayMs(attempt) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-export async function streamTextWithModelId({ modelId, apiKeys, system, prompt, temperature, maxOutputTokens, timeoutMs, fetchImpl, forceOpenRouter, openaiBaseUrlOverride, forceChatCompletions, }) {
+export async function streamTextWithModelId({ modelId, apiKeys, system, prompt, temperature, maxOutputTokens, timeoutMs, fetchImpl: _fetchImpl, forceOpenRouter, openaiBaseUrlOverride, anthropicBaseUrlOverride, googleBaseUrlOverride, xaiBaseUrlOverride, forceChatCompletions, }) {
+    void _fetchImpl;
     const parsed = parseGatewayStyleModelId(modelId);
+    const context = promptToContext({ system, prompt });
     const controller = new AbortController();
     let timeoutId = null;
     const startedAtMs = Date.now();
@@ -330,36 +535,42 @@ export async function streamTextWithModelId({ modelId, apiKeys, system, prompt,
         },
     });
     try {
-        const { streamText } = await import('ai');
-        const onError = ({ error }) => {
-            if (parsed.provider === 'anthropic') {
-                lastError = normalizeAnthropicModelAccessError(error, parsed.model) ?? error;
-                return;
-            }
-            lastError = error;
-        };
-        const shouldSendMaxOutputTokens = () => typeof maxOutputTokens === 'number';
         if (parsed.provider === 'xai') {
             const apiKey = apiKeys.xaiApiKey;
             if (!apiKey)
                 throw new Error('Missing XAI_API_KEY for xai/... model');
-            const { createXai } = await import('@ai-sdk/xai');
-            const xai = createXai({ apiKey, fetch: fetchImpl });
-            const result = streamText({
-                model: xai(parsed.model),
-                system,
-                ...(typeof prompt === 'string' ? { prompt } : { messages: prompt }),
+            const model = resolveModelForCall({
+                modelId: parsed.model,
+                parsedProvider: parsed.provider,
+                openaiConfig: null,
+                context,
+                xaiBaseUrlOverride,
+            });
+            const stream = streamSimple(model, context, {
                 ...(typeof temperature === 'number' ? { temperature } : {}),
-                ...(shouldSendMaxOutputTokens() ? { maxOutputTokens } : {}),
-                abortSignal: controller.signal,
-                onError,
+                ...(typeof maxOutputTokens === 'number' ? { maxTokens: maxOutputTokens } : {}),
+                apiKey,
+                signal: controller.signal,
             });
+            const textStream = {
+                async *[Symbol.asyncIterator]() {
+                    for await (const event of stream) {
+                        if (event.type === 'text_delta')
+                            yield event.delta;
+                        if (event.type === 'error') {
+                            lastError = event.error;
+                            break;
+                        }
+                    }
+                },
+            };
             return {
-                textStream: wrapTextStream(result.textStream),
+                textStream: wrapTextStream(textStream),
                 canonicalModelId: parsed.canonical,
                 provider: parsed.provider,
-                usage: Promise.resolve(result.totalUsage)
-                    .then((raw) => normalizeTokenUsage(raw))
+                usage: stream
+                    .result()
+                    .then((msg) => normalizeTokenUsage(msg.usage))
                     .catch(() => null),
                 lastError: () => lastError,
             };
@@ -368,23 +579,38 @@ export async function streamTextWithModelId({ modelId, apiKeys, system, prompt,
             const apiKey = apiKeys.googleApiKey;
             if (!apiKey)
                 throw new Error('Missing GEMINI_API_KEY (or GOOGLE_GENERATIVE_AI_API_KEY / GOOGLE_API_KEY) for google/... model');
-            const { createGoogleGenerativeAI } = await import('@ai-sdk/google');
-            const google = createGoogleGenerativeAI({ apiKey, fetch: fetchImpl });
-            const result = streamText({
-                model: google(parsed.model),
-                system,
-                ...(typeof prompt === 'string' ? { prompt } : { messages: prompt }),
+            const model = resolveModelForCall({
+                modelId: parsed.model,
+                parsedProvider: parsed.provider,
+                openaiConfig: null,
+                context,
+                googleBaseUrlOverride,
+            });
+            const stream = streamSimple(model, context, {
                 ...(typeof temperature === 'number' ? { temperature } : {}),
-                ...(shouldSendMaxOutputTokens() ? { maxOutputTokens } : {}),
-                abortSignal: controller.signal,
-                onError,
+                ...(typeof maxOutputTokens === 'number' ? { maxTokens: maxOutputTokens } : {}),
+                apiKey,
+                signal: controller.signal,
             });
+            const textStream = {
+                async *[Symbol.asyncIterator]() {
+                    for await (const event of stream) {
+                        if (event.type === 'text_delta')
+                            yield event.delta;
+                        if (event.type === 'error') {
+                            lastError = event.error;
+                            break;
+                        }
+                    }
+                },
+            };
             return {
-                textStream: wrapTextStream(result.textStream),
+                textStream: wrapTextStream(textStream),
                 canonicalModelId: parsed.canonical,
                 provider: parsed.provider,
-                usage: Promise.resolve(result.totalUsage)
-                    .then((raw) => normalizeTokenUsage(raw))
+                usage: stream
+                    .result()
+                    .then((msg) => normalizeTokenUsage(msg.usage))
                     .catch(() => null),
                 lastError: () => lastError,
             };
@@ -393,59 +619,124 @@ export async function streamTextWithModelId({ modelId, apiKeys, system, prompt,
             const apiKey = apiKeys.anthropicApiKey;
             if (!apiKey)
                 throw new Error('Missing ANTHROPIC_API_KEY for anthropic/... model');
-            const { createAnthropic } = await import('@ai-sdk/anthropic');
-            const anthropic = createAnthropic({ apiKey, fetch: fetchImpl });
-            const result = streamText({
-                model: anthropic(parsed.model),
-                system,
-                ...(typeof prompt === 'string' ? { prompt } : { messages: prompt }),
+            const model = resolveModelForCall({
+                modelId: parsed.model,
+                parsedProvider: parsed.provider,
+                openaiConfig: null,
+                context,
+                anthropicBaseUrlOverride,
+            });
+            const stream = streamSimple(model, context, {
                 ...(typeof temperature === 'number' ? { temperature } : {}),
-                ...(shouldSendMaxOutputTokens() ? { maxOutputTokens } : {}),
-                abortSignal: controller.signal,
-                onError,
+                ...(typeof maxOutputTokens === 'number' ? { maxTokens: maxOutputTokens } : {}),
+                apiKey,
+                signal: controller.signal,
             });
+            const textStream = {
+                async *[Symbol.asyncIterator]() {
+                    for await (const event of stream) {
+                        if (event.type === 'text_delta')
+                            yield event.delta;
+                        if (event.type === 'error') {
+                            lastError =
+                                normalizeAnthropicModelAccessError(event.error, parsed.model) ?? event.error;
+                            break;
+                        }
+                    }
+                },
+            };
             return {
-                textStream: wrapTextStream(result.textStream),
+                textStream: wrapTextStream(textStream),
                 canonicalModelId: parsed.canonical,
                 provider: parsed.provider,
-                usage: Promise.resolve(result.totalUsage)
-                    .then((raw) => normalizeTokenUsage(raw))
+                usage: stream
+                    .result()
+                    .then((msg) => normalizeTokenUsage(msg.usage))
+                    .catch(() => null),
+                lastError: () => lastError,
+            };
+        }
+        if (parsed.provider === 'zai') {
+            const apiKey = apiKeys.openaiApiKey;
+            if (!apiKey)
+                throw new Error('Missing Z_AI_API_KEY for zai/... model');
+            const model = resolveModelForCall({
+                modelId: parsed.model,
+                parsedProvider: parsed.provider,
+                openaiConfig: null,
+                context,
+                openaiBaseUrlOverride,
+            });
+            const stream = streamSimple(model, context, {
+                ...(typeof temperature === 'number' ? { temperature } : {}),
+                ...(typeof maxOutputTokens === 'number' ? { maxTokens: maxOutputTokens } : {}),
+                apiKey,
+                signal: controller.signal,
+            });
+            const textStream = {
+                async *[Symbol.asyncIterator]() {
+                    for await (const event of stream) {
+                        if (event.type === 'text_delta')
+                            yield event.delta;
+                        if (event.type === 'error') {
+                            lastError = event.error;
+                            break;
+                        }
+                    }
+                },
+            };
+            return {
+                textStream: wrapTextStream(textStream),
+                canonicalModelId: parsed.canonical,
+                provider: parsed.provider,
+                usage: stream
+                    .result()
+                    .then((msg) => normalizeTokenUsage(msg.usage))
                     .catch(() => null),
                 lastError: () => lastError,
             };
         }
-        const { createOpenAI } = await import('@ai-sdk/openai');
         const openaiConfig = resolveOpenAiClientConfig({
             apiKeys,
-            fetchImpl,
             forceOpenRouter,
             openaiBaseUrlOverride,
             forceChatCompletions,
         });
-        const openai = createOpenAI({
-            apiKey: openaiConfig.apiKey,
-            ...(openaiConfig.baseURL ? { baseURL: openaiConfig.baseURL } : {}),
-            fetch: openaiConfig.fetch,
+        const model = resolveModelForCall({
+            modelId: parsed.model,
+            parsedProvider: parsed.provider,
+            openaiConfig,
+            context,
+            openaiBaseUrlOverride,
+            anthropicBaseUrlOverride,
+            googleBaseUrlOverride,
+            xaiBaseUrlOverride,
         });
-        // OpenRouter requires chat completions endpoint
-        const useChatCompletions = openaiConfig.useChatCompletions;
-        const responsesModelId = parsed.model;
-        const chatModelId = parsed.model;
-        const result = streamText({
-            model: useChatCompletions ? openai.chat(chatModelId) : openai(responsesModelId),
-            system,
-            ...(typeof prompt === 'string' ? { prompt } : { messages: prompt }),
+        const stream = streamSimple(model, context, {
             ...(typeof temperature === 'number' ? { temperature } : {}),
-            ...(shouldSendMaxOutputTokens() ? { maxOutputTokens } : {}),
-            abortSignal: controller.signal,
-            onError,
+            ...(typeof maxOutputTokens === 'number' ? { maxTokens: maxOutputTokens } : {}),
+            apiKey: openaiConfig.apiKey,
+            signal: controller.signal,
         });
+        const textStream = {
+            async *[Symbol.asyncIterator]() {
+                for await (const event of stream) {
+                    if (event.type === 'text_delta')
+                        yield event.delta;
+                    if (event.type === 'error') {
+                        lastError = event.error;
+                        break;
+                    }
+                }
+            },
+        };
         return {
-            textStream: wrapTextStream(result.textStream),
+            textStream: wrapTextStream(textStream),
             canonicalModelId: parsed.canonical,
             provider: parsed.provider,
-            usage: Promise.resolve(result.totalUsage)
-                .then((raw) => normalizeTokenUsage(raw))
+            usage: stream
+                .result()
+                .then((msg) => normalizeTokenUsage(msg.usage))
                 .catch(() => null),
             lastError: () => lastError,
         };