@huydao/karrot 0.1.1

package/dist/executors/adapters/ag-ui-post.js

@@ -0,0 +1,703 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAgUiPostMessage = runAgUiPostMessage;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const run_result_1 = require("../run-result");
+function getValueByPath(payload, pathExpression) {
+    return pathExpression
+        .split('.')
+        .filter(Boolean)
+        .reduce((currentValue, segment) => {
+        if (!currentValue || typeof currentValue !== 'object') {
+            return undefined;
+        }
+        return currentValue[segment];
+    }, payload);
+}
+async function waitForCompletionCheck(options) {
+    const deadline = Date.now() + (options.timeoutMs ?? 300_000);
+    const intervalMs = options.intervalMs ?? 5_000;
+    while (Date.now() < deadline) {
+        const response = await fetch(options.url, {
+            method: 'GET',
+            headers: {
+                accept: 'application/json',
+                ...(options.headers ?? {}),
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Completion check failed with HTTP ${response.status}.`);
+        }
+        const payload = await response.json();
+        const rawStatus = getValueByPath(payload, options.statusPath);
+        const status = typeof rawStatus === 'string' ? rawStatus.trim() : '';
+        if (!status) {
+            throw new Error(`Completion check did not find a status at "${options.statusPath}".`);
+        }
+        if (options.successStatuses.includes(status)) {
+            return {
+                status,
+                payload,
+            };
+        }
+        if (options.failureStatuses?.includes(status)) {
+            throw new Error(`Completion check reached failure status "${status}".`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    throw new Error(`Completion check timed out after ${options.timeoutMs ?? 300_000}ms.`);
+}
+function getStringAtPath(payload, pathExpression) {
+    const rawValue = getValueByPath(payload, pathExpression);
+    return typeof rawValue === 'string' ? rawValue.trim() : '';
+}
+function getArrayAtPath(payload, pathExpression) {
+    const rawValue = getValueByPath(payload, pathExpression);
+    return Array.isArray(rawValue) ? rawValue : [];
+}
+async function appendObserveEvent(outputPath, event) {
+    await promises_1.default.appendFile(outputPath, `${JSON.stringify(event)}\n`, 'utf8');
+}
+async function waitForObservedCompletion(options) {
+    const seenProgressIds = new Set();
+    const deadline = Date.now() + (options.observe.timeoutMs ?? 300_000);
+    const intervalMs = options.observe.intervalMs ?? 5_000;
+    let latestOutput = options.fallbackOutput;
+    while (Date.now() < deadline) {
+        for (const endpoint of options.observe.progressEndpoints ?? []) {
+            const response = await fetch(endpoint.url, {
+                method: 'GET',
+                headers: {
+                    accept: 'application/json',
+                    ...(endpoint.headers ?? {}),
+                },
+            });
+            if (response.status === 404) {
+                continue;
+            }
+            if (!response.ok) {
+                throw new Error(`Observe progress request failed with HTTP ${response.status}.`);
+            }
+            const payload = await response.json();
+            const items = getArrayAtPath(payload, endpoint.itemsPath);
+            for (const item of items) {
+                const itemId = endpoint.idPath && getStringAtPath(item, endpoint.idPath)
+                    ? getStringAtPath(item, endpoint.idPath)
+                    : JSON.stringify(item);
+                if (seenProgressIds.has(itemId)) {
+                    continue;
+                }
+                seenProgressIds.add(itemId);
+                await appendObserveEvent(options.outputPath, {
+                    source: 'observe-progress',
+                    type: endpoint.eventType ?? 'progress',
+                    id: itemId,
+                    item,
+                    observedAt: new Date().toISOString(),
+                });
+            }
+        }
+        if (options.observe.outputEndpoint) {
+            const response = await fetch(options.observe.outputEndpoint.url, {
+                method: 'GET',
+                headers: {
+                    accept: 'application/json',
+                    ...(options.observe.outputEndpoint.headers ?? {}),
+                },
+            });
+            if (response.status !== 404) {
+                if (!response.ok) {
+                    throw new Error(`Observe output request failed with HTTP ${response.status}.`);
+                }
+                const payload = await response.json();
+                const observedOutput = getStringAtPath(payload, options.observe.outputEndpoint.textPath);
+                if (observedOutput && observedOutput !== latestOutput) {
+                    latestOutput = observedOutput;
+                    await appendObserveEvent(options.outputPath, {
+                        source: 'observe-output',
+                        type: 'output',
+                        outputLength: observedOutput.length,
+                        observedAt: new Date().toISOString(),
+                    });
+                }
+            }
+        }
+        const statusResponse = await fetch(options.observe.status.url, {
+            method: 'GET',
+            headers: {
+                accept: 'application/json',
+                ...(options.observe.status.headers ?? {}),
+            },
+        });
+        if (!statusResponse.ok) {
+            throw new Error(`Observe status request failed with HTTP ${statusResponse.status}.`);
+        }
+        const statusPayload = await statusResponse.json();
+        const status = getStringAtPath(statusPayload, options.observe.status.statusPath);
+        if (!status) {
+            throw new Error(`Observe status did not find a status at "${options.observe.status.statusPath}".`);
+        }
+        await appendObserveEvent(options.outputPath, {
+            source: 'observe-status',
+            type: 'status',
+            status,
+            observedAt: new Date().toISOString(),
+        });
+        if (options.observe.status.successStatuses.includes(status)) {
+            return {
+                status,
+                output: latestOutput,
+            };
+        }
+        if (options.observe.status.failureStatuses?.includes(status)) {
+            throw new run_result_1.MessageRunError(`Observe status reached failure status "${status}".`, {
+                threadId: options.fallbackThreadId,
+                outputPath: options.outputPath,
+                output: latestOutput,
+                toolCallCount: options.toolCalls.length,
+                toolCalls: options.toolCalls,
+            });
+        }
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    throw new run_result_1.MessageRunError(`Observe status timed out after ${options.observe.timeoutMs ?? 300_000}ms.`, {
+        threadId: options.fallbackThreadId,
+        outputPath: options.outputPath,
+        output: latestOutput,
+        toolCallCount: options.toolCalls.length,
+        toolCalls: options.toolCalls,
+    });
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function withInjectedPayload(options) {
+    const { payload, message, threadId, runId, injectMessage, injectRunMetadata, } = options;
+    if (!isRecord(payload)) {
+        throw new Error('ag-ui-post transport requires request.payload to be an object.');
+    }
+    const body = isRecord(payload.body) ? payload.body : {};
+    const existingMessages = Array.isArray(body.messages) ? body.messages : [];
+    const firstMessage = isRecord(existingMessages[0]) ? existingMessages[0] : {};
+    const resolvedThreadId = threadId ||
+        (typeof body.threadId === 'string' && body.threadId.trim() ? body.threadId.trim() : node_crypto_1.default.randomUUID());
+    return {
+        ...payload,
+        body: {
+            ...body,
+            ...(injectRunMetadata
+                ? {
+                    threadId: resolvedThreadId,
+                    runId,
+                }
+                : {}),
+            ...(injectMessage
+                ? {
+                    messages: [
+                        {
+                            ...firstMessage,
+                            ...(injectRunMetadata ? { id: node_crypto_1.default.randomUUID() } : {}),
+                            content: message ?? firstMessage.content,
+                            role: 'user',
+                        },
+                    ],
+                }
+                : {}),
+        },
+    };
+}
+function parseSseEvents(rawContent) {
+    const normalized = rawContent.replace(/\r\n/g, '\n');
+    const blocks = normalized
+        .split('\n\n')
+        .map((block) => block.trim())
+        .filter(Boolean);
+    return blocks.map((block) => {
+        const lines = block.split('\n');
+        let event;
+        const dataLines = [];
+        for (const line of lines) {
+            if (line.startsWith('event:')) {
+                event = line.slice('event:'.length).trim();
+                continue;
+            }
+            if (line.startsWith('data:')) {
+                dataLines.push(line.slice('data:'.length).trimStart());
+            }
+        }
+        return {
+            event,
+            data: dataLines.join('\n'),
+        };
+    });
+}
+function parseSseBlock(block) {
+    const trimmedBlock = block.trim();
+    if (!trimmedBlock) {
+        return undefined;
+    }
+    const lines = trimmedBlock.split('\n');
+    let event;
+    const dataLines = [];
+    for (const line of lines) {
+        if (line.startsWith('event:')) {
+            event = line.slice('event:'.length).trim();
+            continue;
+        }
+        if (line.startsWith('data:')) {
+            dataLines.push(line.slice('data:'.length).trimStart());
+        }
+    }
+    return {
+        event,
+        data: dataLines.join('\n'),
+    };
+}
+function createConnectCollector(options) {
+    const assistantFragments = [];
+    const toolCalls = [];
+    let latestAssistantContent;
+    let resolvedThreadId = options.fallbackThreadId;
+    let started = false;
+    let finished = false;
+    let sawAnyEvent = false;
+    const consume = (sseEvent) => {
+        if (!sseEvent.data) {
+            return false;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(sseEvent.data);
+        }
+        catch {
+            return false;
+        }
+        sawAnyEvent = true;
+        if (typeof parsed.threadId === 'string' && parsed.threadId.trim()) {
+            resolvedThreadId = parsed.threadId.trim();
+        }
+        else if (typeof parsed.conversationId === 'string' && parsed.conversationId.trim()) {
+            resolvedThreadId = parsed.conversationId.trim();
+        }
+        if (parsed.type === 'RUN_STARTED' && parsed.runId === options.targetRunId) {
+            started = true;
+            return false;
+        }
+        if (!started) {
+            return false;
+        }
+        if (parsed.type === 'RUN_ERROR' && (!parsed.runId || parsed.runId === options.targetRunId)) {
+            throw new run_result_1.MessageRunError(parsed.error?.trim() || 'Agent run failed.', {
+                threadId: resolvedThreadId,
+                output: latestAssistantContent?.trim() || assistantFragments.join('').trim(),
+                toolCallCount: toolCalls.length,
+                toolCalls,
+            });
+        }
+        const isAssistantMessage = parsed.role === 'assistant' || typeof parsed.role !== 'string';
+        if ((parsed.type === 'TEXT_MESSAGE_CHUNK' || parsed.type === 'TEXT_MESSAGE_CONTENT') && isAssistantMessage) {
+            if (typeof parsed.content === 'string' && parsed.content.trim()) {
+                latestAssistantContent = parsed.content.trim();
+            }
+            else if (typeof parsed.delta === 'string' && parsed.delta) {
+                assistantFragments.push(parsed.delta);
+            }
+        }
+        if (parsed.type === 'TOOL_CALL_START' && typeof parsed.toolCallName === 'string' && parsed.toolCallName.trim()) {
+            toolCalls.push(parsed.toolCallName.trim());
+        }
+        if (parsed.type === 'RUN_FINISHED' && (!parsed.runId || parsed.runId === options.targetRunId)) {
+            finished = true;
+            return true;
+        }
+        return false;
+    };
+    return {
+        consume,
+        getResult() {
+            return {
+                output: latestAssistantContent?.trim() || assistantFragments.join('').trim(),
+                toolCalls: [...toolCalls],
+                threadId: resolvedThreadId,
+                finished,
+                sawAnyEvent,
+            };
+        },
+    };
+}
+async function postAndCaptureResponse(options) {
+    const abortController = new AbortController();
+    const timeoutId = typeof options.processTimeoutMs === 'number'
+        ? setTimeout(() => abortController.abort(), options.processTimeoutMs)
+        : undefined;
+    try {
+        await promises_1.default.writeFile(options.outputPath, '', 'utf8');
+        const response = await fetch(options.url, {
+            method: 'POST',
+            headers: {
+                accept: options.accept ?? 'text/event-stream',
+                'content-type': 'application/json',
+                ...(options.headers ?? {}),
+            },
+            body: JSON.stringify(options.payload),
+            signal: abortController.signal,
+        });
+        let rawContent = '';
+        if (response.body) {
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    rawContent += decoder.decode();
+                    break;
+                }
+                const chunkText = decoder.decode(value, { stream: true });
+                rawContent += chunkText;
+                await promises_1.default.appendFile(options.outputPath, chunkText, 'utf8');
+            }
+        }
+        else {
+            rawContent = await response.text();
+            await promises_1.default.writeFile(options.outputPath, rawContent, 'utf8');
+        }
+        return {
+            status: response.status,
+            rawContent,
+        };
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            throw new run_result_1.MessageRunError(`ag-ui-post exceeded ${options.processTimeoutMs}ms and was terminated.`, {
+                outputPath: options.outputPath,
+            });
+        }
+        throw error;
+    }
+    finally {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+    }
+}
+function startConnectStream(options) {
+    let resolveReady;
+    let rejectReady;
+    const ready = new Promise((resolve, reject) => {
+        resolveReady = resolve;
+        rejectReady = reject;
+    });
+    const result = (async () => {
+        const abortController = new AbortController();
+        const timeoutId = typeof options.processTimeoutMs === 'number'
+            ? setTimeout(() => abortController.abort(), options.processTimeoutMs)
+            : undefined;
+        try {
+            await promises_1.default.writeFile(options.outputPath, '', 'utf8');
+            const response = await fetch(options.url, {
+                method: 'POST',
+                headers: {
+                    accept: 'text/event-stream',
+                    'content-type': 'application/json',
+                    ...(options.headers ?? {}),
+                },
+                body: JSON.stringify(options.payload),
+                signal: abortController.signal,
+            });
+            if (!response.ok) {
+                throw new run_result_1.MessageRunError(`ag-ui-connect failed with HTTP ${response.status}.`, {
+                    threadId: options.fallbackThreadId,
+                    outputPath: options.outputPath,
+                });
+            }
+            resolveReady();
+            const collector = createConnectCollector({
+                targetRunId: options.targetRunId,
+                fallbackThreadId: options.fallbackThreadId,
+            });
+            if (!response.body) {
+                const rawContent = await response.text();
+                await promises_1.default.writeFile(options.outputPath, rawContent, 'utf8');
+                const parsed = extractResultFromSse(rawContent, options.fallbackThreadId);
+                return {
+                    output: parsed.output,
+                    toolCalls: parsed.toolCalls,
+                    threadId: parsed.threadId,
+                    finished: parsed.finished,
+                    sawAnyEvent: parsed.sawAnyEvent,
+                };
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    buffer += decoder.decode();
+                }
+                else {
+                    const chunkText = decoder.decode(value, { stream: true });
+                    buffer += chunkText;
+                    await promises_1.default.appendFile(options.outputPath, chunkText, 'utf8');
+                }
+                buffer = buffer.replace(/\r\n/g, '\n');
+                const blocks = buffer.split('\n\n');
+                buffer = blocks.pop() ?? '';
+                for (const block of blocks) {
+                    const parsedEvent = parseSseBlock(block);
+                    if (!parsedEvent) {
+                        continue;
+                    }
+                    const shouldStop = collector.consume(parsedEvent);
+                    if (shouldStop) {
+                        await reader.cancel();
+                        const parsed = collector.getResult();
+                        return parsed;
+                    }
+                }
+                if (done) {
+                    break;
+                }
+            }
+            if (buffer.trim()) {
+                const parsedEvent = parseSseBlock(buffer);
+                if (parsedEvent) {
+                    collector.consume(parsedEvent);
+                }
+            }
+            return collector.getResult();
+        }
+        catch (error) {
+            rejectReady(error);
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new run_result_1.MessageRunError(`ag-ui-connect exceeded ${options.processTimeoutMs}ms and was terminated.`, {
+                    threadId: options.fallbackThreadId,
+                    outputPath: options.outputPath,
+                });
+            }
+            throw error;
+        }
+        finally {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+        }
+    })();
+    result.catch(() => { });
+    ready.catch(() => { });
+    return {
+        ready,
+        result,
+    };
+}
+function extractResultFromSse(rawContent, fallbackThreadId) {
+    const fragments = [];
+    let latestContent;
+    let resolvedThreadId = fallbackThreadId;
+    const toolCalls = [];
+    let finished = false;
+    let sawAnyEvent = false;
+    for (const sseEvent of parseSseEvents(rawContent)) {
+        if (!sseEvent.data) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(sseEvent.data);
+            sawAnyEvent = true;
+            if (typeof parsed.threadId === 'string' && parsed.threadId.trim()) {
+                resolvedThreadId = parsed.threadId.trim();
+            }
+            else if (typeof parsed.conversationId === 'string' && parsed.conversationId.trim()) {
+                resolvedThreadId = parsed.conversationId.trim();
+            }
+            if (parsed.type === 'TEXT_MESSAGE_CONTENT') {
+                if (typeof parsed.content === 'string' && parsed.content.trim()) {
+                    latestContent = parsed.content.trim();
+                }
+                else if (typeof parsed.delta === 'string' && parsed.delta) {
+                    fragments.push(parsed.delta);
+                }
+            }
+            if (parsed.type === 'TOOL_CALL_START' && typeof parsed.toolCallName === 'string' && parsed.toolCallName.trim()) {
+                toolCalls.push(parsed.toolCallName.trim());
+            }
+            if (parsed.type === 'RUN_FINISHED') {
+                finished = true;
+            }
+            if (parsed.type === 'RUN_ERROR') {
+                throw new run_result_1.MessageRunError(parsed.error?.trim() || 'Agent run failed.', {
+                    threadId: resolvedThreadId,
+                    output: latestContent?.trim() || fragments.join('').trim(),
+                    toolCallCount: toolCalls.length,
+                    toolCalls,
+                });
+            }
+        }
+        catch (error) {
+            if (error instanceof run_result_1.MessageRunError) {
+                throw error;
+            }
+        }
+    }
+    return {
+        output: latestContent?.trim() || fragments.join('').trim(),
+        toolCalls,
+        threadId: resolvedThreadId,
+        finished,
+        sawAnyEvent,
+    };
+}
+async function runAgUiPostMessage(options) {
+    await promises_1.default.mkdir(options.outputDirectory, { recursive: true });
+    const runRequest = options.run;
+    if (!runRequest) {
+        throw new Error('ag-ui-post transport requires run config.');
+    }
+    const runId = node_crypto_1.default.randomUUID();
+    const runPayload = withInjectedPayload({
+        payload: runRequest.payload,
+        message: options.message,
+        threadId: options.threadId,
+        runId,
+        injectMessage: options.injectMessage ?? true,
+        injectRunMetadata: options.injectRunMetadata ?? true,
+    });
+    const runPayloadBody = isRecord(runPayload) && isRecord(runPayload.body) ? runPayload.body : undefined;
+    const resolvedThreadId = runPayloadBody && typeof runPayloadBody.threadId === 'string'
+        ? runPayloadBody.threadId
+        : options.threadId ?? node_crypto_1.default.randomUUID();
+    const outputPath = node_path_1.default.join(options.outputDirectory, `${resolvedThreadId}-${Date.now()}.sse`);
+    const runOutputPath = node_path_1.default.join(options.outputDirectory, `${resolvedThreadId}-${Date.now()}.run.sse`);
+    const observePath = node_path_1.default.join(options.outputDirectory, `${resolvedThreadId}-${Date.now()}.observe.jsonl`);
+    try {
+        if (options.connect) {
+            const connectPayload = withInjectedPayload({
+                payload: options.connect.payload,
+                threadId: resolvedThreadId,
+                runId,
+                injectMessage: false,
+                injectRunMetadata: true,
+            });
+            const connectStream = startConnectStream({
+                url: options.connect.url,
+                headers: options.connect.headers,
+                payload: connectPayload,
+                outputPath,
+                targetRunId: runId,
+                fallbackThreadId: resolvedThreadId,
+                processTimeoutMs: options.connect.processTimeoutMs ?? options.processTimeoutMs,
+            });
+            await connectStream.ready;
+            const runResponse = await postAndCaptureResponse({
+                url: runRequest.url,
+                headers: runRequest.headers,
+                payload: runPayload,
+                outputPath: runOutputPath,
+                processTimeoutMs: options.processTimeoutMs,
+            });
+            if (runResponse.status < 200 || runResponse.status >= 300) {
+                throw new run_result_1.MessageRunError(`ag-ui-post run failed with HTTP ${runResponse.status}.`, {
+                    threadId: resolvedThreadId,
+                    outputPath: runOutputPath,
+                    output: runResponse.rawContent,
+                });
+            }
+            const connected = await connectStream.result;
+            if (!connected.finished && !connected.output) {
+                throw new run_result_1.MessageRunError(connected.sawAnyEvent
+                    ? 'ag-ui-connect returned without RUN_FINISHED or assistant output.'
+                    : 'ag-ui-connect returned no stream events for the submitted turn.', {
+                    threadId: connected.threadId,
+                    outputPath,
+                    toolCallCount: connected.toolCalls.length,
+                    toolCalls: connected.toolCalls,
+                });
+            }
+            return {
+                output: connected.output,
+                threadId: connected.threadId,
+                outputPath,
+                note: `Run log: ${node_path_1.default.basename(runOutputPath)}`,
+                toolCallCount: connected.toolCalls.length,
+                toolCalls: connected.toolCalls,
+                metrics: {},
+            };
+        }
+        const runResponse = await postAndCaptureResponse({
+            url: runRequest.url,
+            headers: runRequest.headers,
+            payload: runPayload,
+            outputPath,
+            processTimeoutMs: options.processTimeoutMs,
+        });
+        if (runResponse.status < 200 || runResponse.status >= 300) {
+            throw new run_result_1.MessageRunError(`ag-ui-post failed with HTTP ${runResponse.status}.`, {
+                threadId: resolvedThreadId,
+                outputPath,
+                output: runResponse.rawContent,
+            });
+        }
+        const parsed = extractResultFromSse(runResponse.rawContent, resolvedThreadId);
+        if (options.observe) {
+            await promises_1.default.writeFile(observePath, '', 'utf8');
+            const observed = await waitForObservedCompletion({
+                observe: options.observe,
+                outputPath: observePath,
+                fallbackOutput: parsed.output,
+                fallbackThreadId: parsed.threadId,
+                toolCalls: parsed.toolCalls,
+            });
+            return {
+                output: observed.output,
+                threadId: parsed.threadId,
+                outputPath,
+                note: `Observe status: ${observed.status}. Observe log: ${node_path_1.default.basename(observePath)}`,
+                toolCallCount: parsed.toolCalls.length,
+                toolCalls: parsed.toolCalls,
+                metrics: {},
+            };
+        }
+        if (options.completionCheck) {
+            const completion = await waitForCompletionCheck(options.completionCheck);
+            return {
+                output: parsed.output,
+                threadId: parsed.threadId,
+                outputPath,
+                note: `Completion status: ${completion.status}`,
+                toolCallCount: parsed.toolCalls.length,
+                toolCalls: parsed.toolCalls,
+                metrics: {},
+            };
+        }
+        if (!parsed.finished && !parsed.output) {
+            throw new run_result_1.MessageRunError(parsed.sawAnyEvent
+                ? 'ag-ui-post returned without RUN_FINISHED or assistant output.'
+                : 'ag-ui-post returned no stream events, so the turn completion could not be verified.', {
+                threadId: parsed.threadId,
+                outputPath,
+                output: runResponse.rawContent,
+                toolCallCount: parsed.toolCalls.length,
+                toolCalls: parsed.toolCalls,
+            });
+        }
+        return {
+            output: parsed.output,
+            threadId: parsed.threadId,
+            outputPath,
+            toolCallCount: parsed.toolCalls.length,
+            toolCalls: parsed.toolCalls,
+            metrics: {},
+        };
+    }
+    catch (error) {
+        if (error instanceof run_result_1.MessageRunError) {
+            throw error;
+        }
+        throw error;
+    }
+}