@anvia/core 0.8.0 → 0.9.1-preview.20260628T064832.aaab367

package/README.md

@@ -96,6 +96,16 @@ for await (const event of createCompletionStream(model, {
 }
 ```
 
+Use `createCompletionUIStream` when a React UI sends standardized `UIMessage[]`:
+
+```ts
+import { createCompletionUIStream } from "@anvia/core/ui";
+
+const uiEvents = createCompletionUIStream(model, {
+  messages,
+});
+```
+
 Use `createParsedCompletion` when you want a direct completion to return schema-validated data:
 
 ```ts

package/dist/agent/index.d.ts

@@ -1,16 +1,17 @@
-import { A as AnyTool, e as ToolApprovalsOptions, d as ToolApprovalRequest } from '../tool-BLypI31e.js';
-export { b as ToolApprovalDecision } from '../tool-BLypI31e.js';
-import { k as ToolSearchDocument, l as ToolSet, A as AgentMiddleware, e as ToolMiddleware } from '../middleware-CZocYAtZ.js';
-export { C as CompletionRequestMiddlewareArgs, a as CompletionRequestMiddlewareResult, b as CompletionResponseMiddlewareArgs, c as CompletionResponseMiddlewareResult, T as ToolInputMiddlewareArgs, d as ToolInputMiddlewareResult, f as ToolOutputMiddlewareArgs, g as ToolOutputMiddlewareResult, h as ToolResultMiddlewareArgs, i as createMiddleware, j as createToolMiddleware } from '../middleware-CZocYAtZ.js';
-import { D as DynamicContextOptions, f as DynamicToolOptions, g as PromptHook, h as AgentEventStore, i as AgentEventStoreOptions, e as Agent } from '../agent-BW19m79B.js';
-export { A as AgentChildStreamEvent, j as AgentEventAppendInput, k as AgentEventRecord, l as AgentEventStoreInclude, a as AgentStreamEvent, C as CompletionCallHookArgs, m as CompletionErrorHookArgs, n as CompletionResponseHookArgs, H as HookAction, o as HookResult, P as PromptResponse, R as RunControl, p as RunEndHookArgs, q as RunErrorHookArgs, u as RunStartHookArgs, T as ToolApprovalRequestOptions, v as ToolCallControl, w as ToolCallHookAction, x as ToolCallHookArgs, y as ToolCallHookResult, z as ToolErrorHookArgs, B as ToolHookArgs, E as ToolResultHookArgs, F as TurnEndHookArgs, G as TurnStartHookArgs, c as cancelPrompt, b as createHook, r as requestToolApproval, d as runControl, s as skipTool, t as toolCallControl } from '../agent-BW19m79B.js';
+import { A as AnyTool, e as ToolApprovalsOptions, d as ToolApprovalRequest } from '../tool-C79JYHlw.js';
+export { b as ToolApprovalDecision } from '../tool-C79JYHlw.js';
+import { k as ToolSearchDocument, l as ToolSet, A as AgentMiddleware, e as ToolMiddleware } from '../middleware-7jwASFQb.js';
+export { C as CompletionRequestMiddlewareArgs, a as CompletionRequestMiddlewareResult, b as CompletionResponseMiddlewareArgs, c as CompletionResponseMiddlewareResult, T as ToolInputMiddlewareArgs, d as ToolInputMiddlewareResult, f as ToolOutputMiddlewareArgs, g as ToolOutputMiddlewareResult, h as ToolResultMiddlewareArgs, i as createMiddleware, j as createToolMiddleware } from '../middleware-7jwASFQb.js';
+import { D as DynamicContextOptions, d as DynamicToolOptions, P as PromptHook, e as AgentEventStore, f as AgentEventStoreOptions, A as Agent } from '../agent-DVTjbqHH.js';
+export { g as AgentEventAppendInput, h as AgentEventRecord, i as AgentEventStoreInclude, C as CompletionCallHookArgs, j as CompletionErrorHookArgs, k as CompletionResponseHookArgs, H as HookAction, l as HookResult, R as RunControl, m as RunEndHookArgs, n as RunErrorHookArgs, o as RunStartHookArgs, T as ToolApprovalRequestOptions, p as ToolCallControl, q as ToolCallHookAction, u as ToolCallHookArgs, v as ToolCallHookResult, w as ToolErrorHookArgs, x as ToolHookArgs, y as ToolResultHookArgs, z as TurnEndHookArgs, B as TurnStartHookArgs, c as cancelPrompt, a as createHook, r as requestToolApproval, b as runControl, s as skipTool, t as toolCallControl } from '../agent-DVTjbqHH.js';
 import { Z as ZodSchema } from '../zod-schema-C7F4clpm.js';
-import { C as CompletionModel, e as JsonValue, n as ToolChoice, M as Message } from '../types-C8loR4il.js';
-import { a as McpServer } from '../types-CIwm9p4w.js';
+import { C as CompletionModel, e as JsonValue, q as ToolChoice, M as Message } from '../types-BhXVKZCw.js';
+import { a as McpServer } from '../types-D9EnChuM.js';
 import { MemoryStore, MemoryOptions } from '../memory/index.js';
 import { AgentObserver, ObserveOptions } from '../observability/index.js';
-import { a as SkillSet } from '../types-D-YTJdLj.js';
+import { a as SkillSet } from '../types-yFrkmqy3.js';
 import { VectorSearchIndex } from '../vector-store/index.js';
+export { A as AgentChildStreamEvent, a as AgentStreamEvent, P as PromptResponse } from '../request-types-iGJLBlZv.js';
 import '../types-IB2e9u5M.js';
 import 'zod';
 import '@modelcontextprotocol/sdk/client/sse.js';

package/dist/agent/index.js

@@ -1,6 +1,6 @@
 import {
   AgentBuilder
-} from "../chunk-RAHDO2B2.js";
+} from "../chunk-TM4LFNPT.js";
 import {
   MaxTurnsError,
   PromptCancelledError,
@@ -11,21 +11,21 @@ import {
   runControl,
   skipTool,
   toolCallControl
-} from "../chunk-EIBAVYOR.js";
+} from "../chunk-HBICH2OA.js";
 import "../chunk-XUUY2L2D.js";
 import "../chunk-XXT2UCAR.js";
 import "../chunk-YK4WAAS4.js";
 import {
   createMiddleware,
   createToolMiddleware
-} from "../chunk-USWULPZJ.js";
-import "../chunk-VQE5PAAT.js";
+} from "../chunk-IA47SXLS.js";
+import "../chunk-66IJDP6L.js";
 import "../chunk-MMHG7WAM.js";
