@convex-dev/agent 0.1.18-alpha.1 → 0.2.0-alpha.2

package/dist/client/definePlaygroundAPI.d.ts

@@ -1,5 +1,5 @@
-import { type GenericDataModel, type GenericQueryCtx, type ApiFromModules, type GenericActionCtx } from "convex/server";
-import { type AgentComponent, type Agent } from "./index.js";
+import { type ApiFromModules, type GenericActionCtx, type GenericDataModel, type GenericQueryCtx } from "convex/server";
+import { type Agent, type AgentComponent } from "./index.js";
 export type PlaygroundAPI = ApiFromModules<{
     playground: ReturnType<typeof definePlaygroundAPI>;
 }>["playground"];
@@ -73,203 +73,153 @@ export declare function definePlaygroundAPI<DataModel extends GenericDataModel>(
             numItems: number;
             cursor: string | null;
         };
-    }, Promise<{
-        continueCursor: string;
-        isDone: boolean;
-        page: {
-            _creationTime: number;
-            _id: string;
-            agentName?: string | undefined;
-            embeddingId?: string | undefined;
-            error?: string | undefined;
-            fileIds?: string[] | undefined;
-            finishReason?: "stop" | "length" | "content-filter" | "tool-calls" | "error" | "other" | "unknown" | undefined;
-            id?: string | undefined;
-            message?: {
-                content: string | ({
-                    providerOptions?: {
-                        [x: string]: {
-                            [x: string]: any;
-                        };
-                    } | undefined;
-                    text: string;
-                    type: "text";
-                } | {
-                    image: string | ArrayBuffer;
-                    mimeType?: string | undefined;
-                    providerOptions?: {
-                        [x: string]: {
-                            [x: string]: any;
-                        };
-                    } | undefined;
-                    type: "image";
-                } | {
-                    data: string | ArrayBuffer;
-                    filename?: string | undefined;
-                    mimeType: string;
-                    providerOptions?: {
-                        [x: string]: {
-                            [x: string]: any;
-                        };
-                    } | undefined;
-                    type: "file";
-                })[];
-                providerOptions?: {
-                    [x: string]: {
-                        [x: string]: any;
-                    };
-                } | undefined;
-                role: "user";
+    }, Promise<import("convex/server").PaginationResult<{
+        id?: string | undefined;
+        userId?: string | undefined;
+        embeddingId?: string | undefined;
+        fileIds?: string[] | undefined;
+        error?: string | undefined;
+        agentName?: string | undefined;
+        model?: string | undefined;
+        provider?: string | undefined;
+        providerOptions?: Record<string, Record<string, any>> | undefined;
+        message?: {
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            role: "user";
+            content: string | ({
+                providerOptions?: Record<string, Record<string, any>> | undefined;
+                type: "text";
+                text: string;
             } | {
-                content: string | ({
-                    providerOptions?: {
-                        [x: string]: {
-                            [x: string]: any;
-                        };
-                    } | undefined;
-                    text: string;
-                    type: "text";
-                } | {
-                    data: string | ArrayBuffer;
-                    filename?: string | undefined;
-                    mimeType: string;
-                    providerOptions?: {
-                        [x: string]: {
-                            [x: string]: any;
-                        };
-                    } | undefined;
-                    type: "file";
-                } | {
-                    providerOptions?: {
-                        [x: string]: {
-                            [x: string]: any;
-                        };
-                    } | undefined;
-                    signature?: string | undefined;
-                    text: string;
-                    type: "reasoning";
-                } | {
-                    data: string;
-                    providerOptions?: {
-                        [x: string]: {
-                            [x: string]: any;
-                        };
-                    } | undefined;
-                    type: "redacted-reasoning";
-                } | {
-                    args: any;
-                    providerOptions?: {
-                        [x: string]: {
-                            [x: string]: any;
-                        };
-                    } | undefined;
-                    toolCallId: string;
-                    toolName: string;
-                    type: "tool-call";
-                })[];
-                providerOptions?: {
-                    [x: string]: {
-                        [x: string]: any;
-                    };
-                } | undefined;
-                role: "assistant";
+                providerOptions?: Record<string, Record<string, any>> | undefined;
+                mimeType?: string | undefined;
+                type: "image";
+                image: string | ArrayBuffer;
             } | {
-                content: {
-                    args?: any;
-                    experimental_content?: ({
-                        text: string;
-                        type: "text";
-                    } | {
-                        data: string;
-                        mimeType?: string | undefined;
-                        type: "image";
-                    })[] | undefined;
-                    isError?: boolean | undefined;
-                    providerOptions?: {
-                        [x: string]: {
-                            [x: string]: any;
-                        };
-                    } | undefined;
-                    result: any;
-                    toolCallId: string;
-                    toolName: string;
-                    type: "tool-result";
-                }[];
-                providerOptions?: {
-                    [x: string]: {
-                        [x: string]: any;
-                    };
-                } | undefined;
-                role: "tool";
+                providerOptions?: Record<string, Record<string, any>> | undefined;
+                filename?: string | undefined;
+                type: "file";
+                mimeType: string;
+                data: string | ArrayBuffer;
+            })[];
+        } | {
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            role: "assistant";
+            content: string | ({
+                providerOptions?: Record<string, Record<string, any>> | undefined;
+                type: "text";
+                text: string;
             } | {
-                content: string;
-                providerOptions?: {
-                    [x: string]: {
-                        [x: string]: any;
-                    };
-                } | undefined;
-                role: "system";
-            } | undefined;
-            model?: string | undefined;
-            order: number;
-            provider?: string | undefined;
-            providerMetadata?: {
-                [x: string]: {
-                    [x: string]: any;
-                };
-            } | undefined;
-            providerOptions?: {
-                [x: string]: {
-                    [x: string]: any;
-                };
-            } | undefined;
-            reasoning?: string | undefined;
-            reasoningDetails?: ({
+                providerOptions?: Record<string, Record<string, any>> | undefined;
+                filename?: string | undefined;
+                type: "file";
+                mimeType: string;
+                data: string | ArrayBuffer;
+            } | {
+                providerOptions?: Record<string, Record<string, any>> | undefined;
                 signature?: string | undefined;
+                state?: "streaming" | "done" | undefined;
+                type: "reasoning";
                 text: string;
-                type: "text";
             } | {
+                providerOptions?: Record<string, Record<string, any>> | undefined;
+                type: "redacted-reasoning";
                 data: string;
-                type: "redacted";
-            })[] | undefined;
-            sources?: {
-                id: string;
-                providerOptions?: {
-                    [x: string]: {
-                        [x: string]: any;
-                    };
-                } | undefined;
-                sourceType: "url";
-                title?: string | undefined;
-                url: string;
-            }[] | undefined;
-            status: "pending" | "success" | "failed";
-            stepOrder: number;
-            text?: string | undefined;
-            threadId: string;
-            tool: boolean;
-            usage?: {
-                completionTokens: number;
-                promptTokens: number;
-                totalTokens: number;
-            } | undefined;
-            userId?: string | undefined;
-            warnings?: ({
-                details?: string | undefined;
-                setting: string;
-                type: "unsupported-setting";
-            } | {
-                details?: string | undefined;
-                tool: any;
-                type: "unsupported-tool";
             } | {
-                message: string;
-                type: "other";
-            })[] | undefined;
-        }[];
-        pageStatus?: "SplitRecommended" | "SplitRequired" | null | undefined;
-        splitCursor?: string | null | undefined;
-    }>>;
+                providerOptions?: Record<string, Record<string, any>> | undefined;
+                providerExecuted?: boolean | undefined;
+                type: "tool-call";
+                toolCallId: string;
+                toolName: string;
+                args: any;
+            })[];
+        } | {
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            role: "tool";
+            content: {
+                providerOptions?: Record<string, Record<string, any>> | undefined;
+                args?: any;
+                providerExecuted?: boolean | undefined;
+                isError?: boolean | undefined;
+                experimental_content?: ({
+                    type: "text";
+                    text: string;
+                } | {
+                    mimeType?: string | undefined;
+                    type: "image";
+                    data: string;
+                })[] | undefined;
+                type: "tool-result";
+                toolCallId: string;
+                toolName: string;
+                result: any;
+            }[];
+        } | {
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            role: "system";
+            content: string;
+        } | undefined;
+        text?: string | undefined;
+        reasoning?: string | undefined;
+        usage?: {
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        } | undefined;
+        providerMetadata?: Record<string, Record<string, any>> | undefined;
+        sources?: ({
+            title?: string | undefined;
+            type?: "source" | undefined;
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            url?: string | undefined;
+            id: string;
+            sourceType: "url";
+        } | {
+            filename?: string | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            id: string;
+            title: string;
+            type: "source";
+            sourceType: "document";
+            mediaType: string;
+        })[] | undefined;
+        reasoningDetails?: ({
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            signature?: string | undefined;
+            state?: "streaming" | "done" | undefined;
+            type: "reasoning";
+            text: string;
+        } | {
+            signature?: string | undefined;
+            type: "text";
+            text: string;
+        } | {
+            type: "redacted";
+            data: string;
+        })[] | undefined;
+        warnings?: ({
+            details?: string | undefined;
+            type: "unsupported-setting";
+            setting: string;
+        } | {
+            details?: string | undefined;
+            type: "unsupported-tool";
+            tool: any;
+        } | {
+            type: "other";
+            message: string;
+        })[] | undefined;
+        finishReason?: "length" | "error" | "other" | "stop" | "content-filter" | "tool-calls" | "unknown" | undefined;
+        _id: string;
+        _creationTime: number;
+        status: "pending" | "success" | "failed";
+        order: number;
+        threadId: string;
+        stepOrder: number;
+        tool: boolean;
+    }>>>;
     listAgents: import("convex/server").RegisteredQuery<"public", {
         userId?: string | undefined;
         threadId?: string | undefined;
@@ -279,7 +229,6 @@ export declare function definePlaygroundAPI<DataModel extends GenericDataModel>(
         instructions: string | undefined;
         contextOptions: import("./types.js").ContextOptions | undefined;
         storageOptions: import("./types.js").StorageOptions | undefined;
-        maxSteps: number | undefined;
         maxRetries: number | undefined;
         tools: string[];
     }[]>>;
@@ -329,6 +278,7 @@ export declare function definePlaygroundAPI<DataModel extends GenericDataModel>(
             } | {
                 providerOptions?: Record<string, Record<string, any>> | undefined;
                 signature?: string | undefined;
+                state?: "streaming" | "done" | undefined;
                 type: "reasoning";
                 text: string;
             } | {
@@ -337,6 +287,7 @@ export declare function definePlaygroundAPI<DataModel extends GenericDataModel>(
                 data: string;
             } | {
                 providerOptions?: Record<string, Record<string, any>> | undefined;
+                providerExecuted?: boolean | undefined;
                 type: "tool-call";
                 toolCallId: string;
                 toolName: string;
@@ -348,6 +299,8 @@ export declare function definePlaygroundAPI<DataModel extends GenericDataModel>(
             content: {
                 providerOptions?: Record<string, Record<string, any>> | undefined;
                 args?: any;
+                providerExecuted?: boolean | undefined;
+                isError?: boolean | undefined;
                 experimental_content?: ({
                     type: "text";
                     text: string;
@@ -356,7 +309,6 @@ export declare function definePlaygroundAPI<DataModel extends GenericDataModel>(
                     type: "image";
                     data: string;
                 })[] | undefined;
-                isError?: boolean | undefined;
                 type: "tool-result";
                 toolCallId: string;
                 toolName: string;
@@ -391,7 +343,7 @@ export declare function definePlaygroundAPI<DataModel extends GenericDataModel>(
         agentName: string;
         apiKey: string;
     }, Promise<{
-        messageId: string;
+        messageId: string | undefined;
         text: string;
     }>>;
     fetchPromptContext: import("convex/server").RegisteredAction<"public", {
@@ -434,6 +386,7 @@ export declare function definePlaygroundAPI<DataModel extends GenericDataModel>(
             } | {
                 providerOptions?: Record<string, Record<string, any>> | undefined;
                 signature?: string | undefined;
+                state?: "streaming" | "done" | undefined;
                 type: "reasoning";
                 text: string;
             } | {
@@ -442,6 +395,7 @@ export declare function definePlaygroundAPI<DataModel extends GenericDataModel>(
                 data: string;
             } | {
                 providerOptions?: Record<string, Record<string, any>> | undefined;
+                providerExecuted?: boolean | undefined;
                 type: "tool-call";
                 toolCallId: string;
                 toolName: string;
@@ -453,6 +407,8 @@ export declare function definePlaygroundAPI<DataModel extends GenericDataModel>(
             content: {
                 providerOptions?: Record<string, Record<string, any>> | undefined;
                 args?: any;
+                providerExecuted?: boolean | undefined;
+                isError?: boolean | undefined;
                 experimental_content?: ({
                     type: "text";
                     text: string;
@@ -461,7 +417,6 @@ export declare function definePlaygroundAPI<DataModel extends GenericDataModel>(
                     type: "image";
                     data: string;
                 })[] | undefined;
-                isError?: boolean | undefined;
                 type: "tool-result";
                 toolCallId: string;
                 toolName: string;
@@ -533,6 +488,7 @@ export declare function definePlaygroundAPI<DataModel extends GenericDataModel>(
             } | {
                 providerOptions?: Record<string, Record<string, any>> | undefined;
                 signature?: string | undefined;
+                state?: "streaming" | "done" | undefined;
                 type: "reasoning";
                 text: string;
             } | {
@@ -541,6 +497,7 @@ export declare function definePlaygroundAPI<DataModel extends GenericDataModel>(
                 data: string;
             } | {
                 providerOptions?: Record<string, Record<string, any>> | undefined;
+                providerExecuted?: boolean | undefined;
                 type: "tool-call";
                 toolCallId: string;
                 toolName: string;
@@ -552,6 +509,8 @@ export declare function definePlaygroundAPI<DataModel extends GenericDataModel>(
             content: {
                 providerOptions?: Record<string, Record<string, any>> | undefined;
                 args?: any;
+                providerExecuted?: boolean | undefined;
+                isError?: boolean | undefined;
                 experimental_content?: ({
                     type: "text";
                     text: string;
@@ -560,7 +519,6 @@ export declare function definePlaygroundAPI<DataModel extends GenericDataModel>(
                     type: "image";
                     data: string;
                 })[] | undefined;
-                isError?: boolean | undefined;
                 type: "tool-result";
                 toolCallId: string;
                 toolName: string;
@@ -574,19 +532,36 @@ export declare function definePlaygroundAPI<DataModel extends GenericDataModel>(
         text?: string | undefined;
         reasoning?: string | undefined;
         usage?: {
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
             promptTokens: number;
             completionTokens: number;
             totalTokens: number;
         } | undefined;
         providerMetadata?: Record<string, Record<string, any>> | undefined;
-        sources?: {
+        sources?: ({
             title?: string | undefined;
+            type?: "source" | undefined;
             providerOptions?: Record<string, Record<string, any>> | undefined;
+            url?: string | undefined;
             id: string;
             sourceType: "url";
-            url: string;
-        }[] | undefined;
+        } | {
+            filename?: string | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            id: string;
+            title: string;
+            type: "source";
+            sourceType: "document";
+            mediaType: string;
+        })[] | undefined;
         reasoningDetails?: ({
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            signature?: string | undefined;
+            state?: "streaming" | "done" | undefined;
+            type: "reasoning";
+            text: string;
+        } | {
             signature?: string | undefined;
             type: "text";
             text: string;

package/dist/client/definePlaygroundAPI.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definePlaygroundAPI.d.ts","sourceRoot":"","sources":["../../src/client/definePlaygroundAPI.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACtB,MAAM,eAAe,CAAC;AACvB,OAAO,EAOL,KAAK,cAAc,EACnB,KAAK,KAAK,EACX,MAAM,YAAY,CAAC;AAGpB,MAAM,MAAM,aAAa,GAAG,cAAc,CAAC;IACzC,UAAU,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC;CACpD,CAAC,CAAC,YAAY,CAAC,CAAC;AAEjB,MAAM,MAAM,QAAQ,CAAC,SAAS,SAAS,gBAAgB,IAAI,CACzD,GAAG,EAAE,gBAAgB,CAAC,SAAS,CAAC,GAAG,eAAe,CAAC,SAAS,CAAC,EAC7D,IAAI,EAAE;IAAE,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,KAC/D,KAAK,EAAE,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;AAGhC,wBAAgB,mBAAmB,CAAC,SAAS,SAAS,gBAAgB,EACpE,SAAS,EAAE,cAAc,EACzB,EACE,MAAM,EAAE,UAAU,EAClB,cAAc,GACf,EAAE;IACD,MAAM,EAAE,KAAK,EAAE,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC;IACtC,cAAc,CAAC,EAAE,CACf,GAAG,EAAE,eAAe,CAAC,SAAS,CAAC,EAC/B,MAAM,EAAE,MAAM,KACX,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAC/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiSF"}
+{"version":3,"file":"definePlaygroundAPI.d.ts","sourceRoot":"","sources":["../../src/client/definePlaygroundAPI.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACrB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAUL,KAAK,KAAK,EACV,KAAK,cAAc,EACpB,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,aAAa,GAAG,cAAc,CAAC;IACzC,UAAU,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC;CACpD,CAAC,CAAC,YAAY,CAAC,CAAC;AAEjB,MAAM,MAAM,QAAQ,CAAC,SAAS,SAAS,gBAAgB,IAAI,CACzD,GAAG,EAAE,gBAAgB,CAAC,SAAS,CAAC,GAAG,eAAe,CAAC,SAAS,CAAC,EAC7D,IAAI,EAAE;IAAE,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,KAC/D,KAAK,EAAE,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;AAGhC,wBAAgB,mBAAmB,CAAC,SAAS,SAAS,gBAAgB,EACpE,SAAS,EAAE,cAAc,EACzB,EACE,MAAM,EAAE,UAAU,EAClB,cAAc,GACf,EAAE;IACD,MAAM,EAAE,KAAK,EAAE,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC;IACtC,cAAc,CAAC,EAAE,CACf,GAAG,EAAE,eAAe,CAAC,SAAS,CAAC,EAC/B,MAAM,EAAE,MAAM,KACX,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAC/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgRF"}

package/dist/client/definePlaygroundAPI.js

@@ -1,6 +1,6 @@
-import { paginationOptsValidator, queryGeneric, mutationGeneric, actionGeneric, } from "convex/server";
-import { vMessageDoc, vThreadDoc, vPaginationResult, vMessage, vContextOptions, vStorageOptions, } from "./index.js";
+import { actionGeneric, mutationGeneric, paginationOptsValidator, queryGeneric, } from "convex/server";
 import { v } from "convex/values";
+import { createThread as createThread_, listMessages as listMessages_, deserializeMessage, vContextOptions, vMessage, vMessageDoc, vPaginationResult, vStorageOptions, vThreadDoc, } from "./index.js";
 // Playground API definition
 export function definePlaygroundAPI(component, { agents: agentsOrFn, userNameLookup, }) {
     function validateAgents(agents) {
@@ -14,9 +14,7 @@ export function definePlaygroundAPI(component, { agents: agentsOrFn, userNameLoo
         await ctx.runQuery(component.apiKeys.validate, { apiKey });
     }
     const isApiKeyValid = queryGeneric({
-        args: {
-            apiKey: v.string(),
-        },
+        args: { apiKey: v.string() },
         handler: async (ctx, args) => {
             try {
                 await validateApiKey(ctx, args.apiKey);
@@ -56,17 +54,13 @@ export function definePlaygroundAPI(component, { agents: agentsOrFn, userNameLoo
                 instructions: agent.options.instructions,
                 contextOptions: agent.options.contextOptions,
                 storageOptions: agent.options.storageOptions,
-                maxSteps: agent.options.maxSteps,
-                maxRetries: agent.options.maxRetries,
+                maxRetries: agent.options.callSettings?.maxRetries,
                 tools: agent.options.tools ? Object.keys(agent.options.tools) : [],
             }));
         },
     });
     const listUsers = queryGeneric({
-        args: {
-            apiKey: v.string(),
-            paginationOpts: paginationOptsValidator,
-        },
+        args: { apiKey: v.string(), paginationOpts: paginationOptsValidator },
         handler: async (ctx, args) => {
             await validateApiKey(ctx, args.apiKey);
             const users = await ctx.runQuery(component.users.listUsersWithThreads, {
@@ -80,10 +74,7 @@ export function definePlaygroundAPI(component, { agents: agentsOrFn, userNameLoo
                 }))),
             };
         },
-        returns: vPaginationResult(v.object({
-            _id: v.string(),
-            name: v.string(),
-        })),
+        returns: vPaginationResult(v.object({ _id: v.string(), name: v.string() })),
     });
     // List threads for a user (query)
     const listThreads = queryGeneric({
@@ -105,10 +96,7 @@ export function definePlaygroundAPI(component, { agents: agentsOrFn, userNameLoo
                     const { page: [last], } = await ctx.runQuery(component.messages.listMessagesByThreadId, {
                         threadId: thread._id,
                         order: "desc",
-                        paginationOpts: {
-                            numItems: 1,
-                            cursor: null,
-                        },
+                        paginationOpts: { numItems: 1, cursor: null },
                     });
                     return {
                         ...thread,
@@ -135,10 +123,9 @@ export function definePlaygroundAPI(component, { agents: agentsOrFn, userNameLoo
         },
         handler: async (ctx, args) => {
             await validateApiKey(ctx, args.apiKey);
-            return ctx.runQuery(component.messages.listMessagesByThreadId, {
+            return listMessages_(ctx, component, {
                 threadId: args.threadId,
                 paginationOpts: args.paginationOpts,
-                order: "desc",
                 statuses: ["success", "failed", "pending"],
             });
         },
@@ -155,18 +142,13 @@ export function definePlaygroundAPI(component, { agents: agentsOrFn, userNameLoo
             agentName: v.optional(v.string()),
         },
         handler: async (ctx, args) => {
-            // if (args.agentName) {
-            //   console.warn(
-            //     "Upgrade to the latest version of @convex-dev/agent-playground"
-            //   );
-            // }
             await validateApiKey(ctx, args.apiKey);
-            const { _id } = await ctx.runMutation(component.threads.createThread, {
+            const threadId = await createThread_(ctx, component, {
                 userId: args.userId,
                 title: args.title,
                 summary: args.summary,
             });
-            return { threadId: _id };
+            return { threadId };
         },
         returns: v.object({ threadId: v.string() }),
     });
@@ -186,7 +168,7 @@ export function definePlaygroundAPI(component, { agents: agentsOrFn, userNameLoo
             system: v.optional(v.string()),
         },
         handler: async (ctx, args) => {
-            const { apiKey, agentName, userId, threadId, contextOptions, storageOptions, system, ...rest } = args;
+            const { apiKey, agentName, userId, threadId, contextOptions, storageOptions, system, messages, ...rest } = args;
             await validateApiKey(ctx, apiKey);
             const agents = await getAgents(ctx, {
                 userId: args.userId,
@@ -196,11 +178,11 @@ export function definePlaygroundAPI(component, { agents: agentsOrFn, userNameLoo
             if (!namedAgent)
                 throw new Error(`Unknown agent: ${agentName}`);
             const { agent } = namedAgent;
-            const { thread } = await agent.continueThread(ctx, { threadId, userId });
-            const { messageId, text } = await thread.generateText({ ...rest, ...(system ? { system } : {}) }, {
-                contextOptions,
-                storageOptions,
-            });
+            const { messageId, text } = await agent.generateText(ctx, { threadId, userId }, {
+                ...rest,
+                ...(system ? { system } : {}),
+                ...(messages ? { messages: messages.map(deserializeMessage) } : {}),
+            }, { contextOptions, storageOptions });
             return { messageId, text };
         },
     });
@@ -233,7 +215,7 @@ export function definePlaygroundAPI(component, { agents: agentsOrFn, userNameLoo
             const messages = await agent.fetchContextMessages(ctx, {
                 userId: args.userId,
                 threadId: args.threadId,
-                messages: args.messages,
+                messages: args.messages.map(deserializeMessage),
                 contextOptions: args.contextOptions,
                 upToAndIncludingMessageId: args.beforeMessageId,
             });