veryfront 0.1.516 → 0.1.518

package/esm/src/agent/conversation/root-run-context.js

@@ -0,0 +1,79 @@
+import { createConversationAgentRun } from "../durable.js";
+function normalizeProvidedRun(input) {
+    return {
+        runId: input.providedRun.runId,
+        conversationId: input.conversationId,
+        messageId: input.providedRun.messageId,
+        latestEventId: input.providedRun.latestEventId ?? 0,
+        latestExternalEventSequence: input.providedRun.latestExternalEventSequence ?? 0,
+        waitingToolCallId: null,
+        waitingToolName: null,
+        status: "running",
+    };
+}
+function createMirrorPublisher(appendEvents) {
+    return appendEvents ? (events) => appendEvents(events) : undefined;
+}
+export function createConversationRootRunContext(input) {
+    return {
+        run: input.run,
+        effectiveParentRunId: input.run?.runId ?? input.parentRunId,
+        effectiveParentMessageId: input.run?.messageId ?? input.parentMessageId,
+        publishParentRunEvents: createMirrorPublisher(input.appendParentRunEvents),
+    };
+}
+export async function startConversationRootRun(input) {
+    if (input.providedRun) {
+        if (!input.conversationId) {
+            throw new Error("CONVERSATION_ROOT_RUN_REQUIRES_CONVERSATION");
+        }
+        return normalizeProvidedRun({
+            conversationId: input.conversationId,
+            providedRun: input.providedRun,
+        });
+    }
+    if (!input.conversationId) {
+        return null;
+    }
+    return createConversationAgentRun({
+        authToken: input.authToken,
+        apiUrl: input.apiUrl,
+        conversationId: input.conversationId,
+        projectId: input.projectId ?? null,
+        branchId: input.branchId,
+        agentId: input.agentId,
+        implementationKind: input.implementationKind,
+    });
+}
+export function createConversationRootRunStartAdapter(input) {
+    return async () => ({
+        run: await startConversationRootRun({
+            authToken: input.authToken,
+            apiUrl: input.apiUrl,
+            conversationId: input.conversationId,
+            projectId: input.projectId,
+            branchId: input.branchId,
+            agentId: input.agentId,
+            implementationKind: input.implementationKind,
+            providedRun: input.providedRun,
+        }),
+    });
+}
+export async function prepareConversationRootRunContext(input) {
+    const { run } = await createConversationRootRunStartAdapter({
+        authToken: input.authToken,
+        apiUrl: input.apiUrl,
+        conversationId: input.conversationId,
+        projectId: input.projectId,
+        branchId: input.branchId,
+        agentId: input.agentId,
+        implementationKind: input.implementationKind,
+        providedRun: input.providedRun,
+    })({ abortSignal: new AbortController().signal });
+    return createConversationRootRunContext({
+        run,
+        parentRunId: input.parentRunId,
+        parentMessageId: input.parentMessageId,
+        appendParentRunEvents: input.appendParentRunEvents,
+    });
+}

package/esm/src/agent/conversation/root-run-lifecycle.d.ts

