veryfront 0.1.263 → 0.1.265

package/src/src/agent/hosted-child-mirror.ts

@@ -0,0 +1,208 @@
+import type { ChatMessageMetadata, ChatUiMessageChunk } from "../chat/protocol.js";
+import type { HostedStreamPartForUiChunkMapping } from "../chat/hosted-ui-chunk-mapping.js";
+
+export interface HostedChildChunkMirror {
+  handleChunk(chunk: ChatUiMessageChunk<ChatMessageMetadata>): Promise<void> | void;
+}
+
+export interface HostedChildMirrorState {
+  reasoningStarted: boolean;
+  textStarted: boolean;
+}
+
+type CoreMirroredPartType =
+  | "reasoning-delta"
+  | "text-delta"
+  | "tool-input-start"
+  | "tool-input-delta"
+  | "tool-call"
+  | "tool-result";
+
+type MirroredPartType = CoreMirroredPartType | "tool-error" | "error";
+
+type DurableMirrorChunkType = ChatUiMessageChunk<ChatMessageMetadata>["type"];
+
+const ALREADY_MIRRORED_CHUNK_TYPES_BY_PART_TYPE: Readonly<
+  Partial<Record<MirroredPartType, readonly DurableMirrorChunkType[]>>
+> = {
+  "reasoning-delta": ["reasoning-delta"],
+  "text-delta": ["text-delta"],
+  "tool-input-start": ["tool-input-start"],
+  "tool-call": ["tool-input-start", "tool-input-available", "tool-input-error"],
+  "tool-result": ["tool-output-available"],
+  "tool-error": ["tool-input-start", "tool-input-error"],
+};
+
+export function isAlreadyMirroredHostedChunk(
+  partType: MirroredPartType,
+  mirroredChunkType: DurableMirrorChunkType,
+): boolean {
+  return ALREADY_MIRRORED_CHUNK_TYPES_BY_PART_TYPE[partType]?.includes(mirroredChunkType) ?? false;
+}
+
+type MirroredHostedStreamPart = Extract<
+  HostedStreamPartForUiChunkMapping,
+  | { type: "reasoning-delta" }
+  | { type: "text-delta" }
+  | { type: "source" }
+  | { type: "tool-input-start" }
+  | { type: "tool-call" }
+  | { type: "tool-input-delta" }
+  | { type: "tool-result" }
+  | { type: "tool-error" }
+  | { type: "error" }
+>;
+
+type HostedMirrorBasePart =
+  | { type: "reasoning-delta"; text: string }
+  | { type: "text-delta"; text: string }
+  | { type: "tool-input-start"; toolCallId: string; toolName: string }
+  | { type: "tool-input-delta"; toolCallId: string; delta: string }
+  | { type: "tool-call"; toolCallId: string; toolName: string; input: unknown }
+  | { type: "tool-result"; toolCallId: string; toolName: string; input: unknown; output: unknown }
+  | { type: "tool-error"; toolCallId: string; toolName: string; input: unknown; error: Error }
+  | { type: "error"; error: Error };
+
+type ExtraMirroredHostedStreamPart = Extract<HostedStreamPartForUiChunkMapping, { type: "source" }>;
+
+export type HostedChildMirrorPart = HostedMirrorBasePart | ExtraMirroredHostedStreamPart;
+
+export function toMirroredHostedStreamPart(
+  part: HostedChildMirrorPart,
+  ids: {
+    messageId: string | null;
+    reasoningMessageId: string | null;
+  },
+): MirroredHostedStreamPart {
+  switch (part.type) {
+    case "reasoning-delta":
+      return {
+        type: "reasoning-delta",
+        id: ids.reasoningMessageId ?? "fork-reasoning",
+        text: part.text,
+      };
+
+    case "text-delta":
+      return {
+        type: "text-delta",
+        id: ids.messageId ?? "fork-message",
+        text: part.text,
+      };
+
+    case "tool-input-start":
+      return {
+        type: "tool-input-start",
+        id: part.toolCallId,
+        toolName: part.toolName,
+      };
+
+    case "source":
+      if (part.sourceType === "url") {
+        return {
+          type: "source",
+          id: part.id,
+          sourceType: "url",
+          url: part.url,
+          ...(part.title ? { title: part.title } : {}),
+        };
+      }
+
+      return {
+        type: "source",
+        id: part.id,
+        sourceType: "document",
+        mediaType: part.mediaType,
+        title: part.title ?? part.filename ?? part.id,
+        ...(part.filename ? { filename: part.filename } : {}),
+      };
+
+    case "tool-call":
+      return {
+        type: "tool-call",
+        toolCallId: part.toolCallId,
+        toolName: part.toolName,
+        input: part.input,
+      };
+
+    case "tool-input-delta":
+      return {
+        type: "tool-input-delta",
+        id: part.toolCallId,
+        delta: part.delta,
+      };
+
+    case "tool-result":
+      return {
+        type: "tool-result",
+        toolCallId: part.toolCallId,
+        toolName: part.toolName,
+        input: part.input,
+        output: part.output,
+      };
+
+    case "tool-error":
+      return {
+        type: "tool-error",
+        toolCallId: part.toolCallId,
+        toolName: part.toolName,
+        input: part.input,
+        error: part.error,
+      };
+
+    case "error":
+      return {
+        type: "error",
+        error: part.error,
+      };
+  }
+}
+
+export async function appendHostedChildMirrorChunk(input: {
+  mirror: HostedChildChunkMirror | null;
+  chunk: ChatUiMessageChunk<ChatMessageMetadata>;
+}): Promise<boolean> {
+  if (!input.mirror) {
+    return false;
+  }
+
+  await input.mirror.handleChunk(input.chunk);
+  return true;
+}
+
+export async function closeHostedChildReasoningSegment(input: {
+  mirror: HostedChildChunkMirror | null;
+  reasoningMessageId: string | null;
+  state: HostedChildMirrorState;
+}): Promise<void> {
+  if (!input.state.reasoningStarted || !input.reasoningMessageId) {
+    return;
+  }
+
+  input.state.reasoningStarted = false;
+  await appendHostedChildMirrorChunk({
+    mirror: input.mirror,
+    chunk: {
+      type: "reasoning-end",
+      id: input.reasoningMessageId,
+    },
+  });
+}
+
+export async function closeHostedChildTextSegment(input: {
+  mirror: HostedChildChunkMirror | null;
+  messageId: string | null;
+  state: HostedChildMirrorState;
+}): Promise<void> {
+  if (!input.state.textStarted || !input.messageId) {
+    return;
+  }
+
+  input.state.textStarted = false;
+  await appendHostedChildMirrorChunk({
+    mirror: input.mirror,
+    chunk: {
+      type: "text-end",
+      id: input.messageId,
+    },
+  });
+}

