@steipete/summarize 0.11.0 → 0.12.0

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

@@ -1,193 +1,79 @@
-import { completeSimple, streamSimple } from "@mariozechner/pi-ai";
-import { createUnsupportedFunctionalityError } from "./errors.js";
+import { completeSimple } from "@mariozechner/pi-ai";
+import { maybeGenerateDocumentText } from "./generate-text-document.js";
+import { computeRetryDelayMs, isGoogleEmptySummaryError, isRetryableTimeoutError, promptToContext, resolveEffectiveTemperature, resolveGoogleEmptyResponseFallbackModelId, sleep, } from "./generate-text-shared.js";
+import { streamTextWithContext } from "./generate-text-stream.js";
 import { parseGatewayStyleModelId } from "./model-id.js";
-import { userTextAndImageMessage } from "./prompt.js";
-import { completeAnthropicDocument, completeAnthropicText, normalizeAnthropicModelAccessError, } from "./providers/anthropic.js";
-import { completeGoogleDocument, completeGoogleText } from "./providers/google.js";
-import { resolveAnthropicModel, resolveGoogleModel, resolveOpenAiModel, resolveXaiModel, resolveZaiModel, } from "./providers/models.js";
-import { completeOpenAiDocument, completeOpenAiText, resolveOpenAiClientConfig, } from "./providers/openai.js";
+import { resolveOpenAiCompatibleClientConfigForProvider } from "./provider-capabilities.js";
+import { completeAnthropicText, normalizeAnthropicModelAccessError, } from "./providers/anthropic.js";
+import { completeGoogleText } from "./providers/google.js";
+import { resolveNvidiaModel, resolveXaiModel, resolveZaiModel, } from "./providers/models.js";
+import { completeOpenAiText } from "./providers/openai.js";
 import { extractText } from "./providers/shared.js";
 import { normalizeTokenUsage } from "./usage.js";