@@ -0,0 +1,61 @@
+import { type ConversationRootRunContext, type ConversationRootRunDescriptor } from "./root-run-context.js";
+import { persistLatestConversationUserMessage } from "./bootstrap.js";
+import { type ConversationRunChunkMirror, type HostedConversationRunChunkMirrorInstrumentation } from "./run-chunk-mirror.js";
+import { type ConversationRunEvent } from "./run-events.js";
+import type { ConversationRunProjection } from "../durable.js";
+import type { ChatUiMessage } from "../../chat/types.js";
+export interface ConversationRootRunLifecycle<TMirror> extends ConversationRootRunContext {
+    mirror: TMirror | null;
+}
+export interface PrepareConversationRootRunLifecycleOptions<TMirror> {
+    startRun: (input: {
+        abortSignal: AbortSignal;
+    }) => Promise<{
+        run: ConversationRunProjection | null;
+    }> | {
+        run: ConversationRunProjection | null;
+    };
+    parentRunId?: string;
+    parentMessageId?: string;
+    appendParentRunEvents?: ((events: unknown[]) => Promise<void> | void) | undefined;
+    createMirror?: (run: ConversationRunProjection) => Promise<TMirror> | TMirror;
+}
+export declare function prepareConversationRootRunLifecycle<TMirror>(input: PrepareConversationRootRunLifecycleOptions<TMirror>, options: {
+    abortSignal: AbortSignal;
+}): Promise<ConversationRootRunLifecycle<TMirror>>;
+export interface HostedConversationRootRunState {
+    runId: string;
+    conversationId: string;
+    messageId: string;
+    latestEventId: number;
+    latestExternalEventSequence: number;
+}
+export interface HostedConversationRootRunContext {
+    durableRootRun: HostedConversationRootRunState | null;
+    durableRunMirror: ConversationRunChunkMirror | null;
+    effectiveParentRunId?: string;
+    effectiveParentMessageId?: string;
+    publishParentRunEvents?: (events: ConversationRunEvent[]) => Promise<void>;
+}
+export interface PrepareHostedConversationRootRunContextInput {
+    authToken: string;
+    apiUrl: string;
+    conversationId?: string;
+    projectId?: string | null;
+    branchId?: string | null;
+    agentId: string;
+    implementationKind?: string | null;
+    messages: ChatUiMessage[];
+    parentRunId?: string;
+    parentMessageId?: string;
+    providedRun?: ConversationRootRunDescriptor;
+    persistLatestUserMessageBeforeRun: boolean;
+    persistLatestUserMessageOperation?: string;
+    missingUserMessageErrorMessage?: string;
+    onPersistLatestUserMessageFailure?: Parameters<typeof persistLatestConversationUserMessage>[0]["onFailure"];
+    instrumentation?: HostedConversationRunChunkMirrorInstrumentation;
+}
+export declare function prepareHostedConversationRootRunContext(input: PrepareHostedConversationRootRunContextInput, options: {
+    abortSignal: AbortSignal;
+}): Promise<HostedConversationRootRunContext>;
+//# sourceMappingURL=root-run-lifecycle.d.ts.map

package/esm/src/agent/conversation/root-run-lifecycle.d.ts.map

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

package/esm/src/agent/conversation/root-run-lifecycle.js

@@ -0,0 +1,94 @@
+import { createConversationRootRunContext, createConversationRootRunStartAdapter, } from "./root-run-context.js";
+import { persistLatestConversationUserMessage } from "./bootstrap.js";
+import { createHostedConversationRunChunkMirror, } from "./run-chunk-mirror.js";
+export async function prepareConversationRootRunLifecycle(input, options) {
+    const { run } = await input.startRun({ abortSignal: options.abortSignal });
+    const context = createConversationRootRunContext({
+        run,
+        parentRunId: input.parentRunId,
+        parentMessageId: input.parentMessageId,
+        appendParentRunEvents: input.appendParentRunEvents,
+    });
+    return {
+        ...context,
+        mirror: run && input.createMirror ? await input.createMirror(run) : null,
+    };
+}
+function isConversationRunEvent(value) {
+    return typeof value === "object" && value !== null && "type" in value &&
+        typeof value.type === "string";
+}
+function toHostedConversationRootRunState(run) {
+    if (!run) {
+        return null;
+    }
+    return {
+        runId: run.runId,
+        conversationId: run.conversationId,
+        messageId: run.messageId,
+        latestEventId: run.latestEventId,
+        latestExternalEventSequence: run.latestExternalEventSequence,
+    };
+}
+export async function prepareHostedConversationRootRunContext(input, options) {
+    let durableRunMirror = null;
+    const startConversationRootRun = createConversationRootRunStartAdapter({
+        authToken: input.authToken,
+        apiUrl: input.apiUrl,
+        conversationId: input.conversationId,
+        projectId: input.projectId,
+        branchId: input.branchId,
+        agentId: input.agentId,
+        implementationKind: input.implementationKind,
+        providedRun: input.providedRun,
+    });
+    const rootRunLifecycle = await prepareConversationRootRunLifecycle({
+        startRun: async ({ abortSignal }) => {
+            if (!input.providedRun) {
+                await persistLatestConversationUserMessage({
+                    authToken: input.authToken,
+                    apiUrl: input.apiUrl,
+                    conversationId: input.conversationId,
+                    messages: input.messages,
+                    enabled: input.persistLatestUserMessageBeforeRun,
+                    operation: input.persistLatestUserMessageOperation,
+                    missingUserMessageErrorMessage: input.missingUserMessageErrorMessage,
+                    onFailure: input.onPersistLatestUserMessageFailure,
+                });
+            }
+            return await startConversationRootRun({ abortSignal });
+        },
+        parentRunId: input.parentRunId,
+        parentMessageId: input.parentMessageId,
+        appendParentRunEvents: async (events) => {
+            if (!durableRunMirror || !events.every(isConversationRunEvent)) {
+                return;
+            }
+            await durableRunMirror.appendEvents(events);
+        },
+        createMirror: (run) => {
+            durableRunMirror = createHostedConversationRunChunkMirror({
+                authToken: input.authToken,
+                apiUrl: input.apiUrl,
+                conversationId: run.conversationId,
+                runId: run.runId,
+                latestEventId: run.latestEventId,
+                latestExternalEventSequence: run.latestExternalEventSequence,
+                instrumentation: input.instrumentation,
+            });
+            return durableRunMirror;
+        },
+    }, options);
+    durableRunMirror = rootRunLifecycle.mirror;
+    return {
+        durableRootRun: toHostedConversationRootRunState(rootRunLifecycle.run),
+        durableRunMirror,
+        effectiveParentRunId: rootRunLifecycle.effectiveParentRunId,
+        effectiveParentMessageId: rootRunLifecycle.effectiveParentMessageId,
+        publishParentRunEvents: rootRunLifecycle.publishParentRunEvents
+            ? async (events) => {
+                await rootRunLifecycle.publishParentRunEvents?.(events);
+            }
+            : undefined,
+    };
+}