-import "../chunk-FTO3W4UP.js";
-import "../chunk-OIMLU4SF.js";
 import "../chunk-S5IGJ4RB.js";
 import "../chunk-WJO6NVE2.js";
 import "../chunk-WQKHFADH.js";
+import "../chunk-FTO3W4UP.js";
+import "../chunk-OIMLU4SF.js";
 export {
   AgentBuilder,
   MaxTurnsError,

package/dist/{agent-BW19m79B.d.ts → agent-DVTjbqHH.d.ts}

@@ -1,9 +1,10 @@
-import { M as Message, U as Usage, c as CompletionResponse, k as ToolResultContent, x as ReasoningContentType, f as ToolCall, C as CompletionModel, D as Document, e as JsonValue, n as ToolChoice, J as JsonObject } from './types-C8loR4il.js';
+import { M as Message, U as Usage, c as CompletionResponse, k as ToolResultContent, C as CompletionModel, D as Document, e as JsonValue, q as ToolChoice, J as JsonObject } from './types-BhXVKZCw.js';
 import { MemoryContext, MemoryRegistration, SessionOptions } from './memory/index.js';
-import { AgentTraceInfo, AgentTraceOptions, AgentObserverRegistration } from './observability/index.js';
-import { A as AgentMiddleware, e as ToolMiddleware, l as ToolSet, k as ToolSearchDocument } from './middleware-CZocYAtZ.js';
-import { e as ToolApprovalsOptions, T as Tool, A as AnyTool, f as ToolCallContext, N as NormalizedToolOutput } from './tool-BLypI31e.js';
+import { AgentTraceOptions, AgentObserverRegistration } from './observability/index.js';
+import { A as AgentMiddleware, e as ToolMiddleware, l as ToolSet, k as ToolSearchDocument } from './middleware-7jwASFQb.js';
+import { e as ToolApprovalsOptions, T as Tool, A as AnyTool, f as ToolCallContext, N as NormalizedToolOutput } from './tool-C79JYHlw.js';
 import { VectorFilter, VectorSearchResult, VectorSearchIndex } from './vector-store/index.js';
+import { P as PromptResponse, a as AgentStreamEvent } from './request-types-iGJLBlZv.js';
 
 type HookAction = {
     type: "continue";
@@ -122,67 +123,6 @@ interface PromptHook<RawResponse = unknown> {
     onToolError?: HookCallback<ToolErrorHookArgs>;
 }
 
-type PromptResponse = {
-    output: string;
-    usage: Usage;
-    messages: Message[];
-    trace?: AgentTraceInfo | undefined;
-};
-type AgentChildStreamEvent<RawResponse = unknown> = {
-    type: "turn_start";
-    turn: number;
-    prompt: Message;
-    history: Message[];
-} | {
-    type: "text_delta";
-    turn: number;
-    delta: string;
-} | {
-    type: "reasoning_delta";
-    turn: number;
-    delta: string;
-    id?: string;
-    contentType?: ReasoningContentType;
-    signature?: string;
-} | {
-    type: "tool_call";
-    turn: number;
-    toolCall: ToolCall;
-} | {
-    type: "tool_result";
-    turn: number;
-    toolName: string;
-    toolCallId?: string;
-    internalCallId: string;
-    args: string;
-    result: string;
-    structuredResult?: ToolResultContent[] | undefined;
-} | {
-    type: "turn_end";
-    turn: number;
-    response: CompletionResponse<RawResponse>;
-} | {
-    type: "final";
-    runId: string;
-    output: string;
-    usage: Usage;
-    messages: Message[];
-    trace?: AgentTraceInfo | undefined;
-} | {
-    type: "error";
-    error: unknown;
-};
-type AgentStreamEvent<RawResponse = unknown> = AgentChildStreamEvent<RawResponse> | {
-    type: "agent_tool_event";
-    turn: number;
-    toolName: string;
-    toolCallId?: string;
-    internalCallId: string;
-    agentId: string;
-    agentName?: string;
-    event: AgentChildStreamEvent<RawResponse>;
-};
-
 declare class PromptRequest<M extends CompletionModel = CompletionModel> {
     private readonly agent;
     private readonly promptMessage;
@@ -374,4 +314,4 @@ declare class AgentSession<M extends CompletionModel = CompletionModel> {
     clear(): Promise<void>;
 }
 
-export { type AgentChildStreamEvent as A, type ToolHookArgs as B, type CompletionCallHookArgs as C, type DynamicContextOptions as D, type ToolResultHookArgs as E, type TurnEndHookArgs as F, type TurnStartHookArgs as G, type HookAction as H, type AgentEventStoreRegistration as I, type AgentOptions as J, AgentSession as K, type AgentToolOptions as L, DEFAULT_MAX_TURNS as M, type DynamicContextRegistration as N, type DynamicToolRegistration as O, type PromptResponse as P, type RunControl as R, type ToolApprovalRequestOptions as T, type AgentStreamEvent as a, createHook as b, cancelPrompt as c, runControl as d, Agent as e, type DynamicToolOptions as f, type PromptHook as g, type AgentEventStore as h, type AgentEventStoreOptions as i, type AgentEventAppendInput as j, type AgentEventRecord as k, type AgentEventStoreInclude as l, type CompletionErrorHookArgs as m, type CompletionResponseHookArgs as n, type HookResult as o, type RunEndHookArgs as p, type RunErrorHookArgs as q, requestToolApproval as r, skipTool as s, toolCallControl as t, type RunStartHookArgs as u, type ToolCallControl as v, type ToolCallHookAction as w, type ToolCallHookArgs as x, type ToolCallHookResult as y, type ToolErrorHookArgs as z };
+export { Agent as A, type TurnStartHookArgs as B, type CompletionCallHookArgs as C, type DynamicContextOptions as D, type AgentEventStoreRegistration as E, type AgentOptions as F, AgentSession as G, type HookAction as H, type AgentToolOptions as I, DEFAULT_MAX_TURNS as J, type DynamicContextRegistration as K, type DynamicToolRegistration as L, type PromptHook as P, type RunControl as R, type ToolApprovalRequestOptions as T, createHook as a, runControl as b, cancelPrompt as c, type DynamicToolOptions as d, type AgentEventStore as e, type AgentEventStoreOptions as f, type AgentEventAppendInput as g, type AgentEventRecord as h, type AgentEventStoreInclude as i, type CompletionErrorHookArgs as j, type CompletionResponseHookArgs as k, type HookResult as l, type RunEndHookArgs as m, type RunErrorHookArgs as n, type RunStartHookArgs as o, type ToolCallControl as p, type ToolCallHookAction as q, requestToolApproval as r, skipTool as s, toolCallControl as t, type ToolCallHookArgs as u, type ToolCallHookResult as v, type ToolErrorHookArgs as w, type ToolHookArgs as x, type ToolResultHookArgs as y, type TurnEndHookArgs as z };

package/dist/audio-generation/index.d.ts

@@ -1,4 +1,4 @@
-import { e as JsonValue } from '../types-C8loR4il.js';
+import { e as JsonValue } from '../types-BhXVKZCw.js';
 
 type AudioGenerationRequest = {
     text: string;

package/dist/{chunk-VQE5PAAT.js → chunk-66IJDP6L.js}

@@ -1,13 +1,13 @@
 import {
   compact
 } from "./chunk-MMHG7WAM.js";
+import {
+  toProviderJsonSchema
+} from "./chunk-WQKHFADH.js";
 import {
   cosineSimilarity,
   embedText
 } from "./chunk-FTO3W4UP.js";
-import {
-  toProviderJsonSchema
-} from "./chunk-WQKHFADH.js";
 
 // src/vector-store/index.ts
 import { z } from "zod";
@@ -325,4 +325,4 @@ export {
   InMemoryVectorIndex,
   createVectorSearchTool
 };
-//# sourceMappingURL=chunk-VQE5PAAT.js.map
+//# sourceMappingURL=chunk-66IJDP6L.js.map

package/dist/{chunk-4KQ536VD.js → chunk-BKIXV5C4.js}

@@ -1,12 +1,12 @@
 import {
   AgentBuilder
-} from "./chunk-RAHDO2B2.js";
+} from "./chunk-TM4LFNPT.js";
 import {
   extractRagText
-} from "./chunk-EIBAVYOR.js";
+} from "./chunk-HBICH2OA.js";
 import {
   createTool
-} from "./chunk-VQE5PAAT.js";
+} from "./chunk-66IJDP6L.js";
 import {
   CompletionRequestBuilder
 } from "./chunk-S5IGJ4RB.js";
@@ -138,4 +138,4 @@ export {
   Extractor,
   ExtractorBuilder
 };
-//# sourceMappingURL=chunk-4KQ536VD.js.map
+//# sourceMappingURL=chunk-BKIXV5C4.js.map

package/dist/chunk-BYRCLOKA.js

@@ -0,0 +1,416 @@
+import {
+  createCompletionStream
+} from "./chunk-S5IGJ4RB.js";
+import {
+  AssistantContent,
+  Message,
+  ToolContent,
+  UserContent,
+  reasoningDisplayText,
+  serializeToolResultOutput,
+  textFromAssistantContent
+} from "./chunk-WJO6NVE2.js";
+
+// src/ui/index.ts
+function uiMessagesToCoreMessages(messages) {
+  const coreMessages = [];
+  for (const message of messages) {
+    const text = textFromUIParts(message.parts);
+    if (message.role === "system") {
+      if (text.length > 0) {
+        coreMessages.push(Message.system(text));
+      }
+      continue;
+    }
+    if (message.role === "user") {
+      const content = message.parts.filter((part) => part.type === "text").map((part) => UserContent.text(part.text));
+      if (content.length > 0) {
+        coreMessages.push(Message.user(content));
+      }
+      continue;
+    }
+    if (message.role === "assistant") {
+      const content = [];
+      for (const part of message.parts) {
+        if (part.type === "text" && part.text.length > 0) {
+          content.push(AssistantContent.text(part.text));
+          continue;
+        }
+        if (part.type === "reasoning" && part.text.length > 0) {
+          content.push(AssistantContent.reasoning(part.text, part.reasoningId));
+          continue;
+        }
+        if (part.type === "tool" && (part.state === "input-streaming" || part.state === "input-available")) {
+          content.push(
+            AssistantContent.toolCall(
+              part.toolCallId,
+              part.toolName,
+              part.input ?? {},
+              part.callId
+            )
+          );
+        }
+      }
+      if (content.length > 0) {
+        coreMessages.push(Message.assistant(content, message.id));
+      }
+      continue;
+    }
+    const toolResults = [];
+    for (const part of message.parts) {
+      if (part.type !== "tool" || part.state !== "output-available") {
+        continue;
+      }
+      toolResults.push(
+        ToolContent.toolResult(
+          part.toolCallId,
+          outputToToolResultContent(part.output),
+          part.callId
+        )
+      );
+    }
+    if (toolResults.length > 0) {
+      coreMessages.push(Message.tool(toolResults));
+    }
+  }
+  return coreMessages;
+}
+function coreMessagesToUIMessages(messages) {
+  const uiMessages = [];
+  for (const message of messages) {
+    if (message.role === "system") {
+      uiMessages.push({
+        id: createId("msg"),
+        role: "system",
+        parts: [{ id: createId("part"), type: "text", text: message.content }]
+      });
+      continue;
+    }
+    if (message.role === "user") {
+      const parts2 = [];
+      for (const content of message.content) {
+        if (content.type === "text") {
+          parts2.push({ id: createId("part"), type: "text", text: content.text });
+        } else {
+          parts2.push({
+            id: createId("part"),
+            type: "data",
+            name: content.type,
+            data: content
+          });
+        }
+      }
+      uiMessages.push({ id: createId("msg"), role: "user", parts: parts2 });
+      continue;
+    }
+    if (message.role === "assistant") {
+      const parts2 = [];
+      for (const content of message.content) {
+        if (content.type === "text") {
+          parts2.push({ id: createId("part"), type: "text", text: content.text });
+          continue;
+        }
+        if (content.type === "reasoning") {
+          const part = {
+            id: createId("part"),
+            type: "reasoning",
+            text: reasoningDisplayText(content)
+          };
+          if (content.id !== void 0) {
+            part.reasoningId = content.id;
+          }
+          parts2.push(part);
+          continue;
+        }
+        if (content.type === "tool_call") {
+          const part = {
+            id: toolPartId(content.id),
+            type: "tool",
+            toolName: content.function.name,
+            toolCallId: content.id,
+            state: "input-available",
+            input: content.function.arguments
+          };
+          if (content.callId !== void 0) {
+            part.callId = content.callId;
+          }
+          parts2.push(part);
+          continue;
+        }
+        parts2.push({
+          id: createId("part"),
+          type: "data",
+          name: content.type,
+          data: content
+        });
+      }
+      uiMessages.push({ id: message.id ?? createId("msg"), role: "assistant", parts: parts2 });
+      continue;
+    }
+    const parts = [];
+    for (const content of message.content) {
+      const part = {
+        id: toolPartId(content.id),
+        type: "tool",
+        toolName: "tool",
+        toolCallId: content.id,
+        state: "output-available",
+        output: toolResultContentToJson(content.content)
+      };
+      if (content.callId !== void 0) {
+        part.callId = content.callId;
+      }
+      parts.push(part);
+    }
+    uiMessages.push({ id: createId("msg"), role: "tool", parts });
+  }
+  return uiMessages;
+}
+async function* createCompletionUIStream(model, options) {
+  const { messages, ...completionOptions } = options;
+  yield* completionStreamToUIStream(
+    createCompletionStream(model, {
+      ...completionOptions,
+      messages: uiMessagesToCoreMessages(messages)
+    })
+  );
+}
+async function* createAgentUIStream(agent, options) {
+  yield* agentStreamToUIStream(agent.prompt(uiMessagesToCoreMessages(options.messages)).stream());
+}
+async function* completionStreamToUIStream(events, options = {}) {
+  const messageId = options.messageId ?? createId("msg");
+  let accumulatedText = "";
+  yield messageStart(messageId);
+  for await (const event of events) {
+    if (event.type === "text_delta") {
+      accumulatedText += event.delta;
+      yield {
+        type: "text_delta",
+        messageId,
+        partId: textPartId(messageId),
+        delta: event.delta
+      };
+      continue;
+    }
+    if (event.type === "reasoning_delta") {
+      const partId = reasoningPartId(messageId, event.id);
+      yield {
+        type: "reasoning_delta",
+        messageId,
+        partId,
+        delta: event.delta
+      };
+      continue;
+    }
+    if (event.type === "tool_call_delta") {
+      const partId = toolPartId(event.id);
+      yield {
+        type: "tool_update",
+        messageId,
+        partId,
+        part: {
+          id: partId,
+          type: "tool",
+          toolName: event.name ?? "",
+          toolCallId: event.id,
+          ...event.callId === void 0 ? {} : { callId: event.callId },
+          state: "input-streaming",
+          ...event.argumentsDelta === void 0 ? {} : { input: event.argumentsDelta }
+        }
+      };
+      continue;
+    }
+    if (event.type === "tool_call") {
+      yield {
+        type: "tool_update",
+        messageId,
+        partId: toolPartId(event.toolCall.id),
+        part: {
+          id: toolPartId(event.toolCall.id),
+          type: "tool",
+          toolName: event.toolCall.function.name,
+          toolCallId: event.toolCall.id,
+          ...event.toolCall.callId === void 0 ? {} : { callId: event.toolCall.callId },
+          state: "input-available",
+          input: event.toolCall.function.arguments
+        }
+      };
+      continue;
+    }
+    if (event.type === "final") {
+      const finalText = textFromAssistantContent(event.response.choice);
+      const missingText = missingTextDelta(accumulatedText, finalText);
+      if (missingText !== void 0) {
+        accumulatedText += missingText;
+        yield {
+          type: "text_delta",
+          messageId,
+          partId: textPartId(messageId),
+          delta: missingText
+        };
+      }
+      const endEvent = {
+        type: "message_end",
+        messageId,
+        usage: event.response.usage
+      };
+      if (event.response.messageId !== void 0) {
+        endEvent.metadata = { providerMessageId: event.response.messageId };
+      }
+      yield endEvent;
+      continue;
+    }
+    if (event.type === "error") {
+      yield { type: "error", error: uiError(event.error) };
+    }
+  }
+}
+async function* agentStreamToUIStream(events, options = {}) {
+  const messageId = options.messageId ?? createId("msg");
+  let accumulatedText = "";
+  yield messageStart(messageId);
+  for await (const event of events) {
+    if (event.type === "text_delta") {
+      accumulatedText += event.delta;
+      yield {
+        type: "text_delta",
+        messageId,
+        partId: textPartId(messageId),
+        delta: event.delta
+      };
+      continue;
+    }
+    if (event.type === "reasoning_delta") {
+      yield {
+        type: "reasoning_delta",
+        messageId,
+        partId: reasoningPartId(messageId, event.id),
+        delta: event.delta
+      };
+      continue;
+    }
+    if (event.type === "tool_call") {
+      yield {
+        type: "tool_update",
+        messageId,
+        partId: toolPartId(event.toolCall.id),
+        part: {
+          id: toolPartId(event.toolCall.id),
+          type: "tool",
+          toolName: event.toolCall.function.name,
+          toolCallId: event.toolCall.id,
+          ...event.toolCall.callId === void 0 ? {} : { callId: event.toolCall.callId },
+          state: "input-available",
+          input: event.toolCall.function.arguments
+        }
+      };
+      continue;
+    }
+    if (event.type === "tool_result") {
+      const toolCallId = event.toolCallId ?? event.internalCallId;
+      yield {
+        type: "tool_update",
+        messageId,
+        partId: toolPartId(toolCallId),
+        part: {
+          id: toolPartId(toolCallId),
+          type: "tool",
+          toolName: event.toolName,
+          toolCallId,
+          ...event.toolCallId === void 0 ? {} : { callId: event.toolCallId },
+          state: "output-available",
+          output: event.structuredResult === void 0 ? event.result : event.structuredResult
+        }
+      };
+      continue;
+    }
+    if (event.type === "final") {
+      const missingText = missingTextDelta(accumulatedText, event.output);
+      if (missingText !== void 0) {
+        accumulatedText += missingText;
+        yield {
+          type: "text_delta",
+          messageId,
+          partId: textPartId(messageId),
+          delta: missingText
+        };
+      }
+      yield {
+        type: "message_end",
+        messageId,
+        usage: event.usage,
+        metadata: { runId: event.runId }
+      };
+      continue;
+    }
+    if (event.type === "error") {
+      yield { type: "error", error: uiError(event.error) };
+    }
+  }
+}
+function messageStart(messageId) {
+  return {
+    type: "message_start",
+    message: {
+      id: messageId,
+      role: "assistant",
+      parts: []
+    }
+  };
+}
+function textFromUIParts(parts) {
+  return parts.flatMap((part) => part.type === "text" ? [part.text] : []).join("");
+}
+function outputToToolResultContent(output) {
+  return [{ type: "text", text: serializeToolResultOutput(output ?? null) }];
+}
+function toolResultContentToJson(content) {
+  if (content.length === 1 && content[0]?.type === "text") {
+    return content[0].text;
+  }
+  return content;
+}
+function uiError(error) {
+  if (error instanceof Error) {
+    return { name: error.name, message: error.message };
+  }
+  return { message: typeof error === "string" ? error : serializeToolResultOutput(error) };
+}
+function missingTextDelta(current, finalText) {
+  if (finalText.length === 0 || finalText === current) {
+    return void 0;
+  }
+  if (finalText.startsWith(current)) {
+    return finalText.slice(current.length);
+  }
+  return current.length === 0 ? finalText : void 0;
+}
+function textPartId(messageId) {
+  return `${messageId}_text`;
+}
+function reasoningPartId(messageId, id) {
+  return id === void 0 ? `${messageId}_reasoning` : `${messageId}_reasoning_${id}`;
+}
+function toolPartId(toolCallId) {
+  return `tool_${toolCallId}`;
+}
+var nextId = 0;
+function createId(prefix) {
+  const random = globalThis.crypto?.randomUUID?.();
+  if (random !== void 0) {
+    return `${prefix}_${random}`;
+  }
+  nextId += 1;
+  return `${prefix}_${nextId.toString(36)}`;
+}
+
+export {
+  uiMessagesToCoreMessages,
+  coreMessagesToUIMessages,
+  createCompletionUIStream,
+  createAgentUIStream,
+  completionStreamToUIStream,
+  agentStreamToUIStream
+};
+//# sourceMappingURL=chunk-BYRCLOKA.js.map