@mastra/client-js 1.0.0-beta.0 → 1.0.0-beta.10

package/dist/index.js

@@ -3,8 +3,7 @@ import { v4 } from '@lukeed/uuid';
 import { getErrorFromUnknown } from '@mastra/core/error';
 import { RequestContext } from '@mastra/core/request-context';
 import { isVercelTool } from '@mastra/core/tools/is-vercel-tool';
-import { z } from 'zod';
-import originalZodToJsonSchema from 'zod-to-json-schema';
+import { zodToJsonSchema as zodToJsonSchema$1 } from '@mastra/schema-compat/zod-to-json';
 
 // src/resources/agent.ts
 function parseClientRequestContext(requestContext) {
@@ -37,11 +36,7 @@ function zodToJsonSchema(zodSchema) {
   if (!isZodType(zodSchema)) {
     return zodSchema;
   }
-  if ("toJSONSchema" in z) {
-    const fn = "toJSONSchema";
-    return z[fn].call(z, zodSchema);
-  }
-  return originalZodToJsonSchema(zodSchema, { $refStrategy: "relative" });
+  return zodToJsonSchema$1(zodSchema);
 }
 
 // src/utils/process-client-tools.ts
@@ -92,7 +87,6 @@ async function sharedProcessMastraStream({
         if (line.startsWith("data: ")) {
           const data = line.slice(6);
           if (data === "[DONE]") {
-            console.info("\u{1F3C1} Stream finished");
             return;
           }
           let json;
@@ -145,11 +139,20 @@ var BaseResource = class {
    */
   async request(path, options = {}) {
     let lastError = null;
-    const { baseUrl, retries = 3, backoffMs = 100, maxBackoffMs = 1e3, headers = {}, credentials } = this.options;
+    const {
+      baseUrl,
+      retries = 3,
+      backoffMs = 100,
+      maxBackoffMs = 1e3,
+      headers = {},
+      credentials,
+      fetch: customFetch
+    } = this.options;
+    const fetchFn = customFetch || fetch;
     let delay = backoffMs;
     for (let attempt = 0; attempt <= retries; attempt++) {
       try {
-        const response = await fetch(`${baseUrl.replace(/\/$/, "")}${path}`, {
+        const response = await fetchFn(`${baseUrl.replace(/\/$/, "")}${path}`, {
           ...options,
           headers: {
             ...options.body && !(options.body instanceof FormData) && (options.method === "POST" || options.method === "PUT") ? { "content-type": "application/json" } : {},
@@ -208,14 +211,14 @@ async function executeToolCallAndRespond({
       return response;
     }
     for (const toolCall of toolCalls) {
-      const clientTool = params.clientTools?.[toolCall.toolName];
+      const clientTool = params.clientTools?.[toolCall.payload.toolName];
       if (clientTool && clientTool.execute) {
-        const result = await clientTool.execute(toolCall?.args, {
+        const result = await clientTool.execute(toolCall?.payload.args, {
           requestContext,
           tracingContext: { currentSpan: void 0 },
           agent: {
             messages: response.messages,
-            toolCallId: toolCall?.toolCallId,
+            toolCallId: toolCall?.payload.toolCallId,
             suspend: async () => {
             },
             threadId,
@@ -229,8 +232,8 @@ async function executeToolCallAndRespond({
             content: [
               {
                 type: "tool-result",
-                toolCallId: toolCall.toolCallId,
-                toolName: toolCall.toolName,
+                toolCallId: toolCall.payload.toolCallId,
+                toolName: toolCall.payload.toolName,
                 result
               }
             ]
@@ -243,6 +246,7 @@ async function executeToolCallAndRespond({
       }
     }
   }
+  return response;
 }
 var AgentVoice = class extends BaseResource {
   constructor(options, agentId) {
@@ -975,7 +979,7 @@ var Agent = class extends BaseResource {
     });
     onFinish?.({ message, finishReason, usage });
   }
-  async processStreamResponse(processedParams, writable, route = "stream") {
+  async processStreamResponse(processedParams, controller, route = "stream") {
     const response = await this.request(`/api/agents/${this.agentId}/${route}`, {
       method: "POST",
       body: processedParams,
@@ -987,29 +991,30 @@ var Agent = class extends BaseResource {
     try {
       let toolCalls = [];
       let messages = [];
-      const [streamForWritable, streamForProcessing] = response.body.tee();
-      streamForWritable.pipeTo(
+      const [streamForController, streamForProcessing] = response.body.tee();
+      const pipePromise = streamForController.pipeTo(
         new WritableStream({
           async write(chunk) {
-            let writer;
             try {
-              writer = writable.getWriter();
               const text = new TextDecoder().decode(chunk);
               const lines = text.split("\n\n");
-              const readableLines = lines.filter((line) => line !== "[DONE]").join("\n\n");
-              await writer.write(new TextEncoder().encode(readableLines));
-            } catch {
-              await writer?.write(chunk);
-            } finally {
-              writer?.releaseLock();
+              const readableLines = lines.filter((line) => line.trim() !== "[DONE]" && line.trim() !== "data: [DONE]").join("\n\n");
+              if (readableLines) {
+                const encoded = new TextEncoder().encode(readableLines);
+                controller.enqueue(encoded);
+              }
+            } catch (error) {
+              console.error("Error enqueueing to controller:", error);
+              controller.enqueue(chunk);
             }
           }
-        }),
-        {
-          preventClose: true
-        }
+        })
       ).catch((error) => {
-        console.error("Error piping to writable stream:", error);
+        console.error("Error piping to controller:", error);
+        try {
+          controller.close();
+        } catch {
+        }
       });
       this.processChatResponse_vNext({
         stream: streamForProcessing,
@@ -1065,31 +1070,36 @@ var Agent = class extends BaseResource {
                   toolInvocation.result = result;
                 }
                 const updatedMessages = lastMessage != null ? [...messages.filter((m) => m.id !== lastMessage.id), lastMessage] : [...messages];
-                this.processStreamResponse(
-                  {
-                    ...processedParams,
-                    messages: updatedMessages
-                  },
-                  writable
-                ).catch((error) => {
-                  console.error("Error processing stream response:", error);
-                });
+                try {
+                  await this.processStreamResponse(
+                    {
+                      ...processedParams,
+                      messages: updatedMessages
+                    },
+                    controller
+                  );
+                } catch (error) {
+                  console.error("Error processing recursive stream response:", error);
+                }
               }
             }
             if (!shouldExecuteClientTool) {
-              setTimeout(() => {
-                writable.close();
-              }, 0);
+              await pipePromise;
+              controller.close();
             }
           } else {
-            setTimeout(() => {
-              writable.close();
-            }, 0);
+            await pipePromise;
+            controller.close();
           }
         },
         lastMessage: void 0
-      }).catch((error) => {
+      }).catch(async (error) => {
         console.error("Error processing stream response:", error);
+        try {
+          await pipePromise;
+          controller.close();
+        } catch {
+        }
       });
     } catch (error) {
       console.error("Error processing stream response:", error);
@@ -1139,8 +1149,13 @@ var Agent = class extends BaseResource {
         schema: zodToJsonSchema(params.structuredOutput.schema)
       } : void 0
     };
-    const { readable, writable } = new TransformStream();
-    const response = await this.processStreamResponse(processedParams, writable);
+    let readableController;
+    const readable = new ReadableStream({
+      start(controller) {
+        readableController = controller;
+      }
+    });
+    const response = await this.processStreamResponse(processedParams, readableController);
     const streamResponse = new Response(readable, {
       status: response.status,
       statusText: response.statusText,
@@ -1157,8 +1172,13 @@ var Agent = class extends BaseResource {
     return streamResponse;
   }
   async approveToolCall(params) {
-    const { readable, writable } = new TransformStream();
-    const response = await this.processStreamResponse(params, writable, "approve-tool-call");
+    let readableController;
+    const readable = new ReadableStream({
+      start(controller) {
+        readableController = controller;
+      }
+    });
+    const response = await this.processStreamResponse(params, readableController, "approve-tool-call");
     const streamResponse = new Response(readable, {
       status: response.status,
       statusText: response.statusText,
@@ -1175,8 +1195,13 @@ var Agent = class extends BaseResource {
     return streamResponse;
   }
   async declineToolCall(params) {
-    const { readable, writable } = new TransformStream();
-    const response = await this.processStreamResponse(params, writable, "decline-tool-call");
+    let readableController;
+    const readable = new ReadableStream({
+      start(controller) {
+        readableController = controller;
+      }
+    });
+    const response = await this.processStreamResponse(params, readableController, "decline-tool-call");
     const streamResponse = new Response(readable, {
       status: response.status,
       statusText: response.statusText,
@@ -1431,7 +1456,7 @@ var MemoryThread = class extends BaseResource {
     if (include) queryParams.include = JSON.stringify(include);
     const query = new URLSearchParams(queryParams);
     const queryString = query.toString();
-    const url = `/api/memory/threads/${this.threadId}/messages${queryString ? `?${queryString}` : ""}${requestContextQueryString(requestContext, queryString ? "&" : "?")}`;
+    const url = `/api/memory/threads/${this.threadId}/messages?agentId=${this.agentId}${queryString ? `&${queryString}` : ""}${requestContextQueryString(requestContext, "&")}`;
     return this.request(url);
   }
   /**
@@ -1590,15 +1615,21 @@ var Workflow = class extends BaseResource {
     if (params?.toDate) {
       searchParams.set("toDate", params.toDate.toISOString());
     }
-    if (params?.perPage !== null && params?.perPage !== void 0) {
-      if (params.perPage === false) {
-        searchParams.set("perPage", "false");
-      } else if (typeof params.perPage === "number" && params.perPage > 0 && Number.isInteger(params.perPage)) {
-        searchParams.set("perPage", String(params.perPage));
+    if (params?.page !== void 0) {
+      searchParams.set("page", String(params.page));
+    }
+    if (params?.perPage !== void 0) {
+      searchParams.set("perPage", String(params.perPage));
+    }
+    if (params?.limit !== null && params?.limit !== void 0) {
+      if (params.limit === false) {
+        searchParams.set("limit", "false");
+      } else if (typeof params.limit === "number" && params.limit > 0 && Number.isInteger(params.limit)) {
+        searchParams.set("limit", String(params.limit));
       }
     }
-    if (params?.page !== null && params?.page !== void 0 && !isNaN(Number(params?.page))) {
-      searchParams.set("page", String(params.page));
+    if (params?.offset !== null && params?.offset !== void 0 && !isNaN(Number(params?.offset))) {
+      searchParams.set("offset", String(params.offset));
     }
     if (params?.resourceId) {
       searchParams.set("resourceId", params.resourceId);
@@ -1621,6 +1652,16 @@ var Workflow = class extends BaseResource {
   runById(runId, requestContext) {
     return this.request(`/api/workflows/${this.workflowId}/runs/${runId}${requestContextQueryString(requestContext)}`);
   }
+  /**
+   * Deletes a specific workflow run by its ID
+   * @param runId - The ID of the workflow run to delete
+   * @returns Promise containing a success message
+   */
+  deleteRunById(runId) {
+    return this.request(`/api/workflows/${this.workflowId}/runs/${runId}`, {
+      method: "DELETE"
+    });
+  }
   /**
    * Retrieves the execution result for a specific workflow run by its ID
    * @param runId - The ID of the workflow run to retrieve the execution result for
@@ -1665,6 +1706,7 @@ var Workflow = class extends BaseResource {
         return this.start({
           runId,
           inputData: p.inputData,
+          initialState: p.initialState,
           requestContext: p.requestContext,
           tracingOptions: p.tracingOptions
         });
@@ -1673,12 +1715,18 @@ var Workflow = class extends BaseResource {
         return this.startAsync({
           runId,
           inputData: p.inputData,
+          initialState: p.initialState,
           requestContext: p.requestContext,
           tracingOptions: p.tracingOptions
         });
       },
       stream: async (p) => {
-        return this.stream({ runId, inputData: p.inputData, requestContext: p.requestContext });
+        return this.stream({
+          runId,
+          inputData: p.inputData,
+          initialState: p.initialState,
+          requestContext: p.requestContext
+        });
       },
       resume: async (p) => {
         return this.resume({
@@ -1710,14 +1758,19 @@ var Workflow = class extends BaseResource {
   }
   /**
    * Starts a workflow run synchronously without waiting for the workflow to complete
-   * @param params - Object containing the runId, inputData and requestContext
+   * @param params - Object containing the runId, inputData, initialState and requestContext
    * @returns Promise containing success message
    */
   start(params) {
     const requestContext = parseClientRequestContext(params.requestContext);
     return this.request(`/api/workflows/${this.workflowId}/start?runId=${params.runId}`, {
       method: "POST",
-      body: { inputData: params?.inputData, requestContext, tracingOptions: params.tracingOptions }
+      body: {
+        inputData: params?.inputData,
+        initialState: params?.initialState,
+        requestContext,
+        tracingOptions: params.tracingOptions
+      }
     });
   }
   /**
@@ -1745,7 +1798,7 @@ var Workflow = class extends BaseResource {
   }
   /**
    * Starts a workflow run asynchronously and returns a promise that resolves when the workflow is complete
-   * @param params - Object containing the optional runId, inputData and requestContext
+   * @param params - Object containing the optional runId, inputData, initialState and requestContext
    * @returns Promise containing the workflow execution results
    */
   startAsync(params) {
@@ -1756,12 +1809,17 @@ var Workflow = class extends BaseResource {
     const requestContext = parseClientRequestContext(params.requestContext);
     return this.request(`/api/workflows/${this.workflowId}/start-async?${searchParams.toString()}`, {
       method: "POST",
-      body: { inputData: params.inputData, requestContext, tracingOptions: params.tracingOptions }
+      body: {
+        inputData: params.inputData,
+        initialState: params.initialState,
+        requestContext,
+        tracingOptions: params.tracingOptions
+      }
     });
   }
   /**
    * Starts a workflow run and returns a stream
-   * @param params - Object containing the optional runId, inputData and requestContext
+   * @param params - Object containing the optional runId, inputData, initialState and requestContext
    * @returns Promise containing the workflow execution results
    */
   async stream(params) {
@@ -1774,7 +1832,12 @@ var Workflow = class extends BaseResource {
       `/api/workflows/${this.workflowId}/stream?${searchParams.toString()}`,
       {
         method: "POST",
-        body: { inputData: params.inputData, requestContext, tracingOptions: params.tracingOptions },
+        body: {
+          inputData: params.inputData,
+          initialState: params.initialState,
+          requestContext,
+          tracingOptions: params.tracingOptions
+        },
         stream: true
       }
     );
@@ -1859,7 +1922,7 @@ var Workflow = class extends BaseResource {
   }
   /**
    * Starts a workflow run and returns a stream
-   * @param params - Object containing the optional runId, inputData and requestContext
+   * @param params - Object containing the optional runId, inputData, initialState and requestContext
    * @returns Promise containing the workflow execution results
    */
   async streamVNext(params) {
@@ -1874,6 +1937,7 @@ var Workflow = class extends BaseResource {
         method: "POST",
         body: {
           inputData: params.inputData,
+          initialState: params.initialState,
           requestContext,
           closeOnSuspend: params.closeOnSuspend,
           tracingOptions: params.tracingOptions
@@ -2054,6 +2118,142 @@ var Workflow = class extends BaseResource {
       }
     });
   }
+  /**
+   * Restarts an active workflow run synchronously without waiting for the workflow to complete
+   * @param params - Object containing the runId and requestContext
+   * @returns Promise containing success message
+   */
+  restart(params) {
+    const requestContext = parseClientRequestContext(params.requestContext);
+    return this.request(`/api/workflows/${this.workflowId}/restart?runId=${params.runId}`, {
+      method: "POST",
+      body: {
+        requestContext,
+        tracingOptions: params.tracingOptions
+      }
+    });
+  }
+  /**
+   * Restarts an active workflow run asynchronously
+   * @param params - Object containing the runId and requestContext
+   * @returns Promise containing the workflow restart results
+   */
+  restartAsync(params) {
+    const requestContext = parseClientRequestContext(params.requestContext);
+    return this.request(`/api/workflows/${this.workflowId}/restart-async?runId=${params.runId}`, {
+      method: "POST",
+      body: {
+        requestContext,
+        tracingOptions: params.tracingOptions
+      }
+    });
+  }
+  /**
+   * Restart all active workflow runs synchronously without waiting for the workflow to complete
+   * @returns Promise containing success message
+   */
+  restartAllActiveWorkflowRuns() {
+    return this.request(`/api/workflows/${this.workflowId}/restart-all-active-workflow-runs`, {
+      method: "POST"
+    });
+  }
+  /**
+   * Restart all active workflow runs asynchronously
+   * @returns Promise containing success message
+   */
+  restartAllActiveWorkflowRunsAsync() {
+    return this.request(`/api/workflows/${this.workflowId}/restart-all-active-workflow-runs-async`, {
+      method: "POST"
+    });
+  }
+  /**
+   * Time travels a workflow run synchronously without waiting for the workflow to complete
+   * @param params - Object containing the runId, step, inputData, resumeData, initialState, context, nestedStepsContext, requestContext and tracingOptions
+   * @returns Promise containing success message
+   */
+  timeTravel({
+    runId,
+    requestContext: paramsRequestContext,
+    ...params
+  }) {
+    const requestContext = parseClientRequestContext(paramsRequestContext);
+    return this.request(`/api/workflows/${this.workflowId}/time-travel?runId=${runId}`, {
+      method: "POST",
+      body: {
+        ...params,
+        requestContext
+      }
+    });
+  }
+  /**
+   * Time travels a workflow run asynchronously
+   * @param params - Object containing the runId, step, inputData, resumeData, initialState, context, nestedStepsContext, requestContext and tracingOptions
+   * @returns Promise containing the workflow time travel results
+   */
+  timeTravelAsync({
+    runId,
+    requestContext: paramsRequestContext,
+    ...params
+  }) {
+    const requestContext = parseClientRequestContext(paramsRequestContext);
+    return this.request(`/api/workflows/${this.workflowId}/time-travel-async?runId=${runId}`, {
+      method: "POST",
+      body: {
+        ...params,
+        requestContext
+      }
+    });
+  }
+  /**
+   * Time travels a workflow run and returns a stream
+   * @param params - Object containing the runId, step, inputData, resumeData, initialState, context, nestedStepsContext, requestContext and tracingOptions
+   * @returns Promise containing the workflow execution results
+   */
+  async timeTravelStream({ runId, requestContext: paramsRequestContext, ...params }) {
+    const requestContext = parseClientRequestContext(paramsRequestContext);
+    const response = await this.request(
+      `/api/workflows/${this.workflowId}/time-travel-stream?runId=${runId}`,
+      {
+        method: "POST",
+        body: {
+          ...params,
+          requestContext
+        },
+        stream: true
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to time travel workflow: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    let failedChunk = void 0;
+    const transformStream = new TransformStream({
+      start() {
+      },
+      async transform(chunk, controller) {
+        try {
+          const decoded = new TextDecoder().decode(chunk);
+          const chunks = decoded.split(RECORD_SEPARATOR);
+          for (const chunk2 of chunks) {
+            if (chunk2) {
+              const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
+              try {
+                const parsedChunk = JSON.parse(newChunk);
+                controller.enqueue(parsedChunk);
+                failedChunk = void 0;
+              } catch {
+                failedChunk = newChunk;
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    });
+    return response.body.pipeThrough(transformStream);
+  }
 };
 
 // src/resources/a2a.ts
@@ -2096,7 +2296,8 @@ var A2A = class extends BaseResource {
       body: {
         method: "message/stream",
         params
-      }
+      },
+      stream: true
     });
     return response;
   }
@@ -2527,6 +2728,16 @@ var AgentBuilder = class extends BaseResource {
     if (params?.page !== void 0) {
       searchParams.set("page", String(params.page));
     }
+    if (params?.limit !== null && params?.limit !== void 0) {
+      if (params.limit === false) {
+        searchParams.set("limit", "false");
+      } else if (typeof params.limit === "number" && params.limit > 0 && Number.isInteger(params.limit)) {
+        searchParams.set("limit", String(params.limit));
+      }
+    }
+    if (params?.offset !== null && params?.offset !== void 0 && !isNaN(Number(params?.offset))) {
+      searchParams.set("offset", String(params.offset));
+    }
     if (params?.resourceId) {
       searchParams.set("resourceId", params.resourceId);
     }
@@ -2633,6 +2844,41 @@ var Observability = class extends BaseResource {
   }
 };
 
+// src/resources/stored-agent.ts
+var StoredAgent = class extends BaseResource {
+  constructor(options, storedAgentId) {
+    super(options);
+    this.storedAgentId = storedAgentId;
+  }
+  /**
+   * Retrieves details about the stored agent
+   * @returns Promise containing stored agent details
+   */
+  details() {
+    return this.request(`/api/stored/agents/${encodeURIComponent(this.storedAgentId)}`);
+  }
+  /**
+   * Updates the stored agent with the provided fields
+   * @param params - Fields to update
+   * @returns Promise containing the updated stored agent
+   */
+  update(params) {
+    return this.request(`/api/stored/agents/${encodeURIComponent(this.storedAgentId)}`, {
+      method: "PATCH",
+      body: params
+    });
+  }
+  /**
+   * Deletes the stored agent
+   * @returns Promise containing deletion confirmation
+   */
+  delete() {
+    return this.request(`/api/stored/agents/${encodeURIComponent(this.storedAgentId)}`, {
+      method: "DELETE"
+    });
+  }
+};
+
 // src/client.ts
 var MastraClient = class extends BaseResource {
   observability;
@@ -2645,12 +2891,15 @@ var MastraClient = class extends BaseResource {
    * @param requestContext - Optional request context to pass as query parameter
    * @returns Promise containing map of agent IDs to agent details
    */
-  listAgents(requestContext) {
+  listAgents(requestContext, partial) {
     const requestContextParam = base64RequestContext(parseClientRequestContext(requestContext));
     const searchParams = new URLSearchParams();
     if (requestContextParam) {
       searchParams.set("requestContext", requestContextParam);
     }
+    if (partial) {
+      searchParams.set("partial", "true");
+    }
     const queryString = searchParams.toString();
     return this.request(`/api/agents${queryString ? `?${queryString}` : ""}`);
   }
@@ -2792,12 +3041,15 @@ var MastraClient = class extends BaseResource {
    * @param requestContext - Optional request context to pass as query parameter
    * @returns Promise containing map of workflow IDs to workflow details
    */
-  listWorkflows(requestContext) {
+  listWorkflows(requestContext, partial) {
     const requestContextParam = base64RequestContext(parseClientRequestContext(requestContext));
     const searchParams = new URLSearchParams();
     if (requestContextParam) {
       searchParams.set("requestContext", requestContextParam);
     }
+    if (partial) {
+      searchParams.set("partial", "true");
+    }
     const queryString = searchParams.toString();
     return this.request(`/api/workflows${queryString ? `?${queryString}` : ""}`);
   }
@@ -2927,16 +3179,22 @@ var MastraClient = class extends BaseResource {
   }
   /**
    * Retrieves a list of available MCP servers.
-   * @param params - Optional parameters for pagination (perPage, page).
+   * @param params - Optional parameters for pagination (page, perPage, or deprecated offset, limit).
    * @returns Promise containing the list of MCP servers and pagination info.
    */
   getMcpServers(params) {
     const searchParams = new URLSearchParams();
+    if (params?.page !== void 0) {
+      searchParams.set("page", String(params.page));
+    }
     if (params?.perPage !== void 0) {
       searchParams.set("perPage", String(params.perPage));
     }
-    if (params?.page !== void 0) {
-      searchParams.set("page", String(params.page));
+    if (params?.limit !== void 0) {
+      searchParams.set("limit", String(params.limit));
+    }
+    if (params?.offset !== void 0) {
+      searchParams.set("offset", String(params.offset));
     }
     const queryString = searchParams.toString();
     return this.request(`/api/mcp/v0/servers${queryString ? `?${queryString}` : ""}`);
@@ -3136,6 +3394,52 @@ var MastraClient = class extends BaseResource {
   score(params) {
     return this.observability.score(params);
   }
+  // ============================================================================
+  // Stored Agents
+  // ============================================================================
+  /**
+   * Lists all stored agents with optional pagination
+   * @param params - Optional pagination and ordering parameters
+   * @returns Promise containing paginated list of stored agents
+   */
+  listStoredAgents(params) {
+    const searchParams = new URLSearchParams();
+    if (params?.page !== void 0) {
+      searchParams.set("page", String(params.page));
+    }
+    if (params?.perPage !== void 0) {
+      searchParams.set("perPage", String(params.perPage));
+    }
+    if (params?.orderBy) {
+      if (params.orderBy.field) {
+        searchParams.set("orderBy[field]", params.orderBy.field);
+      }
+      if (params.orderBy.direction) {
+        searchParams.set("orderBy[direction]", params.orderBy.direction);
+      }
+    }
+    const queryString = searchParams.toString();
+    return this.request(`/api/stored/agents${queryString ? `?${queryString}` : ""}`);
+  }
+  /**
+   * Creates a new stored agent
+   * @param params - Agent configuration including id, name, instructions, model, etc.
+   * @returns Promise containing the created stored agent
+   */
+  createStoredAgent(params) {
+    return this.request("/api/stored/agents", {
+      method: "POST",
+      body: params
+    });
+  }
+  /**
+   * Gets a stored agent instance by ID for further operations (details, update, delete)
+   * @param storedAgentId - ID of the stored agent to retrieve
+   * @returns StoredAgent instance
+   */
+  getStoredAgent(storedAgentId) {
+    return new StoredAgent(this.options, storedAgentId);
+  }
 };
 
 // src/tools.ts