package/esm/src/agent/conversation/run-chunk-mirror.d.ts

@@ -0,0 +1,74 @@
+import type { ChatMessageMetadata, ChatUiMessageChunk } from "../../chat/protocol.js";
+import { type ConversationRunEvent, ConversationRunEventEncoder } from "./run-events.js";
+import { type ConversationRunMirror, type ConversationRunMirrorRetryScheduledState, type ConversationRunMirrorStoppedState } from "./run-mirror.js";
+import { type ConversationRunEventQueueController } from "../durable.js";
+export interface ConversationRunChunkMirror {
+    handleChunk(chunk: ChatUiMessageChunk<ChatMessageMetadata>): Promise<void>;
+    appendEvents(events: ConversationRunEvent[]): Promise<void>;
+    flush(): Promise<void>;
+    getSnapshot(): ReturnType<ConversationRunMirror["getSnapshot"]>;
+    dispose(): void;
+}
+export interface ConversationRunChunkMirrorPreparedChunk {
+    chunk: ChatUiMessageChunk<ChatMessageMetadata>;
+    events: ConversationRunEvent[];
+}
+export interface ConversationRunChunkMirrorPreparedEvents {
+    events: ConversationRunEvent[];
+}
+export interface ConversationRunChunkMirrorPrepareChunkEventsInput {
+    chunk: ChatUiMessageChunk<ChatMessageMetadata>;
+    defaultPrepare: () => ConversationRunEvent[];
+}
+export interface ConversationRunChunkMirrorPrepareExternalEventsInput {
+    events: ConversationRunEvent[];
+    defaultPrepare: () => ConversationRunEvent[];
+}
+interface ConversationRunChunkMirrorSharedOptions {
+    immediateFlushEventCount?: number;
+    encoder?: ConversationRunEventEncoder;
+    flushDelayMs?: number;
+    getRetryDelayMs?: (consecutiveFailures: number) => number;
+    onRetryScheduled?: (state: ConversationRunMirrorRetryScheduledState) => Promise<void> | void;
+    onStopped?: (state: ConversationRunMirrorStoppedState) => Promise<void> | void;
+    prepareChunkEvents?: (input: ConversationRunChunkMirrorPrepareChunkEventsInput) => Promise<ConversationRunEvent[]> | ConversationRunEvent[];
+    prepareExternalEvents?: (input: ConversationRunChunkMirrorPrepareExternalEventsInput) => Promise<ConversationRunEvent[]> | ConversationRunEvent[];
+    onChunkPrepared?: (input: ConversationRunChunkMirrorPreparedChunk) => Promise<void> | void;
+    onExternalEventsPrepared?: (input: ConversationRunChunkMirrorPreparedEvents) => Promise<void> | void;
+}
+export interface ConversationRunChunkMirrorQueueOptions extends ConversationRunChunkMirrorSharedOptions {
+    queueController: ConversationRunEventQueueController;
+}
+export interface ConversationRunChunkMirrorApiOptions extends ConversationRunChunkMirrorSharedOptions {
+    authToken: string;
+    apiUrl: string;
+    conversationId: string;
+    runId: string;
+    latestEventId: number;
+    latestExternalEventSequence?: number;
+    maxEventsPerBatch?: number;
+    maxCursorResyncsPerFlush?: number;
+}
+export type ConversationRunChunkMirrorOptions = ConversationRunChunkMirrorQueueOptions | ConversationRunChunkMirrorApiOptions;
+export type HostedConversationRunChunkMirrorTraceAttributes = Record<string, string | number | boolean | null | undefined>;
+export interface HostedConversationRunChunkMirrorInstrumentation {
+    trace?: <T>(operationName: string, operation: () => Promise<T>) => Promise<T>;
+    setTraceAttributes?: (attributes: HostedConversationRunChunkMirrorTraceAttributes) => void;
+    debug?: (message: string, metadata: Record<string, unknown>) => void;
+    warn?: (message: string, metadata: Record<string, unknown>) => void;
+    error?: (message: string, metadata: Record<string, unknown>) => void;
+}
+export interface HostedConversationRunChunkMirrorOptions {
+    authToken: string;
+    apiUrl: string;
+    conversationId: string;
+    runId: string;
+    latestEventId: number;
+    latestExternalEventSequence?: number;
+    batchSize?: number;
+    instrumentation?: HostedConversationRunChunkMirrorInstrumentation;
+}
+export declare function createConversationRunChunkMirror(input: ConversationRunChunkMirrorOptions): ConversationRunChunkMirror;
+export declare function createHostedConversationRunChunkMirror(input: HostedConversationRunChunkMirrorOptions): ConversationRunChunkMirror;
+export {};
+//# sourceMappingURL=run-chunk-mirror.d.ts.map

