veryfront 0.1.324 → 0.1.327

package/esm/src/agent/fork-runtime-stream.d.ts

@@ -0,0 +1,143 @@
+import type { Tool } from "../tool/index.js";
+import type { AgUiRuntimeStreamEvent } from "./ag-ui-browser-encoder.js";
+import type { AgentResponse, Message as AgentMessage } from "./schemas/index.js";
+interface ForkStreamPart {
+    type: "reasoning-delta" | "text-delta";
+    text: string;
+}
+interface ForkToolInputStartPart {
+    type: "tool-input-start";
+    toolCallId: string;
+    toolName: string;
+}
+interface ForkToolInputDeltaPart {
+    type: "tool-input-delta";
+    toolCallId: string;
+    delta: string;
+}
+interface ForkToolCallPart {
+    type: "tool-call";
+    toolName: string;
+    toolCallId: string;
+    input: unknown;
+}
+interface ForkToolResultPart {
+    type: "tool-result";
+    toolName: string;
+    toolCallId: string;
+    input: unknown;
+    output: unknown;
+}
+interface ForkToolErrorPart {
+    type: "tool-error";
+    toolName: string;
+    toolCallId: string;
+    input: unknown;
+    error: Error;
+}
+interface ForkErrorPart {
+    type: "error";
+    error: Error;
+}
+export interface ForkRuntimeStep {
+    text: string;
+    messages: unknown[];
+    toolCalls: Array<{
+        toolCallId: string;
+        toolName: string;
+        input: unknown;
+    }>;
+    toolResults: Array<{
+        toolCallId: string;
+        toolName: string;
+        input: unknown;
+        output: unknown;
+    }>;
+    finishReason: string | null;
+}
+interface RecoveredToolObservation {
+    sawInputStart: boolean;
+    sawInputDelta: boolean;
+    sawInputAvailable: boolean;
+    sawOutputAvailable: boolean;
+    sawOutputError: boolean;
+}
+export interface ForkRecoveredPartsState {
+    toolCalls: Map<string, RecoveredToolObservation>;
+    emittedToolCallIds: Set<string>;
+    emittedToolResultIds: Set<string>;
+    logger?: ForkRuntimeStreamLogger;
+}
+type FrameworkToolCallState = RecoveredToolObservation & {
+    toolName: string;
+    inputText: string;
+    input: Record<string, unknown>;
+};
+type StreamedToolCallState = {
+    toolCallId: string;
+    toolName: string;
+    inputText: string;
+    input: unknown;
+    status: "pending" | "completed" | "error";
+    output?: unknown;
+    errorText?: string;
+};
+type StreamedMessage = {
+    role: "assistant" | "tool";
+    parts: AgentMessage["parts"];
+};
+type StreamedStepState = {
+    text: string;
+    toolCalls: Map<string, StreamedToolCallState>;
+    messages: StreamedMessage[];
+};
+export type FrameworkStreamState = {
+    toolCalls: Map<string, FrameworkToolCallState>;
+    emittedToolCallIds: Set<string>;
+    emittedToolResultIds: Set<string>;
+    logger?: ForkRuntimeStreamLogger;
+};
+export type ForkPart = ForkStreamPart | ForkToolInputStartPart | ForkToolInputDeltaPart | ForkToolCallPart | ForkToolResultPart | ForkToolErrorPart | ForkErrorPart;
+export type ForkRuntimeStreamLogger = {
+    warn: (message: string, metadata?: Record<string, unknown>) => void;
+};
+export interface ForkRuntimeStreamResult {
+    fullStream: AsyncIterable<ForkPart>;
+    steps: PromiseLike<readonly ForkRuntimeStep[]>;
+    totalUsage: PromiseLike<{
+        inputTokens?: number;
+        outputTokens?: number;
+    } | undefined>;
+}
+export declare const DEFAULT_FORK_RESPONSE_PROMISE_TIMEOUT_MS = 1000;
+export declare function runFrameworkForkStep(input: {
+    apiUrl: string;
+    authToken: string;
+    projectId: string | null;
+    model: string;
+    messages: AgentMessage[];
+    system: string;
+    abortSignal?: AbortSignal;
+    forkToolNames: string[];
+    frameworkTools: Record<string, Tool | boolean>;
+    providerOptions?: Record<string, unknown>;
+}): Promise<{
+    stream: ReadableStream<Uint8Array>;
+    responsePromise: Promise<AgentResponse>;
+}>;
+export declare function createStreamedStepState(): StreamedStepState;
+export declare function applyPartToStreamedStepState(state: StreamedStepState, part: ForkPart): void;
+export declare function resolveForkStepResponse(input: {
+    responsePromise: Promise<AgentResponse>;
+    responseTimeoutMs: number;
+    abortSignal?: AbortSignal;
+    currentMessages: readonly AgentMessage[];
+    streamedStepState: StreamedStepState;
+}): Promise<AgentResponse>;
+export declare function buildRecoveredStepParts(step: ForkRuntimeStep, state: ForkRecoveredPartsState): Array<ForkToolCallPart | ForkToolResultPart>;
+export declare function createFrameworkStreamState(input?: {
+    logger?: ForkRuntimeStreamLogger;
+}): FrameworkStreamState;
+export declare function mapFrameworkEventToForkParts(event: AgUiRuntimeStreamEvent, state: FrameworkStreamState): ForkPart[];
+export {};
+//# sourceMappingURL=fork-runtime-stream.d.ts.map

