veryfront 0.1.261 → 0.1.262

package/src/src/chat/chat-ui-message-helpers.ts

@@ -0,0 +1,114 @@
+import type { ChatMessageMetadata, ChatUiMessageChunk } from "./protocol.js";
+
+type StreamChunkMetadataPart = {
+  type: string;
+  totalUsage?: unknown;
+};
+
+export interface BuildChatStreamChunkMessageMetadataInput {
+  agentId: string;
+  modelId: string;
+  runId?: string;
+  streamingMessageId?: string;
+  part: StreamChunkMetadataPart;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function normalizeUsageMetadata(value: unknown): ChatMessageMetadata["usage"] | undefined {
+  if (!isRecord(value)) {
+    return undefined;
+  }
+
+  const usage = {
+    ...(typeof value.inputTokens === "number" ? { inputTokens: value.inputTokens } : {}),
+    ...(typeof value.outputTokens === "number" ? { outputTokens: value.outputTokens } : {}),
+    ...(typeof value.reasoningTokens === "number"
+      ? { reasoningTokens: value.reasoningTokens }
+      : {}),
+    ...(typeof value.cachedInputTokens === "number"
+      ? { cachedInputTokens: value.cachedInputTokens }
+      : {}),
+  };
+
+  return Object.keys(usage).length > 0 ? usage : undefined;
+}
+
+export function normalizeChatMessageMetadata(value: unknown): ChatMessageMetadata {
+  if (!isRecord(value)) {
+    return {};
+  }
+
+  const usage = normalizeUsageMetadata(value.usage);
+
+  return {
+    ...(typeof value.createdAt === "string" ? { createdAt: value.createdAt } : {}),
+    ...(typeof value.isStopped === "boolean" ? { isStopped: value.isStopped } : {}),
+    ...(typeof value.isCompleted === "boolean" ? { isCompleted: value.isCompleted } : {}),
+    ...(typeof value.completedAt === "string" ? { completedAt: value.completedAt } : {}),
+    ...(typeof value.agentId === "string" ? { agentId: value.agentId } : {}),
+    ...(typeof value.agentName === "string" ? { agentName: value.agentName } : {}),
+    ...(typeof value.conversationId === "string" ? { conversationId: value.conversationId } : {}),
+    ...(typeof value.modelId === "string" ? { modelId: value.modelId } : {}),
+    ...(typeof value.runId === "string" ? { runId: value.runId } : {}),
+    ...(typeof value.streamingMessageId === "string"
+      ? { streamingMessageId: value.streamingMessageId }
+      : {}),
+    ...(usage ? { usage } : {}),
+  };
+}
+
+export function extractChatMessageMetadata(value: unknown): ChatMessageMetadata | undefined {
+  const normalized = normalizeChatMessageMetadata(value);
+  return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
+
+export function buildChatStreamChunkMessageMetadata(
+  input: BuildChatStreamChunkMessageMetadataInput,
+): ChatMessageMetadata {
+  const baseMetadata: ChatMessageMetadata = {
+    agentId: input.agentId,
+    modelId: input.modelId,
+    ...(input.runId ? { runId: input.runId } : {}),
+    ...(input.streamingMessageId ? { streamingMessageId: input.streamingMessageId } : {}),
+  };
+
+  if (input.part.type !== "finish" || !input.part.totalUsage) {
+    return baseMetadata;
+  }
+
+  const usage = normalizeUsageMetadata(input.part.totalUsage);
+  return usage ? { ...baseMetadata, usage } : baseMetadata;
+}
+
+export function normalizeChatUiMessageChunk(
+  chunk: ChatUiMessageChunk<unknown>,
+): ChatUiMessageChunk<ChatMessageMetadata> {
+  switch (chunk.type) {
+    case "start":
+      return {
+        type: "start",
+        ...(chunk.messageId ? { messageId: chunk.messageId } : {}),
+        ...(chunk.messageMetadata !== undefined
+          ? { messageMetadata: normalizeChatMessageMetadata(chunk.messageMetadata) }
+          : {}),
+      };
+    case "message-metadata":
+      return {
+        type: "message-metadata",
+        messageMetadata: normalizeChatMessageMetadata(chunk.messageMetadata),
+      };
+    case "finish":
+      return {
+        type: "finish",
+        ...(chunk.finishReason ? { finishReason: chunk.finishReason } : {}),
+        ...(chunk.messageMetadata !== undefined
+          ? { messageMetadata: normalizeChatMessageMetadata(chunk.messageMetadata) }
+          : {}),
+      };
+    default:
+      return chunk;
+  }
+}

package/src/src/chat/index.ts

@@ -212,12 +212,29 @@ export {
   type UseChatResult,
 } from "../agent/react/use-chat/index.js";
 
+export type {
+  ChatMessageMetadata,
+  ChatMessageMetadataUsage,
+  ChatUiMessageChunk,
+  ChildRunAudit,
+  ChildRunAuditToolCall,
+  ChildRunAuditToolResult,
+} from "./protocol.js";
+
 export {
   useAgent,
   type UseAgentOptions,
   type UseAgentResult,
 } from "../agent/react/use-agent.js";
 
+export {
+  buildChatStreamChunkMessageMetadata,
+  type BuildChatStreamChunkMessageMetadataInput,
+  extractChatMessageMetadata,
+  normalizeChatMessageMetadata,
+  normalizeChatUiMessageChunk,
+} from "./chat-ui-message-helpers.js";
+
 export {
   useCompletion,
   type UseCompletionOptions,

package/src/src/chat/protocol.ts

@@ -77,6 +77,52 @@ export interface ChatMessage {
   createdAt?: Date | string;
 }
 
+export interface ChatMessageMetadataUsage {
+  inputTokens?: number;
+  outputTokens?: number;
+  reasoningTokens?: number;
+  cachedInputTokens?: number;
+}
+
+export interface ChildRunAuditToolCall {
+  toolName: string;
+  toolCallId: string;
+  input?: unknown;
+}
+
+export interface ChildRunAuditToolResult {
+  toolName: string;
+  toolCallId: string;
+  input: unknown;
+  output: unknown;
+}
+
+export interface ChildRunAudit {
+  status: "completed" | "failed" | "cancelled" | "stopped";
+  description?: string;
+  steps?: number;
+  durationMs?: number;
+  toolCalls?: ChildRunAuditToolCall[];
+  toolResults?: ChildRunAuditToolResult[];
+  terminalErrorCode?: string | null;
+  terminalErrorMessage?: string | null;
+}
+
+export interface ChatMessageMetadata {
+  createdAt?: string;
+  isStopped?: boolean;
+  isCompleted?: boolean;
+  completedAt?: string;
+  agentId?: string;
+  agentName?: string;
+  conversationId?: string;
+  modelId?: string;
+  runId?: string;
+  streamingMessageId?: string;
+  childRunAudit?: ChildRunAudit;
+  usage?: ChatMessageMetadataUsage;
+}
+
 export type ChatFinishReason =
   | "stop"
   | "length"
@@ -208,3 +254,105 @@ export type ChatStreamEvent =
     type: "error";
     errorText: string;
   };
+
+type MessageLifecycleChunk<TMessageMetadata> =
+  | {
+    type: "start";
+    messageId?: string;
+    messageMetadata?: TMessageMetadata;
+  }
+  | {
+    type: "finish";
+    finishReason?: string;
+    messageMetadata?: TMessageMetadata;
+  }
+  | {
+    type: "message-metadata";
+    messageMetadata: TMessageMetadata;
+  };
+
+type IdChunk<TType extends string> = {
+  type: TType;
+  id: string;
+};
+
+type IdDeltaChunk<TType extends string> = IdChunk<TType> & {
+  delta: string;
+};
+
+type ToolCallChunk<TType extends string> = {
+  type: TType;
+  toolCallId: string;
+};
+
+type NamedToolCallChunk<TType extends string> = ToolCallChunk<TType> & {
+  toolName: string;
+};
+
+type ToolInputChunk<TType extends string> = NamedToolCallChunk<TType> & {
+  input: unknown;
+};
+
+type ToolErrorChunk<TType extends string> = ToolCallChunk<TType> & {
+  errorText: string;
+};
+
+export type ChatUiMessageChunk<TMessageMetadata = ChatMessageMetadata> =
+  | MessageLifecycleChunk<TMessageMetadata>
+  | {
+    type: "start-step";
+  }
+  | {
+    type: "finish-step";
+  }
+  | {
+    type: "abort";
+  }
+  | IdChunk<"reasoning-start">
+  | IdDeltaChunk<"reasoning-delta">
+  | IdChunk<"reasoning-end">
+  | IdChunk<"text-start">
+  | IdDeltaChunk<"text-delta">
+  | IdChunk<"text-end">
+  | {
+    type: "source-url";
+    sourceId: string;
+    url: string;
+    title?: string;
+  }
+  | {
+    type: "source-document";
+    sourceId: string;
+    mediaType: string;
+    title: string;
+    filename?: string;
+  }
+  | {
+    type: "file";
+    mediaType: string;
+    url: string;
+  }
+  | NamedToolCallChunk<"tool-input-start">
+  | (ToolCallChunk<"tool-input-delta"> & {
+    inputTextDelta: string;
+  })
+  | ToolInputChunk<"tool-input-available">
+  | (ToolInputChunk<"tool-input-error"> & {
+    errorText: string;
+  })
+  | (ToolCallChunk<"tool-output-available"> & {
+    output: unknown;
+  })
+  | ToolErrorChunk<"tool-output-error">
+  | ToolCallChunk<"tool-output-denied">
+  | (ToolCallChunk<"tool-approval-request"> & {
+    approvalId: string;
+  })
+  | {
+    type: "error";
+    errorText: string;
+  }
+  | {
+    type: `data-${string}`;
+    data: unknown;
+  };

package/src/src/utils/version-constant.ts

@@ -1,3 +1,3 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
-export const VERSION = "0.1.261";
+export const VERSION = "0.1.262";