package/esm/src/agent/conversation/run-chunk-mirror.d.ts.map

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

package/esm/src/agent/conversation/run-chunk-mirror.js

@@ -0,0 +1,188 @@
+import { ConversationRunEventEncoder } from "./run-events.js";
+import { createConversationRunMirror, } from "./run-mirror.js";
+import { prepareConversationRunChunkEvents, prepareConversationRunExternalEvents, } from "./run-event-preparation.js";
+import { createConversationRunEventQueueController, } from "../durable.js";
+const DEFAULT_IMMEDIATE_FLUSH_EVENT_COUNT = 24;
+const DEFAULT_MAX_CURSOR_RESYNCS_PER_FLUSH = 3;
+const DEFAULT_HOSTED_CHUNK_MIRROR_BATCH_SIZE = 24;
+function resolveQueueController(input) {
+    if ("queueController" in input) {
+        return input.queueController;
+    }
+    const maxEventsPerBatch = input.maxEventsPerBatch ?? DEFAULT_IMMEDIATE_FLUSH_EVENT_COUNT;
+    return createConversationRunEventQueueController({
+        authToken: input.authToken,
+        apiUrl: input.apiUrl,
+        conversationId: input.conversationId,
+        runId: input.runId,
+        latestEventId: input.latestEventId,
+        latestExternalEventSequence: input.latestExternalEventSequence ?? 0,
+        maxEventsPerBatch,
+        maxCursorResyncsPerFlush: input.maxCursorResyncsPerFlush ??
+            DEFAULT_MAX_CURSOR_RESYNCS_PER_FLUSH,
+    });
+}
+export function createConversationRunChunkMirror(input) {
+    const encoder = input.encoder ?? new ConversationRunEventEncoder();
+    const immediateFlushEventCount = input.immediateFlushEventCount ??
+        DEFAULT_IMMEDIATE_FLUSH_EVENT_COUNT;
+    const mirror = createConversationRunMirror({
+        queueController: resolveQueueController(input),
+        immediateFlushEventCount,
+        ...(input.flushDelayMs !== undefined ? { flushDelayMs: input.flushDelayMs } : {}),
+        ...(input.getRetryDelayMs ? { getRetryDelayMs: input.getRetryDelayMs } : {}),
+        ...(input.onRetryScheduled ? { onRetryScheduled: input.onRetryScheduled } : {}),
+        ...(input.onStopped ? { onStopped: input.onStopped } : {}),
+    });
+    return {
+        async handleChunk(chunk) {
+            if (mirror.getSnapshot().disabled) {
+                return;
+            }
+            const events = await (input.prepareChunkEvents?.({
+                chunk,
+                defaultPrepare: () => prepareConversationRunChunkEvents([chunk], encoder),
+            }) ?? prepareConversationRunChunkEvents([chunk], encoder));
+            await input.onChunkPrepared?.({ chunk, events });
+            if (events.length === 0) {
+                return;
+            }
+            mirror.enqueue(events);
+        },
+        async appendEvents(events) {
+            if (mirror.getSnapshot().disabled || events.length === 0) {
+                return;
+            }
+            const normalizedEvents = await (input.prepareExternalEvents?.({
+                events,
+                defaultPrepare: () => prepareConversationRunExternalEvents(events),
+            }) ?? prepareConversationRunExternalEvents(events));
+            await input.onExternalEventsPrepared?.({ events: normalizedEvents });
+            if (normalizedEvents.length === 0) {
+                return;
+            }
+            mirror.enqueue(normalizedEvents);
+        },
+        flush() {
+            return mirror.flush();
+        },
+        getSnapshot() {
+            return mirror.getSnapshot();
+        },
+        dispose() {
+            mirror.dispose();
+        },
+    };
+}
+function createHostedChunkMirrorRetryMetadata(input) {
+    return {
+        conversationId: input.conversationId,
+        runId: input.runId,
+        error: input.errorMessage,
+        retryDelayMs: input.retryDelayMs,
+        pendingEventCount: input.pendingEventCount,
+        consecutiveFailures: input.consecutiveFailures,
+    };
+}
+async function runHostedChunkMirrorTrace(instrumentation, operationName, operation) {
+    if (instrumentation?.trace) {
+        return await instrumentation.trace(operationName, operation);
+    }
+    return await operation();
+}
+function recordHostedChunkMirrorRetryScheduled(input) {
+    input.instrumentation?.error?.("Durable run mirror flush failed; queued for retry", createHostedChunkMirrorRetryMetadata({
+        conversationId: input.conversationId,
+        runId: input.runId,
+        errorMessage: input.flushAttempt.errorMessage ?? "Conversation run append failed",
+        retryDelayMs: input.flushAttempt.retryDelayMs,
+        pendingEventCount: input.flushAttempt.pendingEventCount,
+        consecutiveFailures: input.flushAttempt.consecutiveFailures,
+    }));
+}
+function recordHostedChunkMirrorStopped(input) {
+    if (input.flushAttempt.disableReason === "cursor_resyncs_exhausted") {
+        input.instrumentation?.error?.("Disabling durable run mirroring after repeated cursor resync failures", {
+            conversationId: input.conversationId,
+            runId: input.runId,
+        });
+        return;
+    }
+    if (input.flushAttempt.disableReason === "ignorable_append_rejection") {
+        input.instrumentation?.warn?.("Disabling durable run mirroring after external append rejection", {
+            conversationId: input.conversationId,
+            runId: input.runId,
+        });
+        return;
+    }
+    if (input.flushAttempt.disableReason === "non_appendable") {
+        input.instrumentation?.warn?.("Disabling durable run mirroring after cursor mismatch reached a non-appendable run state", {
+            conversationId: input.conversationId,
+            runId: input.runId,
+            latestEventId: input.flushAttempt.latestEventId,
+            latestExternalEventSequence: input.flushAttempt.latestExternalEventSequence,
+        });
+    }
+}
+export function createHostedConversationRunChunkMirror(input) {
+    const batchSize = input.batchSize ?? DEFAULT_HOSTED_CHUNK_MIRROR_BATCH_SIZE;
+    return createConversationRunChunkMirror({
+        authToken: input.authToken,
+        apiUrl: input.apiUrl,
+        conversationId: input.conversationId,
+        runId: input.runId,
+        latestEventId: input.latestEventId,
+        latestExternalEventSequence: input.latestExternalEventSequence,
+        maxEventsPerBatch: batchSize,
+        maxCursorResyncsPerFlush: DEFAULT_MAX_CURSOR_RESYNCS_PER_FLUSH,
+        immediateFlushEventCount: batchSize,
+        prepareChunkEvents: ({ chunk, defaultPrepare }) => runHostedChunkMirrorTrace(input.instrumentation, "durable.mirrorChunk", async () => {
+            const events = defaultPrepare();
+            input.instrumentation?.setTraceAttributes?.({
+                "conversation.id": input.conversationId,
+                "run.id": input.runId,
+                "stream.ui_chunk.type": chunk.type,
+                "durable.event_count": events.length,
+            });
+            input.instrumentation?.debug?.("Durable run mirror processed UI chunk", {
+                conversationId: input.conversationId,
+                runId: input.runId,
+                chunkType: chunk.type,
+                durableEventTypes: events.map((event) => event.type),
+                durableEventCount: events.length,
+            });
+            return events;
+        }),
+        prepareExternalEvents: ({ defaultPrepare }) => runHostedChunkMirrorTrace(input.instrumentation, "durable.mirrorAppendEvents", async () => {
+            const events = defaultPrepare();
+            input.instrumentation?.setTraceAttributes?.({
+                "conversation.id": input.conversationId,
+                "run.id": input.runId,
+                "durable.event_count": events.length,
+            });
+            input.instrumentation?.debug?.("Durable run mirror queued external events", {
+                conversationId: input.conversationId,
+                runId: input.runId,
+                durableEventTypes: events.map((event) => event.type),
+                durableEventCount: events.length,
+            });
+            return events;
+        }),
+        onRetryScheduled: (flushAttempt) => {
+            recordHostedChunkMirrorRetryScheduled({
+                instrumentation: input.instrumentation,
+                conversationId: input.conversationId,
+                runId: input.runId,
+                flushAttempt,
+            });
+        },
+        onStopped: (flushAttempt) => {
+            recordHostedChunkMirrorStopped({
+                instrumentation: input.instrumentation,
+                conversationId: input.conversationId,
+                runId: input.runId,
+                flushAttempt,
+            });
+        },
+    });
+}

