@convex-dev/agent 0.1.18 → 0.2.0

package/dist/client/index.js

@@ -1,25 +1,30 @@
-import { embedMany, generateObject, generateText, streamObject, streamText, } from "ai";
+import { embedMany, generateObject, generateText, stepCountIs, streamObject, streamText, } from "ai";
 import { assert, omit, pick } from "convex-helpers";
 import { internalActionGeneric, internalMutationGeneric, } from "convex/server";
-import { v } from "convex/values";
+import { convexToJson, v } from "convex/values";
 import { validateVectorDimension, } from "../component/vector/tables.js";
-import { deserializeMessage, promptOrMessagesToCoreMessages, serializeMessage, serializeNewMessagesInStep, serializeObjectResult, } from "../mapping.js";
+import { deserializeMessage, serializeMessage, serializeNewMessagesInStep, serializeObjectResult, } from "../mapping.js";
 import { extractText, isTool } from "../shared.js";
-import { vMessageWithMetadata, vSafeObjectArgs, vTextArgs, } from "../validators.js";
+import { vMessageEmbeddings, vMessageWithMetadata, vSafeObjectArgs, vTextArgs, } from "../validators.js";
 import { createTool, wrapTools } from "./createTool.js";
-import { listMessages } from "./listMessages.js";
-import { fetchContextMessages } from "./search.js";
+import { listMessages, saveMessages, } from "./messages.js";
+import { fetchContextMessages, getModelName, getProviderName, } from "./search.js";
 import { DeltaStreamer, mergeTransforms, syncStreams, } from "./streaming.js";
+import { createThread, getThreadMetadata } from "./threads.js";
+import { inlineMessagesFiles } from "./files.js";
+export { stepCountIs } from "ai";
 export { vMessageDoc, vThreadDoc } from "../component/schema.js";
-export { serializeDataOrUrl } from "../mapping.js";
+export { deserializeMessage, serializeDataOrUrl, serializeMessage, } from "../mapping.js";
 // NOTE: these are also exported via @convex-dev/agent/validators
 // a future version may put them all here or move these over there
 export { vAssistantMessage, vContextOptions, vMessage, vPaginationResult, vProviderMetadata, vStorageOptions, vStreamArgs, vSystemMessage, vToolMessage, vUsage, vUserMessage, } from "../validators.js";
-export { getFile, storeFile } from "./files.js";
-export { filterOutOrphanedToolMessages } from "./search.js";
-export { abortStream, listStreams } from "./streaming.js";
-export { createTool, extractText, fetchContextMessages, isTool, listMessages, syncStreams, };
 export { definePlaygroundAPI, } from "./definePlaygroundAPI.js";
