ai-utils.js/model-function/executeCall.cjs

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

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.executeCall = 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");
async function executeCall({ model, options, getStartEvent, getAbortEvent, getFailureEvent, getSuccessEvent, generateResponse, extractOutputValue, }) {
    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(getStartEvent(startMetadata, settings));
    const result = await (0, runSafe_js_1.runSafe)(() => generateResponse({
        functionId: options?.functionId,
        settings,
        run,
    }));
    const finishMetadata = {
        ...startMetadata,
        durationInMs: durationMeasurement.durationInMs,
    };
    if (!result.ok) {
        if (result.isAborted) {
            eventSource.notifyModelCallFinished(getAbortEvent(finishMetadata, settings));
            throw new AbortError_js_1.AbortError();
        }
        eventSource.notifyModelCallFinished(getFailureEvent(finishMetadata, settings, result.error));
        throw result.error;
    }
    const response = result.output;
    const output = extractOutputValue(response);
    eventSource.notifyModelCallFinished(getSuccessEvent(finishMetadata, settings, response, output));
    return {
        output,
        response,
        metadata: finishMetadata,
    };
}
exports.executeCall = executeCall;