package/esm/src/agent/conversation/run-context.d.ts

@@ -0,0 +1,19 @@
+import type { ConversationRunProjection } from "../durable.js";
+export interface ConversationRunContext {
+    run: ConversationRunProjection | null;
+    effectiveParentRunId?: string;
+    effectiveParentMessageId?: string;
+    publishParentRunEvents?: (events: unknown[]) => Promise<void> | void;
+}
+export declare function createConversationRunContext(input: {
+    run: ConversationRunProjection | null;
+    parentRunId?: string;
+    parentMessageId?: string;
+    publishParentRunEvents?: ((events: unknown[]) => Promise<void> | void) | undefined;
+}): {
+    run: ConversationRunProjection | null;
+    effectiveParentRunId: string | undefined;
+    effectiveParentMessageId: string | undefined;
+    publishParentRunEvents: ((events: unknown[]) => Promise<void> | void) | undefined;
+};
+//# sourceMappingURL=run-context.d.ts.map

package/esm/src/agent/conversation/run-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-context.d.ts","sourceRoot":"","sources":["../../../../src/src/agent/conversation/run-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAE/D,MAAM,WAAW,sBAAsB;IACrC,GAAG,EAAE,yBAAyB,GAAG,IAAI,CAAC;IACtC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,sBAAsB,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACtE;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE;IAClD,GAAG,EAAE,yBAAyB,GAAG,IAAI,CAAC;IACtC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,sBAAsB,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,GAAG,SAAS,CAAC;CACpF;;;;sCADoC,OAAO,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;EAQtE"}

