veryfront 0.1.252 → 0.1.255

package/src/deno.js

@@ -1,6 +1,6 @@
 export default {
   "name": "veryfront",
-  "version": "0.1.252",
+  "version": "0.1.255",
   "license": "Apache-2.0",
   "nodeModulesDir": "auto",
   "workspace": [

package/src/src/agent/conversation-hosted-lifecycle.ts

@@ -4,11 +4,13 @@ import {
   type ConversationRunProjection,
   finalizeConversationAgentRun,
 } from "./durable.js";
+import { prepareConversationRunStreamEvents } from "./conversation-run-event-preparation.js";
 import {
   type InvokeAgentChildRunProgressEvent,
   type InvokeAgentChildRunProgressInput,
   publishInvokeAgentChildRunProgress,
 } from "./invoke-agent-child-runs.js";
+import type { ChatStreamEvent } from "../chat/protocol.js";
 import type {
   HostedChildLifecycleAdapter,
   HostedChildLifecycleTerminalState,
@@ -100,6 +102,18 @@ export function createConversationHostedLifecycleAdapter<TChunk>(
   };
 }
 
+export function createConversationHostedStreamLifecycleAdapter(
+  options: Omit<
+    CreateConversationHostedLifecycleAdapterOptions<ChatStreamEvent>,
+    "mapChunkToEvents"
+  >,
+): HostedLifecycleAdapter<ConversationRunProjection, ChatStreamEvent> {
+  return createConversationHostedLifecycleAdapter({
+    ...options,
+    mapChunkToEvents: (chunk) => prepareConversationRunStreamEvents([chunk]),
+  });
+}
+
 export interface ConversationChildLifecycleContext {
   authToken: string;
   apiUrl: string;

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

@@ -0,0 +1,20 @@
+import { type ChatStreamEvent } from "../chat/protocol.js";
+import {
+  type ConversationRunEvent,
+  ConversationRunEventEncoder,
+  encodeConversationRunEvents,
+} from "./conversation-run-events.js";
+import { normalizeConversationRunEvents } from "./conversation-run-event-normalization.js";
+
+export function prepareConversationRunStreamEvents(
+  events: ChatStreamEvent[],
+  encoder = new ConversationRunEventEncoder(),
+): ConversationRunEvent[] {
+  return normalizeConversationRunEvents(encodeConversationRunEvents(events, encoder));
+}
+
+export function prepareConversationRunExternalEvents(
+  events: ConversationRunEvent[],
+): ConversationRunEvent[] {
+  return normalizeConversationRunEvents(events);
+}

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

@@ -0,0 +1,234 @@
+import { z } from "zod";
+import { type ChatStreamEvent } from "../chat/protocol.js";
+import { normalizeConversationRunEvents } from "./conversation-run-event-normalization.js";
+
+export const conversationRunEventTypes = {
+  custom: "CUSTOM",
+  textMessageStart: "TEXT_MESSAGE_START",
+  textMessageContent: "TEXT_MESSAGE_CONTENT",
+  textMessageEnd: "TEXT_MESSAGE_END",
+  reasoningMessageStart: "REASONING_MESSAGE_START",
+  reasoningMessageContent: "REASONING_MESSAGE_CONTENT",
+  reasoningMessageEnd: "REASONING_MESSAGE_END",
+  toolCallStart: "TOOL_CALL_START",
+  toolCallArgs: "TOOL_CALL_ARGS",
+  toolCallEnd: "TOOL_CALL_END",
+  toolCallResult: "TOOL_CALL_RESULT",
+} as const;
+
+export const ConversationRunEventSchema = z.object({
+  type: z.string().min(1),
+}).passthrough();
+
+export type ConversationRunEvent = z.infer<typeof ConversationRunEventSchema>;
+
+function serializeToolInput(input: unknown): string {
+  try {
+    return JSON.stringify(input ?? {});
+  } catch {
+    return "{}";
+  }
+}
+
+function encodeCustomDataEvent(
+  chunk: Extract<ChatStreamEvent, { type: `data-${string}` }>,
+): ConversationRunEvent[] {
+  const name = chunk.type.slice("data-".length);
+  if (name.length === 0) {
+    return [];
+  }
+
+  return [{
+    type: conversationRunEventTypes.custom,
+    name,
+    value: chunk.data,
+  }];
+}
+
+export class ConversationRunEventEncoder {
+  private readonly streamedToolInputs = new Set<string>();
+  private readonly toolInputs = new Map<string, unknown>();
+  private activeMessageId: string | null = null;
+
+  private getToolResultMessageId(toolCallId: string) {
+    return this.activeMessageId
+      ? `${this.activeMessageId}:tool:${toolCallId}`
+      : `tool:${toolCallId}`;
+  }
+
+  private serializeToolResultContent(value: unknown): string {
+    if (typeof value === "string") {
+      return value;
+    }
+
+    try {
+      return JSON.stringify(value ?? null);
+    } catch {
+      return String(value);
+    }
+  }
+
+  encode(chunk: ChatStreamEvent): ConversationRunEvent[] {
+    switch (chunk.type) {
+      case "start":
+        this.activeMessageId = chunk.messageId ?? null;
+        return [];
+
+      case "text-start":
+        return [{
+          type: conversationRunEventTypes.textMessageStart,
+          messageId: chunk.id,
+          role: "assistant",
+        }];
+
+      case "text-delta":
+        return [{
+          type: conversationRunEventTypes.textMessageContent,
+          messageId: chunk.id,
+          delta: chunk.delta,
+        }];
+
+      case "text-end":
+        return [{ type: conversationRunEventTypes.textMessageEnd, messageId: chunk.id }];
+
+      case "reasoning-start":
+        return [{
+          type: conversationRunEventTypes.reasoningMessageStart,
+          messageId: chunk.id,
+          role: "assistant",
+        }];
+
+      case "reasoning-delta":
+        return [{
+          type: conversationRunEventTypes.reasoningMessageContent,
+          messageId: chunk.id,
+          delta: chunk.delta,
+        }];
+
+      case "reasoning-end":
+        return [{ type: conversationRunEventTypes.reasoningMessageEnd, messageId: chunk.id }];
+
+      case "tool-input-start":
+        return [{
+          type: conversationRunEventTypes.toolCallStart,
+          toolCallId: chunk.toolCallId,
+          toolCallName: chunk.toolName,
+        }];
+
+      case "tool-input-delta":
+        this.streamedToolInputs.add(chunk.toolCallId);
+        return [{
+          type: conversationRunEventTypes.toolCallArgs,
+          toolCallId: chunk.toolCallId,
+          delta: chunk.inputTextDelta,
+        }];
+
+      case "tool-input-available": {
+        this.toolInputs.set(chunk.toolCallId, chunk.input);
+        const events: ConversationRunEvent[] = [];
+        if (!this.streamedToolInputs.has(chunk.toolCallId)) {
+          events.push({
+            type: conversationRunEventTypes.toolCallArgs,
+            toolCallId: chunk.toolCallId,
+            delta: serializeToolInput(chunk.input),
+          });
+        }
+        events.push({ type: conversationRunEventTypes.toolCallEnd, toolCallId: chunk.toolCallId });
+        return events;
+      }
+
+      case "tool-input-error": {
+        this.toolInputs.set(chunk.toolCallId, chunk.input);
+        const events: ConversationRunEvent[] = [];
+        if (!this.streamedToolInputs.has(chunk.toolCallId)) {
+          events.push({
+            type: conversationRunEventTypes.toolCallArgs,
+            toolCallId: chunk.toolCallId,
+            delta: serializeToolInput(chunk.input),
+          });
+        }
+        events.push({ type: conversationRunEventTypes.toolCallEnd, toolCallId: chunk.toolCallId });
+        events.push({
+          type: conversationRunEventTypes.toolCallResult,
+          messageId: this.getToolResultMessageId(chunk.toolCallId),
+          toolCallId: chunk.toolCallId,
+          content: this.serializeToolResultContent(chunk.errorText),
+          role: "tool",
+          ...(this.toolInputs.has(chunk.toolCallId)
+            ? { input: this.toolInputs.get(chunk.toolCallId) }
+            : {}),
+          isError: true,
+        });
+        this.toolInputs.delete(chunk.toolCallId);
+        return events;
+      }
+
+      case "tool-output-available":
+        return [{
+          type: conversationRunEventTypes.toolCallResult,
+          messageId: this.getToolResultMessageId(chunk.toolCallId),
+          toolCallId: chunk.toolCallId,
+          content: this.serializeToolResultContent(chunk.output),
+          role: "tool",
+          ...(this.toolInputs.has(chunk.toolCallId)
+            ? { input: this.toolInputs.get(chunk.toolCallId) }
+            : {}),
+        }];
+
+      case "tool-output-error":
+        return [{
+          type: conversationRunEventTypes.toolCallResult,
+          messageId: this.getToolResultMessageId(chunk.toolCallId),
+          toolCallId: chunk.toolCallId,
+          content: this.serializeToolResultContent(chunk.errorText),
+          role: "tool",
+          ...(this.toolInputs.has(chunk.toolCallId)
+            ? { input: this.toolInputs.get(chunk.toolCallId) }
+            : {}),
+          isError: true,
+        }];
+
+      case "tool-output-denied":
+        return [{
+          type: conversationRunEventTypes.toolCallResult,
+          messageId: this.getToolResultMessageId(chunk.toolCallId),
+          toolCallId: chunk.toolCallId,
+          content: "Tool output denied",
+          role: "tool",
+          ...(this.toolInputs.has(chunk.toolCallId)
+            ? { input: this.toolInputs.get(chunk.toolCallId) }
+            : {}),
+          isError: true,
+        }];
+
+      case "error":
+      case "finish":
+      case "abort":
+      case "message-metadata":
+      case "source-url":
+      case "source-document":
+      case "file":
+      case "tool-approval-request":
+      case "start-step":
+      case "finish-step":
+        return [];
+
+      default:
+        return chunk.type.startsWith("data-") ? encodeCustomDataEvent(chunk) : [];
+    }
+  }
+}
+
+export function encodeConversationRunEvents(
+  events: ChatStreamEvent[],
+  encoder = new ConversationRunEventEncoder(),
+): ConversationRunEvent[] {
+  return events.flatMap((event) => encoder.encode(event));
+}
+
+export function normalizeEncodedConversationRunEvents(
+  events: ChatStreamEvent[],
+  encoder = new ConversationRunEventEncoder(),
+): ConversationRunEvent[] {
+  return normalizeConversationRunEvents(encodeConversationRunEvents(events, encoder));
+}

package/src/src/agent/conversation-run-stream-mirror.ts

@@ -0,0 +1,59 @@
+import { type ChatStreamEvent } from "../chat/protocol.js";
+import {
+  type ConversationRunEvent,
+  ConversationRunEventEncoder,
+} from "./conversation-run-events.js";
+import {
+  type ConversationRunMirror,
+  type ConversationRunMirrorRetryScheduledState,
+  type ConversationRunMirrorStoppedState,
+  createConversationRunMirror,
+} from "./conversation-run-mirror.js";
+import { normalizeConversationRunEvents } from "./conversation-run-event-normalization.js";
+import { type ConversationRunEventQueueController } from "./durable.js";
+
+export interface ConversationRunStreamMirror {
+  handleStreamEvent(event: ChatStreamEvent): void;
+  appendEvents(events: ConversationRunEvent[]): void;
+  flush(): Promise<void>;
+  getSnapshot(): ReturnType<ConversationRunMirror["getSnapshot"]>;
+  dispose(): void;
+}
+
+export function createConversationRunStreamMirror(input: {
+  queueController: ConversationRunEventQueueController;
+  immediateFlushEventCount: number;
+  encoder?: ConversationRunEventEncoder;
+  flushDelayMs?: number;
+  getRetryDelayMs?: (consecutiveFailures: number) => number;
+  onRetryScheduled?: (state: ConversationRunMirrorRetryScheduledState) => Promise<void> | void;
+  onStopped?: (state: ConversationRunMirrorStoppedState) => Promise<void> | void;
+}): ConversationRunStreamMirror {
+  const encoder = input.encoder ?? new ConversationRunEventEncoder();
+  const mirror = createConversationRunMirror({
+    queueController: input.queueController,
+    immediateFlushEventCount: input.immediateFlushEventCount,
+    ...(input.flushDelayMs !== undefined ? { flushDelayMs: input.flushDelayMs } : {}),
+    ...(input.getRetryDelayMs ? { getRetryDelayMs: input.getRetryDelayMs } : {}),
+    ...(input.onRetryScheduled ? { onRetryScheduled: input.onRetryScheduled } : {}),
+    ...(input.onStopped ? { onStopped: input.onStopped } : {}),
+  });
+
+  return {
+    handleStreamEvent(event) {
+      mirror.enqueue(normalizeConversationRunEvents(encoder.encode(event)));
+    },
+    appendEvents(events) {
+      mirror.enqueue(normalizeConversationRunEvents(events));
+    },
+    flush() {
+      return mirror.flush();
+    },
+    getSnapshot() {
+      return mirror.getSnapshot();
+    },
+    dispose() {
+      mirror.dispose();
+    },
+  };
+}

package/src/src/agent/index.ts

@@ -210,12 +210,25 @@ export {
   createConversationChildLifecycleAdapter,
   createConversationHostedLifecycleAdapter,
   type CreateConversationHostedLifecycleAdapterOptions,
+  createConversationHostedStreamLifecycleAdapter,
 } from "./conversation-hosted-lifecycle.js";
 export {
   getConversationRunEventJsonByteLength,
   normalizeConversationRunEvent,
   normalizeConversationRunEvents,
 } from "./conversation-run-event-normalization.js";
+export {
+  type ConversationRunEvent,
+  ConversationRunEventEncoder,
+  ConversationRunEventSchema,
+  conversationRunEventTypes,
+  encodeConversationRunEvents,
+  normalizeEncodedConversationRunEvents,
+} from "./conversation-run-events.js";
+export {
+  prepareConversationRunExternalEvents,
+  prepareConversationRunStreamEvents,
+} from "./conversation-run-event-preparation.js";
 export {
   type ConversationRunMirror,
   type ConversationRunMirrorRetryScheduledState,
@@ -223,6 +236,10 @@ export {
   type ConversationRunMirrorStoppedState,
   createConversationRunMirror,
 } from "./conversation-run-mirror.js";
+export {
+  type ConversationRunStreamMirror,
+  createConversationRunStreamMirror,
+} from "./conversation-run-stream-mirror.js";
 export {
   type ActiveConversationRunStatus,
   appendConversationRunEvents,