@mastra/client-js 1.15.2-alpha.0 → 1.15.2-alpha.1

package/CHANGELOG.md

@@ -1,5 +1,113 @@
 # @mastra/client-js
 
+## 1.15.2-alpha.1
+
+### Patch Changes
+
+- Add durable agents with resumable streams ([#12557](https://github.com/mastra-ai/mastra/pull/12557))
+
+  Durable agents make agent execution resilient to disconnections, crashes, and long-running operations.
+
+  ### The Problem
+
+  Standard agent streaming has two fragility points:
+  1. **Connection drops** - If a client disconnects mid-stream (network blip, browser refresh, mobile app backgrounded), all subsequent events are lost. The client has no way to "catch up" on what they missed.
+  2. **Long-running operations** - Agent loops with tool calls can take minutes. Holding an HTTP connection open that long is unreliable. If the server restarts or the connection times out, the work is lost.
+
+  ### The Solution
+
+  **Resumable streams** solve connection drops. Every event is cached with a sequential index. If a client disconnects at event 5, they can reconnect and request events starting from index 6. They receive cached events immediately, then continue with live events as they arrive.
+
+  **Durable execution** solves long-running operations. Instead of executing the agent loop directly in the HTTP request, execution happens in a workflow engine (built-in evented engine or Inngest). The HTTP request just subscribes to events. If the connection drops, execution continues. The client can reconnect anytime to observe progress.
+
+  ### Usage
+
+  Wrap any existing `Agent` with durability using factory functions:
+
+  ```typescript
+  import { Agent } from '@mastra/core/agent';
+  import { createDurableAgent } from '@mastra/core/agent/durable';
+
+  const agent = new Agent({
+    id: 'my-agent',
+    model: openai('gpt-4'),
+    instructions: 'You are helpful',
+  });
+
+  const durableAgent = createDurableAgent({ agent });
+  ```
+
+  **Factory functions for different execution strategies:**
+
+  | Factory                                  | Execution                           | Use Case                        |
+  | ---------------------------------------- | ----------------------------------- | ------------------------------- |
+  | `createDurableAgent({ agent })`          | Local, synchronous                  | Development, simple deployments |
+  | `createEventedAgent({ agent })`          | Fire-and-forget via workflow engine | Long-running operations         |
+  | `createInngestAgent({ agent, inngest })` | Inngest-powered                     | Production, distributed systems |
+
+  ### Resumable Streams
+
+  ```typescript
+  // Start streaming
+  const { runId, output } = await durableAgent.stream('Analyze this data...');
+
+  // Client disconnects at event 5...
+
+  // Reconnect and resume from where we left off
+  const { output: resumed } = await durableAgent.observe(runId, { offset: 6 });
+  // Receives events 6, 7, 8... from cache, then continues with live events
+  ```
+
+  ### PubSub and Cache
+
+  Durable agents use two infrastructure components:
+
+  | Component  | Purpose                                   | Default               |
+  | ---------- | ----------------------------------------- | --------------------- |
+  | **PubSub** | Real-time event delivery during streaming | `EventEmitterPubSub`  |
+  | **Cache**  | Stores events for replay on reconnection  | `InMemoryServerCache` |
+
+  When `stream()` is called, events flow through pubsub in real-time. The cache stores each event with a sequential index. When `observe()` is called, missed events replay from cache before continuing with live events.
+
+  **Configure via Mastra instance (recommended):**
+
+  ```typescript
+  const mastra = new Mastra({
+    cache: new RedisServerCache({ url: 'redis://...' }),
+    pubsub: new RedisPubSub({ url: 'redis://...' }),
+    agents: {
+      // Inherits cache and pubsub from Mastra
+      myAgent: createDurableAgent({ agent }),
+    },
+  });
+  ```
+
+  **Configure per-agent (overrides Mastra):**
+
+  ```typescript
+  const durableAgent = createDurableAgent({
+    agent,
+    cache: new RedisServerCache({ url: 'redis://...' }),
+    pubsub: new RedisPubSub({ url: 'redis://...' }),
+  });
+  ```
+
+  **Disable caching (streams won't be resumable):**
+
+  ```typescript
+  const durableAgent = createDurableAgent({ agent, cache: false });
+  ```
+
+  For single-instance deployments, the defaults work fine. For multi-instance deployments (load balancer, horizontal scaling), use Redis-backed implementations so any instance can serve reconnection requests.
+
+  ### Class Hierarchy
+  - `DurableAgent` extends `Agent` - base class with resumable streams
+  - `EventedAgent` extends `DurableAgent` - fire-and-forget execution
+  - `InngestAgent` extends `DurableAgent` - Inngest-powered execution
+
+- Updated dependencies [[`920c757`](https://github.com/mastra-ai/mastra/commit/920c75799c6bd71787d86deaf654a35af4c839ca), [`1fe2533`](https://github.com/mastra-ai/mastra/commit/1fe2533c4382ca6858aac7c4b63e888c2eac6541), [`f8694b6`](https://github.com/mastra-ai/mastra/commit/f8694b6fa0b7a5cde71d794c3bbef4957c55bcb8)]:
+  - @mastra/core@1.30.0-alpha.1
+
 ## 1.15.2-alpha.0
 
 ### Patch Changes

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-client-js
 description: Documentation for @mastra/client-js. Use when working with @mastra/client-js APIs, configuration, or implementation.
 metadata:
   package: "@mastra/client-js"
-  version: "1.15.2-alpha.0"
+  version: "1.15.2-alpha.1"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.15.2-alpha.0",
+  "version": "1.15.2-alpha.1",
   "package": "@mastra/client-js",
   "exports": {
     "RequestContext": {

package/dist/index.cjs

@@ -1558,6 +1558,51 @@ var Agent = class extends BaseResource {
     };
     return streamResponse;
   }
+  /**
+   * Observe (reconnect to) an existing agent stream.
+   * Use this to resume receiving events after a disconnection.
+   *
+   * @param params.runId - The run ID to observe
+   * @param params.offset - Optional position to resume from (0-based). If omitted, replays all events.
+   * @returns Promise containing a streaming Response
+   *
+   * @example
+   * ```typescript
+   * // Reconnect to a stream from a specific position
+   * const response = await client.agents('my-agent').observe({
+   *   runId: 'run-123',
+   *   offset: 42, // Resume from event 42
+   * });
+   *
+   * await response.processDataStream({
+   *   onChunk: (chunk) => console.log('Received:', chunk),
+   * });
+   * ```
+   */
+  async observe(params) {
+    const response = await this.request(`/agents/${this.agentId}/observe`, {
+      method: "POST",
+      body: params,
+      stream: true
+    });
+    if (!response.body) {
+      throw new Error("No response body");
+    }
+    const streamResponse = new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+    streamResponse.processDataStream = async ({
+      onChunk
+    }) => {
+      await processMastraStream({
+        stream: streamResponse.body,
+        onChunk
+      });
+    };
+    return streamResponse;
+  }
   /**
    * Resumes a suspended agent stream with custom resume data.
    * Used to continue execution after a suspension point (e.g., workflow suspend within an agent).
@@ -2311,19 +2356,32 @@ var Run = class extends BaseResource {
     return response.body.pipeThrough(this.createChunkTransformStream());
   }
   /**
-   * Observes workflow stream for a workflow run
-   * @returns Promise containing the workflow execution results
+   * Observe (reconnect to) an existing workflow stream.
+   * Use this to resume receiving events after a disconnection.
+   *
+   * @param params.offset - Optional position to resume from (0-based). If omitted, replays all events.
+   * @returns Promise containing a ReadableStream of workflow events
+   *
+   * @example
+   * ```typescript
+   * // Reconnect to a workflow stream from a specific position
+   * const stream = await run.observe({ offset: 42 });
+   *
+   * for await (const event of stream) {
+   *   console.log('Received:', event);
+   * }
+   * ```
    */
-  async observeStream() {
+  async observe(params) {
     const searchParams = new URLSearchParams();
     searchParams.set("runId", this.runId);
-    const response = await this.request(
-      `/workflows/${this.workflowId}/observe-stream?${searchParams.toString()}`,
-      {
-        method: "POST",
-        stream: true
-      }
-    );
+    if (params?.offset !== void 0) {
+      searchParams.set("offset", String(params.offset));
+    }
+    const response = await this.request(`/workflows/${this.workflowId}/observe?${searchParams.toString()}`, {
+      method: "POST",
+      stream: true
+    });
     if (!response.ok) {
       throw new Error(`Failed to observe workflow stream: ${response.statusText}`);
     }
@@ -2332,6 +2390,14 @@ var Run = class extends BaseResource {
     }
     return response.body.pipeThrough(this.createChunkTransformStream());
   }
+  /**
+   * Observes workflow stream for a workflow run
+   * @deprecated Use `observe()` instead for better control over replay position
+   * @returns Promise containing the workflow execution results
+   */
+  async observeStream() {
+    return this.observe();
+  }
   /**
    * Resumes a suspended workflow step asynchronously and returns a promise that resolves when the workflow is complete
    * @param params - Object containing the step, resumeData and requestContext