package/esm/src/agent/conversation/run-event-normalization.d.ts

@@ -0,0 +1,8 @@
+type ConversationRunEventRecord = Record<string, unknown> & {
+    type: string;
+};
+export declare function getConversationRunEventJsonByteLength(value: unknown): number;
+export declare function normalizeConversationRunEvent(event: ConversationRunEventRecord): ConversationRunEventRecord[];
+export declare function normalizeConversationRunEvents(events: ConversationRunEventRecord[]): ConversationRunEventRecord[];
+export {};
+//# sourceMappingURL=run-event-normalization.d.ts.map

package/esm/src/agent/conversation/run-event-normalization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-event-normalization.d.ts","sourceRoot":"","sources":["../../../../src/src/agent/conversation/run-event-normalization.ts"],"names":[],"mappings":"AAQA,KAAK,0BAA0B,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAS7E,wBAAgB,qCAAqC,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAM5E;AAED,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,0BAA0B,GAChC,0BAA0B,EAAE,CAkB9B;AAED,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,0BAA0B,EAAE,GACnC,0BAA0B,EAAE,CAE9B"}

package/esm/src/agent/conversation/run-event-preparation.d.ts

@@ -0,0 +1,7 @@
+import { type ChatMessageMetadata, type ChatStreamEvent, type ChatUiMessageChunk } from "../../chat/protocol.js";
+import { type ConversationRunEvent, ConversationRunEventEncoder } from "./run-events.js";
+export declare function toConversationRunStreamEvent(chunk: ChatUiMessageChunk<ChatMessageMetadata>): ChatStreamEvent;
+export declare function prepareConversationRunStreamEvents(events: ChatStreamEvent[], encoder?: ConversationRunEventEncoder): ConversationRunEvent[];
+export declare function prepareConversationRunChunkEvents(chunks: ChatUiMessageChunk<ChatMessageMetadata>[], encoder?: ConversationRunEventEncoder): ConversationRunEvent[];
+export declare function prepareConversationRunExternalEvents(events: ConversationRunEvent[]): ConversationRunEvent[];
+//# sourceMappingURL=run-event-preparation.d.ts.map