package/esm/src/agent/fork-runtime-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fork-runtime-stream.d.ts","sourceRoot":"","sources":["../../../src/src/agent/fork-runtime-stream.ts"],"names":[],"mappings":"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"}

package/esm/src/agent/fork-runtime-stream.js

@@ -0,0 +1,505 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { isRecord } from "../chat/conversation.js";
+import { safeJsonParse } from "../chat/provider-errors.js";
+import { runWithVeryfrontCloudContextAsync } from "../provider/veryfront-cloud/context.js";
+import { mergeToolInputDelta, parseToolInputObject, stripLeadingEmptyObjectPlaceholder, } from "./data-stream.js";
+import { HOSTED_CHILD_STREAM_TIMEOUT_TOKEN, resolveHostedChildPromiseWithTimeout, } from "./hosted-child-stream-watchdog.js";
+import { AgentRuntime } from "./runtime/index.js";
+export const DEFAULT_FORK_RESPONSE_PROMISE_TIMEOUT_MS = 1_000;
+function createFrameworkForkAbortError(abortSignal) {
+    if (abortSignal?.reason instanceof Error) {
+        return abortSignal.reason;
+    }
+    return new DOMException("Framework fork aborted before completion.", "AbortError");
+}
+export async function runFrameworkForkStep(input) {
+    let resolveResponsePromise;
+    let rejectResponsePromise;
+    const responsePromise = new Promise((resolve, reject) => {
+        resolveResponsePromise = resolve;
+        rejectResponsePromise = reject;
+    });
+    const abortHandler = () => {
+        rejectResponsePromise(createFrameworkForkAbortError(input.abortSignal));
+    };
+    if (input.abortSignal) {
+        if (input.abortSignal.aborted) {
+            abortHandler();
+        }
+        else {
+            input.abortSignal.addEventListener("abort", abortHandler, { once: true });
+        }
+    }
+    const runtimeConfig = {
+        model: input.model,
+        system: input.system,
+        tools: input.frameworkTools,
+        maxSteps: 1,
+        ...(input.providerOptions
+            ? { resolveModelTransport: () => ({ providerOptions: input.providerOptions }) }
+            : {}),
+        __vfAllowedRemoteTools: input.forkToolNames,
+    };
+    const runtime = new AgentRuntime("invoke-agent-child-framework", runtimeConfig);
+    const stream = await runWithVeryfrontCloudContextAsync({
+        apiBaseUrl: input.apiUrl,
+        apiToken: input.authToken,
+        serviceLayer: "cloud",
+    }, () => runtime.stream(input.messages, input.projectId ? { projectId: input.projectId } : undefined, {
+        onFinish: (response) => {
+            input.abortSignal?.removeEventListener("abort", abortHandler);
+            resolveResponsePromise(response);
+        },
+    }, input.model, undefined, input.abortSignal));
+    return {
+        stream,
+        responsePromise,
+    };
+}
+export function createStreamedStepState() {
+    return {
+        text: "",
+        toolCalls: new Map(),
+        messages: [],
+    };
+}
+function appendStreamedMessagePart(state, role, part) {
+    const lastMessage = state.messages.at(-1);
+    if (lastMessage?.role === role) {
+        lastMessage.parts.push(part);
+        return;
+    }
+    state.messages.push({
+        role,
+        parts: [part],
+    });
+}
+function isFrameworkTextPart(part) {
+    return part.type === "text";
+}
+export function applyPartToStreamedStepState(state, part) {
+    switch (part.type) {
+        case "tool-input-start": {
+            const existing = state.toolCalls.get(part.toolCallId);
+            state.toolCalls.set(part.toolCallId, {
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                inputText: existing?.inputText ?? "",
+                input: existing?.input ?? {},
+                status: existing?.status ?? "pending",
+                ...(existing?.output !== undefined ? { output: existing.output } : {}),
+                ...(existing?.errorText ? { errorText: existing.errorText } : {}),
+            });
+            break;
+        }
+        case "text-delta": {
+            state.text += part.text;
+            const lastAssistantMessage = state.messages.at(-1);
+            const lastAssistantPart = lastAssistantMessage?.role === "assistant"
+                ? lastAssistantMessage.parts.at(-1)
+                : null;
+            if (lastAssistantMessage && lastAssistantPart && isFrameworkTextPart(lastAssistantPart)) {
+                lastAssistantPart.text += part.text;
+            }
+            else {
+                appendStreamedMessagePart(state, "assistant", {
+                    type: "text",
+                    text: part.text,
+                });
+            }
+            break;
+        }
+        case "tool-input-delta": {
+            const existing = state.toolCalls.get(part.toolCallId);
+            if (!existing) {
+                break;
+            }
+            existing.inputText = mergeToolInputDelta(existing.inputText, part.delta);
+            const parsedInput = getParsedStreamedToolInput(existing.inputText);
+            if (parsedInput) {
+                existing.input = parsedInput;
+            }
+            break;
+        }
+        case "tool-call": {
+            const existing = state.toolCalls.get(part.toolCallId);
+            state.toolCalls.set(part.toolCallId, {
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                input: part.input,
+                inputText: existing?.inputText ?? "",
+                status: "pending",
+                ...(existing?.output !== undefined ? { output: existing.output } : {}),
+                ...(existing?.errorText ? { errorText: existing.errorText } : {}),
+            });
+            appendStreamedMessagePart(state, "assistant", {
+                type: `tool-${part.toolName}`,
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                args: parseToolInputObject(part.input),
+            });
+            break;
+        }
+        case "tool-result": {
+            const existing = state.toolCalls.get(part.toolCallId);
+            state.toolCalls.set(part.toolCallId, {
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                input: part.input,
+                inputText: existing?.inputText ?? "",
+                status: "completed",
+                output: part.output,
+                ...(existing?.errorText ? { errorText: existing.errorText } : {}),
+            });
+            appendStreamedMessagePart(state, "tool", {
+                type: "tool-result",
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                result: part.output,
+            });
+            break;
+        }
+        case "tool-error": {
+            const existing = state.toolCalls.get(part.toolCallId);
+            state.toolCalls.set(part.toolCallId, {
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                input: part.input,
+                inputText: existing?.inputText ?? "",
+                status: "error",
+                ...(existing?.output !== undefined ? { output: existing.output } : {}),
+                errorText: part.error.message,
+            });
+            break;
+        }
+        default:
+            break;
+    }
+}
+function buildFallbackFrameworkMessages(baseMessages, state) {
+    const messages = baseMessages.map((message) => ({
+        ...message,
+        parts: [...message.parts],
+    }));
+    if (state.messages.length > 0) {
+        messages.push(...state.messages.map((message) => ({
+            id: dntShim.crypto.randomUUID(),
+            role: message.role,
+            timestamp: Date.now(),
+            parts: structuredClone(message.parts),
+        })));
+    }
+    else if (state.text.trim().length > 0) {
+        messages.push({
+            id: dntShim.crypto.randomUUID(),
+            role: "assistant",
+            timestamp: Date.now(),
+            parts: [{ type: "text", text: state.text }],
+        });
+    }
+    return messages;
+}
+function collectToolResultPaths(messages) {
+    const paths = new Set();
+    for (const message of messages) {
+        for (const part of message.parts) {
+            if (part.type !== "tool-result") {
+                continue;
+            }
+            const partResult = "result" in part ? part.result : null;
+            const result = isRecord(partResult) ? partResult : null;
+            const path = typeof result?.path === "string" ? result.path : null;
+            if (path) {
+                paths.add(path);
+            }
+        }
+    }
+    return [...paths];
+}
+function buildRecoverablePriorWorkState(messages) {
+    const paths = collectToolResultPaths(messages);
+    if (paths.length === 0) {
+        return null;
+    }
+    const previewPaths = paths.slice(0, 8);
+    const suffix = paths.length > previewPaths.length
+        ? ` and ${paths.length - previewPaths.length} more`
+        : "";
+    const text = `Completed child tool work. Project artifact(s): ${previewPaths.join(", ")}${suffix}.`;
+    return {
+        text,
+        toolCalls: new Map(),
+        messages: [
+            {
+                role: "assistant",
+                parts: [{ type: "text", text }],
+            },
+        ],
+    };
+}
+function hasFallbackStepContent(state) {
+    return state.text.trim().length > 0 || state.toolCalls.size > 0;
+}
+function buildFallbackAgentResponse(input) {
+    return {
+        text: input.state.text,
+        messages: buildFallbackFrameworkMessages(input.baseMessages, input.state),
+        toolCalls: [...input.state.toolCalls.values()].map((toolCall) => ({
+            id: toolCall.toolCallId,
+            name: toolCall.toolName,
+            args: parseToolInputObject(toolCall.input),
+            status: toolCall.status,
+            ...(toolCall.status === "completed" ? { result: toolCall.output } : {}),
+            ...(toolCall.status === "error" && toolCall.errorText ? { error: toolCall.errorText } : {}),
+        })),
+        metadata: {},
+        status: "completed",
+    };
+}
+export async function resolveForkStepResponse(input) {
+    const resolvedResponse = await resolveHostedChildPromiseWithTimeout(input.responsePromise, input.responseTimeoutMs);
+    if (resolvedResponse !== HOSTED_CHILD_STREAM_TIMEOUT_TOKEN) {
+        return resolvedResponse;
+    }
+    if (input.abortSignal?.aborted) {
+        throw createFrameworkForkAbortError(input.abortSignal);
+    }
+    const fallbackState = hasFallbackStepContent(input.streamedStepState)
+        ? input.streamedStepState
+        : buildRecoverablePriorWorkState(input.currentMessages);
+    if (!fallbackState) {
+        throw new Error("Framework fork stream ended without onFinish and without recoverable output.");
+    }
+    return buildFallbackAgentResponse({
+        baseMessages: input.currentMessages,
+        state: fallbackState,
+    });
+}
+function warnForkRuntimeStream(logger, message, metadata) {
+    logger?.warn(message, metadata);
+}
+export function buildRecoveredStepParts(step, state) {
+    const recoveredParts = [];
+    for (const toolCall of step.toolCalls) {
+        if (state.emittedToolCallIds.has(toolCall.toolCallId)) {
+            continue;
+        }
+        const streamedCall = state.toolCalls.get(toolCall.toolCallId);
+        warnForkRuntimeStream(state.logger, "Child fork recovered missing tool-call from final step", {
+            toolCallId: toolCall.toolCallId,
+            toolName: toolCall.toolName,
+            sawInputStart: streamedCall?.sawInputStart ?? false,
+            sawInputDelta: streamedCall?.sawInputDelta ?? false,
+            sawInputAvailable: streamedCall?.sawInputAvailable ?? false,
+            sawOutputAvailable: streamedCall?.sawOutputAvailable ?? false,
+            sawOutputError: streamedCall?.sawOutputError ?? false,
+        });
+        state.emittedToolCallIds.add(toolCall.toolCallId);
+        recoveredParts.push({
+            type: "tool-call",
+            toolCallId: toolCall.toolCallId,
+            toolName: toolCall.toolName,
+            input: toolCall.input,
+        });
+    }
+    for (const toolResult of step.toolResults) {
+        if (state.emittedToolResultIds.has(toolResult.toolCallId)) {
+            continue;
+        }
+        const streamedCall = state.toolCalls.get(toolResult.toolCallId);
+        warnForkRuntimeStream(state.logger, "Child fork recovered missing tool-result from final step", {
+            toolCallId: toolResult.toolCallId,
+            toolName: toolResult.toolName,
+            sawInputStart: streamedCall?.sawInputStart ?? false,
+            sawInputDelta: streamedCall?.sawInputDelta ?? false,
+            sawInputAvailable: streamedCall?.sawInputAvailable ?? false,
+            sawOutputAvailable: streamedCall?.sawOutputAvailable ?? false,
+            sawOutputError: streamedCall?.sawOutputError ?? false,
+        });
+        state.emittedToolResultIds.add(toolResult.toolCallId);
+        recoveredParts.push({
+            type: "tool-result",
+            toolCallId: toolResult.toolCallId,
+            toolName: toolResult.toolName,
+            input: toolResult.input,
+            output: toolResult.output,
+        });
+    }
+    return recoveredParts;
+}
+function isEmptyRecord(value) {
+    return Object.keys(value).length === 0;
+}
+function getParsedStreamedToolInput(inputText) {
+    const strippedInputText = stripLeadingEmptyObjectPlaceholder(inputText).trim();
+    const normalizedInputText = strippedInputText.startsWith('"')
+        ? `{${strippedInputText}`
+        : strippedInputText;
+    if (normalizedInputText.length === 0) {
+        return {};
+    }
+    const parsed = safeJsonParse(normalizedInputText);
+    if (!parsed.ok) {
+        return null;
+    }
+    return isRecord(parsed.value) ? Object.fromEntries(Object.entries(parsed.value)) : {};
+}
+function buildToolCallPartIfNeeded(toolCallId, state) {
+    const toolCall = state.toolCalls.get(toolCallId);
+    if (!toolCall || state.emittedToolCallIds.has(toolCallId)) {
+        return [];
+    }
+    state.emittedToolCallIds.add(toolCallId);
+    return [
+        {
+            type: "tool-call",
+            toolCallId,
+            toolName: toolCall.toolName,
+            input: toolCall.input,
+        },
+    ];
+}
+export function createFrameworkStreamState(input = {}) {
+    return {
+        toolCalls: new Map(),
+        emittedToolCallIds: new Set(),
+        emittedToolResultIds: new Set(),
+        ...(input.logger ? { logger: input.logger } : {}),
+    };
+}
+export function mapFrameworkEventToForkParts(event, state) {
+    switch (event.type) {
+        case "reasoning-delta":
+            return typeof event.delta === "string"
+                ? [{ type: "reasoning-delta", text: event.delta }]
+                : [];
+        case "text-delta":
+            return typeof event.delta === "string" ? [{ type: "text-delta", text: event.delta }] : [];
+        case "tool-input-start": {
+            const toolCallId = typeof event.toolCallId === "string" ? event.toolCallId : null;
+            const toolName = typeof event.toolName === "string" ? event.toolName : null;
+            if (!toolCallId || !toolName) {
+                return [];
+            }
+            const existing = state.toolCalls.get(toolCallId);
+            state.toolCalls.set(toolCallId, {
+                toolName,
+                inputText: existing?.inputText ?? "",
+                input: existing?.input ?? {},
+                sawInputStart: true,
+                sawInputDelta: existing?.sawInputDelta ?? false,
+                sawInputAvailable: existing?.sawInputAvailable ?? false,
+                sawOutputAvailable: existing?.sawOutputAvailable ?? false,
+                sawOutputError: existing?.sawOutputError ?? false,
+            });
+            return [{ type: "tool-input-start", toolCallId, toolName }];
+        }
+        case "tool-input-delta": {
+            const inputToolCallId = typeof event.toolCallId === "string" ? event.toolCallId : null;
+            const inputDelta = typeof event.inputTextDelta === "string" ? event.inputTextDelta : null;
+            if (!inputToolCallId || !inputDelta) {
+                return [];
+            }
+            const existing = state.toolCalls.get(inputToolCallId);
+            if (existing) {
+                existing.inputText = mergeToolInputDelta(existing.inputText, inputDelta);
+                existing.sawInputDelta = true;
+                const parsedInput = getParsedStreamedToolInput(existing.inputText);
+                if (parsedInput) {
+                    existing.input = parsedInput;
+                }
+            }
+            else {
+                warnForkRuntimeStream(state.logger, "Child fork received tool-input-delta before tool-input-start", {
+                    toolCallId: inputToolCallId,
+                    deltaLength: inputDelta.length,
+                });
+            }
+            return [{ type: "tool-input-delta", toolCallId: inputToolCallId, delta: inputDelta }];
+        }
+        case "tool-input-available": {
+            const toolCallId = typeof event.toolCallId === "string" ? event.toolCallId : null;
+            const toolName = typeof event.toolName === "string" ? event.toolName : null;
+            if (!toolCallId || !toolName) {
+                return [];
+            }
+            const input = parseToolInputObject(event.input);
+            const existing = state.toolCalls.get(toolCallId);
+            const resolvedInput = existing && isEmptyRecord(input) && !isEmptyRecord(existing.input)
+                ? existing.input
+                : input;
+            state.toolCalls.set(toolCallId, {
+                toolName,
+                inputText: "",
+                input: resolvedInput,
+                sawInputStart: existing?.sawInputStart ?? false,
+                sawInputDelta: existing?.sawInputDelta ?? false,
+                sawInputAvailable: true,
+                sawOutputAvailable: existing?.sawOutputAvailable ?? false,
+                sawOutputError: existing?.sawOutputError ?? false,
+            });
+            return buildToolCallPartIfNeeded(toolCallId, state);
+        }
+        case "tool-output-available": {
+            if (event.preliminary === true) {
+                return [];
+            }
+            const toolCallId = typeof event.toolCallId === "string" ? event.toolCallId : null;
+            if (!toolCallId) {
+                return [];
+            }
+            const call = state.toolCalls.get(toolCallId);
+            if (!call) {
+                return [];
+            }
+            call.sawOutputAvailable = true;
+            const parts = [
+                ...buildToolCallPartIfNeeded(toolCallId, state),
+            ];
+            state.emittedToolResultIds.add(toolCallId);
+            parts.push({
+                type: "tool-result",
+                toolCallId,
+                toolName: call.toolName,
+                input: call.input,
+                output: Object.hasOwn(event, "output") ? event.output : null,
+            });
+            return parts;
+        }
+        case "tool-output-error":
+        case "tool-input-error": {
+            const toolCallId = typeof event.toolCallId === "string" ? event.toolCallId : null;
+            if (!toolCallId) {
+                return [];
+            }
+            const call = state.toolCalls.get(toolCallId);
+            const errorText = typeof event.errorText === "string"
+                ? event.errorText
+                : typeof event.error === "string"
+                    ? event.error
+                    : "Tool execution failed";
+            if (call) {
+                call.sawOutputError = true;
+            }
+            const parts = [
+                ...buildToolCallPartIfNeeded(toolCallId, state),
+            ];
+            parts.push({
+                type: "tool-error",
+                toolCallId,
+                toolName: call?.toolName ?? "unknown",
+                input: call?.input ?? {},
+                error: new Error(errorText),
+            });
+            return parts;
+        }
+        case "error": {
+            const errorText = typeof event.errorText === "string"
+                ? event.errorText
+                : "Framework stream failed";
+            return [{ type: "error", error: new Error(errorText) }];
+        }
+        default:
+            return [];
+    }
+}