@assistant-ui/react 0.4.5 → 0.4.6

package/dist/index.d.ts

@@ -12,8 +12,48 @@ import * as class_variance_authority from 'class-variance-authority';
 import { VariantProps } from 'class-variance-authority';
 import * as class_variance_authority_types from 'class-variance-authority/types';
 
+declare const LanguageModelV1CallSettingsSchema: z.ZodObject<{
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    topP: z.ZodOptional<z.ZodNumber>;
+    presencePenalty: z.ZodOptional<z.ZodNumber>;
+    frequencyPenalty: z.ZodOptional<z.ZodNumber>;
+    seed: z.ZodOptional<z.ZodNumber>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodString>>>;
+}, "strip", z.ZodTypeAny, {
+    maxTokens?: number | undefined;
+    temperature?: number | undefined;
+    topP?: number | undefined;
+    presencePenalty?: number | undefined;
+    frequencyPenalty?: number | undefined;
+    seed?: number | undefined;
+    headers?: Record<string, string | undefined> | undefined;
+}, {
+    maxTokens?: number | undefined;
+    temperature?: number | undefined;
+    topP?: number | undefined;
+    presencePenalty?: number | undefined;
+    frequencyPenalty?: number | undefined;
+    seed?: number | undefined;
+    headers?: Record<string, string | undefined> | undefined;
+}>;
+type LanguageModelV1CallSettings = z.infer<typeof LanguageModelV1CallSettingsSchema>;
+declare const LanguageModelConfigSchema: z.ZodObject<{
+    apiKey: z.ZodOptional<z.ZodString>;
+    baseUrl: z.ZodOptional<z.ZodString>;
+    modelName: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    apiKey?: string | undefined;
+    baseUrl?: string | undefined;
+    modelName?: string | undefined;
+}, {
+    apiKey?: string | undefined;
+    baseUrl?: string | undefined;
+    modelName?: string | undefined;
+}>;
+type LanguageModelConfig = z.infer<typeof LanguageModelConfigSchema>;
 type ToolExecuteFunction<TArgs, TResult> = (args: TArgs) => TResult | Promise<TResult>;