package/esm/src/agent/conversation/run-event-preparation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-event-preparation.d.ts","sourceRoot":"","sources":["../../../../src/src/agent/conversation/run-event-preparation.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACxB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,KAAK,oBAAoB,EACzB,2BAA2B,EAE5B,MAAM,iBAAiB,CAAC;AAiBzB,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,kBAAkB,CAAC,mBAAmB,CAAC,GAC7C,eAAe,CAuBjB;AAED,wBAAgB,kCAAkC,CAChD,MAAM,EAAE,eAAe,EAAE,EACzB,OAAO,8BAAoC,GAC1C,oBAAoB,EAAE,CAExB;AAED,wBAAgB,iCAAiC,CAC/C,MAAM,EAAE,kBAAkB,CAAC,mBAAmB,CAAC,EAAE,EACjD,OAAO,8BAAoC,GAC1C,oBAAoB,EAAE,CAKxB;AAED,wBAAgB,oCAAoC,CAClD,MAAM,EAAE,oBAAoB,EAAE,GAC7B,oBAAoB,EAAE,CAExB"}

package/esm/src/agent/conversation/run-event-preparation.js

@@ -0,0 +1,48 @@
+import { ConversationRunEventEncoder, encodeConversationRunEvents, } from "./run-events.js";
+import { normalizeConversationRunEvents } from "./run-event-normalization.js";
+function normalizeFinishReason(reason) {
+    switch (reason) {
+        case "stop":
+        case "length":
+        case "tool-calls":
+        case "content-filter":
+        case "error":
+        case "other":
+            return reason;
+        default:
+            return undefined;
+    }
+}
+export function toConversationRunStreamEvent(chunk) {
+    switch (chunk.type) {
+        case "start":
+            return {
+                type: "start",
+                ...(chunk.messageId !== undefined ? { messageId: chunk.messageId } : {}),
+                ...(chunk.messageMetadata !== undefined ? { messageMetadata: chunk.messageMetadata } : {}),
+            };
+        case "finish": {
+            const finishReason = normalizeFinishReason(chunk.finishReason);
+            return {
+                type: "finish",
+                ...(finishReason !== undefined ? { finishReason } : {}),
+            };
+        }
+        case "message-metadata":
+            return {
+                type: "message-metadata",
+                messageMetadata: chunk.messageMetadata,
+            };
+        default:
+            return chunk;
+    }
+}
+export function prepareConversationRunStreamEvents(events, encoder = new ConversationRunEventEncoder()) {
+    return normalizeConversationRunEvents(encodeConversationRunEvents(events, encoder));
+}
+export function prepareConversationRunChunkEvents(chunks, encoder = new ConversationRunEventEncoder()) {
+    return prepareConversationRunStreamEvents(chunks.map((chunk) => toConversationRunStreamEvent(chunk)), encoder);
+}
+export function prepareConversationRunExternalEvents(events) {
+    return normalizeConversationRunEvents(events);
+}

