veryfront 0.1.149 → 0.1.151

package/src/src/agent/runtime/model-message-converter.ts

@@ -1,13 +1,19 @@
 /**
  * Model Message Converter
  *
- * Converts between veryfront's internal Message format and AI SDK ModelMessage format.
- * Used when calling streamText() / generateText() from the AI SDK.
+ * Converts between veryfront's internal Message format and the current
+ * model-runtime message format.
  *
  * @module ai/agent/runtime/model-message-converter
  */
 
-import type { ModelMessage } from "ai";
+import type {
+  ModelRuntimeAssistantMessage,
+  ModelRuntimeMessage,
+  ModelRuntimeTextPart,
+  ModelRuntimeToolCallPart,
+  ModelRuntimeToolMessage,
+} from "./model-runtime-types.js";
 import {
   getTextFromParts,
   getToolArguments,
@@ -16,24 +22,10 @@ import {
   type ToolResultPart,
 } from "../types.js";
 
-interface TextContent {
-  type: "text";
-  text: string;
-}
-
-interface ToolCallContent {
-  type: "tool-call";
-  toolCallId: string;
-  toolName: string;
-  input: Record<string, unknown>;
-}
-
-type AssistantContent = TextContent | ToolCallContent;
-
 /**
- * Convert a veryfront Message to AI SDK ModelMessage format.
+ * Convert a veryfront Message to the current model-runtime message format.
  */
-export function convertToModelMessage(msg: Message): ModelMessage {
+export function convertToModelMessage(msg: Message): ModelRuntimeMessage {
   switch (msg.role) {
     case "system": {
       const text = getTextFromParts(msg.parts);
@@ -46,7 +38,7 @@ export function convertToModelMessage(msg: Message): ModelMessage {
     }
 
     case "assistant": {
-      const content: AssistantContent[] = [];
+      const content: Array<ModelRuntimeTextPart | ModelRuntimeToolCallPart> = [];
 
       for (const part of msg.parts) {
         if (part.type === "text" && "text" in part) {
@@ -74,16 +66,12 @@ export function convertToModelMessage(msg: Message): ModelMessage {
         content.push({ type: "text", text: "" });
       }
 
-      return { role: "assistant", content } as ModelMessage;
+      const assistantMessage: ModelRuntimeAssistantMessage = { role: "assistant", content };
+      return assistantMessage;
     }
 
     case "tool": {
-      const content: Array<{
-        type: "tool-result";
-        toolCallId: string;
-        toolName: string;
-        output: { type: "json"; value: unknown };
-      }> = [];
+      const content: ModelRuntimeToolMessage["content"] = [];
 
       for (const part of msg.parts) {
         if (part.type !== "tool-result") continue;
@@ -97,7 +85,8 @@ export function convertToModelMessage(msg: Message): ModelMessage {
         });
       }
 
-      return { role: "tool", content } as ModelMessage;
+      const toolMessage: ModelRuntimeToolMessage = { role: "tool", content };
+      return toolMessage;
     }
 
     default: {
@@ -110,7 +99,7 @@ export function convertToModelMessage(msg: Message): ModelMessage {
 
 function convertToolResultPart(
   part: ToolResultPart,
-): ModelMessage {
+): ModelRuntimeToolMessage {
   return {
     role: "tool",
     content: [{
@@ -119,14 +108,14 @@ function convertToolResultPart(
       toolName: part.toolName ?? "unknown",
       output: { type: "json", value: part.result },
     }],
-  } as ModelMessage;
+  };
 }
 
 /**
- * Convert an array of veryfront Messages to AI SDK ModelMessage format.
+ * Convert an array of veryfront Messages to the current model-runtime message format.
  */
-export function convertToModelMessages(messages: Message[]): ModelMessage[] {
-  const modelMessages: ModelMessage[] = [];
+export function convertToModelMessages(messages: Message[]): ModelRuntimeMessage[] {
+  const modelMessages: ModelRuntimeMessage[] = [];
   const toolResultMessageIndexes = new Map<string, number>();
 
   for (const message of messages) {

package/src/src/agent/runtime/model-runtime-types.ts

@@ -0,0 +1,55 @@
+/**
+ * Model Runtime Types
+ *
+ * Framework-owned message types for the current text-generation runtime
+ * boundary. These describe the subset of message shapes the runtime uses
+ * today without exposing SDK-owned message contracts upward.
+ */
+
+export interface ModelRuntimeTextPart {
+  type: "text";
+  text: string;
+}
+
+export interface ModelRuntimeToolCallPart {
+  type: "tool-call";
+  toolCallId: string;
+  toolName: string;
+  input: Record<string, unknown>;
+}
+
+export interface ModelRuntimeToolResultPart {
+  type: "tool-result";
+  toolCallId: string;
+  toolName: string;
+  output: {
+    type: "json";
+    value: unknown;
+  };
+}
+
+export interface ModelRuntimeSystemMessage {
+  role: "system";
+  content: string;
+}
+
+export interface ModelRuntimeUserMessage {
+  role: "user";
+  content: string;
+}
+
+export interface ModelRuntimeAssistantMessage {
+  role: "assistant";
+  content: Array<ModelRuntimeTextPart | ModelRuntimeToolCallPart>;
+}
+
+export interface ModelRuntimeToolMessage {
+  role: "tool";
+  content: ModelRuntimeToolResultPart[];
+}
+
+export type ModelRuntimeMessage =
+  | ModelRuntimeSystemMessage
+  | ModelRuntimeUserMessage
+  | ModelRuntimeAssistantMessage
+  | ModelRuntimeToolMessage;

package/src/src/agent/runtime/model-tool-converter.ts

@@ -1,18 +1,21 @@
 /**
  * Model Tool Converter
  *
- * Converts veryfront ToolDefinition[] to AI SDK ToolSet format.
- * Uses jsonSchema() to pass JSON Schema parameters directly to the AI SDK.
+ * Converts veryfront ToolDefinition[] to the current model-runtime ToolSet
+ * format using framework-owned plain tool/schema objects.
  *
- * @module ai/agent/runtime/model-tool-converter
+ * @module agent/runtime/model-tool-converter
  */
-
-import { jsonSchema, tool } from "ai";
-import type { ToolSet } from "ai";
 import type { ToolDefinition } from "../../tool/index.js";
-import { anthropic } from "@ai-sdk/anthropic";
+import type { RuntimeToolSet } from "./runtime-tool-types.js";
+import {
+  addRuntimeTool,
+  createRuntimeJsonSchema,
+  createRuntimeTool,
+} from "./runtime-tool-builder.js";
+import { createAnthropicWebSearchToolSet } from "./provider-native-tools.js";
 
-export interface ConvertToolsToAISDKOptions {
+export interface ConvertToolsToRuntimeToolsOptions {
   model?: string;
   allowedToolNames?: string[];
 }
@@ -30,8 +33,8 @@ function resolveHostedProvider(model?: string): string | undefined {
 }
 
 function resolveProviderNativeTools(
-  options?: ConvertToolsToAISDKOptions,
-): ToolSet | undefined {
+  options?: ConvertToolsToRuntimeToolsOptions,
+): RuntimeToolSet | undefined {
   if (!options?.allowedToolNames?.includes("web_search")) {
     return undefined;
   }
@@ -40,30 +43,30 @@ function resolveProviderNativeTools(
     return undefined;
   }
 
-  return {
-    web_search: anthropic.tools.webSearch_20250305({
-      maxUses: 5,
-    }),
-  };
+  return createAnthropicWebSearchToolSet();
 }
 
 /**
- * Convert veryfront tool definitions to AI SDK ToolSet.
+ * Convert veryfront tool definitions to the current model-runtime ToolSet.
  *
- * The AI SDK tool() function wraps each tool with its schema.
- * We don't provide `execute` — the agent runtime handles execution.
+ * We only provide the schema/metadata the runtime substrate needs here.
+ * Tool execution remains owned by the agent runtime.
  */
-export function convertToolsToAISDK(
+export function convertToolsToRuntimeTools(
   tools: ToolDefinition[],
-  options?: ConvertToolsToAISDKOptions,
-): ToolSet | undefined {
-  const toolSet: ToolSet = {};
+  options?: ConvertToolsToRuntimeToolsOptions,
+): RuntimeToolSet | undefined {
+  const toolSet: RuntimeToolSet = {};
 
   for (const def of tools) {
-    toolSet[def.name] = tool({
-      description: def.description,
-      inputSchema: jsonSchema(def.parameters),
-    });
+    addRuntimeTool(
+      toolSet,
+      def.name,
+      createRuntimeTool({
+        description: def.description,
+        inputSchema: createRuntimeJsonSchema(def.parameters),
+      }),
+    );
   }
 
   const providerNativeTools = resolveProviderNativeTools(options);

package/src/src/agent/runtime/provider-native-tools.ts

@@ -0,0 +1,61 @@
+import type { JsonSchema } from "../../tool/schema/index.js";
+import { createLazyRuntimeJsonSchema, createRuntimeProviderTool } from "./runtime-tool-builder.js";
+import type { RuntimeToolSet } from "./runtime-tool-types.js";
+
+const WEB_SEARCH_INPUT_SCHEMA: JsonSchema = {
+  type: "object",
+  properties: {
+    query: {
+      type: "string",
+    },
+  },
+  required: ["query"],
+  additionalProperties: false,
+};
+
+const WEB_SEARCH_OUTPUT_SCHEMA: JsonSchema = {
+  type: "array",
+  items: {
+    type: "object",
+    properties: {
+      url: {
+        type: "string",
+      },
+      title: {
+        anyOf: [
+          { type: "string" },
+          { type: "null" },
+        ],
+      },
+      pageAge: {
+        anyOf: [
+          { type: "string" },
+          { type: "null" },
+        ],
+      },
+      encryptedContent: {
+        type: "string",
+      },
+      type: {
+        type: "string",
+        const: "web_search_result",
+      },
+    },
+    required: ["url", "title", "pageAge", "encryptedContent", "type"],
+    additionalProperties: false,
+  },
+};
+
+export function createAnthropicWebSearchToolSet(): RuntimeToolSet {
+  return {
+    web_search: createRuntimeProviderTool({
+      id: "anthropic.web_search_20250305",
+      args: {
+        maxUses: 5,
+      },
+      inputSchema: createLazyRuntimeJsonSchema(WEB_SEARCH_INPUT_SCHEMA),
+      outputSchema: createLazyRuntimeJsonSchema(WEB_SEARCH_OUTPUT_SCHEMA),
+      supportsDeferredResults: true,
+    }),
+  };
+}

package/src/src/agent/runtime/repair-tool-call.ts

@@ -1,17 +1,13 @@
-import {
-  InvalidToolInputError,
-  NoSuchToolError,
-  type ToolCallRepairFunction,
-  type ToolSet,
-} from "ai";
+import { isInvalidToolInputError, isNoSuchToolError } from "./runtime-tool-errors.js";
+import type { RuntimeToolCallRepairFunction } from "./runtime-tool-types.js";
 
 const REPAIRABLE_PROVIDER_TOOL_NAMES = new Set(["web_search"]);
 
-export const repairToolCall: ToolCallRepairFunction<ToolSet> = async ({
+export const repairToolCall: RuntimeToolCallRepairFunction = async ({
   toolCall,
   error,
 }) => {
-  if (NoSuchToolError.isInstance(error)) {
+  if (isNoSuchToolError(error)) {
     return null;
   }
 
@@ -22,7 +18,8 @@ export const repairToolCall: ToolCallRepairFunction<ToolSet> = async ({
   if (toolCall.providerExecuted !== true) {
     return null;
   }
-  if (!InvalidToolInputError.isInstance(error) || typeof toolCall.input !== "string") {
+
+  if (!isInvalidToolInputError(error) || typeof toolCall.input !== "string") {
     return null;
   }
 

package/src/src/agent/runtime/runtime-tool-builder.ts

@@ -0,0 +1,82 @@
+import type { JsonSchema } from "../../tool/schema/index.js";
+import type { RuntimeToolSet } from "./runtime-tool-types.js";
+
+interface RuntimeJsonSchema<T = unknown> {
+  readonly jsonSchema: JsonSchema | PromiseLike<JsonSchema>;
+  validate?: (value: unknown) => T | PromiseLike<T>;
+}
+
+type RuntimeLazySchema<T = unknown> = () => RuntimeJsonSchema<T>;
+
+interface RuntimeToolDefinition {
+  description: string;
+  inputSchema: RuntimeJsonSchema;
+  type?: "function" | "dynamic";
+  execute?: (...args: unknown[]) => unknown;
+  onInputAvailable?: (...args: unknown[]) => unknown;
+  onInputStart?: (...args: unknown[]) => unknown;
+  onInputDelta?: (...args: unknown[]) => unknown;
+  needsApproval?: (...args: unknown[]) => unknown;
+}
+
+interface RuntimeProviderToolDefinition {
+  type: "provider";
+  id: string;
+  args: Record<string, unknown>;
+  inputSchema: RuntimeLazySchema;
+  outputSchema?: RuntimeLazySchema;
+  execute?: undefined;
+  needsApproval?: undefined;
+  toModelOutput?: undefined;
+  onInputStart?: undefined;
+  onInputDelta?: undefined;
+  onInputAvailable?: undefined;
+  supportsDeferredResults?: boolean;
+}
+
+export function createRuntimeJsonSchema(json: JsonSchema): RuntimeJsonSchema {
+  return {
+    jsonSchema: json,
+  };
+}
+
+export function createLazyRuntimeJsonSchema(json: JsonSchema): RuntimeLazySchema {
+  return () => createRuntimeJsonSchema(json);
+}
+
+export function createRuntimeTool(definition: {
+  description: string;
+  inputSchema: RuntimeJsonSchema;
+  type?: "function" | "dynamic";
+}): RuntimeToolDefinition {
+  return {
+    type: definition.type ?? "function",
+    description: definition.description,
+    inputSchema: definition.inputSchema,
+  };
+}
+
+export function addRuntimeTool(
+  toolSet: RuntimeToolSet,
+  name: string,
+  definition: RuntimeToolDefinition,
+): void {
+  toolSet[name] = definition;
+}
+
+export function createRuntimeProviderTool(definition: {
+  id: string;
+  args: Record<string, unknown>;
+  inputSchema: RuntimeLazySchema;
+  outputSchema?: RuntimeLazySchema;
+  supportsDeferredResults?: boolean;
+}): RuntimeProviderToolDefinition {
+  return {
+    type: "provider",
+    id: definition.id,
+    args: definition.args,
+    inputSchema: definition.inputSchema,
+    outputSchema: definition.outputSchema,
+    supportsDeferredResults: definition.supportsDeferredResults,
+  };
+}

package/src/src/agent/runtime/runtime-tool-errors.ts

@@ -0,0 +1,46 @@
+const INVALID_TOOL_INPUT_ERROR_NAME = "AI_InvalidToolInputError";
+const NO_SUCH_TOOL_ERROR_NAME = "AI_NoSuchToolError";
+
+type ErrorWithName = {
+  name: string;
+};
+
+type InvalidToolInputErrorShape = ErrorWithName & {
+  toolInput: unknown;
+  toolName: string;
+};
+
+function isErrorWithName(error: unknown, expectedName: string): error is ErrorWithName {
+  return !!error &&
+    typeof error === "object" &&
+    "name" in error &&
+    error.name === expectedName;
+}
+
+export function isInvalidToolInputError(error: unknown): error is InvalidToolInputErrorShape {
+  return isErrorWithName(error, INVALID_TOOL_INPUT_ERROR_NAME) &&
+    "toolName" in error &&
+    typeof error.toolName === "string" &&
+    "toolInput" in error;
+}
+
+export function isNoSuchToolError(error: unknown): boolean {
+  return isErrorWithName(error, NO_SUCH_TOOL_ERROR_NAME) &&
+    "toolName" in error &&
+    typeof error.toolName === "string";
+}
+
+export function createInvalidToolInputErrorForTest(options: {
+  cause: Error;
+  toolInput: string;
+  toolName: string;
+}): unknown {
+  const error = new Error(`Invalid input for tool ${options.toolName}: ${options.cause.message}`);
+  error.name = INVALID_TOOL_INPUT_ERROR_NAME;
+
+  return Object.assign(error, {
+    cause: options.cause,
+    toolInput: options.toolInput,
+    toolName: options.toolName,
+  });
+}

package/src/src/agent/runtime/runtime-tool-types.ts

@@ -0,0 +1,114 @@
+/**
+ * Runtime Tool Types
+ *
+ * Framework-owned types for the current tool-calling and streaming runtime
+ * boundary. These cover only the shapes the framework consumes today.
+ */
+
+import type { ModelRuntimeMessage } from "./model-runtime-types.js";
+
+export type RuntimeToolSet = Record<string, unknown>;
+
+export interface RuntimeGenerateToolCall {
+  toolCallId: string;
+  toolName: string;
+  input: unknown;
+}
+
+export interface RuntimeGenerateToolResult {
+  toolCallId: string;
+  toolName: string;
+  result: unknown;
+  isError?: boolean;
+}
+
+export interface RuntimeGenerateUsage {
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+}
+
+export interface RuntimeGenerateTextResult {
+  text: string;
+  toolCalls?: RuntimeGenerateToolCall[];
+  toolResults?: RuntimeGenerateToolResult[];
+  usage?: RuntimeGenerateUsage;
+  finishReason?: string | null;
+}
+
+export interface RuntimeRepairToolCall {
+  type: "tool-call";
+  toolCallId: string;
+  toolName: string;
+  input: unknown;
+  providerExecuted?: boolean;
+}
+
+export interface RuntimeToolCallRepairContext {
+  error: unknown;
+  inputSchema: (...args: unknown[]) => unknown;
+  messages: ModelRuntimeMessage[];
+  system?: string;
+  toolCall: RuntimeRepairToolCall;
+  tools: RuntimeToolSet;
+}
+
+export type RuntimeToolCallRepairFunction = (
+  context: RuntimeToolCallRepairContext,
+) => Promise<RuntimeRepairToolCall | null> | RuntimeRepairToolCall | null;
+
+export type RuntimeStreamPart =
+  | { type: "text-delta"; text: string }
+  | {
+    type: "tool-input-start";
+    id: string;
+    toolName: string;
+    providerExecuted?: boolean;
+    dynamic?: boolean;
+  }
+  | { type: "tool-input-delta"; id: string; delta: string }
+  | {
+    type: "tool-call";
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+    providerExecuted?: boolean;
+    dynamic?: boolean;
+  }
+  | {
+    type: "tool-result";
+    toolCallId: string;
+    toolName: string;
+    output?: unknown;
+    error?: unknown;
+    input?: unknown;
+    providerExecuted?: boolean;
+    dynamic?: boolean;
+    preliminary?: boolean;
+    isError?: boolean;
+  }
+  | {
+    type: "tool-error";
+    toolCallId: string;
+    toolName: string;
+    error?: unknown;
+    input?: unknown;
+    providerExecuted?: boolean;
+    dynamic?: boolean;
+    preliminary?: boolean;
+    isError?: boolean;
+  }
+  | {
+    type: "finish";
+    finishReason?: string | null;
+    totalUsage?: {
+      inputTokens?: number;
+      outputTokens?: number;
+    } | null;
+  }
+  | { type: "error"; error: unknown };
+
+export interface RuntimeStreamResult {
+  fullStream: AsyncIterable<unknown>;
+  textStream: AsyncIterable<string>;
+}

package/src/src/chat/index.ts

@@ -50,7 +50,7 @@
 import "../../_dnt.polyfills.js";
 
 
-export { Chat, ChatComponents, type ChatProps } from "../react/components/ai/chat.js";
+export { Chat, ChatComponents, type ChatProps } from "../react/components/chat/chat.js";
 
 export {
   ChatComposer,
@@ -69,7 +69,7 @@ export {
   type MessageRootProps,
   ModelAvatar,
   type ModelAvatarProps,
-} from "../react/components/ai/chat.js";
+} from "../react/components/chat/chat.js";
 
 export {
   ChatContextProvider,
@@ -88,7 +88,7 @@ export {
   useMessageContextOptional,
   useThreadListContext,
   useThreadListContextOptional,
-} from "../react/components/ai/chat.js";
+} from "../react/components/chat/chat.js";
 
 export {
   type AttachmentInfo,
@@ -173,38 +173,40 @@ export {
   useThreads,
   type UseThreadsOptions,
   type UseThreadsResult,
-} from "../react/components/ai/chat.js";
+} from "../react/components/chat/chat.js";
 
 export {
   Message as StandaloneMessage,
   type MessageProps,
   StreamingMessage,
   type StreamingMessageProps,
-} from "../react/components/ai/message.js";
+} from "../react/components/chat/message.js";
 
-export { AgentCard, type AgentCardProps } from "../react/components/ai/agent-card.js";
+export { AgentCard, type AgentCardProps } from "../react/components/chat/agent-card.js";
 export {
-  AIErrorBoundary,
-  type AIErrorBoundaryProps,
-  useAIErrorHandler,
-} from "../react/components/ai/error-boundary.js";
-export type { AgentTheme, ChatTheme } from "../react/components/ai/theme.js";
+  ChatErrorBoundary,
+  type ChatErrorBoundaryProps,
+  useChatErrorHandler,
+} from "../react/components/chat/error-boundary.js";
+export type { AgentTheme, ChatTheme } from "../react/components/chat/theme.js";
 
 export {
   type BranchInfo,
   type BrowserInferenceStatus,
-  type DynamicToolUIPart,
+  type ChatDynamicToolPart,
+  type ChatFinishReason,
+  type ChatMessage,
+  type ChatMessagePart,
+  type ChatReasoningPart,
+  type ChatStepPart,
+  type ChatStreamEvent,
+  type ChatTextPart,
+  type ChatToolPart,
+  type ChatToolResultPart,
+  type ChatToolState,
   type InferenceMode,
   type OnToolCallArg,
-  type ReasoningUIPart,
-  type StepUIPart,
-  type TextUIPart,
   type ToolOutput,
-  type ToolResultUIPart,
-  type ToolState,
-  type ToolUIPart,
-  type UIMessage,
-  type UIMessagePart,
   useChat,
   type UseChatOptions,
   type UseChatResult,