+export { getFile, storeFile } from "./files.js";
+export { listMessages, saveMessage, saveMessages, } from "./messages.js";
+export { fetchContextMessages, filterOutOrphanedToolMessages, } from "./search.js";
+export { abortStream, listStreams, syncStreams } from "./streaming.js";
+export { createThread, getThreadMetadata } from "./threads.js";
+export { createTool, extractText, isTool };
 export class Agent {
     component;
     options;
@@ -35,13 +40,8 @@ export class Agent {
         const { thread } = await this.continueThread(ctx, {
             threadId,
             userId: args?.userId,
-            usageHandler: args?.usageHandler,
-            tools: args?.tools,
         });
-        return {
-            threadId,
-            thread,
-        };
+        return { threadId, thread };
     }
     /**
      * Continues a thread using this agent. Note: threads can be continued
@@ -69,99 +69,188 @@ export class Agent {
             },
         };
     }
+    async start(ctx, 
     /**
-     * Search for threads by title, paginated.
-     * @param ctx The context passed from the query/mutation/action.
-     * @returns The threads matching the search, paginated.
-     */
-    async searchThreadTitles(ctx, { userId, query, limit, }) {
-        return ctx.runQuery(this.component.threads.searchThreadTitles, {
-            userId,
-            query,
-            limit: limit ?? 10,
-        });
-    }
-    /**
-     * This behaves like {@link generateText} from the "ai" package except that
-     * it add context based on the userId and threadId and saves the input and
-     * resulting messages to the thread, if specified.
-     * Use {@link continueThread} to get a version of this function already scoped
-     * to a thread (and optionally userId).
-     * @param ctx The context passed from the action function calling this.
-     * @param { userId, threadId }: The user and thread to associate the message with
-     * @param args The arguments to the generateText function, along with extra controls
-     * for the {@link ContextOptions} and {@link StorageOptions}.
-     * @returns The result of the generateText function.
+     * These are the arguments you'll pass to the LLM call such as
+     * `generateText` or `streamText`. This function will look up the context
+     * and provide functions to save the steps, abort the generation, and more.
+     * The type of the arguments returned infers from the type of the arguments
+     * you pass here.
      */
-    async generateText(ctx, { userId: argsUserId, threadId, tools: threadTools, ...usageHandler }, args, options) {
-        const opts = { ...this.options, ...options, ...usageHandler };
+    args, options) {
+        const { threadId, ...opts } = { ...this.options, ...options };
         const context = await this._saveMessagesAndFetchContext(ctx, args, {
-            userId: argsUserId ?? undefined,
-            threadId,
+            userId: options?.userId,
+            threadId: options?.threadId,
             ...opts,
         });
-        const { args: aiArgs, messageId, order, userId } = context;
+        let pendingMessageId = context.pendingMessageId;
+        // TODO: extract pending message if one exists
+        const { args: aiArgs, promptMessageId, order, stepOrder, userId } = context;
+        const messages = context.savedMessages ?? [];
+        if (pendingMessageId) {
+            if (!aiArgs._internal?.generateId) {
+                aiArgs._internal = {
+                    ...aiArgs._internal,
+                    generateId: () => pendingMessageId ?? crypto.randomUUID(),
+                };
+            }
+        }
         const toolCtx = {
             ...ctx,
             userId,
             threadId,
-            messageId,
+            promptMessageId,
             agent: this,
         };
-        const tools = wrapTools(toolCtx, args.tools ?? threadTools ?? this.options.tools);
+        const tools = wrapTools(toolCtx, args.tools ?? this.options.tools);
         const saveOutput = opts.storageOptions?.saveMessages !== "none";
-        try {
-            const result = (await generateText({
-                // Can be overridden
-                maxSteps: this.options.maxSteps,
+        const fail = async (reason) => {
+            if (threadId && promptMessageId) {
+                console.error("RollbackMessage", promptMessageId, reason);
+            }
+            if (pendingMessageId) {
+                await ctx.runMutation(this.component.messages.finalizeMessage, {
+                    messageId: pendingMessageId,
+                    result: { status: "failed", error: reason },
+                });
+            }
+        };
+        let activeModel = aiArgs.model;
+        if (aiArgs.abortSignal) {
+            const abortSignal = aiArgs.abortSignal;
+            aiArgs.abortSignal.addEventListener("abort", async () => {
+                await fail(abortSignal.reason ?? "Aborted");
+            }, { once: true });
+        }
+        return {
+            args: {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                stopWhen: args.stopWhen ?? this.options.stopWhen,
                 ...aiArgs,
                 tools,
-                onStepFinish: async (step) => {
-                    if (threadId && messageId && saveOutput) {
-                        await this.saveStep(ctx, {
-                            userId,
-                            threadId,
-                            promptMessageId: messageId,
-                            model: aiArgs.model.modelId,
-                            provider: aiArgs.model.provider,
-                            step,
+                // abortSignal: abortController.signal,
+            },
+            order: order ?? 0,
+            stepOrder: stepOrder ?? 0,
+            userId,
+            promptMessageId,
+            getSavedMessages: () => messages,
+            updateModel: (model) => {
+                if (model) {
+                    activeModel = model;
+                }
+            },
+            fail,
+            save: async (toSave, createPendingMessage) => {
+                if (threadId && promptMessageId && saveOutput) {
+                    const metadata = {
+                        // TODO: get up to date one when user selects mid-generation
+                        model: getModelName(activeModel),
+                        provider: getProviderName(activeModel),
+                    };
+                    const serialized = "object" in toSave
+                        ? await serializeObjectResult(ctx, this.component, toSave.object, metadata)
+                        : await serializeNewMessagesInStep(ctx, this.component, toSave.step, metadata);
+                    const embeddings = await this.generateEmbeddings(ctx, { userId, threadId }, serialized.messages.map((m) => m.message));
+                    if (createPendingMessage) {
+                        serialized.messages.push({
+                            message: { role: "assistant", content: [] },
+                            status: "pending",
                         });
+                        embeddings?.vectors.push(null);
                     }
-                    if (this.options.rawRequestResponseHandler) {
-                        await this.options.rawRequestResponseHandler(ctx, {
-                            userId,
-                            threadId,
-                            agentName: this.options.name,
-                            request: step.request,
-                            response: step.response,
-                        });
+                    const saved = await ctx.runMutation(this.component.messages.addMessages, {
+                        userId,
+                        threadId,
+                        agentName: this.options.name,
+                        promptMessageId,
+                        pendingMessageId,
+                        messages: serialized.messages,
+                        embeddings,
+                        failPendingSteps: false,
+                    });
+                    const lastMessage = saved.messages.at(-1);
+                    if (createPendingMessage) {
+                        if (lastMessage.status === "failed") {
+                            pendingMessageId = undefined;
+                            messages.push(...saved.messages);
+                            await fail(lastMessage.error ??
+                                "Aborting - the pending message was marked as failed");
+                        }
+                        else {
+                            pendingMessageId = lastMessage._id;
+                            messages.push(...saved.messages.slice(0, -1));
+                        }
                     }
-                    if (opts.usageHandler && step.usage) {
-                        await opts.usageHandler(ctx, {
-                            userId,
-                            threadId,
-                            agentName: this.options.name,
-                            model: aiArgs.model.modelId,
-                            provider: aiArgs.model.provider,
-                            usage: step.usage,
-                            providerMetadata: step.providerMetadata,
-                        });
+                    else {
+                        pendingMessageId = undefined;
+                        messages.push(...saved.messages);
                     }
-                    return args.onStepFinish?.(step);
+                }
+                const output = "object" in toSave ? toSave.object : toSave.step;
+                if (this.options.rawRequestResponseHandler) {
+                    await this.options.rawRequestResponseHandler(ctx, {
+                        userId,
+                        threadId,
+                        agentName: this.options.name,
+                        request: output.request,
+                        response: output.response,
+                    });
+                }
+                if (opts.usageHandler && output.usage) {
+                    await opts.usageHandler(ctx, {
+                        userId,
+                        threadId,
+                        agentName: this.options.name,
+                        model: getModelName(activeModel),
+                        provider: getProviderName(activeModel),
+                        usage: output.usage,
+                        providerMetadata: output.providerMetadata,
+                    });
+                }
+            },
+        };
+    }
+    /**
+     * This behaves like {@link generateText} from the "ai" package except that
+     * it add context based on the userId and threadId and saves the input and
+     * resulting messages to the thread, if specified.
+     * Use {@link continueThread} to get a version of this function already scoped
+     * to a thread (and optionally userId).
+     * @param ctx The context passed from the action function calling this.
+     * @param { userId, threadId }: The user and thread to associate the message with
+     * @param generateTextArgs The arguments to the generateText function, along with extra controls
+     * for the {@link ContextOptions} and {@link StorageOptions}.
+     * @returns The result of the generateText function.
+     */
+    async generateText(ctx, threadOpts, generateTextArgs, options) {
+        const { args, promptMessageId, order, ...call } = await this.start(ctx, generateTextArgs, { ...threadOpts, ...options });
+        const steps = [];
+        try {
+            const result = (await generateText({
+                ...args,
+                prepareStep: async (options) => {
+                    const result = await generateTextArgs.prepareStep?.(options);
+                    call.updateModel(result?.model ?? options.model);
+                    return result;
+                },
+                onStepFinish: async (step) => {
+                    steps.push(step);
+                    await call.save({ step }, await willContinue(steps, args.stopWhen));
+                    return generateTextArgs.onStepFinish?.(step);
                 },
             }));
-            result.messageId = messageId;
-            result.order = order;
-            return result;
+            const metadata = {
+                promptMessageId,
+                order,
+                savedMessages: call.getSavedMessages(),
+                messageId: promptMessageId,
+            };
+            return Object.assign(result, metadata);
         }
         catch (error) {
-            if (threadId && messageId) {
-                console.error("RollbackMessage", messageId);
-                await ctx.runMutation(this.component.messages.rollbackMessage, {
-                    messageId,
-                    error: error.message,
-                });
-            }
+            await call.fail(errorToString(error));
             throw error;
         }
     }
@@ -172,109 +261,78 @@ export class Agent {
      * Use {@link continueThread} to get a version of this function already scoped
      * to a thread (and optionally userId).
      */
-    async streamText(ctx, { userId: argsUserId, threadId, 
-    /** Note: to get better type inference, pass tools in the next arg */
-    tools: threadTools, ...usageHandler }, 
+    async streamText(ctx, threadOpts, 
     /**
      * The arguments to the streamText function, similar to the ai `streamText` function.
      */
-    args, 
+    streamTextArgs, 
     /**
      * The {@link ContextOptions} and {@link StorageOptions}
      * options to use for fetching contextual messages and saving input/output messages.
      */
     options) {
-        const opts = { ...this.options, ...options, ...usageHandler };
-        const context = await this._saveMessagesAndFetchContext(ctx, args, {
-            userId: argsUserId ?? undefined,
-            threadId,
-            ...opts,
-        });
-        const { args: aiArgs, messageId, order, stepOrder, userId } = context;
-        const toolCtx = {
-            ...ctx,
-            userId,
-            threadId,
-            messageId,
-            agent: this,
-        };
-        const tools = wrapTools(toolCtx, args.tools ?? threadTools ?? this.options.tools);
-        const saveOutput = opts.storageOptions?.saveMessages !== "none";
+        const { threadId } = threadOpts;
+        const { args, userId, order, stepOrder, promptMessageId, ...call } = await this.start(ctx, streamTextArgs, { ...threadOpts, ...options });
+        const steps = [];
+        const opts = { ...this.options, ...options };
         const streamer = threadId && opts.saveStreamDeltas
             ? new DeltaStreamer(this.component, ctx, opts.saveStreamDeltas, {
                 threadId,
                 userId,
                 agentName: this.options.name,
-                model: aiArgs.model.modelId,
-                provider: aiArgs.model.provider,
-                providerOptions: aiArgs.providerOptions,
+                model: getModelName(args.model),
+                provider: getProviderName(args.model),
+                providerOptions: args.providerOptions,
                 order,
                 stepOrder,
-                abortSignal: aiArgs.abortSignal,
+                abortSignal: args.abortSignal,
             })
             : undefined;
         const result = streamText({
-            // Can be overridden
-            maxSteps: this.options.maxSteps,
-            ...aiArgs,
-            tools,
-            abortSignal: streamer?.abortController.signal ?? aiArgs.abortSignal,
-            experimental_transform: mergeTransforms(options?.saveStreamDeltas, args.experimental_transform),
+            ...args,
+            abortSignal: streamer?.abortController.signal ?? args.abortSignal,
+            // TODO: this is probably why reasoning isn't streaming
+            experimental_transform: mergeTransforms(options?.saveStreamDeltas, streamTextArgs.experimental_transform),
             onChunk: async (event) => {
                 await streamer?.addParts([event.chunk]);
                 // console.log("onChunk", chunk);
-                return args.onChunk?.(event);
+                return streamTextArgs.onChunk?.(event);
             },
             onError: async (error) => {
                 console.error("onError", error);
-                if (threadId && messageId && saveOutput) {
-                    await ctx.runMutation(this.component.messages.rollbackMessage, {
-                        messageId,
-                        error: error.error.message,
-                    });
+                await call.fail(errorToString(error.error));
+                await streamer?.fail(errorToString(error.error));
+                return streamTextArgs.onError?.(error);
+            },
+            // onFinish: async (event) => {
+            //   return streamTextArgs.onFinish?.(event);
+            // },
+            prepareStep: async (options) => {
+                const result = await streamTextArgs.prepareStep?.(options);
+                if (result) {
+                    const model = result.model ?? options.model;
+                    call.updateModel(model);
+                    return result;
                 }
-                // TODO: update the streamer to error state
-                return args.onError?.(error);
+                return undefined;
             },
             onStepFinish: async (step) => {
-                // console.log("onStepFinish", step);
-                if (threadId && messageId && saveOutput) {
-                    const saved = await this.saveStep(ctx, {
-                        userId,
-                        threadId,
-                        model: aiArgs.model.modelId,
-                        provider: aiArgs.model.provider,
-                        promptMessageId: messageId,
-                        step,
-                    });
-                    await streamer?.finish(saved.messages);
-                }
-                if (this.options.rawRequestResponseHandler) {
-                    await this.options.rawRequestResponseHandler(ctx, {
-                        userId,
-                        threadId,
-                        agentName: this.options.name,
-                        request: step.request,
-                        response: step.response,
-                    });
-                }
-                if (opts.usageHandler && step.usage) {
-                    await opts.usageHandler(ctx, {
-                        userId,
-                        threadId,
-                        agentName: this.options.name,
-                        model: aiArgs.model.modelId,
-                        provider: aiArgs.model.provider,
-                        usage: step.usage,
-                        providerMetadata: step.providerMetadata,
-                    });
+                steps.push(step);
+                const createPendingMessage = await willContinue(steps, args.stopWhen);
+                await call.save({ step }, createPendingMessage);
+                if (!createPendingMessage) {
+                    await streamer?.finish();
                 }
                 return args.onStepFinish?.(step);
             },
         });
-        result.messageId = messageId;
-        result.order = order;
-        return result;
+        const metadata = {
+            promptMessageId,
+            order,
+            savedMessages: call.getSavedMessages(),
+            messageId: promptMessageId,
+        };
+        return Object.assign(result, metadata);
     }
     /**
      * This behaves like {@link generateObject} from the "ai" package except that
@@ -283,69 +341,30 @@ export class Agent {
      * Use {@link continueThread} to get a version of this function already scoped
      * to a thread (and optionally userId).
      */
-    async generateObject(ctx, { userId: argsUserId, threadId, ...usageHandler }, 
+    async generateObject(ctx, threadOpts, 
     /**
      * The arguments to the generateObject function, similar to the ai.generateObject function.
      */
-    args, 
+    generateObjectArgs, 
     /**
      * The {@link ContextOptions} and {@link StorageOptions}
      * options to use for fetching contextual messages and saving input/output messages.
      */
     options) {
-        const opts = { ...this.options, ...options, ...usageHandler };
-        const context = await this._saveMessagesAndFetchContext(ctx, args, {
-            userId: argsUserId ?? undefined,
-            threadId,
-            ...opts,
-        });
-        const { args: aiArgs, messageId, order, userId } = context;
-        const saveOutput = opts.storageOptions?.saveMessages !== "none";
+        const { args, promptMessageId, order, fail, save, getSavedMessages } = await this.start(ctx, generateObjectArgs, { ...threadOpts, ...options });
         try {
-            const result = (await generateObject(
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            aiArgs));
-            if (threadId && messageId && saveOutput) {
-                await this.saveObject(ctx, {
-                    threadId,
-                    promptMessageId: messageId,
-                    result,
-                    userId,
-                    model: aiArgs.model.modelId,
-                    provider: aiArgs.model.provider,
-                });
-            }
-            result.messageId = messageId;
-            result.order = order;
-            if (this.options.rawRequestResponseHandler) {
-                await this.options.rawRequestResponseHandler(ctx, {
-                    userId,
-                    threadId,
-                    agentName: this.options.name,
-                    request: result.request,
-                    response: result.response,
-                });
-            }
-            if (opts.usageHandler && result.usage) {
-                await opts.usageHandler(ctx, {
-                    userId,
-                    threadId,
-                    agentName: this.options.name,
-                    model: aiArgs.model.modelId,
-                    provider: aiArgs.model.provider,
-                    usage: result.usage,
-                    providerMetadata: result.providerMetadata,
-                });
-            }
-            return result;
+            const result = (await generateObject(args));
+            await save({ object: result });
+            const metadata = {
+                promptMessageId,
+                order,
+                savedMessages: getSavedMessages(),
+                messageId: promptMessageId,
+            };
+            return Object.assign(result, metadata);
         }
         catch (error) {
-            if (threadId && messageId) {
-                await ctx.runMutation(this.component.messages.rollbackMessage, {
-                    messageId,
-                    error: error.message,
-                });
-            }
+            await fail(errorToString(error));
             throw error;
         }
     }
@@ -356,81 +375,50 @@ export class Agent {
      * Use {@link continueThread} to get a version of this function already scoped
      * to a thread (and optionally userId).
      */
-    async streamObject(ctx, { userId: argsUserId, threadId, ...usageHandler }, 
+    async streamObject(ctx, threadOpts, 
     /**
      * The arguments to the streamObject function, similar to the ai `streamObject` function.
      */
-    args, 
+    streamObjectArgs, 
     /**
      * The {@link ContextOptions} and {@link StorageOptions}
      * options to use for fetching contextual messages and saving input/output messages.
      */
     options) {
-        // TODO: unify all this shared code between all the generate* and stream* functions
-        const opts = { ...this.options, ...options, ...usageHandler };
-        const context = await this._saveMessagesAndFetchContext(ctx, args, {
-            userId: argsUserId ?? undefined,
-            threadId,
-            ...opts,
-        });
-        const { args: aiArgs, messageId, order, userId } = context;
-        const saveOutput = opts.storageOptions?.saveMessages !== "none";
+        const { args, promptMessageId, order, fail, save, getSavedMessages } = await this.start(ctx, streamObjectArgs, { ...threadOpts, ...options });
         const stream = streamObject({
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            ...aiArgs,
+            ...args,
             onError: async (error) => {
-                console.error("onError", error);
+                console.error(" streamObject onError", error);
+                // TODO: content that we have so far
+                // content: stream.fullStream.
+                await fail(errorToString(error.error));
                 return args.onError?.(error);
             },
             onFinish: async (result) => {
-                if (threadId && messageId && saveOutput) {
-                    await this.saveObject(ctx, {
-                        userId,
-                        threadId,
-                        promptMessageId: messageId,
-                        result: {
-                            object: result.object,
-                            finishReason: "stop",
-                            usage: result.usage,
-                            warnings: result.warnings,
-                            request: await stream.request,
-                            response: result.response,
-                            providerMetadata: result.providerMetadata,
-                            experimental_providerMetadata: result.experimental_providerMetadata,
-                            logprobs: undefined,
-                            toJsonResponse: stream.toTextStreamResponse,
-                        },
-                        model: aiArgs.model.modelId,
-                        provider: aiArgs.model.provider,
-                    });
-                }
-                if (opts.usageHandler && result.usage) {
-                    await opts.usageHandler(ctx, {
-                        userId,
-                        threadId,
-                        agentName: this.options.name,
-                        model: aiArgs.model.modelId,
-                        provider: aiArgs.model.provider,
+                await save({
+                    object: {
+                        object: result.object,
+                        finishReason: result.error ? "error" : "stop",
                         usage: result.usage,
-                        providerMetadata: result.providerMetadata,
-                    });
-                }
-                if (this.options.rawRequestResponseHandler) {
-                    await this.options.rawRequestResponseHandler(ctx, {
-                        userId,
-                        threadId,
-                        agentName: this.options.name,
+                        warnings: result.warnings,
                         request: await stream.request,
                         response: result.response,
-                    });
-                }
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        providerMetadata: result.providerMetadata,
+                        toJsonResponse: stream.toTextStreamResponse,
+                    },
+                });
                 return args.onFinish?.(result);
             },
         });
-        stream.messageId = messageId;
-        stream.order = order;
-        return stream;
+        const metadata = {
+            promptMessageId,
+            order,
+            savedMessages: getSavedMessages(),
+            messageId: promptMessageId,
+        };
+        return Object.assign(stream, metadata);
     }
     /**
      * Save a message to the thread.
@@ -440,22 +428,21 @@ export class Agent {
      * @returns The messageId of the saved message.
      */
     async saveMessage(ctx, args) {
-        const { lastMessageId, messages } = await this.saveMessages(ctx, {
+        const { messages } = await this.saveMessages(ctx, {
             threadId: args.threadId,
             userId: args.userId,
             embeddings: args.embedding
-                ? {
-                    model: args.embedding.model,
-                    vectors: [args.embedding.vector],
-                }
+                ? { model: args.embedding.model, vectors: [args.embedding.vector] }
                 : undefined,
             messages: args.prompt !== undefined
                 ? [{ role: "user", content: args.prompt }]
                 : [args.message],
             metadata: args.metadata ? [args.metadata] : undefined,
             skipEmbeddings: args.skipEmbeddings,
+            pendingMessageId: args.pendingMessageId,
         });
-        return { messageId: lastMessageId, message: messages.at(-1) };
+        const message = messages.at(-1);
+        return { messageId: message._id, message };
     }
     /**
      * Explicitly save messages associated with the thread (& user if provided)
@@ -471,7 +458,7 @@ export class Agent {
         if (args.embeddings) {
             embeddings = args.embeddings;
         }
-        else if (!skipEmbeddings && this.options.textEmbedding) {
+        else if (!skipEmbeddings && this.options.textEmbeddingModel) {
             if (!("runAction" in ctx)) {
                 console.warn("You're trying to save messages and generate embeddings, but you're in a mutation. " +
                     "Pass `skipEmbeddings: true` to skip generating embeddings in the mutation and skip this warning. " +
@@ -485,10 +472,7 @@ export class Agent {
                     "You can explicitly generate them asynchronously by using the scheduler to run an action later that calls `agent.generateAndSaveEmbeddings`.");
             }
             else {
-                embeddings = await this.generateEmbeddings(ctx, {
-                    userId: args.userId ?? undefined,
-                    threadId: args.threadId,
-                }, args.messages);
+                embeddings = await this.generateEmbeddings(ctx, { userId: args.userId ?? undefined, threadId: args.threadId }, args.messages);
             }
         }
         return saveMessages(ctx, this.component, {
@@ -540,14 +524,14 @@ export class Agent {
             contextOptions,
             getEmbedding: async (text) => {
                 assert("runAction" in ctx);
-                assert(this.options.textEmbedding, "A textEmbedding model is required to be set on the Agent that you're doing vector search with");
+                assert(this.options.textEmbeddingModel, "A textEmbeddingModel is required to be set on the Agent that you're doing vector search with");
                 return {
                     embedding: (await this.doEmbed(ctx, {
                         userId: args.userId,
                         threadId: args.threadId,
                         values: [text],
                     })).embeddings[0],
-                    embeddingModel: this.options.textEmbedding.modelId,
+                    textEmbeddingModel: this.options.textEmbeddingModel,
                 };
             },
         });
@@ -578,7 +562,7 @@ export class Agent {
      * @returns The embeddings for the messages.
      */
     async generateEmbeddings(ctx, { userId, threadId, }, messages) {
-        if (!this.options.textEmbedding) {
+        if (!this.options.textEmbeddingModel) {
             return undefined;
         }
         let embeddings;
@@ -590,13 +574,13 @@ export class Agent {
         if (textIndexes.length === 0) {
             return undefined;
         }
+        const values = messageTexts.filter((t) => !!t);
         // Then embed those messages.
         const textEmbeddings = await this.doEmbed(ctx, {
             userId,
             threadId,
-            values: messageTexts,
+            values,
         });
-        // TODO: record usage of embeddings
         // Then assemble the embeddings into a single array with nulls for the messages without text.
         const embeddingsOrNull = Array(messages.length).fill(null);
         textIndexes.forEach((i, j) => {
@@ -605,11 +589,8 @@ export class Agent {
         if (textEmbeddings.embeddings.length > 0) {
             const dimension = textEmbeddings.embeddings[0].length;
             validateVectorDimension(dimension);
-            embeddings = {
-                vectors: embeddingsOrNull,
-                dimension,
-                model: this.options.textEmbedding.modelId,
-            };
+            const model = getModelName(this.options.textEmbeddingModel);
+            embeddings = { vectors: embeddingsOrNull, dimension, model };
         }
         return embeddings;
     }
@@ -647,10 +628,10 @@ export class Agent {
         const embeddings = await this.generateEmbeddings(ctx, {
             userId: messagesMissingEmbeddings[0].userId,
             threadId: messagesMissingEmbeddings[0].threadId,
-        }, messagesMissingEmbeddings.map((m) => m.message));
+        }, messagesMissingEmbeddings.map((m) => deserializeMessage(m.message)));
         if (!embeddings) {
-            if (!this.options.textEmbedding) {
-                throw new Error("No embeddings were generated for the messages. You must pass a textEmbedding model to the agent constructor.");
+            if (!this.options.textEmbeddingModel) {
+                throw new Error("No embeddings were generated for the messages. You must pass a textEmbeddingModel to the agent constructor.");
             }
             throw new Error("No embeddings were generated for these messages: " +
                 messagesMissingEmbeddings.map((m) => m._id).join(", "));
@@ -675,12 +656,12 @@ export class Agent {
      * @param args The Step generated by the AI SDK.
      */
     async saveStep(ctx, args) {
-        const messages = await serializeNewMessagesInStep(ctx, this.component, args.step, {
-            provider: args.provider ?? this.options.chat.provider,
-            model: args.model ?? this.options.chat.modelId,
+        const { messages } = await serializeNewMessagesInStep(ctx, this.component, args.step, {
+            provider: args.provider ?? getProviderName(this.options.languageModel),
+            model: args.model ?? getModelName(this.options.languageModel),
         });
         const embeddings = await this.generateEmbeddings(ctx, { userId: args.userId, threadId: args.threadId }, messages.map((m) => m.message));
-        const saved = await ctx.runMutation(this.component.messages.addMessages, {
+        return ctx.runMutation(this.component.messages.addMessages, {
             userId: args.userId,
             threadId: args.threadId,
             agentName: this.options.name,
@@ -689,7 +670,6 @@ export class Agent {
             embeddings,
             failPendingSteps: false,
         });
-        return saved;
     }
     /**
      * Manually save the result of a generateObject call to the thread.
@@ -700,11 +680,15 @@ export class Agent {
      */
     async saveObject(ctx, args) {
         const { messages } = await serializeObjectResult(ctx, this.component, args.result, {
-            model: args.model ?? this.options.chat.modelId,
-            provider: args.provider ?? this.options.chat.provider,
+            model: args.model ??
+                args.metadata?.model ??
+                getModelName(this.options.languageModel),
+            provider: args.provider ??
+                args.metadata?.provider ??
+                getProviderName(this.options.languageModel),
         });
         const embeddings = await this.generateEmbeddings(ctx, { userId: args.userId, threadId: args.threadId }, messages.map((m) => m.message));
-        await ctx.runMutation(this.component.messages.addMessages, {
+        return ctx.runMutation(this.component.messages.addMessages, {
             userId: args.userId,
             threadId: args.threadId,
             promptMessageId: args.promptMessageId,
@@ -712,7 +696,6 @@ export class Agent {
             messages,
             embeddings,
             agentName: this.options.name,
-            pending: false,
         });
     }
     /**
@@ -723,19 +706,11 @@ export class Agent {
      * @param args What message to save. Generally the parent message sent into
      *   the generateText call.
      */
-    async completeMessage(ctx, args) {
-        const result = args.result;
-        if (result.kind === "success") {
-            await ctx.runMutation(this.component.messages.commitMessage, {
-                messageId: args.messageId,
-            });
-        }
-        else {
-            await ctx.runMutation(this.component.messages.rollbackMessage, {
-                messageId: args.messageId,
-                error: result.error,
-            });
-        }
+    async finalizeMessage(ctx, args) {
+        await ctx.runMutation(this.component.messages.finalizeMessage, {
+            messageId: args.messageId,
+            result: args.result,
+        });
     }
     /**
      * Update a message by its id.
@@ -850,11 +825,17 @@ export class Agent {
     }
     async _saveMessagesAndFetchContext(ctx, args, { userId: argsUserId, threadId, contextOptions, storageOptions, }) {
         // If only a promptMessageId is provided, this will be empty.
-        const messages = promptOrMessagesToCoreMessages(args);
+        const messages = args.messages ?? [];
+        const prompt = !args.prompt
+            ? []
+            : Array.isArray(args.prompt)
+                ? args.prompt
+                : [{ role: "user", content: args.prompt }];
         const userId = argsUserId ??
             (threadId &&
                 (await ctx.runQuery(this.component.threads.getThread, { threadId }))
-                    ?.userId);
+                    ?.userId) ??
+            undefined;
         // If only a messageId is provided, this will add that message to the end.
         const contextMessages = await this.fetchContextMessages(ctx, {
             userId,
@@ -865,167 +846,132 @@ export class Agent {
         });
         // If it was a promptMessageId, pop it off context messages
         // and add to the end of messages.
-        // TODO: slice it from the prompt message, to append all of them
-        const promptMessage = !!args.promptMessageId &&
-            contextMessages.at(-1)?._id === args.promptMessageId
-            ? contextMessages.pop()
+        const promptMessageIndex = args.promptMessageId
+            ? contextMessages.findIndex((m) => m._id === args.promptMessageId)
+            : -1;
+        const promptMessage = promptMessageIndex !== -1
+            ? contextMessages.splice(promptMessageIndex, 1)[0]
             : undefined;
-        if (promptMessage && args.prompt) {
-            // If they specify both a promptMessageId and a prompt, we prefer
-            // the prompt to stand in for the promptMessageId message.
-            promptMessage.message = { role: "user", content: args.prompt };
-        }
-        let messageId = promptMessage?._id;
+        let promptMessageId = promptMessage?._id;
         let order = promptMessage?.order;
         let stepOrder = promptMessage?.stepOrder;
-        if (threadId &&
-            messages.length &&
-            storageOptions?.saveMessages !== "none" &&
-            // If it was a promptMessageId, we don't want to save it again.
-            (!args.promptMessageId || storageOptions?.saveMessages === "all")) {
-            const saveAll = storageOptions?.saveMessages === "all";
-            const coreMessages = saveAll ? messages : messages.slice(-1);
-            const saved = await this.saveMessages(ctx, {
-                threadId,
-                userId,
-                messages: coreMessages,
-                metadata: coreMessages.map((_, i) => i === coreMessages.length - 1 ? { id: args.id } : {}),
-                failPendingSteps: true,
-            });
-            messageId = saved.lastMessageId;
-            order = saved.messages.at(-1)?.order;
-            stepOrder = saved.messages.at(-1)?.stepOrder;
+        let savedMessages = undefined;
+        let pendingMessageId = undefined;
+        if (threadId && storageOptions?.saveMessages !== "none") {
+            let saved;
+            if (messages.length + prompt.length &&
+                // If it was a promptMessageId, we don't want to save it again.
+                (!args.promptMessageId || storageOptions?.saveMessages === "all")) {
+                const saveAll = storageOptions?.saveMessages === "all";
+                const coreMessages = [...messages, ...prompt];
+                const toSave = saveAll ? coreMessages : coreMessages.slice(-1);
+                const metadata = Array.from({ length: toSave.length }, () => ({}));
+                saved = await this.saveMessages(ctx, {
+                    threadId,
+                    userId,
+                    messages: [...toSave, { role: "assistant", content: [] }],
+                    metadata: [...metadata, { status: "pending" }],
+                    failPendingSteps: true,
+                    pendingMessageId: args.pendingMessageId,
+                });
+                promptMessageId = saved.messages.at(-2)._id;
+            }
+            else {
+                saved = await this.saveMessages(ctx, {
+                    threadId,
+                    userId,
+                    messages: [{ role: "assistant", content: [] }],
+                    metadata: [{ status: "pending" }],
+                    failPendingSteps: true,
+                    pendingMessageId: args.pendingMessageId,
+                });
+            }
+            pendingMessageId = saved.messages.at(-1)._id;
+            order = saved.messages.at(-1).order;
+            stepOrder = saved.messages.at(-1).stepOrder;
+            // Don't return the pending message
+            savedMessages = saved.messages.slice(0, -1);
         }
         if (promptMessage?.message) {
-            // Add the message after saving the messages, so it's not saved again.
-            messages.push(deserializeMessage(promptMessage.message));
+            if (!args.prompt) {
+                // If they override the prompt, we skip the existing prompt message.
+                messages.push(deserializeMessage(promptMessage.message));
+            }
             // Lazily generate embeddings for the prompt message, if it doesn't have
             // embeddings yet. This can happen if the message was saved in a mutation
             // where the LLM is not available.
-            if (!promptMessage.embeddingId && this.options.textEmbedding) {
+            if (!promptMessage.embeddingId && this.options.textEmbeddingModel) {
                 await this._generateAndSaveEmbeddings(ctx, [promptMessage]);
             }
         }
+        const prePrompt = contextMessages.map((m) => deserializeMessage(m.message));
+        let existingResponses = [];
+        if (promptMessageIndex !== -1) {
+            // pull any messages that already responded to the prompt off
+            // and add them after the prompt
+            existingResponses = prePrompt.splice(promptMessageIndex);
+        }
         let processedMessages = [
-            ...contextMessages.map((m) => deserializeMessage(m.message)),
+            ...prePrompt,
             ...messages,
+            ...prompt,
+            ...existingResponses,
         ];
+        if (promptMessageIndex === -1) {
+            processedMessages.push(...prompt);
+        }
+        else {
+            // We add the prompt where the prompt message was
+            processedMessages.splice(promptMessageIndex, 0, ...prompt);
+        }
         // Process messages to inline localhost files (if not, file urls pointing to localhost will be sent to LLM providers)
         if (process.env.CONVEX_CLOUD_URL?.startsWith("http://127.0.0.1")) {
-            processedMessages = await this._inlineMessagesFiles(processedMessages);
+            processedMessages = await inlineMessagesFiles(processedMessages);
         }
         const { prompt: _, model, ...rest } = args;
         return {
             args: {
+                ...this.options.callSettings,
                 ...rest,
-                maxRetries: args.maxRetries ?? this.options.maxRetries,
-                model: model ?? this.options.chat,
+                model: model ?? this.options.languageModel,
                 system: args.system ?? this.options.instructions,
                 messages: processedMessages,
             },
             userId,
-            messageId,
+            promptMessageId,
+            pendingMessageId,
+            savedMessages,
             order,
             stepOrder,
         };
     }
     async doEmbed(ctx, options) {
-        const embeddingModel = this.options.textEmbedding;
-        assert(embeddingModel, "a textEmbedding model is required to be set on the Agent that you're doing vector search with");
+        const embeddingModel = this.options.textEmbeddingModel;
+        assert(embeddingModel, "a textEmbeddingModel is required to be set on the Agent that you're doing vector search with");
         const result = await embedMany({
+            ...this.options.callSettings,
             model: embeddingModel,
             values: options.values,
             abortSignal: options.abortSignal,
             headers: options.headers,
-            maxRetries: this.options.maxRetries,
         });
         if (this.options.usageHandler && result.usage) {
             await this.options.usageHandler(ctx, {
                 userId: options.userId,
                 threadId: options.threadId,
                 agentName: this.options.name,
-                model: embeddingModel.modelId,
-                provider: embeddingModel.provider,
+                model: getModelName(embeddingModel),
+                provider: getProviderName(embeddingModel),
                 providerMetadata: undefined,
                 usage: {
-                    promptTokens: result.usage.tokens,
-                    completionTokens: 0,
+                    inputTokens: result.usage.tokens,
+                    outputTokens: 0,
                     totalTokens: result.usage.tokens,
                 },
             });
         }
         return { embeddings: result.embeddings };
     }
-    /**
-     * Process messages to inline file and image URLs that point to localhost
-     * by converting them to base64. This solves the problem of LLMs not being
-     * able to access localhost URLs.
-     */
-    async _inlineMessagesFiles(messages) {
-        // Process each message to convert localhost URLs to base64
-        return Promise.all(messages.map(async (message) => {
-            if ((message.role !== "user" && message.role !== "assistant") ||
-                typeof message.content === "string" ||
-                !Array.isArray(message.content)) {
-                return message;
-            }
-            const processedContent = await Promise.all(message.content.map(async (part) => {
-                if (part.type === "image" && part.image instanceof URL) {
-                    assert(message.role === "user", "Images can only be in user messages");
-                    if (this._isLocalhostUrl(part.image)) {
-                        const imageData = await this._downloadFile(part.image);
-                        return {
-                            ...part,
-                            image: imageData,
-                        };
-                    }
-                }
-                // Handle file parts
-                if (part.type === "file" && part.data instanceof URL) {
-                    if (this._isLocalhostUrl(part.data)) {
-                        const fileData = await this._downloadFile(part.data);
-                        return {
-                            ...part,
-                            data: fileData,
-                        };
-                    }
-                }
-                return part;
-            }));
-            if (message.role === "user") {
-                return {
-                    ...message,
-                    content: processedContent,
-                };
-            }
-            else {
-                return {
-                    ...message,
-                    content: processedContent,
-                };
-            }
-        }));
-    }
-    /**
-     * Check if a URL points to localhost
-     */
-    _isLocalhostUrl(url) {
-        return (url.hostname === "localhost" ||
-            url.hostname === "127.0.0.1" ||
-            url.hostname === "::1" ||
-            url.hostname === "0.0.0.0");
-    }
-    /**
-     * Download a file from a URL
-     */
-    async _downloadFile(url) {
-        // Fetch the file
-        const response = await fetch(url);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch ${url}: ${response.statusText}`);
-        }
-        return await response.arrayBuffer();
-    }
     /**
      * WORKFLOW UTILITIES
      */
@@ -1064,22 +1010,30 @@ export class Agent {
      * Create an action out of this agent so you can call it from workflows or other actions
      * without a wrapping function.
      * @param spec Configuration for the agent acting as an action, including
-     *   {@link ContextOptions}, {@link StorageOptions}, and maxSteps.
+     *   {@link ContextOptions}, {@link StorageOptions}, and {@link stopWhen}.
      */
-    asTextAction(spec) {
-        const maxSteps = spec?.maxSteps ?? this.options.maxSteps;
+    asTextAction(spec, overrides) {
         return internalActionGeneric({
             args: vTextArgs,
             handler: async (ctx_, args) => {
-                const stream = args.stream === true ? spec?.stream || true : spec?.stream ?? false;
+                const stream = args.stream === true ? spec?.stream || true : (spec?.stream ?? false);
                 const targetArgs = { userId: args.userId, threadId: args.threadId };
                 const llmArgs = {
-                    maxSteps,
+                    stopWhen: spec?.stopWhen ?? this.options.stopWhen,
+                    ...overrides,
                     ...omit(args, ["storageOptions", "contextOptions"]),
+                    messages: args.messages?.map(deserializeMessage),
+                    prompt: Array.isArray(args.prompt)
+                        ? args.prompt.map(deserializeMessage)
+                        : args.prompt,
+                    toolChoice: args.toolChoice,
                 };
+                if (args.maxSteps) {
+                    llmArgs.stopWhen = stepCountIs(args.maxSteps);
+                }
                 const opts = {
                     ...this.options,
-                    ...(spec && pick(spec, ["contextOptions", "storageOptions"])),
+                    ...pick(spec, ["contextOptions", "storageOptions"]),
                     ...pick(args, ["contextOptions", "storageOptions"]),
                     saveStreamDeltas: stream,
                 };
@@ -1087,24 +1041,28 @@ export class Agent {
                     ? { ...ctx_, ...spec.customCtx(ctx_, targetArgs, llmArgs) }
                     : ctx_);
                 if (stream) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     const result = await this.streamText(ctx, targetArgs, llmArgs, opts);
                     await result.consumeStream();
                     return {
                         text: await result.text,
-                        messageId: result.messageId,
+                        promptMessageId: result.promptMessageId,
                         order: result.order,
                         finishReason: await result.finishReason,
                         warnings: result.warnings,
+                        savedMessageIds: result.savedMessages?.map((m) => m._id) ?? [],
                     };
                 }
                 else {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     const res = await this.generateText(ctx, targetArgs, llmArgs, opts);
                     return {
                         text: res.text,
-                        messageId: res.messageId,
+                        promptMessageId: res.promptMessageId,
                         order: res.order,
                         finishReason: res.finishReason,
                         warnings: res.warnings,
+                        savedMessageIds: res.savedMessages?.map((m) => m._id) ?? [],
                     };
                 }
             },
@@ -1115,25 +1073,39 @@ export class Agent {
      * it from workflows or other actions without a wrapping function.
      * @param spec Configuration for the agent acting as an action, including
      * the normal parameters to {@link generateObject}, plus {@link ContextOptions}
-     * and maxSteps.
+     * and stopWhen.
      */
-    asObjectAction(spec, options) {
-        const maxSteps = spec?.maxSteps ?? this.options.maxSteps;
+    asObjectAction(objectArgs, options) {
         return internalActionGeneric({
             args: vSafeObjectArgs,
-            handler: async (ctx, args) => {
-                const overrides = pick(args, ["userId", "threadId"]);
-                const value = await this.generateObject(ctx, { userId: args.userId, threadId: args.threadId }, {
-                    ...spec,
-                    maxSteps,
-                    ...omit(args, ["userId", "threadId"]),
-                }, { ...this.options, ...options, ...overrides });
+            handler: async (ctx_, args) => {
+                const { userId, threadId, callSettings, ...rest } = args;
+                const overrides = pick(rest, ["contextOptions", "storageOptions"]);
+                const targetArgs = { userId, threadId };
+                const llmArgs = {
+                    ...objectArgs,
+                    ...callSettings,
+                    ...omit(rest, ["storageOptions", "contextOptions"]),
+                    messages: args.messages?.map(deserializeMessage),
+                    prompt: Array.isArray(args.prompt)
+                        ? args.prompt.map(deserializeMessage)
+                        : args.prompt,
+                };
+                const ctx = (options?.customCtx
+                    ? { ...ctx_, ...options.customCtx(ctx_, targetArgs, llmArgs) }
+                    : ctx_);
+                const value = await this.generateObject(ctx, targetArgs, llmArgs, {
+                    ...this.options,
+                    ...options,
+                    ...overrides,
+                });
                 return {
-                    object: value.object,
-                    messageId: value.messageId,
+                    object: convexToJson(value.object),
+                    promptMessageId: value.promptMessageId,
                     order: value.order,
                     finishReason: value.finishReason,
                     warnings: value.warnings,
+                    savedMessageIds: value.savedMessages?.map((m) => m._id) ?? [],
                 };
             },
         });
@@ -1165,116 +1137,46 @@ export class Agent {
                 userId: v.optional(v.string()),
                 promptMessageId: v.optional(v.string()),
                 messages: v.array(vMessageWithMetadata),
-                pending: v.optional(v.boolean()),
                 failPendingSteps: v.optional(v.boolean()),
+                embeddings: v.optional(vMessageEmbeddings),
             },
             handler: async (ctx, args) => {
-                const { lastMessageId, messages } = await this.saveMessages(ctx, {
+                const { messages } = await this.saveMessages(ctx, {
                     ...args,
-                    messages: args.messages.map((m) => m.message),
+                    messages: args.messages.map((m) => deserializeMessage(m.message)),
                     metadata: args.messages.map(({ message: _, ...m }) => m),
+                    skipEmbeddings: true,
                 });
                 return {
-                    lastMessageId,
-                    messageIds: messages.map((m) => m._id),
+                    lastMessageId: messages.at(-1)._id,
+                    messages: messages.map((m) => pick(m, ["_id", "order", "stepOrder"])),
                 };
             },
         });
     }
 }
-/**
- * Create a thread to store messages with an Agent.
- * @param ctx The context from a mutation or action.
- * @param component The Agent component, usually `components.agent`.
- * @param args The associated thread metadata.
- * @returns The id of the created thread.
- */
-export async function createThread(ctx, component, args) {
-    const { _id: threadId } = await ctx.runMutation(component.threads.createThread, {
-        userId: args?.userId ?? undefined,
-        title: args?.title,
-        summary: args?.summary,
-    });
-    return threadId;
-}
-/**
- * Get the metadata for a thread.
- * @param ctx A ctx object from a query, mutation, or action.
- * @param args.threadId The thread to get the metadata for.
- * @returns The metadata for the thread.
- */
-export async function getThreadMetadata(ctx, component, args) {
-    const thread = await ctx.runQuery(component.threads.getThread, {
-        threadId: args.threadId,
-    });
-    if (!thread) {
-        throw new Error("Thread not found");
-    }
-    return thread;
-}
-/**
- * Explicitly save messages associated with the thread (& user if provided)
- */
-export async function saveMessages(ctx, component, args) {
-    let embeddings;
-    if (args.embeddings) {
-        const dimension = args.embeddings.vectors.find((v) => v !== null)?.length;
-        if (dimension) {
-            validateVectorDimension(dimension);
-            embeddings = {
-                model: args.embeddings.model,
-                dimension,
-                vectors: args.embeddings.vectors,
-            };
-        }
+async function willContinue(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+steps, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+stopWhen) {
+    const step = steps.at(-1);
+    // we aren't doing another round after a tool result
+    // TODO: whether to handle continuing after too much context used..
+    if (step.finishReason !== "tool-calls")
+        return false;
+    // we don't have a tool result, so we'll wait for more
+    if (step.toolCalls.length > step.toolResults.length)
+        return false;
+    if (Array.isArray(stopWhen)) {
+        return (await Promise.all(stopWhen.map(async (s) => s({ steps })))).every((stop) => !stop);
     }
-    const result = await ctx.runMutation(component.messages.addMessages, {
-        threadId: args.threadId,
-        userId: args.userId ?? undefined,
-        agentName: args.agentName,
-        promptMessageId: args.promptMessageId,
-        embeddings,
-        messages: await Promise.all(args.messages.map(async (m, i) => {
-            const { message, fileIds } = await serializeMessage(ctx, component, m);
-            return {
-                ...args.metadata?.[i],
-                message,
-                fileIds,
-            };
-        })),
-        failPendingSteps: args.failPendingSteps ?? false,
-        pending: args.pending ?? false,
-    });
-    return {
-        lastMessageId: result.messages.at(-1)._id,
-        messages: result.messages,
-    };
+    return !(await stopWhen?.({ steps }));
 }
-/**
- * Save a message to the thread.
- * @param ctx A ctx object from a mutation or action.
- * @param args The message and what to associate it with (user / thread)
- * You can pass extra metadata alongside the message, e.g. associated fileIds.
- * @returns The messageId of the saved message.
- */
-export async function saveMessage(ctx, component, args) {
-    let embeddings;
-    if (args.embedding && args.embedding.vector) {
-        embeddings = {
-            model: args.embedding.model,
-            vectors: [args.embedding.vector],
-        };
+function errorToString(error) {
+    if (error instanceof Error) {
+        return error.message;
     }
-    const { lastMessageId, messages } = await saveMessages(ctx, component, {
-        threadId: args.threadId,
-        userId: args.userId ?? undefined,
-        agentName: args.agentName,
-        messages: args.prompt !== undefined
-            ? [{ role: "user", content: args.prompt }]
-            : [args.message],
-        metadata: args.metadata ? [args.metadata] : undefined,
-        embeddings,
-    });
-    return { messageId: lastMessageId, message: messages.at(-1) };
+    return String(error);
 }
 //# sourceMappingURL=index.js.map