package/esm/src/agent/conversation/run-events.d.ts

@@ -0,0 +1,34 @@
+import type { InferSchema } from "../../extensions/schema/index.js";
+import { type ChatStreamEvent } from "../../chat/protocol.js";
+export declare const conversationRunEventTypes: {
+    readonly custom: "CUSTOM";
+    readonly textMessageStart: "TEXT_MESSAGE_START";
+    readonly textMessageContent: "TEXT_MESSAGE_CONTENT";
+    readonly textMessageEnd: "TEXT_MESSAGE_END";
+    readonly reasoningMessageStart: "REASONING_MESSAGE_START";
+    readonly reasoningMessageContent: "REASONING_MESSAGE_CONTENT";
+    readonly reasoningMessageEnd: "REASONING_MESSAGE_END";
+    readonly toolCallStart: "TOOL_CALL_START";
+    readonly toolCallArgs: "TOOL_CALL_ARGS";
+    readonly toolCallEnd: "TOOL_CALL_END";
+    readonly toolCallResult: "TOOL_CALL_RESULT";
+};
+export declare const getConversationRunEventSchema: () => import("../../internal-agents/schema.js").Schema<{
+    type: string;
+} & {} & Record<string, unknown>>;
+/** @deprecated Use getConversationRunEventSchema() */
+export declare const ConversationRunEventSchema: import("../../internal-agents/schema.js").Schema<{
+    type: string;
+} & {} & Record<string, unknown>>;
+export type ConversationRunEvent = InferSchema<ReturnType<typeof getConversationRunEventSchema>> & Record<string, unknown>;
+export declare class ConversationRunEventEncoder {
+    private readonly streamedToolInputs;
+    private readonly toolInputs;
+    private activeMessageId;
+    private getToolResultMessageId;
+    private serializeToolResultContent;
+    encode(chunk: ChatStreamEvent): ConversationRunEvent[];
+}
+export declare function encodeConversationRunEvents(events: ChatStreamEvent[], encoder?: ConversationRunEventEncoder): ConversationRunEvent[];
+export declare function normalizeEncodedConversationRunEvents(events: ChatStreamEvent[], encoder?: ConversationRunEventEncoder): ConversationRunEvent[];
+//# sourceMappingURL=run-events.d.ts.map

package/esm/src/agent/conversation/run-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-events.d.ts","sourceRoot":"","sources":["../../../../src/src/agent/conversation/run-events.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAG9D,eAAO,MAAM,yBAAyB;;;;;;;;;;;;CAY5B,CAAC;AAEX,eAAO,MAAM,6BAA6B;;iCAIzC,CAAC;AAEF,sDAAsD;AACtD,eAAO,MAAM,0BAA0B;;iCAAkC,CAAC;AAE1E,MAAM,MAAM,oBAAoB,GAC5B,WAAW,CAAC,UAAU,CAAC,OAAO,6BAA6B,CAAC,CAAC,GAC7D,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAyB5B,qBAAa,2BAA2B;IACtC,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAqB;IACxD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA8B;IACzD,OAAO,CAAC,eAAe,CAAuB;IAE9C,OAAO,CAAC,sBAAsB;IAM9B,OAAO,CAAC,0BAA0B;IAYlC,MAAM,CAAC,KAAK,EAAE,eAAe,GAAG,oBAAoB,EAAE;CAqJvD;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,eAAe,EAAE,EACzB,OAAO,8BAAoC,GAC1C,oBAAoB,EAAE,CAExB;AAED,wBAAgB,qCAAqC,CACnD,MAAM,EAAE,eAAe,EAAE,EACzB,OAAO,8BAAoC,GAC1C,oBAAoB,EAAE,CAExB"}