@mastra/client-js 1.21.0-alpha.6 → 1.21.0-alpha.8

package/dist/index.js

@@ -494,6 +494,24 @@ var BaseResource = class {
 };
 
 // src/resources/agent.ts
+var SIGNAL_RUNTIME_OPTIONS_TTL_MS = 5 * 60 * 1e3;
+var signalRuntimeOptionsByRunId = /* @__PURE__ */ new Map();
+var latestSignalRuntimeOptionsByThread = /* @__PURE__ */ new Map();
+var createSignalRuntimeOptionsEntry = (store, key, streamOptions) => {
+  const timeout = setTimeout(() => store.delete(key), SIGNAL_RUNTIME_OPTIONS_TTL_MS);
+  timeout.unref?.();
+  return { streamOptions, timeout };
+};
+var setSignalRuntimeOptionsEntry = (store, key, streamOptions) => {
+  const existing = store.get(key);
+  if (existing) clearTimeout(existing.timeout);
+  store.set(key, createSignalRuntimeOptionsEntry(store, key, streamOptions));
+};
+var deleteSignalRuntimeOptionsEntry = (store, key) => {
+  const existing = store.get(key);
+  if (existing) clearTimeout(existing.timeout);
+  store.delete(key);
+};
 var noopClientToolObserve = {
   async span(_name, fn) {
     return fn();
@@ -691,6 +709,52 @@ var Agent = class extends BaseResource {
     const queryString = searchParams.toString();
     return queryString ? `${delimiter}${queryString}` : "";
   }
+  getSignalRuntimeRunKey(runId) {
+    return `${this.options.baseUrl}|${this.apiPrefix}|${this.agentId}|${runId}`;
+  }
+  getSignalRuntimeThreadKey({
+    resourceId,
+    threadId
+  }) {
+    if (!threadId) return void 0;
+    return `${this.options.baseUrl}|${this.apiPrefix}|${this.agentId}|${resourceId ?? ""}|${threadId}`;
+  }
+  setSignalRuntimeOptions({
+    runId,
+    resourceId,
+    threadId,
+    streamOptions
+  }) {
+    const threadKey = this.getSignalRuntimeThreadKey({ resourceId, threadId });
+    if (runId) {
+      setSignalRuntimeOptionsEntry(signalRuntimeOptionsByRunId, this.getSignalRuntimeRunKey(runId), streamOptions);
+      if (threadKey) deleteSignalRuntimeOptionsEntry(latestSignalRuntimeOptionsByThread, threadKey);
+      return;
+    }
+    if (threadKey) {
+      setSignalRuntimeOptionsEntry(latestSignalRuntimeOptionsByThread, threadKey, streamOptions);
+    }
+  }
+  getSignalRuntimeOptions({
+    runId,
+    resourceId,
+    threadId
+  }) {
+    if (runId) {
+      const runOptions = signalRuntimeOptionsByRunId.get(this.getSignalRuntimeRunKey(runId));
+      if (runOptions) return runOptions.streamOptions;
+    }
+    const threadKey = this.getSignalRuntimeThreadKey({ resourceId, threadId });
+    return threadKey ? latestSignalRuntimeOptionsByThread.get(threadKey)?.streamOptions : void 0;
+  }
+  deleteSignalRuntimeOptions(runId) {
+    if (!runId) return;
+    deleteSignalRuntimeOptionsEntry(signalRuntimeOptionsByRunId, this.getSignalRuntimeRunKey(runId));
+  }
+  deleteLatestSignalRuntimeOptions({ resourceId, threadId }) {
+    const threadKey = this.getSignalRuntimeThreadKey({ resourceId, threadId });
+    if (threadKey) deleteSignalRuntimeOptionsEntry(latestSignalRuntimeOptionsByThread, threadKey);
+  }
   /**
    * Retrieves details about the agent
    * @param requestContext - Optional request context to pass as query parameter
@@ -736,32 +800,227 @@ var Agent = class extends BaseResource {
   /**
    * @experimental Agent signals are experimental and may change in a future release.
    */
-  sendSignal(params) {
-    return this.request(`/agents/${this.agentId}/signals`, {
-      method: "POST",
-      body: params
-    });
+  async sendSignal(params) {
+    const streamOptions = params.ifIdle?.streamOptions;
+    if (streamOptions) {
+      this.setSignalRuntimeOptions({
+        resourceId: params.resourceId,
+        threadId: params.threadId,
+        streamOptions
+      });
+    }
+    const body = params.ifIdle?.streamOptions ? {
+      ...params,
+      ifIdle: {
+        ...params.ifIdle,
+        streamOptions: {
+          ...params.ifIdle.streamOptions,
+          requestContext: parseClientRequestContext(params.ifIdle.streamOptions.requestContext),
+          clientTools: processClientTools(params.ifIdle.streamOptions.clientTools)
+        }
+      }
+    } : params;
+    let response;
+    try {
+      response = await this.request(`/agents/${this.agentId}/signals`, {
+        method: "POST",
+        body
+      });
+    } catch (error) {
+      if (streamOptions) {
+        this.deleteLatestSignalRuntimeOptions({ resourceId: params.resourceId, threadId: params.threadId });
+      }
+      throw error;
+    }
+    if (streamOptions) {
+      this.setSignalRuntimeOptions({
+        runId: response.runId,
+        resourceId: params.resourceId,
+        threadId: params.threadId,
+        streamOptions
+      });
+    }
+    return response;
   }
   /**
    * @experimental Agent signals are experimental and may change in a future release.
    */
   async subscribeToThread(params) {
-    const streamResponse = await this.request(`/agents/${this.agentId}/threads/subscribe`, {
+    const { resourceId, threadId } = params;
+    const requestSubscription = () => this.request(`/agents/${this.agentId}/threads/subscribe`, {
       method: "POST",
-      body: params,
+      body: { resourceId, threadId },
       stream: true
     });
+    const streamResponse = await requestSubscription();
     if (!streamResponse.body) {
       throw new Error("No response body");
     }
-    streamResponse.processDataStream = async ({
-      onChunk
-    }) => {
-      await processMastraStream({
-        stream: streamResponse.body,
-        onChunk,
-        signal: this.options.abortSignal
-      });
+    const agent = this;
+    streamResponse.processDataStream = async ({ onChunk, reconnect }) => {
+      const pendingToolCallsByRunId = /* @__PURE__ */ new Map();
+      const handleSubscribedChunk = async (chunk) => {
+        if (chunk.type === "tool-call") {
+          const payload = chunk.payload;
+          const toolCallId = payload?.toolCallId;
+          const toolName = payload?.toolName;
+          const runId2 = chunk.runId;
+          if (!toolCallId || !toolName || !runId2) return;
+          const pendingToolCalls2 = pendingToolCallsByRunId.get(runId2) ?? [];
+          pendingToolCalls2.push({ toolCallId, toolName, args: payload.args, observability: payload.observability });
+          pendingToolCallsByRunId.set(runId2, pendingToolCalls2);
+          return;
+        }
+        if (chunk.type !== "finish") return;
+        const runId = chunk.runId;
+        const finishPayload = chunk;
+        if (!runId) return;
+        if (finishPayload.payload?.stepResult?.reason !== "tool-calls") {
+          agent.deleteSignalRuntimeOptions(runId);
+          return;
+        }
+        const pendingToolCalls = pendingToolCallsByRunId.get(runId);
+        pendingToolCallsByRunId.delete(runId);
+        if (!pendingToolCalls?.length) {
+          agent.deleteSignalRuntimeOptions(runId);
+          return;
+        }
+        const activeRuntimeOptions = agent.getSignalRuntimeOptions({ runId, resourceId, threadId });
+        const activeClientTools = activeRuntimeOptions?.clientTools;
+        if (!activeClientTools) {
+          agent.deleteSignalRuntimeOptions(runId);
+          return;
+        }
+        const activeRequestContext = activeRuntimeOptions.requestContext;
+        const processedClientTools = processClientTools(activeClientTools);
+        const processedRequestContext = parseClientRequestContext(activeRequestContext);
+        const toolResultMessages = [];
+        for (const toolCall of pendingToolCalls) {
+          const clientTool = activeClientTools[toolCall.toolName];
+          if (!clientTool || typeof clientTool.execute !== "function") continue;
+          let result;
+          let observability;
+          try {
+            const execution = await executeClientToolWithObservability({
+              clientTool,
+              args: toolCall.args,
+              toolName: toolCall.toolName,
+              parentContext: toolCall.observability,
+              executeContext: {
+                requestContext: activeRequestContext,
+                tracingContext: { currentSpan: void 0 },
+                agent: {
+                  agentId: agent.agentId,
+                  messages: finishPayload.payload?.messages?.nonUser ?? [],
+                  toolCallId: toolCall.toolCallId,
+                  suspend: async () => {
+                  },
+                  threadId,
+                  resourceId
+                }
+              }
+            });
+            result = execution.result;
+            observability = execution.observability;
+          } catch (error) {
+            result = { error: String(error) };
+          }
+          const toolResultContent = {
+            type: "tool-result",
+            toolCallId: toolCall.toolCallId,
+            toolName: toolCall.toolName,
+            result
+          };
+          if (observability) {
+            toolResultContent.__mastraObservability = observability;
+          }
+          await onChunk({
+            type: "tool-result",
+            runId,
+            payload: toolResultContent
+          });
+          toolResultMessages.push({
+            role: "tool",
+            content: [toolResultContent]
+          });
+        }
+        if (toolResultMessages.length === 0) {
+          agent.deleteSignalRuntimeOptions(runId);
+          return;
+        }
+        try {
+          const continuation = await agent.streamUntilIdle(
+            [...finishPayload.payload?.messages?.nonUser ?? [], ...toolResultMessages],
+            {
+              ...activeRuntimeOptions,
+              runId: v4(),
+              requestContext: processedRequestContext,
+              memory: threadId ? { thread: threadId, resource: resourceId } : void 0,
+              clientTools: processedClientTools
+            }
+          );
+          try {
+            void continuation.body?.cancel?.();
+          } catch {
+          }
+        } catch (error) {
+          console.error("Error running client-tool continuation:", error);
+        } finally {
+          agent.deleteSignalRuntimeOptions(runId);
+        }
+      };
+      const reconnectOptions = reconnect === true ? { maxRetries: Infinity, delayMs: 1e3 } : reconnect ? { maxRetries: reconnect.maxRetries ?? Infinity, delayMs: reconnect.delayMs ?? 1e3 } : null;
+      let response = streamResponse;
+      let attempts = 0;
+      const onChunkErrorSentinel = /* @__PURE__ */ Symbol("onChunkErrorSentinel");
+      const guardedOnChunk = async (chunk) => {
+        try {
+          await onChunk(chunk);
+          await handleSubscribedChunk(chunk);
+        } catch (cause) {
+          throw { [onChunkErrorSentinel]: true, cause };
+        }
+      };
+      while (true) {
+        if (!response.body) {
+          throw new Error("No response body");
+        }
+        try {
+          await processMastraStream({
+            stream: response.body,
+            onChunk: guardedOnChunk,
+            signal: this.options.abortSignal
+          });
+        } catch (error) {
+          if (typeof error === "object" && error !== null && error[onChunkErrorSentinel]) {
+            throw error.cause;
+          }
+          if (!reconnectOptions || this.options.abortSignal?.aborted || attempts >= reconnectOptions.maxRetries) {
+            throw error;
+          }
+        }
+        if (!reconnectOptions || this.options.abortSignal?.aborted || attempts >= reconnectOptions.maxRetries) {
+          return;
+        }
+        while (attempts < reconnectOptions.maxRetries) {
+          attempts++;
+          if (this.options.abortSignal?.aborted) {
+            return;
+          }
+          await new Promise((resolve) => setTimeout(resolve, reconnectOptions.delayMs));
+          if (this.options.abortSignal?.aborted) {
+            return;
+          }
+          try {
+            response = await requestSubscription();
+            break;
+          } catch (error) {
+            if (this.options.abortSignal?.aborted || attempts >= reconnectOptions.maxRetries) {
+              throw error;
+            }
+          }
+        }
+      }
     };
     return streamResponse;
   }
@@ -1289,6 +1548,7 @@ var Agent = class extends BaseResource {
     update,
     onToolCall,
     onFinish,
+    onStreamChunk,
     getCurrentDate = () => /* @__PURE__ */ new Date(),
     lastMessage
   }) {
@@ -1356,6 +1616,7 @@ var Agent = class extends BaseResource {
       // TODO: casting as any here because the stream types were all typed as any before in core.
       // but this is completely wrong and this fn is probably broken. Remove ":any" and you'll see a bunch of type errors
       onChunk: async (chunk) => {
+        onStreamChunk?.(chunk);
         switch (chunk.type) {
           case "tripwire": {
             message.parts.push({
@@ -1457,6 +1718,7 @@ var Agent = class extends BaseResource {
                 execUpdate();
               }
             }
+            break;
           }
           case "tool-call-input-streaming-start": {
             if (message.toolInvocations == null) {
@@ -1573,6 +1835,7 @@ var Agent = class extends BaseResource {
     try {
       let toolCalls = [];
       let messages = [];
+      let streamRunId = processedParams.runId;
       const [streamForController, streamForProcessing] = response.body.tee();
       const pipePromise = streamForController.pipeTo(
         new WritableStream({
@@ -1626,25 +1889,76 @@ var Agent = class extends BaseResource {
               const clientTool = processedParams.clientTools?.[toolCall2.toolName];
               if (clientTool && clientTool.execute) {
                 shouldExecuteClientTool = true;
-                const { result, observability } = await executeClientToolWithObservability({
-                  clientTool,
-                  args: toolCall2?.args,
-                  toolName: toolCall2.toolName,
-                  parentContext: getClientToolObservabilityContext(toolCall2),
-                  executeContext: {
-                    requestContext: processedParams.requestContext,
-                    tracingContext: { currentSpan: void 0 },
-                    agent: {
-                      agentId: this.agentId,
-                      messages: response.messages,
-                      toolCallId: toolCall2?.toolCallId,
-                      suspend: async () => {
-                      },
-                      threadId,
-                      resourceId
+                const runId = streamRunId ?? toolCall2.toolCallId;
+                let result;
+                let observability;
+                let synthetic;
+                try {
+                  ({ result, observability } = await executeClientToolWithObservability({
+                    clientTool,
+                    args: toolCall2?.args,
+                    toolName: toolCall2.toolName,
+                    parentContext: getClientToolObservabilityContext(toolCall2),
+                    executeContext: {
+                      requestContext: processedParams.requestContext,
+                      tracingContext: { currentSpan: void 0 },
+                      agent: {
+                        agentId: this.agentId,
+                        messages: response.messages,
+                        toolCallId: toolCall2?.toolCallId,
+                        suspend: async () => {
+                        },
+                        threadId,
+                        resourceId
+                      }
                     }
-                  }
-                });
+                  }));
+                  synthetic = {
+                    type: "tool-result",
+                    runId,
+                    from: "AGENT",
+                    payload: {
+                      toolCallId: toolCall2.toolCallId,
+                      toolName: toolCall2.toolName,
+                      result,
+                      isError: false,
+                      providerExecuted: false
+                    }
+                  };
+                } catch (error) {
+                  synthetic = {
+                    type: "tool-error",
+                    runId,
+                    from: "AGENT",
+                    payload: {
+                      toolCallId: toolCall2.toolCallId,
+                      toolName: toolCall2.toolName,
+                      error,
+                      args: toolCall2?.args,
+                      providerExecuted: false
+                    }
+                  };
+                  result = { error: error instanceof Error ? error.message : String(error) };
+                }
+                try {
+                  await pipePromise;
+                } catch {
+                }
+                try {
+                  const errorForSerialization = synthetic.type === "tool-error" ? synthetic.payload.error : void 0;
+                  const serializedError = errorForSerialization instanceof Error ? {
+                    name: errorForSerialization.name,
+                    message: errorForSerialization.message,
+                    stack: errorForSerialization.stack
+                  } : errorForSerialization;
+                  const payloadForWire = synthetic.type === "tool-error" ? { ...synthetic, payload: { ...synthetic.payload, error: serializedError } } : synthetic;
+                  const sseLine = `data: ${JSON.stringify(payloadForWire)}
+
+`;
+                  controller.enqueue(new TextEncoder().encode(sseLine));
+                } catch (enqueueErr) {
+                  console.error("Failed to enqueue synthetic tool-result chunk:", enqueueErr);
+                }
                 const lastMessageRaw = messages[messages.length - 1];
                 const lastMessage = lastMessageRaw != null ? JSON.parse(JSON.stringify(lastMessageRaw)) : void 0;
                 const toolInvocationPart = lastMessage?.parts?.find(
@@ -1694,6 +2008,11 @@ var Agent = class extends BaseResource {
             controller.close();
           }
         },
+        onStreamChunk: (chunk) => {
+          if (!streamRunId && typeof chunk.runId === "string") {
+            streamRunId = chunk.runId;
+          }
+        },
         lastMessage: void 0
       }).catch(async (error) => {
         console.error("Error processing stream response:", error);