-type Tool<TArgs = unknown, TResult = unknown> = {
+type Tool<TArgs extends Record<string | number, unknown> = Record<string | number, unknown>, TResult = unknown> = {
     description?: string | undefined;
     parameters: z.ZodSchema<TArgs> | JSONSchema7;
     execute?: ToolExecuteFunction<TArgs, TResult>;
@@ -22,6 +62,8 @@ type ModelConfig = {
     priority?: number | undefined;
     system?: string | undefined;
     tools?: Record<string, Tool<any, any>> | undefined;
+    callSettings?: LanguageModelV1CallSettings | undefined;
+    config?: LanguageModelConfig | undefined;
 };
 type ModelConfigProvider = {
     getModelConfig: () => ModelConfig;
@@ -41,14 +83,16 @@ type UIContentPart = {
     type: "ui";
     display: ReactNode;
 };
-type ToolCallContentPart<TArgs = unknown, TResult = unknown> = {
+type CoreToolCallContentPart<TArgs extends Record<string | number, unknown> = Record<string | number, unknown>, TResult = unknown> = {
     type: "tool-call";
     toolCallId: string;
     toolName: string;
-    argsText: string;
     args: TArgs;
-    result?: TResult;
-    isError?: boolean;
+    result?: TResult | undefined;
+    isError?: boolean | undefined;
+};
+type ToolCallContentPart<TArgs extends Record<string | number, unknown> = Record<string | number, unknown>, TResult = unknown> = CoreToolCallContentPart<TArgs, TResult> & {
+    argsText: string;
 };
 type ThreadUserContentPart = TextContentPart | ImageContentPart | UIContentPart;
 type ThreadAssistantContentPart = TextContentPart | ToolCallContentPart | UIContentPart;
@@ -57,7 +101,7 @@ type MessageCommonProps = {
     createdAt: Date;
 };
 type MessageStatus = {
-    type: "in_progress";
+    type: "in_progress" | "cancelled";
 } | {
     type: "done";
     finishReason?: LanguageModelV1FinishReason;
@@ -89,7 +133,7 @@ type AppendMessage = CoreMessage & {
 type ThreadMessage = ThreadSystemMessage | ThreadUserMessage | ThreadAssistantMessage;
 /** Core Message Types (without UI content parts) */
 type CoreUserContentPart = TextContentPart | ImageContentPart;
-type CoreAssistantContentPart = TextContentPart | ToolCallContentPart;
+type CoreAssistantContentPart = TextContentPart | CoreToolCallContentPart;
 type CoreSystemMessage = {
     role: "system";
     content: [TextContentPart];
@@ -189,12 +233,12 @@ type UIContentPartProps = {
     status: MessageStatus;
 };
 type UIContentPartComponent = ComponentType<UIContentPartProps>;
-type ToolCallContentPartProps<TArgs = any, TResult = any> = {
+type ToolCallContentPartProps<TArgs extends Record<string | number, unknown> = any, TResult = unknown> = {
     part: ToolCallContentPart<TArgs, TResult>;
     status: MessageStatus;
     addResult: (result: any) => void;
 };
-type ToolCallContentPartComponent<TArgs = any, TResult = any> = ComponentType<ToolCallContentPartProps<TArgs, TResult>>;
+type ToolCallContentPartComponent<TArgs extends Record<string | number, unknown> = any, TResult = any> = ComponentType<ToolCallContentPartProps<TArgs, TResult>>;
 
 type EdgeChatAdapterOptions = {
     api: string;
@@ -380,21 +424,21 @@ declare const useAppendMessage: () => (message: CreateAppendMessage) => void;
 
 declare const useSwitchToNewThread: () => () => void;
 
-type AssistantToolProps<TArgs, TResult> = Tool<TArgs, TResult> & {
+type AssistantToolProps<TArgs extends Record<string | number, unknown>, TResult> = Tool<TArgs, TResult> & {
     toolName: string;
     render?: ToolCallContentPartComponent<TArgs, TResult> | undefined;
 };
-declare const useAssistantTool: <TArgs, TResult>(tool: AssistantToolProps<TArgs, TResult>) => void;
+declare const useAssistantTool: <TArgs extends Record<string | number, unknown>, TResult>(tool: AssistantToolProps<TArgs, TResult>) => void;
 
-declare const makeAssistantTool: <TArgs, TResult>(tool: AssistantToolProps<TArgs, TResult>) => () => null;
+declare const makeAssistantTool: <TArgs extends Record<string | number, unknown>, TResult>(tool: AssistantToolProps<TArgs, TResult>) => () => null;
 
-type AssistantToolUIProps<TArgs, TResult> = {
+type AssistantToolUIProps<TArgs extends Record<string | number, unknown>, TResult> = {
     toolName: string;
     render: ToolCallContentPartComponent<TArgs, TResult>;
 };
 declare const useAssistantToolUI: (tool: AssistantToolUIProps<any, any> | null) => void;
 
-declare const makeAssistantToolUI: <TArgs, TResult>(tool: AssistantToolUIProps<TArgs, TResult>) => () => null;
+declare const makeAssistantToolUI: <TArgs extends Record<string | number, unknown>, TResult>(tool: AssistantToolUIProps<TArgs, TResult>) => () => null;
 
 declare const useAssistantInstructions: (instruction: string) => void;
 

package/dist/index.js

@@ -116,6 +116,21 @@ function useAssistantContext(options) {
 var import_zustand = require("zustand");
 
 // src/types/ModelConfigTypes.ts
+var import_zod = require("zod");
+var LanguageModelV1CallSettingsSchema = import_zod.z.object({
+  maxTokens: import_zod.z.number().int().positive().optional(),
+  temperature: import_zod.z.number().optional(),
+  topP: import_zod.z.number().optional(),
+  presencePenalty: import_zod.z.number().optional(),
+  frequencyPenalty: import_zod.z.number().optional(),
+  seed: import_zod.z.number().int().optional(),
+  headers: import_zod.z.record(import_zod.z.string().optional()).optional()
+});
+var LanguageModelConfigSchema = import_zod.z.object({
+  apiKey: import_zod.z.string().optional(),
+  baseUrl: import_zod.z.string().optional(),
+  modelName: import_zod.z.string().optional()
+});
 var mergeModelConfigs = (configSet) => {
   const configs = Array.from(configSet).map((c) => c.getModelConfig()).sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
   return configs.reduce((acc, config) => {
@@ -2283,6 +2298,10 @@ var toCoreMessages = (message) => {
       role: message2.role,
       content: message2.content.map((part) => {
         if (part.type === "ui") throw new Error("UI parts are not supported");
+        if (part.type === "tool-call") {
+          const { argsText, ...rest } = part;
+          return rest;
+        }
         return part;
       })
     };
@@ -2290,7 +2309,7 @@ var toCoreMessages = (message) => {
 };
 
 // src/runtimes/edge/converters/toLanguageModelTools.ts
-var import_zod = require("zod");
+var import_zod2 = require("zod");
 var import_zod_to_json_schema = __toESM(require("zod-to-json-schema"));
 var toLanguageModelTools = (tools) => {
   if (!tools) return [];
@@ -2298,7 +2317,7 @@ var toLanguageModelTools = (tools) => {
     type: "function",
     name,
     ...tool.description ? { description: tool.description } : void 0,
-    parameters: tool.parameters instanceof import_zod.z.ZodType ? (0, import_zod_to_json_schema.default)(tool.parameters) : tool.parameters
+    parameters: tool.parameters instanceof import_zod2.z.ZodType ? (0, import_zod_to_json_schema.default)(tool.parameters) : tool.parameters
   }));
 };
 
@@ -2875,7 +2894,7 @@ var appendOrUpdateFinish = (message, chunk) => {
 };
 
 // src/runtimes/edge/streams/toolResultStream.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 var import_secure_json_parse2 = __toESM(require("secure-json-parse"));
 function toolResultStream(tools) {
   const toolCallExecutions = /* @__PURE__ */ new Map();
@@ -2889,12 +2908,16 @@ function toolResultStream(tools) {
           const tool = tools?.[toolName];
           if (!tool || !tool.execute) return;
           const args = import_secure_json_parse2.default.parse(argsText);
-          if (tool.parameters instanceof import_zod2.z.ZodType) {
+          if (tool.parameters instanceof import_zod3.z.ZodType) {
             const result = tool.parameters.safeParse(args);
             if (!result.success) {
               controller.enqueue({
-                type: "error",
-                error: new Error("Invalid tool call arguments")
+                type: "tool-result",
+                toolCallType,
+                toolCallId,
+                toolName,
+                result: "Function parameter validation failed. " + JSON.stringify(result.error.issues),
+                isError: true
               });
               return;
             } else {
@@ -2911,9 +2934,14 @@ function toolResultStream(tools) {
                       result: result2
                     });
                   } catch (error) {
+                    console.error("Error: ", error);
                     controller.enqueue({
-                      type: "error",
-                      error
+                      type: "tool-result",
+                      toolCallType,
+                      toolCallId,
+                      toolName,
+                      result: "Error: " + error,
+                      isError: true
                     });
                   } finally {
                     toolCallExecutions.delete(toolCallId);
@@ -2971,7 +2999,9 @@ var EdgeChatAdapter = class {
         messages: toCoreMessages(messages),
         tools: toLanguageModelTools(
           config.tools
-        )
+        ),
+        ...config.callSettings,
+        ...config.config
       }),
       signal: abortSignal
     });
@@ -3199,7 +3229,7 @@ var fromLanguageModelMessages = (lm, mergeRoundtrips) => {
               toolCallId: part.toolCallId,
               toolName: part.toolName,
               argsText: JSON.stringify(part.args),
-              args: typeof part.args === "string" ? part.args : part.args
+              args: part.args
             };
           }
           return part;
@@ -3339,47 +3369,47 @@ var LocalThreadRuntime = class {
   async startRun(parentId) {
     this.repository.resetHead(parentId);
     const messages = this.repository.getMessages();
-    const message = {
+    let message = {
       id: generateId(),
       role: "assistant",
       status: { type: "in_progress" },
       content: [{ type: "text", text: "" }],
       createdAt: /* @__PURE__ */ new Date()
     };
-    this.repository.addOrUpdateMessage(parentId, { ...message });
     this.abortController?.abort();
     this.abortController = new AbortController();
+    this.repository.addOrUpdateMessage(parentId, { ...message });
     this.notifySubscribers();
-    try {
-      const updateHandler = ({ content }) => {
-        message.content = content;
-        const newMessage = { ...message };
-        this.repository.addOrUpdateMessage(parentId, newMessage);
-        this.notifySubscribers();
-        return newMessage;
+    const updateMessage = (m) => {
+      message = {
+        ...message,
+        ...m
       };
+      this.repository.addOrUpdateMessage(parentId, message);
+      this.notifySubscribers();
+      return message;
+    };
+    try {
       const result = await this.adapter.run({
         messages,
         abortSignal: this.abortController.signal,
         config: this.configProvider.getModelConfig(),
-        onUpdate: updateHandler
+        onUpdate: updateMessage
       });
-      if (result !== void 0) {
-        updateHandler(result);
-      }
       if (result.status?.type === "in_progress")
         throw new Error(
           "Unexpected in_progress status returned from ChatModelAdapter"
         );
-      message.status = result.status ?? { type: "done" };
+      this.abortController = null;
+      updateMessage({ status: { type: "done" }, ...result });
       this.repository.addOrUpdateMessage(parentId, { ...message });
     } catch (e) {
-      message.status = { type: "error", error: e };
-      this.repository.addOrUpdateMessage(parentId, { ...message });
-      throw e;
-    } finally {
+      const isAbortError = e instanceof Error && e.name === "AbortError";
       this.abortController = null;
-      this.notifySubscribers();
+      updateMessage({
+        status: isAbortError ? { type: "cancelled" } : { type: "error", error: e }
+      });
+      if (!isAbortError) throw e;
     }
   }
   cancelRun() {