package/src/src/agent/index.ts

@@ -359,6 +359,16 @@ export {
   type HostedChildLifecycleTerminalState,
   runHostedChildLifecycle,
 } from "./hosted-child-lifecycle.js";
+export {
+  appendHostedChildMirrorChunk,
+  closeHostedChildReasoningSegment,
+  closeHostedChildTextSegment,
+  type HostedChildChunkMirror,
+  type HostedChildMirrorPart,
+  type HostedChildMirrorState,
+  isAlreadyMirroredHostedChunk,
+  toMirroredHostedStreamPart,
+} from "./hosted-child-mirror.js";
 export {
   type HostedLifecycleAdapter,
   type HostedLifecycleExecution,
@@ -398,6 +408,11 @@ export {
   normalizeChatUiMessageChunk,
   normalizeChatUiMessageStream,
 } from "../chat/chat-ui-message-helpers.js";
+export {
+  type HostedStreamPartForUiChunkMapping,
+  type HostedUiChunkMappingOptions,
+  mapHostedStreamPartToChatUiChunks,
+} from "../chat/hosted-ui-chunk-mapping.js";
 export {
   expandAllowedRemoteToolNames,
   getProviderNativeToolNames,

package/src/src/chat/hosted-ui-chunk-mapping.ts

@@ -0,0 +1,303 @@
+import type { ChatMessageMetadata, ChatUiMessageChunk } from "./protocol.js";
+
+export type HostedUiChunkMappingOptions = {
+  messageId?: string | null;
+  reasoningMessageId?: string | null;
+  sendReasoning?: boolean;
+  sendSources?: boolean;
+  onError?: (error: unknown) => string;
+};
+
+export type HostedStreamSourcePart =
+  | {
+    type: "source";
+    id: string;
+    sourceType: "url";
+    url: string;
+    title?: string;
+  }
+  | {
+    type: "source";
+    id: string;
+    sourceType: "document";
+    mediaType: string;
+    title?: string;
+    filename?: string;
+  };
+
+export type HostedStreamPartForUiChunkMapping =
+  | {
+    type: "start";
+  }
+  | {
+    type: "start-step";
+  }
+  | {
+    type: "finish-step";
+  }
+  | {
+    type: "finish";
+    finishReason?: string;
+  }
+  | {
+    type: "abort";
+  }
+  | {
+    type: "reasoning-start";
+    id: string;
+  }
+  | {
+    type: "reasoning-delta";
+    id: string;
+    text: string;
+  }
+  | {
+    type: "reasoning-end";
+    id: string;
+  }
+  | {
+    type: "text-start";
+    id: string;
+  }
+  | {
+    type: "text-delta";
+    id: string;
+    text: string;
+  }
+  | {
+    type: "text-end";
+    id: string;
+  }
+  | HostedStreamSourcePart
+  | {
+    type: "file";
+    file: {
+      mediaType: string;
+      base64: string;
+    };
+  }
+  | {
+    type: "tool-input-start";
+    id: string;
+    toolName: string;
+  }
+  | {
+    type: "tool-input-delta";
+    id: string;
+    delta: string;
+  }
+  | {
+    type: "tool-call";
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+    invalid: true;
+    error: unknown;
+  }
+  | {
+    type: "tool-call";
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+    invalid?: false;
+  }
+  | {
+    type: "tool-approval-request";
+    approvalId: string;
+    toolCall: {
+      toolCallId: string;
+    };
+  }
+  | {
+    type: "tool-result";
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+    output: unknown;
+  }
+  | {
+    type: "tool-error";
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+    error: unknown;
+  }
+  | {
+    type: "tool-output-denied";
+    toolCallId: string;
+  }
+  | {
+    type: "error";
+    error: unknown;
+  }
+  | {
+    type: "tool-input-end";
+  }
+  | {
+    type: "raw";
+  };
+
+function defaultOnError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function mapHostedStreamSourceToUiChunks(
+  part: HostedStreamSourcePart,
+  sendSources: boolean,
+): ChatUiMessageChunk<ChatMessageMetadata>[] {
+  if (!sendSources) {
+    return [];
+  }
+
+  if (part.sourceType === "url") {
+    return [{
+      type: "source-url",
+      sourceId: part.id,
+      url: part.url,
+      ...(part.title ? { title: part.title } : {}),
+    }];
+  }
+
+  return [
+    {
+      type: "source-document",
+      sourceId: part.id,
+      mediaType: part.mediaType,
+      title: part.title ?? part.filename ?? part.id,
+      ...(part.filename ? { filename: part.filename } : {}),
+    },
+  ];
+}
+
+function mapToolCallPartToUiChunks(
+  part: Extract<HostedStreamPartForUiChunkMapping, { type: "tool-call" }>,
+  onError: (error: unknown) => string,
+): ChatUiMessageChunk<ChatMessageMetadata>[] {
+  if (part.invalid) {
+    return [{
+      type: "tool-input-error",
+      toolCallId: part.toolCallId,
+      toolName: part.toolName,
+      input: part.input,
+      errorText: onError(part.error),
+    }];
+  }
+
+  return [{
+    type: "tool-input-available",
+    toolCallId: part.toolCallId,
+    toolName: part.toolName,
+    input: part.input,
+  }];
+}
+
+function mapToolErrorPartToUiChunks(
+  part: Extract<HostedStreamPartForUiChunkMapping, { type: "tool-error" }>,
+  onError: (error: unknown) => string,
+): ChatUiMessageChunk<ChatMessageMetadata>[] {
+  return [
+    {
+      type: "tool-input-start",
+      toolCallId: part.toolCallId,
+      toolName: part.toolName,
+    },
+    {
+      type: "tool-input-error",
+      toolCallId: part.toolCallId,
+      toolName: part.toolName,
+      input: part.input,
+      errorText: onError(part.error),
+    },
+  ];
+}
+
+export function mapHostedStreamPartToChatUiChunks(
+  part: HostedStreamPartForUiChunkMapping,
+  options: HostedUiChunkMappingOptions = {},
+): ChatUiMessageChunk<ChatMessageMetadata>[] {
+  const onError = options.onError ?? defaultOnError;
+  const sendReasoning = options.sendReasoning ?? true;
+  const sendSources = options.sendSources ?? true;
+
+  switch (part.type) {
+    case "start":
+      return [{ type: "start", ...(options.messageId ? { messageId: options.messageId } : {}) }];
+
+    case "start-step":
+      return [{ type: "start-step" }];
+
+    case "finish-step":
+      return [{ type: "finish-step" }];
+
+    case "finish":
+      return [{
+        type: "finish",
+        ...(part.finishReason ? { finishReason: part.finishReason } : {}),
+      }];
+
+    case "abort":
+      return [{ type: "abort" }];
+
+    case "reasoning-start":
+      return [{ type: "reasoning-start", id: options.reasoningMessageId ?? part.id }];
+
+    case "reasoning-delta":
+      return sendReasoning
+        ? [{ type: "reasoning-delta", id: options.reasoningMessageId ?? part.id, delta: part.text }]
+        : [];
+
+    case "reasoning-end":
+      return [{ type: "reasoning-end", id: options.reasoningMessageId ?? part.id }];
+
+    case "text-start":
+      return [{ type: "text-start", id: options.messageId ?? part.id }];
+
+    case "text-delta":
+      return [{ type: "text-delta", id: options.messageId ?? part.id, delta: part.text }];
+
+    case "text-end":
+      return [{ type: "text-end", id: options.messageId ?? part.id }];
+
+    case "source":
+      return mapHostedStreamSourceToUiChunks(part, sendSources);
+
+    case "file":
+      return [{
+        type: "file",
+        mediaType: part.file.mediaType,
+        url: `data:${part.file.mediaType};base64,${part.file.base64}`,
+      }];
+
+    case "tool-input-start":
+      return [{ type: "tool-input-start", toolCallId: part.id, toolName: part.toolName }];
+
+    case "tool-input-delta":
+      return [{ type: "tool-input-delta", toolCallId: part.id, inputTextDelta: part.delta }];
+
+    case "tool-call":
+      return mapToolCallPartToUiChunks(part, onError);
+
+    case "tool-approval-request":
+      return [{
+        type: "tool-approval-request",
+        approvalId: part.approvalId,
+        toolCallId: part.toolCall.toolCallId,
+      }];
+
+    case "tool-result":
+      return [{ type: "tool-output-available", toolCallId: part.toolCallId, output: part.output }];
+
+    case "tool-error":
+      return mapToolErrorPartToUiChunks(part, onError);
+
+    case "tool-output-denied":
+      return [{ type: "tool-output-denied", toolCallId: part.toolCallId }];
+
+    case "error":
+      return [{ type: "error", errorText: onError(part.error) }];
+
+    case "tool-input-end":
+    case "raw":
+      return [];
+  }
+}

package/src/src/chat/index.ts

@@ -236,6 +236,11 @@ export {
   normalizeChatUiMessageChunk,
   normalizeChatUiMessageStream,
 } from "./chat-ui-message-helpers.js";
+export {
+  type HostedStreamPartForUiChunkMapping,
+  type HostedUiChunkMappingOptions,
+  mapHostedStreamPartToChatUiChunks,
+} from "./hosted-ui-chunk-mapping.js";
 
 export {
   useCompletion,

package/src/src/provider/runtime-loader/provider-embedding-responses.ts

@@ -0,0 +1,61 @@
+import { readRecord } from "./provider-records.js";
+
+function isNumberArray(value: unknown): value is number[] {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "number");
+}
+
+export function extractOpenAIEmbeddings(payload: unknown): number[][] {
+  const record = readRecord(payload);
+  const data = record?.data;
+  if (!Array.isArray(data)) {
+    throw new Error("Invalid OpenAI embedding response: data array missing");
+  }
+
+  const embeddings: number[][] = [];
+
+  for (const item of data) {
+    const itemRecord = readRecord(item);
+    const embedding = itemRecord?.embedding;
+    if (!isNumberArray(embedding)) {
+      throw new Error("Invalid OpenAI embedding response: embedding vector missing");
+    }
+    embeddings.push(embedding);
+  }
+
+  return embeddings;
+}
+
+export function extractOpenAIUsageTokens(payload: unknown): number | undefined {
+  const record = readRecord(payload);
+  const usage = readRecord(record?.usage);
+  const totalTokens = usage?.total_tokens;
+  return typeof totalTokens === "number" ? totalTokens : undefined;
+}
+
+export function extractGoogleEmbedding(payload: unknown): number[] {
+  const record = readRecord(payload);
+  const embeddings = record?.embeddings;
+
+  if (Array.isArray(embeddings) && embeddings.length > 0) {
+    const firstEmbedding = readRecord(embeddings[0]);
+    const values = firstEmbedding?.values;
+    if (isNumberArray(values)) {
+      return values;
+    }
+  }
+
+  const embedding = readRecord(record?.embedding);
+  const values = embedding?.values;
+  if (isNumberArray(values)) {
+    return values;
+  }
+
+  throw new Error("Invalid Google embedding response: embedding vector missing");
+}
+
+export function extractGoogleUsageTokens(payload: unknown): number | undefined {
+  const record = readRecord(payload);
+  const usageMetadata = readRecord(record?.usageMetadata);
+  const promptTokenCount = usageMetadata?.promptTokenCount;
+  return typeof promptTokenCount === "number" ? promptTokenCount : undefined;
+}

package/src/src/provider/runtime-loader/provider-finish-reasons.ts

@@ -0,0 +1,69 @@
+export type NormalizedFinishReason = string | { unified: string; raw: string } | null;
+
+export function normalizeAnthropicFinishReason(raw: unknown): NormalizedFinishReason {
+  if (typeof raw !== "string") {
+    return null;
+  }
+
+  switch (raw) {
+    case "tool_use":
+      return { unified: "tool-calls", raw };
+    case "end_turn":
+    case "stop_sequence":
+      return { unified: "stop", raw };
+    case "max_tokens":
+      return { unified: "length", raw };
+    default:
+      return raw;
+  }
+}
+
+export function normalizeGoogleFinishReason(raw: unknown): NormalizedFinishReason {
+  if (typeof raw !== "string") {
+    return null;
+  }
+
+  switch (raw) {
+    case "STOP":
+      return { unified: "stop", raw };
+    case "MAX_TOKENS":
+      return { unified: "length", raw };
+    case "SAFETY":
+    case "RECITATION":
+      return { unified: "content-filter", raw };
+    default:
+      return raw.toLowerCase();
+  }
+}
+
+export function normalizeOpenAIFinishReason(raw: unknown): NormalizedFinishReason {
+  if (typeof raw !== "string") {
+    return null;
+  }
+
+  if (raw === "tool_calls") {
+    return { unified: "tool-calls", raw };
+  }
+
+  if (raw === "content_filter") {
+    return { unified: "content-filter", raw };
+  }
+
+  return raw;
+}
+
+export function normalizeOpenAIResponsesFinishReason(raw: unknown): NormalizedFinishReason {
+  if (typeof raw !== "string") return null;
+  switch (raw) {
+    case "completed":
+      return { unified: "stop", raw };
+    case "incomplete":
+      return { unified: "length", raw };
+    case "failed":
+      return { unified: "error", raw };
+    case "in_progress":
+      return null;
+    default:
+      return raw;
+  }
+}

package/src/src/provider/runtime-loader/provider-sse.ts

@@ -0,0 +1,29 @@
+export function parseSseChunk(chunk: string): {
+  events: Array<unknown | "[DONE]">;
+  remainder: string;
+} {
+  const blocks = chunk.split(/\r?\n\r?\n/);
+  const remainder = blocks.pop() ?? "";
+  const events = blocks.flatMap((block) => {
+    const dataLines = block.split(/\r?\n/)
+      .filter((line) => line.startsWith("data:"))
+      .map((line) => line.slice(5).trimStart());
+
+    if (!dataLines.length) {
+      return [];
+    }
+
+    const payload = dataLines.join("\n").trim();
+    if (payload === "[DONE]") {
+      return ["[DONE]" as const];
+    }
+
+    try {
+      return [JSON.parse(payload) as unknown];
+    } catch {
+      return [];
+    }
+  });
+
+  return { events, remainder };
+}