veryfront 0.1.332 → 0.1.334

package/src/deps/esm.sh/@types/{react@19.2.14 → react@19.2.3}/index.d.ts

@@ -16,7 +16,6 @@ type NativeKeyboardEvent = KeyboardEvent;
 type NativeMouseEvent = MouseEvent;
 type NativeTouchEvent = TouchEvent;
 type NativePointerEvent = PointerEvent;
-type NativeSubmitEvent = SubmitEvent;
 type NativeToggleEvent = ToggleEvent;
 type NativeTransitionEvent = TransitionEvent;
 type NativeUIEvent = UIEvent;
@@ -226,20 +225,12 @@ declare namespace React {
 
     type ComponentState = any;
 
-    interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_KEY_TYPES {}
-
     /**
      * A value which uniquely identifies a node among items in an array.
      *
      * @see {@link https://react.dev/learn/rendering-lists#keeping-list-items-in-order-with-key React Docs}
      */
-    type Key =
-        | string
-        | number
-        | bigint
-        | DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_KEY_TYPES[
-            keyof DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_KEY_TYPES
-        ];
+    type Key = string | number | bigint;
 
     /**
      * @internal The props any component can receive.
@@ -1893,7 +1884,7 @@ declare namespace React {
      *
      * @param callback A synchronous, void callback that will execute as a single, complete React commit.
      *
-     * @see {@link https://reactjs.org/blog/2019/02/06/react-v16.8.0.html#testing-hooks}
+     * @see https://reactjs.org/blog/2019/02/06/react-v16.8.0.html#testing-hooks
      */
     // NOTES
     // - the order of these signatures matters - typescript will check the signatures in source order.
@@ -1935,31 +1926,7 @@ declare namespace React {
         reducer: (state: State, action: Action) => State,
     ): [State, (action: Action) => void];
 
-    interface UntrackedReactPromise<T> extends PromiseLike<T> {
-        status?: void;
-    }
-
-    export interface PendingReactPromise<T> extends PromiseLike<T> {
-        status: "pending";
-    }
-
-    export interface FulfilledReactPromise<T> extends PromiseLike<T> {
-        status: "fulfilled";
-        value: T;
-    }
-
-    export interface RejectedReactPromise<T> extends PromiseLike<T> {
-        status: "rejected";
-        reason: unknown;
-    }
-
-    export type ReactPromise<T> =
-        | UntrackedReactPromise<T>
-        | PendingReactPromise<T>
-        | FulfilledReactPromise<T>
-        | RejectedReactPromise<T>;
-
-    export type Usable<T> = ReactPromise<T> | Context<T>;
+    export type Usable<T> = PromiseLike<T> | Context<T>;
 
     export function use<T>(usable: Usable<T>): T;
 
@@ -2074,28 +2041,15 @@ declare namespace React {
         target: EventTarget & Target;
     }
 
-    /**
-     * @deprecated FormEvent doesn't actually exist.
-     *             You probably meant to use {@link ChangeEvent}, {@link InputEvent}, {@link SubmitEvent}, or just {@link SyntheticEvent} instead
-     *             depending on the event type.
-     */
     interface FormEvent<T = Element> extends SyntheticEvent<T> {
     }
 
     interface InvalidEvent<T = Element> extends SyntheticEvent<T> {
+        target: EventTarget & T;
     }
 
-    /**
-     * change events bubble in React so their target is generally unknown.
-     * Only for form elements we know their target type because form events can't
-     * be nested.
-     * This type exists purely to narrow `target` for form elements. It doesn't
-     * reflect a DOM event. Change events are just fired as standard {@link SyntheticEvent}.
-     */
-    interface ChangeEvent<CurrentTarget = Element, Target = Element> extends SyntheticEvent<CurrentTarget> {
-        // TODO: This is wrong for change event handlers on arbitrary. Should
-        // be EventTarget & Target, but kept for backward compatibility until React 20.
-        target: EventTarget & CurrentTarget;
+    interface ChangeEvent<T = Element> extends SyntheticEvent<T> {
+        target: EventTarget & T;
     }
 
     interface InputEvent<T = Element> extends SyntheticEvent<T, NativeInputEvent> {
@@ -2165,13 +2119,6 @@ declare namespace React {
         shiftKey: boolean;
     }
 
-    interface SubmitEvent<T = Element> extends SyntheticEvent<T, NativeSubmitEvent> {
-        // `submitter` is available in react@canary
-        // submitter: HTMLElement | null;
-        // SubmitEvents are always targetted at HTMLFormElements.
-        target: EventTarget & HTMLFormElement;
-    }
-
     interface TouchEvent<T = Element> extends UIEvent<T, NativeTouchEvent> {
         altKey: boolean;
         changedTouches: TouchList;
@@ -2227,19 +2174,11 @@ declare namespace React {
     type CompositionEventHandler<T = Element> = EventHandler<CompositionEvent<T>>;
     type DragEventHandler<T = Element> = EventHandler<DragEvent<T>>;
     type FocusEventHandler<T = Element> = EventHandler<FocusEvent<T>>;
-    /**
-     * @deprecated FormEventHandler doesn't actually exist.
-     *             You probably meant to use {@link ChangeEventHandler}, {@link InputEventHandler}, {@link SubmitEventHandler}, or just {@link EventHandler} instead
-     *             depending on the event type.
-     */
     type FormEventHandler<T = Element> = EventHandler<FormEvent<T>>;
-    type ChangeEventHandler<CurrentTarget = Element, Target = Element> = EventHandler<
-        ChangeEvent<CurrentTarget, Target>
-    >;
+    type ChangeEventHandler<T = Element> = EventHandler<ChangeEvent<T>>;
     type InputEventHandler<T = Element> = EventHandler<InputEvent<T>>;
     type KeyboardEventHandler<T = Element> = EventHandler<KeyboardEvent<T>>;
     type MouseEventHandler<T = Element> = EventHandler<MouseEvent<T>>;
-    type SubmitEventHandler<T = Element> = EventHandler<SubmitEvent<T>>;
     type TouchEventHandler<T = Element> = EventHandler<TouchEvent<T>>;
     type PointerEventHandler<T = Element> = EventHandler<PointerEvent<T>>;
     type UIEventHandler<T = Element> = EventHandler<UIEvent<T>>;
@@ -2293,19 +2232,19 @@ declare namespace React {
         onBlur?: FocusEventHandler<T> | undefined;
         onBlurCapture?: FocusEventHandler<T> | undefined;
 
-        // form related Events
-        onChange?: ChangeEventHandler<T> | undefined;
-        onChangeCapture?: ChangeEventHandler<T> | undefined;
+        // Form Events
+        onChange?: FormEventHandler<T> | undefined;
+        onChangeCapture?: FormEventHandler<T> | undefined;
         onBeforeInput?: InputEventHandler<T> | undefined;
-        onBeforeInputCapture?: InputEventHandler<T> | undefined;
-        onInput?: InputEventHandler<T> | undefined;
-        onInputCapture?: InputEventHandler<T> | undefined;
-        onReset?: ReactEventHandler<T> | undefined;
-        onResetCapture?: ReactEventHandler<T> | undefined;
-        onSubmit?: SubmitEventHandler<T> | undefined;
-        onSubmitCapture?: SubmitEventHandler<T> | undefined;
-        onInvalid?: ReactEventHandler<T> | undefined;
-        onInvalidCapture?: ReactEventHandler<T> | undefined;
+        onBeforeInputCapture?: FormEventHandler<T> | undefined;
+        onInput?: FormEventHandler<T> | undefined;
+        onInputCapture?: FormEventHandler<T> | undefined;
+        onReset?: FormEventHandler<T> | undefined;
+        onResetCapture?: FormEventHandler<T> | undefined;
+        onSubmit?: FormEventHandler<T> | undefined;
+        onSubmitCapture?: FormEventHandler<T> | undefined;
+        onInvalid?: FormEventHandler<T> | undefined;
+        onInvalidCapture?: FormEventHandler<T> | undefined;
 
         // Image Events
         onLoad?: ReactEventHandler<T> | undefined;
@@ -2849,7 +2788,7 @@ declare namespace React {
 
         // Living Standard
         /**
-         * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/inert}
+         * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/inert
          */
         inert?: boolean | undefined;
         /**
@@ -3312,9 +3251,7 @@ declare namespace React {
         value?: string | readonly string[] | number | undefined;
         width?: number | string | undefined;
 
-        // No other element dispatching change events can be nested in a <input>
-        // so we know the target will be a HTMLInputElement.
-        onChange?: ChangeEventHandler<T, HTMLInputElement> | undefined;
+        onChange?: ChangeEventHandler<T> | undefined;
     }
 
     interface KeygenHTMLAttributes<T> extends HTMLAttributes<T> {
@@ -3479,9 +3416,7 @@ declare namespace React {
         required?: boolean | undefined;
         size?: number | undefined;
         value?: string | readonly string[] | number | undefined;
-        // No other element dispatching change events can be nested in a <select>
-        // so we know the target will be a HTMLSelectElement.
-        onChange?: ChangeEventHandler<T, HTMLSelectElement> | undefined;
+        onChange?: ChangeEventHandler<T> | undefined;
     }
 
     interface SourceHTMLAttributes<T> extends HTMLAttributes<T> {
@@ -3533,9 +3468,7 @@ declare namespace React {
         value?: string | readonly string[] | number | undefined;
         wrap?: string | undefined;
 
-        // No other element dispatching change events can be nested in a <textarea>
-        // so we know the target will be a HTMLTextAreaElement.
-        onChange?: ChangeEventHandler<T, HTMLTextAreaElement> | undefined;
+        onChange?: ChangeEventHandler<T> | undefined;
     }
 
     interface TdHTMLAttributes<T> extends HTMLAttributes<T> {
@@ -3607,9 +3540,6 @@ declare namespace React {
         method?: string | undefined;
         min?: number | string | undefined;
         name?: string | undefined;
-        nonce?: string | undefined;
-        part?: string | undefined;
-        slot?: string | undefined;
         style?: CSSProperties | undefined;
         target?: string | undefined;
         type?: string | undefined;
@@ -4127,6 +4057,7 @@ declare namespace React {
          * Captures which component contained the exception, and its ancestors.
          */
         componentStack?: string | null;
+        digest?: string | null;
     }
 
     // Keep in sync with JSX namespace in ./jsx-runtime.d.ts and ./jsx-dev-runtime.d.ts

package/src/deps/esm.sh/react-dom@19.2.4/client.d.ts

@@ -4,7 +4,7 @@
 
 // See https://github.com/facebook/react/blob/main/packages/react-dom/client.js to see how the exports are declared,
 
-import React = require("https://esm.sh/@types/react@19.2.14/index.d.ts");
+import React = require("https://esm.sh/@types/react@19.2.3/index.d.ts");
 
 export {};
 

package/src/src/agent/{framework-message-adapter.ts → agent-runtime-message-adapter.ts}

@@ -1,17 +1,17 @@
 import { isRecord } from "../chat/conversation.js";
 import {
   buildDataFileAnnotation,
-  type ChatModelMessage,
   type ChatToolResultPart,
+  type ProviderModelMessage,
   type UploadedFileReference,
 } from "../chat/types.js";
 import { toChildRunToolInputRecord } from "./child-run-execution-support.js";
 
-type StructuredModelPart = Exclude<ChatModelMessage["content"], string>[number];
+type StructuredProviderPart = Exclude<ProviderModelMessage["content"], string>[number];
 
 type JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue };
 
-type FrameworkMessageLikePart =
+type AgentRuntimeMessageLikePart =
   | { type: "text"; text: string }
   | {
     type: string;
@@ -38,7 +38,7 @@ type FrameworkMessageLikePart =
     output: unknown;
   };
 
-export type FrameworkMessagePart =
+export type AgentRuntimeMessagePart =
   | { type: "text"; text: string }
   | {
     type: string;
@@ -53,32 +53,32 @@ export type FrameworkMessagePart =
     result: unknown;
   };
 
-export interface FrameworkMessage {
+export interface AgentRuntimeMessage {
   id: string;
-  role: ChatModelMessage["role"];
-  parts: FrameworkMessagePart[];
+  role: ProviderModelMessage["role"];
+  parts: AgentRuntimeMessagePart[];
   timestamp: number;
 }
 
-interface FrameworkModelContentParts {
-  textParts: FrameworkModelTextPart[];
-  toolCallParts: FrameworkModelToolCallPart[];
+interface AgentRuntimeProviderContentParts {
+  textParts: ProviderTextPart[];
+  toolCallParts: ProviderToolCallPart[];
   toolResultParts: ChatToolResultPart[];
 }
 
-type FrameworkModelTextPart = { type: "text"; text: string };
+type ProviderTextPart = { type: "text"; text: string };
 
-type FrameworkModelToolCallPart = {
+type ProviderToolCallPart = {
   type: "tool-call";
   toolCallId: string;
   toolName: string;
   input: Record<string, unknown>;
 };
 
-export class FrameworkMessageConversionError extends Error {
+export class AgentRuntimeMessageConversionError extends Error {
   constructor(message: string) {
     super(message);
-    this.name = "FrameworkMessageConversionError";
+    this.name = "AgentRuntimeMessageConversionError";
   }
 }
 
@@ -95,18 +95,18 @@ function getOptionalStringField(part: unknown, key: string): string | undefined
   return typeof value === "string" && value.length > 0 ? value : undefined;
 }
 
-function createFrameworkMessageId(message: ChatModelMessage, index: number): string {
-  return `framework-${message.role}-${index + 1}`;
+function createAgentRuntimeMessageId(message: ProviderModelMessage, index: number): string {
+  return `agent-runtime-${message.role}-${index + 1}`;
 }
 
-function createTextFrameworkPart(text: string): FrameworkMessagePart | null {
+function createTextAgentRuntimePart(text: string): AgentRuntimeMessagePart | null {
   return hasTextContent(text) ? { type: "text", text } : null;
 }
 
-function convertStructuredPart(part: StructuredModelPart): FrameworkMessagePart | null {
+function convertStructuredPart(part: StructuredProviderPart): AgentRuntimeMessagePart | null {
   switch (part.type) {
     case "text":
-      return createTextFrameworkPart(part.text);
+      return createTextAgentRuntimePart(part.text);
 
     case "reasoning":
       return null;
@@ -133,14 +133,14 @@ function convertStructuredPart(part: StructuredModelPart): FrameworkMessagePart
 
     default: {
       const exhaustiveCheck: never = part;
-      throw new FrameworkMessageConversionError(
-        `Unsupported framework message part: ${String(exhaustiveCheck)}`,
+      throw new AgentRuntimeMessageConversionError(
+        `Unsupported agent runtime message part: ${String(exhaustiveCheck)}`,
       );
     }
   }
 }
 
-function createAttachmentReference(part: StructuredModelPart): UploadedFileReference | null {
+function createAttachmentReference(part: StructuredProviderPart): UploadedFileReference | null {
   const filename = getOptionalStringField(part, "filename");
   const mediaType = getOptionalStringField(part, "mediaType");
   const uploadId = getOptionalStringField(part, "uploadId");
@@ -164,7 +164,7 @@ function createAttachmentReference(part: StructuredModelPart): UploadedFileRefer
 
 function buildAttachmentContextPart(
   attachmentReferences: UploadedFileReference[],
-): FrameworkMessagePart | null {
+): AgentRuntimeMessagePart | null {
   if (attachmentReferences.length === 0) {
     return null;
   }
@@ -177,13 +177,15 @@ function buildAttachmentContextPart(
   };
 }
 
-function convertContentToFrameworkParts(message: ChatModelMessage): FrameworkMessage["parts"] {
+function convertContentToAgentRuntimeParts(
+  message: ProviderModelMessage,
+): AgentRuntimeMessage["parts"] {
   if (typeof message.content === "string") {
-    const textPart = createTextFrameworkPart(message.content);
+    const textPart = createTextAgentRuntimePart(message.content);
     return textPart ? [textPart] : [];
   }
 
-  const parts: FrameworkMessage["parts"] = [];
+  const parts: AgentRuntimeMessage["parts"] = [];
   const attachmentReferences: UploadedFileReference[] = [];
 
   for (const part of message.content) {
@@ -238,13 +240,13 @@ function toToolResultOutput(value: unknown): { type: "json"; value: JsonValue }
   };
 }
 
-export function getFrameworkTextPart(part: unknown): { type: "text"; text: string } | null {
+export function getAgentRuntimeTextPart(part: unknown): { type: "text"; text: string } | null {
   return isRecord(part) && part.type === "text" && typeof part.text === "string"
     ? { type: "text", text: part.text }
     : null;
 }
 
-export function getFrameworkToolCallPart(
+export function getAgentRuntimeToolCallPart(
   part: unknown,
 ): { toolCallId: string; toolName: string; input: Record<string, unknown> } | null {
   if (!isRecord(part) || typeof part.type !== "string") {
@@ -268,7 +270,7 @@ export function getFrameworkToolCallPart(
   };
 }
 
-export function getFrameworkToolResultPart(
+export function getAgentRuntimeToolResultPart(
   part: unknown,
 ): { toolCallId: string; toolName: string; output: unknown } | null {
   if (!isRecord(part) || part.type !== "tool-result") {
@@ -301,31 +303,31 @@ export function createToolResultPart(part: {
   };
 }
 
-function joinTextParts(textParts: readonly FrameworkModelTextPart[]): string {
+function joinTextParts(textParts: readonly ProviderTextPart[]): string {
   return textParts.map((part) => part.text).join("\n\n");
 }
 
-function collectFrameworkModelContentParts(
-  parts: ReadonlyArray<FrameworkMessageLikePart>,
-): FrameworkModelContentParts {
-  const textParts: FrameworkModelTextPart[] = [];
-  const toolCallParts: FrameworkModelToolCallPart[] = [];
+function collectAgentRuntimeProviderContentParts(
+  parts: ReadonlyArray<AgentRuntimeMessageLikePart>,
+): AgentRuntimeProviderContentParts {
+  const textParts: ProviderTextPart[] = [];
+  const toolCallParts: ProviderToolCallPart[] = [];
   const toolResultParts: ChatToolResultPart[] = [];
 
   for (const part of parts) {
-    const textPart = getFrameworkTextPart(part);
+    const textPart = getAgentRuntimeTextPart(part);
     if (textPart) {
       textParts.push(textPart);
       continue;
     }
 
-    const toolResultPart = getFrameworkToolResultPart(part);
+    const toolResultPart = getAgentRuntimeToolResultPart(part);
     if (toolResultPart) {
       toolResultParts.push(createToolResultPart(toolResultPart));
       continue;
     }
 
-    const toolCallPart = getFrameworkToolCallPart(part);
+    const toolCallPart = getAgentRuntimeToolCallPart(part);
     if (toolCallPart) {
       toolCallParts.push({
         type: "tool-call",
@@ -339,10 +341,12 @@ function collectFrameworkModelContentParts(
   return { textParts, toolCallParts, toolResultParts };
 }
 
-function createModelMessageFromFrameworkMessage(
-  message: Pick<FrameworkMessage, "role"> & { parts: ReadonlyArray<FrameworkMessageLikePart> },
-): ChatModelMessage | null {
-  const { textParts, toolCallParts, toolResultParts } = collectFrameworkModelContentParts(
+function createProviderMessageFromAgentRuntimeMessage(
+  message: Pick<AgentRuntimeMessage, "role"> & {
+    parts: ReadonlyArray<AgentRuntimeMessageLikePart>;
+  },
+): ProviderModelMessage | null {
+  const { textParts, toolCallParts, toolResultParts } = collectAgentRuntimeProviderContentParts(
     message.parts,
   );
 
@@ -391,8 +395,8 @@ function createModelMessageFromFrameworkMessage(
 
     default: {
       const exhaustiveCheck: never = message.role;
-      throw new FrameworkMessageConversionError(
-        `Unsupported framework message role when converting to model message: ${
+      throw new AgentRuntimeMessageConversionError(
+        `Unsupported agent runtime message role when converting to provider model message: ${
           String(exhaustiveCheck)
         }`,
       );
@@ -400,26 +404,26 @@ function createModelMessageFromFrameworkMessage(
   }
 }
 
-export function convertModelMessagesToFrameworkMessages(
-  messages: readonly ChatModelMessage[],
-): FrameworkMessage[] {
+export function convertProviderMessagesToAgentRuntimeMessages(
+  messages: readonly ProviderModelMessage[],
+): AgentRuntimeMessage[] {
   return messages.map((message, index) => ({
-    id: createFrameworkMessageId(message, index),
+    id: createAgentRuntimeMessageId(message, index),
     role: message.role,
-    parts: convertContentToFrameworkParts(message),
+    parts: convertContentToAgentRuntimeParts(message),
     timestamp: index,
   }));
 }
 
-export function convertFrameworkMessagesToModelMessages(
+export function convertAgentRuntimeMessagesToProviderMessages(
   messages: ReadonlyArray<
-    Pick<FrameworkMessage, "role"> & { parts: ReadonlyArray<FrameworkMessageLikePart> }
+    Pick<AgentRuntimeMessage, "role"> & { parts: ReadonlyArray<AgentRuntimeMessageLikePart> }
   >,
-): ChatModelMessage[] {
-  const converted: ChatModelMessage[] = [];
+): ProviderModelMessage[] {
+  const converted: ProviderModelMessage[] = [];
 
   for (const message of messages) {
-    const convertedMessage = createModelMessageFromFrameworkMessage(message);
+    const convertedMessage = createProviderMessageFromAgentRuntimeMessage(message);
     if (convertedMessage) {
       converted.push(convertedMessage);
     }

package/src/src/agent/fork-runtime-stream.ts

@@ -472,7 +472,7 @@ export function applyPartToStreamedStepState(state: StreamedStepState, part: For
   }
 }
 
-function buildFallbackFrameworkMessages(
+function buildFallbackAgentRuntimeMessages(
   baseMessages: readonly AgentMessage[],
   state: StreamedStepState,
 ): AgentMessage[] {
@@ -561,7 +561,7 @@ function buildFallbackAgentResponse(input: {
 }): AgentResponse {
   return {
     text: input.state.text,
-    messages: buildFallbackFrameworkMessages(input.baseMessages, input.state),
+    messages: buildFallbackAgentRuntimeMessages(input.baseMessages, input.state),
     toolCalls: [...input.state.toolCalls.values()].map((toolCall) => ({
       id: toolCall.toolCallId,
       name: toolCall.toolName,

package/src/src/agent/index.ts

@@ -365,16 +365,16 @@ export {
   toChildRunToolInputRecord,
 } from "./child-run-execution-support.js";
 export {
-  convertFrameworkMessagesToModelMessages,
-  convertModelMessagesToFrameworkMessages,
+  type AgentRuntimeMessage,
+  AgentRuntimeMessageConversionError,
+  type AgentRuntimeMessagePart,
+  convertAgentRuntimeMessagesToProviderMessages,
+  convertProviderMessagesToAgentRuntimeMessages,
   createToolResultPart,
-  type FrameworkMessage,
-  FrameworkMessageConversionError,
-  type FrameworkMessagePart,
-  getFrameworkTextPart,
-  getFrameworkToolCallPart,
-  getFrameworkToolResultPart,
-} from "./framework-message-adapter.js";
+  getAgentRuntimeTextPart,
+  getAgentRuntimeToolCallPart,
+  getAgentRuntimeToolResultPart,
+} from "./agent-runtime-message-adapter.js";
 export {
   type ChildRunExecutionBufferCleanupInput,
   type ChildRunExecutionResourceFinalizeInput,

package/src/src/chat/message-prep.ts

@@ -840,3 +840,5 @@ export function enforceTokenBudget(
 
   return enforceTokenBudgetWithTurnCompression(messages, budget, overhead);
 }
+
+export const prepareProviderModelMessagesFromUiMessages = prepareModelMessagesFromUiMessages;

package/src/src/chat/types.ts

@@ -245,12 +245,14 @@ export type ChatToolMessage = {
   content: ChatToolResultPart[];
 };
 
-export type ChatModelMessage =
+export type ProviderModelMessage =
   | ChatSystemMessage
   | ChatUserMessage
   | ChatAssistantMessage
   | ChatToolMessage;
 
+export type ChatModelMessage = ProviderModelMessage;
+
 export interface DurableRootRunDescriptor {
   runId: string;
   messageId: string;

package/src/src/tool/host-tools.ts

@@ -2,15 +2,32 @@ import * as dntShim from "../../_dnt.shims.js";
 import { z } from "zod";
 import { dynamicTool, tool } from "./factory.js";
 import type { JsonSchema } from "./schema/json-schema.js";
-import type { Tool, ToolConfig, ToolExecutionContext } from "./types.js";
+import type { Tool, ToolConfig, ToolExecutionContext, ToolSet } from "./types.js";
 
-export interface HostToolDefinition {
-  description: string;
-  inputSchema: z.ZodSchema<unknown>;
+type HostToolExecute = {
+  bivarianceHack: (input: unknown, options?: ToolExecutionContext) => Promise<unknown> | unknown;
+}["bivarianceHack"];
+
+export type HostToolDefinition = {
+  id?: string;
+  type?: Tool["type"];
+  title?: string;
+  description?: string;
+  inputSchema?: unknown;
   inputSchemaJson?: JsonSchema;
-  execute: (input: unknown, context: ToolExecutionContext) => Promise<unknown> | unknown;
+  parameters?: unknown;
+  providerOptions?: unknown;
+  execute?: Tool["execute"] | HostToolExecute;
   mcp?: ToolConfig["mcp"];
-}
+};
+
+export type HostToolSet = Record<string, HostToolDefinition>;
+
+type RunnableHostToolDefinition = HostToolDefinition & {
+  description: string;
+  inputSchema: z.ZodSchema<unknown>;
+  execute: HostToolExecute;
+};
 
 export interface HostToolMaterializationOptions {
   generateToolCallId?: (toolName: string) => string;
@@ -26,7 +43,7 @@ function isZodSchema(value: unknown): value is z.ZodSchema<unknown> {
   return typeof value._def.typeName === "string" || typeof value._def.type === "string";
 }
 
-function isHostToolDefinition(value: unknown): value is HostToolDefinition {
+function isHostToolDefinition(value: unknown): value is RunnableHostToolDefinition {
   return (
     isRecord(value) &&
     typeof value.description === "string" &&
@@ -54,11 +71,19 @@ function normalizeExecutionContext(
   };
 }
 
+export function createToolsFromHostDefinitions(
+  definitions: HostToolSet,
+  options?: HostToolMaterializationOptions,
+): ToolSet;
+export function createToolsFromHostDefinitions(
+  definitions: Record<string, unknown>,
+  options?: HostToolMaterializationOptions,
+): ToolSet;
 export function createToolsFromHostDefinitions(
   definitions: Record<string, unknown>,
   options: HostToolMaterializationOptions = {},
-): Record<string, Tool<unknown, unknown>> {
-  const tools: Record<string, Tool<unknown, unknown>> = {};
+): ToolSet {
+  const tools: ToolSet = {};
 
   for (const [toolName, definition] of Object.entries(definitions)) {
     if (!isHostToolDefinition(definition)) continue;

package/src/src/tool/index.ts

@@ -52,6 +52,7 @@ export type {
   ToolDefinition,
   ToolExecutionContext,
   ToolExecutionDataEvent,
+  ToolSet,
 } from "./types.js";
 
 export { dynamicTool, tool } from "./factory.js";
@@ -61,7 +62,11 @@ export type { RemoteMCPToolSourceConfig } from "./remote-mcp.js";
 export { createContext7ToolSource } from "./context7.js";
 export type { Context7ToolSourceConfig } from "./context7.js";
 export { createToolsFromHostDefinitions } from "./host-tools.js";
-export type { HostToolDefinition, HostToolMaterializationOptions } from "./host-tools.js";
+export type {
+  HostToolDefinition,
+  HostToolMaterializationOptions,
+  HostToolSet,
+} from "./host-tools.js";
 export {
   createToolsFromRemoteDefinitions,
   loadRemoteToolsFromSource,