@mastra/client-js 1.32.1-alpha.2 → 1.33.0-alpha.11

package/CHANGELOG.md

@@ -1,5 +1,144 @@
 # @mastra/client-js
 
+## 1.33.0-alpha.11
+
+### Minor Changes
+
+- Added exact thread binding when creating AgentController sessions through the JavaScript client. ([#19902](https://github.com/mastra-ai/mastra/pull/19902))
+
+### Patch Changes
+
+- Updated dependencies [[`c7d30cd`](https://github.com/mastra-ai/mastra/commit/c7d30cd86009c407df91105591f03cd6e3d2854d), [`ef03fbc`](https://github.com/mastra-ai/mastra/commit/ef03fbcc556bcbc04c9b3d06fab88771ecaa043c), [`a7bbe77`](https://github.com/mastra-ai/mastra/commit/a7bbe773577f60bc4761b534ef7ec6b476332dad), [`a7bbe77`](https://github.com/mastra-ai/mastra/commit/a7bbe773577f60bc4761b534ef7ec6b476332dad), [`4e68363`](https://github.com/mastra-ai/mastra/commit/4e683634f94ebd062d26a3bb6093a8dfc7263d37), [`9251370`](https://github.com/mastra-ai/mastra/commit/9251370ad413af464aa22d7566338bec5613e8de)]:
+  - @mastra/core@1.52.0-alpha.11
+
+## 1.33.0-alpha.10
+
+### Minor Changes
+
+- Added request-scoped model overrides to agent execution and approvals, and fixed Studio model selection so each tab can use a different model without changing the agent's configured default. ([#19749](https://github.com/mastra-ai/mastra/pull/19749))
+
+  ```ts
+  await agent.stream(messages, { model: 'google/gemini-2.5-flash' });
+  ```
+
+### Patch Changes
+
+- Updated dependencies [[`41a5392`](https://github.com/mastra-ai/mastra/commit/41a5392d9f6c5e18d6b227f0fc0ddf49c50774e9), [`675fbff`](https://github.com/mastra-ai/mastra/commit/675fbff84d3274391b33e852f76083c38a5514e5), [`da009e1`](https://github.com/mastra-ai/mastra/commit/da009e1aacd89ed94b8d1b2af09c9d4fe7c4db49), [`35c2181`](https://github.com/mastra-ai/mastra/commit/35c2181e6a50e47c90ba36260db7c9723d54696f), [`b4b7ea8`](https://github.com/mastra-ai/mastra/commit/b4b7ea8733f033fc441ea47ed03f6afb17ec2248), [`675fbff`](https://github.com/mastra-ai/mastra/commit/675fbff84d3274391b33e852f76083c38a5514e5), [`c328769`](https://github.com/mastra-ai/mastra/commit/c3287698ff8ef98dba86d415faa566fa3e5f4d56), [`232fcbc`](https://github.com/mastra-ai/mastra/commit/232fcbc14fce625dd672ba043329c0b732c62be2), [`3491666`](https://github.com/mastra-ai/mastra/commit/34916663c4fdd43b48c21f4ab2d5fb6dcccc94f9)]:
+  - @mastra/core@1.52.0-alpha.10
+
+## 1.33.0-alpha.9
+
+### Patch Changes
+
+- Updated dependencies [[`0a2c22c`](https://github.com/mastra-ai/mastra/commit/0a2c22c902604439ec490319e14c17f331e0c84c), [`3a8024c`](https://github.com/mastra-ai/mastra/commit/3a8024ce615f8aa89479c0d71fe61d10bb0040be)]:
+  - @mastra/core@1.52.0-alpha.9
+
+## 1.33.0-alpha.8
+
+### Patch Changes
+
+- Updated dependencies [[`3b77e77`](https://github.com/mastra-ai/mastra/commit/3b77e7704936522e4769d29de1b5ea6901f302bd), [`6b1bf3b`](https://github.com/mastra-ai/mastra/commit/6b1bf3b9494bd51aa8f654c68c9355d6046fa2a1), [`72e437c`](https://github.com/mastra-ai/mastra/commit/72e437c515942c80b9def5b026e0bdee61b469d9)]:
+  - @mastra/core@1.52.0-alpha.8
+
+## 1.33.0-alpha.7
+
+### Patch Changes
+
+- Updated dependencies [[`b7e79c3`](https://github.com/mastra-ai/mastra/commit/b7e79c3c02ac5cd415db34ba0975ceafc1464333), [`b75d749`](https://github.com/mastra-ai/mastra/commit/b75d749621ff5d17e86bcb4ee809d301fb4f7cf3), [`a8799bb`](https://github.com/mastra-ai/mastra/commit/a8799bb8e44f4a60d01e4e2acd3448ff80bf14f8)]:
+  - @mastra/core@1.52.0-alpha.7
+
+## 1.33.0-alpha.6
+
+### Patch Changes
+
+- Updated dependencies [[`a40adeb`](https://github.com/mastra-ai/mastra/commit/a40adeb222b961a56a58af56a106106525721b74), [`821648b`](https://github.com/mastra-ai/mastra/commit/821648bf2871ef840100c7bacbecf676010bd12a), [`11f6cd9`](https://github.com/mastra-ai/mastra/commit/11f6cd96fe42582403416608beb212cc1a2cc79e)]:
+  - @mastra/core@1.52.0-alpha.6
+
+## 1.33.0-alpha.5
+
+### Patch Changes
+
+- Replace `any` with `unknown` in generated route types so clients get real type errors instead of silently unchecked values. Route-types generation now deduplicates shared schemas into reusable type aliases, shrinking the generated `route-types.generated.ts` from ~94K to ~22K lines (77% smaller). The memory config response now types `workingMemory` (enabled, scope, template, schema, version) instead of `unknown`. ([#19573](https://github.com/mastra-ai/mastra/pull/19573))
+
+  If your code read fields from responses that were previously typed `any`, TypeScript now requires you to narrow them before use:
+
+  ```ts
+  // Before: `metadata` was `any`, so this compiled even when unsafe
+  const value = response.metadata.someField;
+
+  // After: `metadata` is `unknown` — narrow it first
+  const metadata = response.metadata;
+  if (metadata && typeof metadata === 'object' && 'someField' in metadata) {
+    const value = metadata.someField;
+  }
+  // ...or cast if you know the shape: (metadata as MyMetadata).someField
+  ```
+
+  Code that reads `workingMemory` from the memory config response no longer needs casts — `config.workingMemory?.enabled`, `scope`, `template`, `schema`, and `version` are now typed directly.
+
+- Updated dependencies [[`ec857fc`](https://github.com/mastra-ai/mastra/commit/ec857fc79c264b53b38e16478c789b7177f2ad59), [`e1f2fae`](https://github.com/mastra-ai/mastra/commit/e1f2faebaf048c3d4c2e2c01d293767c195d5794), [`63aa799`](https://github.com/mastra-ai/mastra/commit/63aa799c6b44eacc7806cda6846b7c5bbee06b37), [`73db8db`](https://github.com/mastra-ai/mastra/commit/73db8db90d69ab6153c7942749f624db0d96952d), [`73db8db`](https://github.com/mastra-ai/mastra/commit/73db8db90d69ab6153c7942749f624db0d96952d), [`76b7181`](https://github.com/mastra-ai/mastra/commit/76b71810366e6d90b9d3973149d1c7ba3659ffb9), [`0c0e8d7`](https://github.com/mastra-ai/mastra/commit/0c0e8d7becd4d1445c656b78d5d845f606c1ff9d), [`9f7c67a`](https://github.com/mastra-ai/mastra/commit/9f7c67abeeb52c41c51a9b5edee60b62afe7cd8d), [`3b65e68`](https://github.com/mastra-ai/mastra/commit/3b65e68d7f1c771c7a70eea42d83fefdd28cad88), [`e3868e2`](https://github.com/mastra-ai/mastra/commit/e3868e22babfffd0133771669ca724501c2dd58e)]:
+  - @mastra/core@1.52.0-alpha.5
+
+## 1.33.0-alpha.4
+
+### Patch Changes
+
+- Updated dependencies [[`4cfdd64`](https://github.com/mastra-ai/mastra/commit/4cfdd645794feaea0c4ea711e70ecdfbef0c5b8e)]:
+  - @mastra/core@1.52.0-alpha.4
+
+## 1.33.0-alpha.3
+
+### Minor Changes
+
+- Added a `requestContext` option to agent controller session methods in @mastra/client-js. You can now pass custom request context to `sendMessage`, `steer`, `followUp`, `approveTool`, and `respondToToolSuspension`, matching what `agent.generate()` already supports. The context is merged into the run's request context on the server, so it reaches dynamic instructions and tools. ([#19531](https://github.com/mastra-ai/mastra/pull/19531))
+
+  ```ts
+  const session = client.getAgentController('code').session('user-1');
+  await session.sendMessage('hello', { requestContext: { userId: 'user-1', tier: 'pro' } });
+  ```
+
+- Added reconnect support to `AgentControllerSession.subscribe()` so SSE subscriptions recover after proxy timeouts or transport errors. Fixes #19202. ([#19560](https://github.com/mastra-ai/mastra/pull/19560))
+
+  ```ts
+  await session.subscribe({
+    onEvent: event => {
+      /* handle event */
+    },
+    reconnect: true,
+  });
+  ```
+
+### Patch Changes
+
+- Fixed AgentController live events and thread history returning serialized message timestamps instead of Date values. ([#18783](https://github.com/mastra-ai/mastra/pull/18783))
+
+- Fixed AgentControllerSession.subscribe() so it resolves only after the stream is established and rejects when it cannot connect (leaving no background retry loop). Reconnect now applies only after an established stream drops, backs off exponentially, and fires a new onReconnect callback on each re-established stream so consumers can re-sync missed events: ([#19580](https://github.com/mastra-ai/mastra/pull/19580))
+
+  ```ts
+  const subscription = await session.subscribe({
+    onEvent: event => applyEvent(event),
+    onError: error => showDisconnected(error),
+    reconnect: { maxRetries: 5, delayMs: 1000, maxDelayMs: 30_000 },
+    onReconnect: async () => {
+      // Events emitted while disconnected are not replayed — re-sync state.
+      applyState(await session.state());
+    },
+  });
+  ```
+
+- Added stable metrics and logs capability reporting for observability storage. The system packages response now includes `observabilityStorageCapabilities` with `metrics` and `logs` flags, enabling capability-based detection that is resilient to bundler-generated constructor name changes. ([#19305](https://github.com/mastra-ai/mastra/pull/19305))
+
+  ```typescript
+  const packages = await client.getSystemPackages();
+  console.log(packages.observabilityStorageCapabilities?.metrics); // true
+  console.log(packages.observabilityStorageCapabilities?.logs); // true
+  ```
+
+  Studio now uses the capability response instead of relying on constructor names, with a fallback for older servers.
+
+- Updated dependencies [[`1426af2`](https://github.com/mastra-ai/mastra/commit/1426af24975879c000d13ac75673f630fcc970c1), [`975295d`](https://github.com/mastra-ai/mastra/commit/975295d418552f0d46a59edfef4c3ee555f9930a), [`85e4fb5`](https://github.com/mastra-ai/mastra/commit/85e4fb50087a81c74df3a762f53b56373db0b912), [`ef03c0c`](https://github.com/mastra-ai/mastra/commit/ef03c0cfc62367a458e4cc56462e2148b35681c5), [`4fb4d88`](https://github.com/mastra-ai/mastra/commit/4fb4d881bc107acee13890ad4d78661016c510ed), [`4eba27a`](https://github.com/mastra-ai/mastra/commit/4eba27adcf60f991df0e62f94b3e75b4e67f3b4b), [`c701be3`](https://github.com/mastra-ai/mastra/commit/c701be32d7d9aa94a66da8c6cc38dcac6856f464)]:
+  - @mastra/core@1.52.0-alpha.3
+
 ## 1.32.1-alpha.2
 
 ### Patch Changes
@@ -2355,9 +2494,7 @@
   await client.storedAgents.unfavorite(agent.id);
 
   // Versioning + publish
-  const draft = await client.storedSkills.create({
-    /* ... */
-  });
+  const draft = await client.storedSkills.create({/* ... */});
   const published = await client.storedSkills.publish(draft.id);
   await client.storedSkills.restore(draft.id, { version: 1 });
   ```
@@ -2529,9 +2666,7 @@
   await client.storedAgents.unfavorite(agent.id);
 
   // Versioning + publish
-  const draft = await client.storedSkills.create({
-    /* ... */
-  });
+  const draft = await client.storedSkills.create({/* ... */});
   const published = await client.storedSkills.publish(draft.id);
   await client.storedSkills.restore(draft.id, { version: 1 });
   ```

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.32.1-alpha.2"
+  version: "1.33.0-alpha.11"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.32.1-alpha.2",
+  "version": "1.33.0-alpha.11",
   "package": "@mastra/client-js",
   "exports": {
     "RequestContext": {

package/dist/docs/references/docs-editor-overview.md

@@ -57,9 +57,7 @@ import { Mastra } from '@mastra/core'
 import { MastraEditor } from '@mastra/editor'
 
 export const mastra = new Mastra({
-  agents: {
-    /* your existing agents */
-  },
+  agents: {/* your existing agents */},
   editor: new MastraEditor(),
 })
 ```
@@ -84,9 +82,7 @@ import { Mastra } from '@mastra/core'
 import { MastraEditor } from '@mastra/editor'
 
 export const mastra = new Mastra({
-  agents: {
-    /* your existing agents */
-  },
+  agents: {/* your existing agents */},
   editor: new MastraEditor({
     source: 'code',
   }),

package/dist/index.cjs

@@ -6144,6 +6144,19 @@ var Channels = class extends BaseResource {
 };
 
 // src/resources/agent-controller.ts
+function hydrateMessage(message) {
+  return {
+    ...message,
+    createdAt: message.createdAt instanceof Date ? message.createdAt : new Date(message.createdAt)
+  };
+}
+function hydrateEventMessage(event) {
+  if (event.type !== "message_start" && event.type !== "message_update" && event.type !== "message_end") return event;
+  return {
+    ...event,
+    message: hydrateMessage(event.message)
+  };
+}
 var AgentControllerSession = class extends BaseResource {
   constructor(options, controllerId, resourceId, scope) {
     super(options);
@@ -6166,59 +6179,175 @@ var AgentControllerSession = class extends BaseResource {
   /**
    * Create or resume this session. Pass `tags` to scope initial thread
    * selection — a thread is a resume candidate only when its metadata matches
-   * every tag. Required when sessions share a resourceId (e.g. git worktrees
-   * using a `{ projectPath }` tag) so each resumes its own thread instead of the
-   * most recent thread across the whole resource.
+   * every tag. Pass `threadId` to bind the session to one exact thread,
+   * creating it with that id when it does not exist.
    */
   create(options) {
     return this.request(`/agent-controller/${encodeURIComponent(this.controllerId)}/sessions`, {
       method: "POST",
-      body: { resourceId: this.resourceId, tags: options?.tags, sessionScope: this.scope }
+      body: {
+        resourceId: this.resourceId,
+        tags: options?.tags,
+        threadId: options?.threadId,
+        sessionScope: this.scope
+      }
     });
   }
   /**
    * Subscribe to this session's event stream (SSE). The assistant's reply to a
    * message arrives here as `message_*` events, not on the sendMessage call.
+   *
+   * The returned promise resolves once the stream is actually established and
+   * rejects when it cannot be. A rejected subscribe leaves nothing running —
+   * `reconnect` governs only re-establishment after an established stream
+   * drops, so callers that want connect-time retry can loop around
+   * `subscribe()` themselves and keep cancellation control.
    */
   async subscribe(options) {
-    const response = await this.request(this.url(`${this.base()}/stream`), { stream: true });
-    if (!response.body) {
-      throw new Error("No response body for agent controller session stream");
-    }
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
+    const finiteOr = (value, fallback) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
+    const retriesOr = (value, fallback) => value === Infinity || typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
+    const reconnectOptions = options.reconnect === true ? { maxRetries: Infinity, delayMs: 1e3, maxDelayMs: 3e4 } : options.reconnect ? {
+      maxRetries: retriesOr(options.reconnect.maxRetries, Infinity),
+      delayMs: finiteOr(options.reconnect.delayMs, 1e3),
+      maxDelayMs: finiteOr(options.reconnect.maxDelayMs, 3e4)
+    } : null;
+    const backoffDelay = (attempt) => reconnectOptions ? Math.min(reconnectOptions.delayMs * 2 ** (attempt - 1), reconnectOptions.maxDelayMs) : 0;
     let cancelled = false;
-    let buffer = "";
-    const pump = async () => {
+    let currentReader = null;
+    let reconnectTimer;
+    let delayResolve;
+    const settleDelay = () => {
+      if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = void 0;
+      }
+      const resolve = delayResolve;
+      delayResolve = void 0;
+      resolve?.();
+    };
+    const delay = (ms) => new Promise((resolve) => {
+      delayResolve = resolve;
+      reconnectTimer = setTimeout(settleDelay, ms);
+    });
+    const requestStream = async () => {
+      const response = await this.request(this.url(`${this.base()}/stream`), { stream: true });
+      if (!response.body) {
+        throw new Error("No response body for agent controller session stream");
+      }
+      return response;
+    };
+    const streamEndedError = () => new Error("Agent controller session stream ended unexpectedly");
+    const findFrameSeparator = (text) => {
+      const candidates = [
+        { index: text.indexOf("\r\n\r\n"), length: 4 },
+        { index: text.indexOf("\n\n"), length: 2 },
+        { index: text.indexOf("\r\r"), length: 2 }
+      ].filter((candidate) => candidate.index !== -1);
+      if (candidates.length === 0) return null;
+      return candidates.reduce((earliest, candidate) => candidate.index < earliest.index ? candidate : earliest);
+    };
+    const pump = async (response) => {
+      const reader = response.body.getReader();
+      currentReader = reader;
+      const decoder = new TextDecoder();
+      let buffer = "";
       try {
         while (!cancelled) {
           const { done, value } = await reader.read();
-          if (done) break;
+          if (done) return cancelled ? { kind: "cancelled" } : { kind: "done" };
           buffer += decoder.decode(value, { stream: true });
-          let sep;
-          while ((sep = buffer.indexOf("\n\n")) !== -1) {
-            const frame = buffer.slice(0, sep);
-            buffer = buffer.slice(sep + 2);
-            for (const line of frame.split("\n")) {
+          let separator;
+          while ((separator = findFrameSeparator(buffer)) !== null) {
+            const frame = buffer.slice(0, separator.index);
+            buffer = buffer.slice(separator.index + separator.length);
+            for (const line of frame.split(/\r\n|\n|\r/)) {
               if (!line.startsWith("data:")) continue;
               const data = line.slice(5).trim();
               if (!data) continue;
+              let event;
               try {
-                options.onEvent(JSON.parse(data));
+                event = hydrateEventMessage(JSON.parse(data));
               } catch {
+                continue;
+              }
+              try {
+                options.onEvent(event);
+              } catch (cause) {
+                if (!cancelled) safeOnError(cause);
+                return { kind: "consumer_error" };
               }
             }
           }
         }
+        return { kind: "cancelled" };
+      } catch (error) {
+        return cancelled ? { kind: "cancelled" } : { kind: "transport_error", error };
+      } finally {
+        if (currentReader === reader) currentReader = null;
+        void reader.cancel().catch(() => {
+        });
+      }
+    };
+    const safeOnError = (error) => {
+      try {
+        options.onError?.(error);
+      } catch {
+      }
+    };
+    const reportTerminalError = (result) => {
+      safeOnError(result.kind === "transport_error" ? result.error : streamEndedError());
+    };
+    const pumpSafe = async (response) => {
+      try {
+        return await pump(response);
       } catch (error) {
-        if (!cancelled) options.onError?.(error);
+        return cancelled ? { kind: "cancelled" } : { kind: "transport_error", error };
       }
     };
-    void pump();
+    const firstResponse = await requestStream();
+    const run = async (initial) => {
+      let response = initial;
+      while (!cancelled) {
+        let result = await pumpSafe(response);
+        if (cancelled || result.kind === "cancelled" || result.kind === "consumer_error") return;
+        if (!reconnectOptions) {
+          reportTerminalError(result);
+          return;
+        }
+        let attempts = 0;
+        let reconnectedResponse;
+        while (!reconnectedResponse) {
+          if (attempts >= reconnectOptions.maxRetries) {
+            reportTerminalError(result);
+            return;
+          }
+          attempts++;
+          await delay(backoffDelay(attempts));
+          if (cancelled) return;
+          try {
+            reconnectedResponse = await requestStream();
+          } catch (error) {
+            result = { kind: "transport_error", error };
+          }
+        }
+        if (cancelled) {
+          void reconnectedResponse.body?.cancel().catch(() => {
+          });
+          return;
+        }
+        response = reconnectedResponse;
+        try {
+          options.onReconnect?.();
+        } catch {
+        }
+      }
+    };
+    void run(firstResponse);
     return {
       unsubscribe: () => {
         cancelled = true;
-        void reader.cancel().catch(() => {
+        settleDelay();
+        void currentReader?.cancel().catch(() => {
         });
       }
     };
@@ -6227,12 +6356,18 @@ var AgentControllerSession = class extends BaseResource {
    * Send a user message. The reply streams over `subscribe()`.
    * Pass a structured message to attach files (e.g. pasted images) as base64-encoded data:
    * `sendMessage({ content: 'What is in this image?', files })`.
+   * Pass `options.requestContext` to merge custom context into the run's request context.
    */
-  async sendMessage(message) {
+  async sendMessage(message, options) {
     const { content, files } = typeof message === "string" ? { content: message, files: void 0 } : message;
+    const requestContext = parseClientRequestContext(options?.requestContext);
     await this.request(this.url(`${this.base()}/messages`), {
       method: "POST",
-      body: { message: content, ...files?.length ? { files } : {} }
+      body: {
+        message: content,
+        ...files?.length ? { files } : {},
+        ...requestContext ? { requestContext } : {}
+      }
     });
   }
   /** Abort the in-flight run for this session. */
@@ -6240,10 +6375,11 @@ var AgentControllerSession = class extends BaseResource {
     await this.request(this.url(`${this.base()}/abort`), { method: "POST" });
   }
   /** Approve or decline a pending tool call (`tool_approval_required`). */
-  async approveTool(toolCallId, approved) {
+  async approveTool(toolCallId, approved, options) {
+    const requestContext = parseClientRequestContext(options?.requestContext);
     await this.request(this.url(`${this.base()}/tool-approval`), {
       method: "POST",
-      body: { toolCallId, approved }
+      body: { toolCallId, approved, ...requestContext ? { requestContext } : {} }
     });
   }
   /**
@@ -6251,15 +6387,20 @@ var AgentControllerSession = class extends BaseResource {
    * depends on the tool: a string (or string[]) for `ask_user`, "Yes"/"No" for
    * `request_access`, and a {@link PlanResume} for `submit_plan`.
    */
-  async respondToToolSuspension(toolCallId, resumeData) {
+  async respondToToolSuspension(toolCallId, resumeData, options) {
+    const requestContext = parseClientRequestContext(options?.requestContext);
     await this.request(this.url(`${this.base()}/tool-suspension`), {
       method: "POST",
-      body: { toolCallId, resumeData }
+      body: { toolCallId, resumeData, ...requestContext ? { requestContext } : {} }
     });
   }
   /** Inject a message into the in-flight run without starting a new turn. */
-  async steer(message) {
-    await this.request(this.url(`${this.base()}/steer`), { method: "POST", body: { message } });
+  async steer(message, options) {
+    const requestContext = parseClientRequestContext(options?.requestContext);
+    await this.request(this.url(`${this.base()}/steer`), {
+      method: "POST",
+      body: { message, ...requestContext ? { requestContext } : {} }
+    });
   }
   /** Get the current mode, model, and thread (for initial UI hydration). */
   state() {
@@ -6335,14 +6476,18 @@ var AgentControllerSession = class extends BaseResource {
     const body = await this.request(
       this.url(`${this.base()}/threads/${encodeURIComponent(threadId)}/messages${params}`)
     );
-    return body.messages;
+    return body.messages.map(hydrateMessage);
   }
   /**
    * Queue a follow-up message. If the session is idle it sends immediately;
    * if a run is active it queues for after completion.
    */
-  async followUp(message) {
-    await this.request(this.url(`${this.base()}/follow-up`), { method: "POST", body: { message } });
+  async followUp(message, options) {
+    const requestContext = parseClientRequestContext(options?.requestContext);
+    await this.request(this.url(`${this.base()}/follow-up`), {
+      method: "POST",
+      body: { message, ...requestContext ? { requestContext } : {} }
+    });
   }
   /** Get the observational memory record for this session's thread. */
   async getOMRecord() {
@@ -6452,7 +6597,7 @@ var AgentController = class extends BaseResource {
   }
 };
 function agentControllerMessageText(message) {
-  return message.content.filter((c) => c.type === "text" && typeof c.text === "string").map((c) => c.text).join("");
+  return message.content.parts.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join("");
 }
 
 // src/client.ts