-function promptToContext(prompt) {
-    const attachments = prompt.attachments ?? [];
-    if (attachments.some((attachment) => attachment.kind === "document")) {
-        throw new Error("Internal error: document prompt cannot be converted to context.");
-    }
-    if (attachments.length === 0) {
-        return {
-            systemPrompt: prompt.system,
-            messages: [{ role: "user", content: prompt.userText, timestamp: Date.now() }],
-        };
-    }
-    if (attachments.length !== 1 || attachments[0]?.kind !== "image") {
-        throw new Error("Internal error: only single image attachments are supported for prompts.");
-    }
-    const attachment = attachments[0];
-    const messages = [
-        userTextAndImageMessage({
-            text: prompt.userText,
-            imageBytes: attachment.bytes,
-            mimeType: attachment.mediaType,
-        }),
-    ];
-    return { systemPrompt: prompt.system, messages };
-}
-function isRetryableTimeoutError(error) {
-    if (!error)
-        return false;
-    const message = typeof error === "string"
-        ? error
-        : error instanceof Error
-            ? error.message
-            : typeof error.message === "string"
-                ? String(error.message)
-                : "";
-    return /timed out/i.test(message) || /empty summary/i.test(message);
-}
-function computeRetryDelayMs(attempt) {
-    const base = 500;
-    const jitter = Math.floor(Math.random() * 200);
-    return Math.min(2000, base * (attempt + 1) + jitter);
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function withTimeoutFallback({ promise, timeoutMs, fallback, }) {
-    const effectiveTimeoutMs = Number.isFinite(timeoutMs) && timeoutMs > 0 ? Math.floor(timeoutMs) : 30_000;
-    let timer = null;
-    try {
-        return await Promise.race([
-            promise,
-            new Promise((resolve) => {
-                timer = setTimeout(() => resolve(fallback), effectiveTimeoutMs);
-            }),
-        ]);
-    }
-    finally {
-        if (timer)
-            clearTimeout(timer);
-    }
-}
-function streamUsageWithTimeout({ result, timeoutMs, }) {
-    const normalized = result.then((msg) => normalizeTokenUsage(msg.usage)).catch(() => null);
-    return withTimeoutFallback({
-        promise: normalized,
-        timeoutMs,
-        fallback: null,
-    });
-}
-function isOpenaiGpt5Model(parsed) {
-    return parsed.provider === "openai" && /^gpt-5([-.].+)?$/i.test(parsed.model);
-}
-function resolveEffectiveTemperature({ parsed, temperature, }) {
-    if (typeof temperature !== "number")
-        return undefined;
-    if (isOpenaiGpt5Model(parsed))
-        return undefined;
-    return temperature;
-}
-export async function generateTextWithModelId({ modelId, apiKeys, prompt, temperature, maxOutputTokens, timeoutMs, fetchImpl, forceOpenRouter, openaiBaseUrlOverride, anthropicBaseUrlOverride, googleBaseUrlOverride, xaiBaseUrlOverride, forceChatCompletions, retries = 0, onRetry, }) {
+export { streamTextWithContext } from "./generate-text-stream.js";
+export async function generateTextWithModelId({ modelId, apiKeys, prompt, temperature, maxOutputTokens, timeoutMs, fetchImpl, forceOpenRouter, openaiBaseUrlOverride, anthropicBaseUrlOverride, googleBaseUrlOverride, xaiBaseUrlOverride, zaiBaseUrlOverride, forceChatCompletions, retries = 0, onRetry, }) {
     const parsed = parseGatewayStyleModelId(modelId);
-    const effectiveTemperature = resolveEffectiveTemperature({ parsed, temperature });
-    const attachments = prompt.attachments ?? [];
-    const documentAttachment = attachments.find((attachment) => attachment.kind === "document") ?? null;
-    if (documentAttachment) {
-        if (attachments.length !== 1) {
-            throw new Error("Internal error: document attachments cannot be combined with other inputs.");
-        }
-        if (parsed.provider === "anthropic") {
-            const apiKey = apiKeys.anthropicApiKey;
-            if (!apiKey)
-                throw new Error("Missing ANTHROPIC_API_KEY for anthropic/... model");
-            try {
-                const result = await completeAnthropicDocument({
-                    modelId: parsed.model,
-                    apiKey,
-                    promptText: prompt.userText,
-                    document: documentAttachment,
-                    system: prompt.system,
-                    maxOutputTokens,
-                    timeoutMs,
-                    fetchImpl,
-                    anthropicBaseUrlOverride,
-                });
-                return {
-                    text: result.text,
-                    canonicalModelId: parsed.canonical,
-                    provider: parsed.provider,
-                    usage: result.usage,
-                };
-            }
-            catch (error) {
-                const normalized = normalizeAnthropicModelAccessError(error, parsed.model);
-                if (normalized)
-                    throw normalized;
-                throw error;
-            }
-        }
-        if (parsed.provider === "openai") {
-            const openaiConfig = resolveOpenAiClientConfig({
-                apiKeys: {
-                    openaiApiKey: apiKeys.openaiApiKey,
-                    openrouterApiKey: apiKeys.openrouterApiKey,
-                },
-                forceOpenRouter,
-                openaiBaseUrlOverride,
-                forceChatCompletions,
-            });
-            const result = await completeOpenAiDocument({
-                modelId: parsed.model,
-                openaiConfig,
-                promptText: prompt.userText,
-                document: documentAttachment,
-                maxOutputTokens,
-                temperature: effectiveTemperature,
-                timeoutMs,
-                fetchImpl,
-            });
-            return {
-                text: result.text,
-                canonicalModelId: parsed.canonical,
-                provider: parsed.provider,
-                usage: result.usage,
-            };
-        }
-        if (parsed.provider === "google") {
-            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 result = await completeGoogleDocument({
-                modelId: parsed.model,
-                apiKey,
-                promptText: prompt.userText,
-                document: documentAttachment,
-                maxOutputTokens,
-                temperature: effectiveTemperature,
-                timeoutMs,
-                fetchImpl,
-                googleBaseUrlOverride,
-            });
-            return {
-                text: result.text,
-                canonicalModelId: parsed.canonical,
-                provider: parsed.provider,
-                usage: result.usage,
-            };
-        }
-        throw createUnsupportedFunctionalityError(`document attachments are not supported for ${parsed.provider}/... models`);
-    }
-    const context = promptToContext(prompt);
-    const openaiConfig = parsed.provider === "openai"
-        ? resolveOpenAiClientConfig({
-            apiKeys: {
-                openaiApiKey: apiKeys.openaiApiKey,
-                openrouterApiKey: apiKeys.openrouterApiKey,
-            },
+    const effectiveTemperature = resolveEffectiveTemperature({
+        provider: parsed.provider,
+        model: parsed.model,
+        temperature,
+    });
+    const documentResult = await maybeGenerateDocumentText({
+        parsed,
+        apiKeys,
+        prompt,
+        maxOutputTokens,
+        temperature: effectiveTemperature,
+        timeoutMs,
+        fetchImpl,
+        forceOpenRouter,
+        openaiBaseUrlOverride,
+        anthropicBaseUrlOverride,
+        googleBaseUrlOverride,
+        forceChatCompletions,
+        retryWithModelId: (fallbackModelId) => generateTextWithModelId({
+            modelId: fallbackModelId,
+            apiKeys,
+            prompt,
+            temperature,
+            maxOutputTokens,
+            timeoutMs,
+            fetchImpl,
             forceOpenRouter,
             openaiBaseUrlOverride,
+            anthropicBaseUrlOverride,
+            googleBaseUrlOverride,
+            xaiBaseUrlOverride,
+            zaiBaseUrlOverride,
             forceChatCompletions,
-        })
-        : null;
+            retries,
+            onRetry,
+        }),
+    });
+    if (documentResult) {
+        return documentResult;
+    }
+    const context = promptToContext(prompt);
+    const resolveOpenAiConfig = () => resolveOpenAiCompatibleClientConfigForProvider({
+        provider: "openai",
+        openaiApiKey: apiKeys.openaiApiKey,
+        openrouterApiKey: apiKeys.openrouterApiKey,
+        forceOpenRouter,
+        openaiBaseUrlOverride,
+        forceChatCompletions,
+    });
+    const completeSimpleText = async ({ model, apiKey, signal, }) => {
+        const result = await completeSimple(model, context, {
+            ...(typeof effectiveTemperature === "number" ? { temperature: effectiveTemperature } : {}),
+            ...(typeof maxOutputTokens === "number" ? { maxTokens: maxOutputTokens } : {}),
+            apiKey,
+            signal,
+        });
+        const text = extractText(result);
+        if (!text)
+            throw new Error(`LLM returned an empty summary (model ${parsed.canonical}).`);
+        return { text, usage: normalizeTokenUsage(result.usage) };
+    };
     const maxRetries = Math.max(0, retries);
     let attempt = 0;
     while (attempt <= maxRetries) {
@@ -262,54 +148,100 @@ export async function generateTextWithModelId({ modelId, apiKeys, prompt, temper
                 };
             }
             if (parsed.provider === "zai") {
-                const apiKey = apiKeys.openaiApiKey;
-                if (!apiKey)
-                    throw new Error("Missing Z_AI_API_KEY for zai/... model");
+                const openaiConfig = resolveOpenAiCompatibleClientConfigForProvider({
+                    provider: "zai",
+                    openaiApiKey: apiKeys.openaiApiKey,
+                    openrouterApiKey: apiKeys.openrouterApiKey,
+                    openaiBaseUrlOverride: zaiBaseUrlOverride ?? openaiBaseUrlOverride,
+                });
                 const model = resolveZaiModel({
                     modelId: parsed.model,
                     context,
+                    openaiBaseUrlOverride: openaiConfig.baseURL,
+                });
+                const result = await completeSimpleText({
+                    model,
+                    apiKey: openaiConfig.apiKey,
+                    signal: controller.signal,
+                });
+                return {
+                    text: result.text,
+                    canonicalModelId: parsed.canonical,
+                    provider: parsed.provider,
+                    usage: result.usage,
+                };
+            }
+            if (parsed.provider === "nvidia") {
+                const openaiConfig = resolveOpenAiCompatibleClientConfigForProvider({
+                    provider: "nvidia",
+                    openaiApiKey: apiKeys.openaiApiKey,
+                    openrouterApiKey: apiKeys.openrouterApiKey,
                     openaiBaseUrlOverride,
                 });
-                const result = await completeSimple(model, context, {
-                    ...(typeof effectiveTemperature === "number"
-                        ? { temperature: effectiveTemperature }
-                        : {}),
-                    ...(typeof maxOutputTokens === "number" ? { maxTokens: maxOutputTokens } : {}),
-                    apiKey,
+                const model = resolveNvidiaModel({
+                    modelId: parsed.model,
+                    context,
+                    openaiBaseUrlOverride: openaiConfig.baseURL,
+                });
+                const result = await completeSimpleText({
+                    model,
+                    apiKey: openaiConfig.apiKey,
                     signal: controller.signal,
                 });
-                const text = extractText(result);
-                if (!text)
-                    throw new Error(`LLM returned an empty summary (model ${parsed.canonical}).`);
                 return {
-                    text,
+                    text: result.text,
                     canonicalModelId: parsed.canonical,
                     provider: parsed.provider,
-                    usage: normalizeTokenUsage(result.usage),
+                    usage: result.usage,
                 };
             }
-            if (!openaiConfig) {
-                throw new Error("Missing OPENAI_API_KEY for openai/... model");
+            if (parsed.provider === "openai") {
+                const openaiConfig = resolveOpenAiConfig();
+                const result = await completeOpenAiText({
+                    modelId: parsed.model,
+                    openaiConfig,
+                    context,
+                    temperature: effectiveTemperature,
+                    maxOutputTokens,
+                    signal: controller.signal,
+                });
+                return {
+                    text: result.text,
+                    canonicalModelId: parsed.canonical,
+                    provider: parsed.provider,
+                    usage: result.usage,
+                };
             }
-            const result = await completeOpenAiText({
-                modelId: parsed.model,
-                openaiConfig,
-                context,
-                temperature: effectiveTemperature,
-                maxOutputTokens,
-                signal: controller.signal,
-            });
-            return {
-                text: result.text,
-                canonicalModelId: parsed.canonical,
-                provider: parsed.provider,
-                usage: result.usage,
-            };
+            /* v8 ignore next */
+            throw new Error(`Unknown provider ${parsed.provider}`);
         }
         catch (error) {
             const normalizedError = error instanceof DOMException && error.name === "AbortError"
                 ? new Error(`LLM request timed out after ${timeoutMs}ms (model ${parsed.canonical}).`)
                 : error;
+            const googleFallbackModelId = parsed.provider === "google" &&
+                isGoogleEmptySummaryError(normalizedError) &&
+                resolveGoogleEmptyResponseFallbackModelId(parsed.canonical);
+            if (googleFallbackModelId) {
+                return generateTextWithModelId({
+                    modelId: googleFallbackModelId,
+                    apiKeys,
+                    prompt,
+                    temperature,
+                    maxOutputTokens,
+                    timeoutMs,
+                    fetchImpl,
+                    forceOpenRouter,
+                    openaiBaseUrlOverride,
+                    anthropicBaseUrlOverride,
+                    googleBaseUrlOverride,
+                    xaiBaseUrlOverride,
+                    zaiBaseUrlOverride,
+                    forceChatCompletions,
+                    retries: Math.max(0, maxRetries - attempt),
+                    onRetry,
+                });
+            }
             if (parsed.provider === "anthropic") {
                 const normalized = normalizeAnthropicModelAccessError(normalizedError, parsed.model);
                 if (normalized)
@@ -348,271 +280,4 @@ export async function streamTextWithModelId({ modelId, apiKeys, prompt, temperat
         forceChatCompletions,
     });
 }
-export async function streamTextWithContext({ modelId, apiKeys, context, temperature, maxOutputTokens, timeoutMs, fetchImpl, forceOpenRouter, openaiBaseUrlOverride, anthropicBaseUrlOverride, googleBaseUrlOverride, xaiBaseUrlOverride, forceChatCompletions, }) {
-    const parsed = parseGatewayStyleModelId(modelId);
-    const effectiveTemperature = resolveEffectiveTemperature({ parsed, temperature });
-    void fetchImpl;
-    const controller = new AbortController();
-    let timeoutId = null;
-    const startedAtMs = Date.now();
-    let lastError = null;
-    const timeoutError = new Error("LLM request timed out");
-    const markTimedOut = () => {
-        if (lastError === timeoutError)
-            return;
-        lastError = timeoutError;
-        controller.abort();
-    };
-    const startTimeout = () => {
-        if (timeoutId)
-            return;
-        timeoutId = setTimeout(markTimedOut, timeoutMs);
-    };
-    const stopTimeout = () => {
-        if (!timeoutId)
-            return;
-        clearTimeout(timeoutId);
-        timeoutId = null;
-    };
-    const nextWithDeadline = async (promise) => {
-        const elapsed = Date.now() - startedAtMs;
-        const remaining = timeoutMs - elapsed;
-        if (remaining <= 0) {
-            markTimedOut();
-            throw timeoutError;
-        }
-        let timer = null;
-        try {
-            return await Promise.race([
-                promise,
-                new Promise((_, reject) => {
-                    timer = setTimeout(() => {
-                        markTimedOut();
-                        reject(timeoutError);
-                    }, remaining);
-                }),
-            ]);
-        }
-        finally {
-            if (timer)
-                clearTimeout(timer);
-        }
-    };
-    const wrapTextStream = (textStream) => ({
-        async *[Symbol.asyncIterator]() {
-            startTimeout();
-            const iterator = textStream[Symbol.asyncIterator]();
-            try {
-                while (true) {
-                    const result = await nextWithDeadline(iterator.next());
-                    if (result.done)
-                        break;
-                    yield result.value;
-                }
-            }
-            finally {
-                stopTimeout();
-                if (typeof iterator.return === "function") {
-                    const cleanup = iterator.return();
-                    const cleanupPromise = typeof cleanup === "undefined" ? undefined : cleanup;
-                    if (typeof cleanupPromise?.catch === "function") {
-                        void cleanupPromise.catch(() => { });
-                    }
-                }
-            }
-        },
-    });
-    try {
-        if (parsed.provider === "xai") {
-            const apiKey = apiKeys.xaiApiKey;
-            if (!apiKey)
-                throw new Error("Missing XAI_API_KEY for xai/... model");
-            const model = resolveXaiModel({
-                modelId: parsed.model,
-                context,
-                xaiBaseUrlOverride,
-            });
-            const stream = streamSimple(model, context, {
-                ...(typeof effectiveTemperature === "number" ? { temperature: effectiveTemperature } : {}),
-                ...(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: streamUsageWithTimeout({ result: stream.result(), timeoutMs }),
-                lastError: () => lastError,
-            };
-        }
-        if (parsed.provider === "google") {
-            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 model = resolveGoogleModel({
-                modelId: parsed.model,
-                context,
-                googleBaseUrlOverride,
-            });
-            const stream = streamSimple(model, context, {
-                ...(typeof effectiveTemperature === "number" ? { temperature: effectiveTemperature } : {}),
-                ...(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: streamUsageWithTimeout({ result: stream.result(), timeoutMs }),
-                lastError: () => lastError,
-            };
-        }
-        if (parsed.provider === "anthropic") {
-            const apiKey = apiKeys.anthropicApiKey;
-            if (!apiKey)
-                throw new Error("Missing ANTHROPIC_API_KEY for anthropic/... model");
-            const model = resolveAnthropicModel({
-                modelId: parsed.model,
-                context,
-                anthropicBaseUrlOverride,
-            });
-            const stream = streamSimple(model, context, {
-                ...(typeof effectiveTemperature === "number" ? { temperature: effectiveTemperature } : {}),
-                ...(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(textStream),
-                canonicalModelId: parsed.canonical,
-                provider: parsed.provider,
-                usage: streamUsageWithTimeout({ result: stream.result(), timeoutMs }),
-                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 = resolveZaiModel({
-                modelId: parsed.model,
-                context,
-                openaiBaseUrlOverride,
-            });
-            const stream = streamSimple(model, context, {
-                ...(typeof effectiveTemperature === "number" ? { temperature: effectiveTemperature } : {}),
-                ...(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: streamUsageWithTimeout({ result: stream.result(), timeoutMs }),
-                lastError: () => lastError,
-            };
-        }
-        const openaiConfig = resolveOpenAiClientConfig({
-            apiKeys: {
-                openaiApiKey: apiKeys.openaiApiKey,
-                openrouterApiKey: apiKeys.openrouterApiKey,
-            },
-            forceOpenRouter,
-            openaiBaseUrlOverride,
-            forceChatCompletions,
-        });
-        const model = resolveOpenAiModel({ modelId: parsed.model, context, openaiConfig });
-        const stream = streamSimple(model, context, {
-            ...(typeof effectiveTemperature === "number" ? { temperature: effectiveTemperature } : {}),
-            ...(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(textStream),
-            canonicalModelId: parsed.canonical,
-            provider: parsed.provider,
-            usage: streamUsageWithTimeout({ result: stream.result(), timeoutMs }),
-            lastError: () => lastError,
-        };
-    }
-    catch (error) {
-        if (parsed.provider === "anthropic") {
-            const normalized = normalizeAnthropicModelAccessError(error, parsed.model);
-            if (normalized)
-                throw normalized;
-        }
-        if (error instanceof DOMException && error.name === "AbortError") {
-            throw new Error("LLM request timed out");
-        }
-        throw error;
-    }
-    finally {
-        stopTimeout();
-    }
-}
 //# sourceMappingURL=generate-text.js.map