ai-utils.js/model-function/generate-text/streamText.cjs

Build AI applications, chatbots, and agents with JavaScript and TypeScript.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.streamText = void 0;
const nanoid_1 = require("nanoid");
const DurationMeasurement_js_1 = require("../../util/DurationMeasurement.cjs");
const AbortError_js_1 = require("../../util/api/AbortError.cjs");
const runSafe_js_1 = require("../../util/runSafe.cjs");
const ModelCallEventSource_js_1 = require("../ModelCallEventSource.cjs");
const extractTextDeltas_js_1 = require("./extractTextDeltas.cjs");
async function streamText(model, prompt, options) {
    if (options?.settings != null) {
        model = model.withSettings(options.settings);
        options = {
            functionId: options.functionId,
            run: options.run,
        };
    }
    const run = options?.run;
    const settings = model.settings;
    const eventSource = new ModelCallEventSource_js_1.ModelCallEventSource({
        observers: [...(settings.observers ?? []), ...(run?.observers ?? [])],
        errorHandler: run?.errorHandler,
    });
    const durationMeasurement = (0, DurationMeasurement_js_1.startDurationMeasurement)();
    const startMetadata = {
        callId: `call-${(0, nanoid_1.nanoid)()}`,
        runId: run?.runId,
        sessionId: run?.sessionId,
        userId: run?.userId,
        functionId: options?.functionId,
        model: model.modelInformation,
        startEpochSeconds: durationMeasurement.startEpochSeconds,
    };
    eventSource.notifyModelCallStarted({
        type: "text-streaming-started",
        metadata: startMetadata,
        settings,
        prompt,
    });
    const result = await (0, runSafe_js_1.runSafe)(async () => (0, extractTextDeltas_js_1.extractTextDeltas)({
        deltaIterable: await model.generateDeltaStreamResponse(prompt, {
            functionId: options?.functionId,
            settings,
            run,
        }),
        extractDelta: (fullDelta) => model.extractTextDelta(fullDelta),
        onDone: (fullText, lastFullDelta) => {
            const finishMetadata = {
                ...startMetadata,
                durationInMs: durationMeasurement.durationInMs,
            };
            eventSource.notifyModelCallFinished({
                type: "text-streaming-finished",
                status: "success",
                metadata: finishMetadata,
                settings,
                prompt,
                response: lastFullDelta,
                generatedText: fullText,
            });
        },
        onError: (error) => {
            const finishMetadata = {
                ...startMetadata,
                durationInMs: durationMeasurement.durationInMs,
            };
            eventSource.notifyModelCallFinished(error instanceof AbortError_js_1.AbortError
                ? {
                    type: "text-streaming-finished",
                    status: "abort",
                    metadata: finishMetadata,
                    settings,
                    prompt,
                }
                : {
                    type: "text-streaming-finished",
                    status: "failure",
                    metadata: finishMetadata,
                    settings,
                    prompt,
                    error,
                });
        },
    }));
    if (!result.ok) {
        const finishMetadata = {
            ...startMetadata,
            durationInMs: durationMeasurement.durationInMs,
        };
        if (result.isAborted) {
            eventSource.notifyModelCallFinished({
                type: "text-streaming-finished",
                status: "abort",
                metadata: finishMetadata,
                settings,
                prompt,
            });
            throw new AbortError_js_1.AbortError();
        }
        eventSource.notifyModelCallFinished({
            type: "text-streaming-finished",
            status: "failure",
            metadata: finishMetadata,
            settings,
            prompt,
            error: result.error,
        });
        throw result.error;
    }
    return {
        textStream: result.output,
        metadata: startMetadata,
    };
}
exports.streamText = streamText;