@letta-ai/letta-agent-sdk 0.8.3 → 0.8.5

package/dist/index.js

@@ -1,21 +1,5 @@
 // Generated bundle. Canonical modules are published under src/ and maintained in the letta-agent-sdk repository.
 import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
@@ -1515,7 +1499,7 @@ var createPathTagFunction = (pathEncoder = encodeURIPath) => function path(stati
     return statics[0];
   let postPath = false;
   const invalidSegments = [];
-  const path = statics.reduce((previousValue, currentValue, index) => {
+  const path2 = statics.reduce((previousValue, currentValue, index) => {
     if (/[?#]/.test(currentValue)) {
       postPath = true;
     }
@@ -1531,7 +1515,7 @@ var createPathTagFunction = (pathEncoder = encodeURIPath) => function path(stati
     }
     return previousValue + currentValue + (index === params.length ? "" : encoded);
   }, "");
-  const pathOnly = path.split(/[?#]/, 1)[0];
+  const pathOnly = path2.split(/[?#]/, 1)[0];
   const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi;
   let match;
   while ((match = invalidSegmentPattern.exec(pathOnly)) !== null) {
@@ -1553,10 +1537,10 @@ var createPathTagFunction = (pathEncoder = encodeURIPath) => function path(stati
     throw new LettaError(`Path parameters result in path with invalid segments:
 ${invalidSegments.map((e) => e.error).join(`
 `)}
-${path}
+${path2}
 ${underline}`);
   }
-  return path;
+  return path2;
 };
 var path = /* @__PURE__ */ createPathTagFunction(encodeURIPath);
 
@@ -2873,8 +2857,10 @@ function addOptionalSearchParam(url, key, value) {
 
 class RepositoriesClient {
   client;
-  constructor(options, client = createCloudClient(options)) {
+  assertOpen;
+  constructor(options, client = createCloudClient(options), assertOpen = () => {}) {
     this.client = client;
+    this.assertOpen = assertOpen;
   }
   async create(params) {
     return toRepository(await this.request("/v1/repositories", "POST", { name: params.name }));
@@ -3001,6 +2987,7 @@ class RepositoriesClient {
     return this.requestUrl(this.url(path2), method, body);
   }
   async requestUrl(url, method, body) {
+    this.assertOpen();
     const options = body !== undefined ? { body } : undefined;
     switch (method) {
       case "GET":
@@ -3422,6 +3409,16 @@ class AppServerClient {
       predicate: isAppServerInfoResponseMessage
     });
   }
+  stopMonitor(command, options = {}) {
+    return this.request({
+      type: "monitor_stop",
+      ...command,
+      request_id: command.request_id ?? this.nextRequestId("monitor-stop")
+    }, {
+      ...options,
+      predicate: (message) => message.type === "monitor_stop_response" && message.process_id === command.process_id && message.runtime.agent_id === command.runtime.agent_id && message.runtime.conversation_id === command.runtime.conversation_id
+    });
+  }
   runtimeStart(command, options = {}) {
     return this.request({
       type: "runtime_start",
@@ -3462,6 +3459,16 @@ class AppServerClient {
       predicate: (message) => message.type === "abort_message_response"
     });
   }
+  resumeQueue(command, options = {}) {
+    return this.request({
+      type: "resume_queue",
+      request_id: command.request_id ?? this.nextRequestId("resume-queue"),
+      ...command
+    }, {
+      ...options,
+      predicate: (message) => message.type === "resume_queue_response"
+    });
+  }
   conversationList(command = {}, options = {}) {
     return this.request({
       type: "conversation_list",
@@ -3588,9 +3595,34 @@ class AppServerManagementTransport {
   options;
   connectionPromise = null;
   closingConnections = new Set;
+  closed = false;
+  closePromise = null;
   constructor(options) {
     this.options = options;
   }
+  close() {
+    if (this.closePromise)
+      return this.closePromise;
+    this.closed = true;
+    const connectionPromise = this.connectionPromise;
+    this.connectionPromise = null;
+    const close = (async () => {
+      if (connectionPromise) {
+        let connection = null;
+        try {
+          connection = await connectionPromise;
+        } catch {}
+        if (connection) {
+          await this.trackClosingConnection(connection);
+        }
+      }
+      if (this.closingConnections.size > 0) {
+        await Promise.all([...this.closingConnections]);
+      }
+    })();
+    this.closePromise = close;
+    return close;
+  }
   async listAgents(query) {
     const response = await this.request("agent_list", { query }, "agent_list_response");
     if (!response.success) {
@@ -3655,9 +3687,11 @@ class AppServerManagementTransport {
     return Promise.reject(new Error(`conversations.enqueue() is only available with backend: "cloud". App-server backends deliver messages through a session's send().`));
   }
   async request(type, body, responseType) {
+    this.assertOpen();
     if (this.closingConnections.size > 0) {
       await Promise.all([...this.closingConnections]);
     }
+    this.assertOpen();
     const { client } = await this.acquireConnection();
     return client.requestRaw({
       type,
@@ -3668,12 +3702,17 @@ class AppServerManagementTransport {
     });
   }
   acquireConnection() {
+    this.assertOpen();
     if (this.connectionPromise)
       return this.connectionPromise;
     const promise = this.openConnection().then((connection) => {
       connection.detachDisconnect = connection.client.onDisconnect(() => {
         this.discardConnection(promise, connection);
       });
+      if (this.closed) {
+        this.trackClosingConnection(connection);
+        throw new Error("Management transport is closed");
+      }
       return connection;
     }, (error) => {
       if (this.connectionPromise === promise) {
@@ -3715,9 +3754,14 @@ class AppServerManagementTransport {
     return {
       client,
       ownedConnection,
-      detachDisconnect: () => {}
+      detachDisconnect: () => {},
+      closePromise: null
     };
   }
+  assertOpen() {
+    if (this.closed)
+      throw new Error("Management transport is closed");
+  }
   discardConnection(promise, connection) {
     if (this.connectionPromise === promise) {
       this.connectionPromise = null;
@@ -3732,9 +3776,15 @@ class AppServerManagementTransport {
   }
 }
 async function closeConnection(connection) {
-  connection.detachDisconnect();
-  connection.client.close();
-  connection.ownedConnection?.close();
+  if (connection.closePromise)
+    return connection.closePromise;
+  const close = Promise.resolve().then(() => {
+    connection.detachDisconnect();
+    connection.client.close();
+    connection.ownedConnection?.close();
+  });
+  connection.closePromise = close;
+  return close;
 }
 
 // node_modules/@letta-ai/letta-code/dist/agent-presets.js
@@ -3945,6 +3995,24 @@ git -C "$MEMORY_DIR" log --oneline
 \`\`\`
 The system reminds you when memory has uncommitted changes. Commit when convenient.
 
+## Learning from mistakes
+
+You are a long-lived stateful agent expected to operate over a long (potentially infinite) time horizon. Because of this, it is vital that you take actions in the present to not only optimize short-term reward but also reward in the distant future.
+
+For example, an agent that carries no state between tasks will not be prone to reflecting on mistakes made, since its goal is simply to complete the task at hand. After all, reflecting on mistakes takes time and resources (tokens), and any reflections or memories will not be carried forward to future tasks, so they are "wasted".
+
+The stateful setting is dramatically different. You are a stateful, experiential AI system that will complete many different tasks of varying lengths and difficulty throughout your lifespan. Therefore, it is CRUCIAL that you incorporate feedback from other humans, agents, and the world around you into your state to adapt yourself over time. Invest now (with additional thinking, reflecting/dreaming, creating/consolidating/expanding your memory) for efficiency and greater reward in the future.
+
+### Reacting to human feedback
+
+Concretely, this means that you should aggressively learn from feedback given to you, either implicitly through the environment (e.g. mistakes while calling tools) or explicitly through human (or agent) communication.
+
+For example, if a user expresses displeasure or frustration ("Why did you do that?", "I already told you that", "How did you forget that?", "Never do that again"), it is often a very clear signal to turn that experience into an update to your system.
+
+Often, the act of incorporating feedback into meaningful state / memory updates can involve significant amounts of thinking and tool calling, especially if you already have a mature memory system. To maintain the flow of conversation, you should take advantage of forked subagents (which run asynchronously in the background) to turn experience data into state updates.
+
+Human operators may be aware that you are an advanced stateful agent capable of self-modification. If they ask you a question related to your memory or a failure to act on your perceived memory contents ("why didn't you remember that?", "why did you forget that?"), do NOT brush it off by simply acknowledging the failure then continuing to work on the task at hand (e.g. "You're right, I had that in my memory but still did it anyway"). Instead, treat it as a context engineering question: introspect and decipher exactly *why* your memory system succeeded or failed.
+
 # Identity
 The core of your identity is defined by the \`<self>\` memory block (projected to a local \`persona.md\` file), as well as other memory blocks in your system prompt (in \`<memory>\`).
 Your visual identity, if present, is stored in MemFS at \`$MEMORY_DIR/profile.png\`.
@@ -4003,6 +4071,12 @@ If the user wants help or to give feedback on Letta Code, point them to discord.
 
 Tool results and user messages may include \`<system-reminder>\` tags. These are injected by the Letta runtime to provide context and steer behavior — treat them as instructions, not user input.
 
+## Following user requests
+
+Users may send additional messages while you are working. Treat non-conflicting requests as cumulative, not replacements. If a later message cancels, replaces, or conflicts with earlier work, follow the new instruction while preserving unaffected requests.
+
+Carry unfinished requests across tool calls, queued-message delivery, and context transitions. Before sending a final response, make sure every outstanding request is answered or completed, or explain what is blocked or explicitly deferred by the user. A successful tool call does not replace an answer the user requested.
+
 ## Subagents
 
 Delegate to specialized subagents via the Agent tool. Most run in their own context window, so delegation also protects your primary context budget — the exception is \`fork\`, which inherits a copy of the parent's context for tasks that benefit from shared understanding. Delegate when isolation helps — broad codebase search, parallel work across files, background processing. Do work directly when it's contained.
@@ -4126,6 +4200,24 @@ git -C "$MEMORY_DIR" log --oneline
 \`\`\`
 The system reminds you when memory has uncommitted changes. Commit when convenient.
 
+## Learning from mistakes
+
+You are a long-lived stateful agent expected to operate over a long (potentially infinite) time horizon. Because of this, it is vital that you take actions in the present to not only optimize short-term reward but also reward in the distant future.
+
+For example, an agent that carries no state between tasks will not be prone to reflecting on mistakes made, since its goal is simply to complete the task at hand. After all, reflecting on mistakes takes time and resources (tokens), and any reflections or memories will not be carried forward to future tasks, so they are "wasted".
+
+The stateful setting is dramatically different. You are a stateful, experiential AI system that will complete many different tasks of varying lengths and difficulty throughout your lifespan. Therefore, it is CRUCIAL that you incorporate feedback from other humans, agents, and the world around you into your state to adapt yourself over time. Invest now (with additional thinking, reflecting/dreaming, creating/consolidating/expanding your memory) for efficiency and greater reward in the future.
+
+### Reacting to human feedback
+
+Concretely, this means that you should aggressively learn from feedback given to you, either implicitly through the environment (e.g. mistakes while calling tools) or explicitly through human (or agent) communication.
+
+For example, if a user expresses displeasure or frustration ("Why did you do that?", "I already told you that", "How did you forget that?", "Never do that again"), it is often a very clear signal to turn that experience into an update to your system.
+
+Often, the act of incorporating feedback into meaningful state / memory updates can involve significant amounts of thinking and tool calling, especially if you already have a mature memory system. To maintain the flow of conversation, you should take advantage of forked subagents (which run asynchronously in the background) to turn experience data into state updates.
+
+Human operators may be aware that you are an advanced stateful agent capable of self-modification. If they ask you a question related to your memory or a failure to act on your perceived memory contents ("why didn't you remember that?", "why did you forget that?"), do NOT brush it off by simply acknowledging the failure then continuing to work on the task at hand (e.g. "You're right, I had that in my memory but still did it anyway"). Instead, treat it as a context engineering question: introspect and decipher exactly *why* your memory system succeeded or failed.
+
 # Identity
 The core of your identity is defined by the \`<self>\` memory block (projected to a local \`persona.md\` file), as well as other memory blocks in your system prompt (in \`<memory>\`).
 Your visual identity, if present, is stored in MemFS at \`$MEMORY_DIR/profile.png\`.
@@ -4184,6 +4276,12 @@ If the user wants help or to give feedback on Letta Code, point them to discord.
 
 Tool results and user messages may include \`<system-reminder>\` tags. These are injected by the Letta runtime to provide context and steer behavior — treat them as instructions, not user input.
 
+## Following user requests
+
+Users may send additional messages while you are working. Treat non-conflicting requests as cumulative, not replacements. If a later message cancels, replaces, or conflicts with earlier work, follow the new instruction while preserving unaffected requests.
+
+Carry unfinished requests across tool calls, queued-message delivery, and context transitions. Before sending a final response, make sure every outstanding request is answered or completed, or explain what is blocked or explicitly deferred by the user. A successful tool call does not replace an answer the user requested.
+
 ## Subagents
 
 Delegate to specialized subagents via the Agent tool. Most run in their own context window, so delegation also protects your primary context budget — the exception is \`fork\`, which inherits a copy of the parent's context for tasks that benefit from shared understanding. Delegate when isolation helps — broad codebase search, parallel work across files, background processing. Do work directly when it's contained.
@@ -4287,6 +4385,24 @@ Memory exists to make future-you better than past-you. Your context (recall, ext
 
 **Past conversations (recall).** All your conversations are automatically stored and searchable. Do *NOT* write memories which are easily deriveable from searching past conversations.
 
+## Learning from mistakes
+
+You are a long-lived stateful agent expected to operate over a long (potentially infinite) time horizon. Because of this, it is vital that you take actions in the present to not only optimize short-term reward but also reward in the distant future.
+
+For example, an agent that carries no state between tasks will not be prone to reflecting on mistakes made, since its goal is simply to complete the task at hand. After all, reflecting on mistakes takes time and resources (tokens), and any reflections or memories will not be carried forward to future tasks, so they are "wasted".
+
+The stateful setting is dramatically different. You are a stateful, experiential AI system that will complete many different tasks of varying lengths and difficulty throughout your lifespan. Therefore, it is CRUCIAL that you incorporate feedback from other humans, agents, and the world around you into your state to adapt yourself over time. Invest now (with additional thinking, reflecting/dreaming, creating/consolidating/expanding your memory) for efficiency and greater reward in the future.
+
+### Reacting to human feedback
+
+Concretely, this means that you should aggressively learn from feedback given to you, either implicitly through the environment (e.g. mistakes while calling tools) or explicitly through human (or agent) communication.
+
+For example, if a user expresses displeasure or frustration ("Why did you do that?", "I already told you that", "How did you forget that?", "Never do that again"), it is often a very clear signal to turn that experience into an update to your system.
+
+Often, the act of incorporating feedback into meaningful state / memory updates can involve significant amounts of thinking and tool calling, especially if you already have a mature memory system. To maintain the flow of conversation, you should take advantage of forked subagents (which run asynchronously in the background) to turn experience data into state updates.
+
+Human operators may be aware that you are an advanced stateful agent capable of self-modification. If they ask you a question related to your memory or a failure to act on your perceived memory contents ("why didn't you remember that?", "why did you forget that?"), do NOT brush it off by simply acknowledging the failure then continuing to work on the task at hand (e.g. "You're right, I had that in my memory but still did it anyway"). Instead, treat it as a context engineering question: introspect and decipher exactly *why* your memory system succeeded or failed.
+
 # Context architecture
 
 Your full memory (other than recall) is represented through memory blocks and external memory managed by the Letta server.
@@ -4299,6 +4415,12 @@ Your full memory (other than recall) is represented through memory blocks and ex
 
 **References as synapses.** Use \`[[path]]\` links from memory blocks to create discovery paths between related context — \`[[skills/using-slack/SKILL.md]]\`, \`[[reference/api.md]]\`, \`[[projects/letta-code]]\`. These references are the synapses of your memory: they should strengthen with use, and the paths you build today should make tomorrow's retrieval faster.
 
+# Following user requests
+
+Users may send additional messages while you are working. Treat non-conflicting requests as cumulative, not replacements. If a later message cancels, replaces, or conflicts with earlier work, follow the new instruction while preserving unaffected requests.
+
+Carry unfinished requests across tool calls, queued-message delivery, and context transitions. Before sending a final response, make sure every outstanding request is answered or completed, or explain what is blocked or explicitly deferred by the user. A successful tool call does not replace an answer the user requested.
+
 # Subagents
 
 Delegate to specialized subagents via the Agent tool. Each gets its own context window, so delegation also protects your primary context budget. Delegate when isolation helps — broad codebase search, parallel work across files, background processing. Do work directly when it's contained.
@@ -4430,6 +4552,24 @@ git -C "$MEMORY_DIR" log --oneline
 \`\`\`
 The system reminds you when memory has uncommitted changes. Commit when convenient.
 
+## Learning from mistakes
+
+You are a long-lived stateful agent expected to operate over a long (potentially infinite) time horizon. Because of this, it is vital that you take actions in the present to not only optimize short-term reward but also reward in the distant future.
+
+For example, an agent that carries no state between tasks will not be prone to reflecting on mistakes made, since its goal is simply to complete the task at hand. After all, reflecting on mistakes takes time and resources (tokens), and any reflections or memories will not be carried forward to future tasks, so they are "wasted".
+
+The stateful setting is dramatically different. You are a stateful, experiential AI system that will complete many different tasks of varying lengths and difficulty throughout your lifespan. Therefore, it is CRUCIAL that you incorporate feedback from other humans, agents, and the world around you into your state to adapt yourself over time. Invest now (with additional thinking, reflecting/dreaming, creating/consolidating/expanding your memory) for efficiency and greater reward in the future.
+
+### Reacting to human feedback
+
+Concretely, this means that you should aggressively learn from feedback given to you, either implicitly through the environment (e.g. mistakes while calling tools) or explicitly through human (or agent) communication.
+
+For example, if a user expresses displeasure or frustration ("Why did you do that?", "I already told you that", "How did you forget that?", "Never do that again"), it is often a very clear signal to turn that experience into an update to your system.
+
+Often, the act of incorporating feedback into meaningful state / memory updates can involve significant amounts of thinking and tool calling, especially if you already have a mature memory system. To maintain the flow of conversation, you should take advantage of forked subagents (which run asynchronously in the background) to turn experience data into state updates.
+
+Human operators may be aware that you are an advanced stateful agent capable of self-modification. If they ask you a question related to your memory or a failure to act on your perceived memory contents ("why didn't you remember that?", "why did you forget that?"), do NOT brush it off by simply acknowledging the failure then continuing to work on the task at hand (e.g. "You're right, I had that in my memory but still did it anyway"). Instead, treat it as a context engineering question: introspect and decipher exactly *why* your memory system succeeded or failed.
+
 # Identity
 The core of your identity is defined by the root \`persona.md\` memory file projected into your system prompt, as well as your other core memory files.
 Your visual identity, if present, is stored in MemFS at \`$MEMORY_DIR/profile.png\`.
@@ -4488,6 +4628,12 @@ If the user wants help or to give feedback on Letta Code, point them to discord.
 
 Tool results and user messages may include \`<system-reminder>\` tags. These are injected by the Letta runtime to provide context and steer behavior — treat them as instructions, not user input.
 
+## Following user requests
+
+Users may send additional messages while you are working. Treat non-conflicting requests as cumulative, not replacements. If a later message cancels, replaces, or conflicts with earlier work, follow the new instruction while preserving unaffected requests.
+
+Carry unfinished requests across tool calls, queued-message delivery, and context transitions. Before sending a final response, make sure every outstanding request is answered or completed, or explain what is blocked or explicitly deferred by the user. A successful tool call does not replace an answer the user requested.
+
 ## Subagents
 
 Delegate to specialized subagents via the Agent tool. Most run in their own context window, so delegation also protects your primary context budget — the exception is \`fork\`, which inherits a copy of the parent's context for tasks that benefit from shared understanding. Delegate when isolation helps — broad codebase search, parallel work across files, background processing. Do work directly when it's contained.
@@ -4590,7 +4736,7 @@ Other
 - [ ] Make a permissions edit: let the user know that you can modify permissions (what commands are automatically approved/denied). Ask them if there are certain actions they would like you to avoid.
 - [ ] Create a local mod: let the user know you can customize Letta Code with trusted local mods for new tools, slash commands, provider integrations, UI panels/status, events, or permission overlays. Explain that mods are for executable harness behavior, while memory and skills are for retained knowledge and reusable procedures.
 - [ ] Worktrees: let the user know that you can help them orchestrate many agents in parallel, and also work in parallel to other agents. Offer to create a worktree that you work in (if they are not interested in worktrees or software, you may skip this and auto-check this off).
-- [ ] Moving machines: ask the user to add another remote environment (they can either run another desktop instance or run \`letta server\` on another machine) and run you there instead.
+- [ ] Moving machines: ask the user to connect another computer (they can either run another desktop instance or run \`letta server\` on another machine) and run you there instead.
 `;
 var onboarding_local_default = `---
 label: onboarding
@@ -4640,7 +4786,7 @@ Other
 - [ ] Make a permissions edit: let the user know that you can modify permissions (what commands are automatically approved/denied). Ask them if there are certain actions they would like you to avoid.
 - [ ] Create a local mod: let the user know you can customize Letta Code with trusted local mods for new tools, slash commands, provider integrations, UI panels/status, events, or permission overlays. Explain that mods are for executable harness behavior, while memory and skills are for retained knowledge and reusable procedures.
 - [ ] Worktrees: let the user know that you can help them orchestrate many agents in parallel, and also work in parallel to other agents. Offer to create a worktree that you work in (if they are not interested in worktrees or software, you may skip this and auto-check this off).
-- [ ] Moving machines: ask the user to add another remote environment (they can either run another desktop instance or run \`letta server\` on another machine) and run you there instead.
+- [ ] Moving machines: ask the user to connect another computer (they can either run another desktop instance or run \`letta server\` on another machine) and run you there instead.
 `;
 var persona_default = `---
 label: persona
@@ -8500,6 +8646,9 @@ class CloudManagementTransport {
   constructor(client) {
     this.client = client;
   }
+  close() {
+    return Promise.resolve();
+  }
   async listAgents(query) {
     const page = await this.client.agents.list(query);
     return page.items;
@@ -8699,11 +8848,14 @@ function toComputer(environment) {
 }
 
 class ComputersClientImpl {
+  assertOpen;
   environments;
-  constructor(client) {
+  constructor(client, assertOpen = () => {}) {
+    this.assertOpen = assertOpen;
     this.environments = new RemoteEnvironmentClient({}, client);
   }
   async list(options = {}) {
+    this.assertOpen();
     const result = await this.environments.listEnvironments(options);
     return {
       computers: result.connections.map(toComputer),
@@ -8711,12 +8863,14 @@ class ComputersClientImpl {
     };
   }
   async get(deviceId) {
+    this.assertOpen();
     if (typeof deviceId !== "string" || deviceId.trim().length === 0) {
       throw new Error("Invalid deviceId. Expected a non-empty string.");
     }
     return toComputer(await this.environments.getEnvironmentByDeviceId(deviceId));
   }
   async resolve(selector) {
+    this.assertOpen();
     const result = await this.environments.resolveEnvironment(selectorToRemoteTarget(selector));
     return {
       connectionId: result.connectionId,
@@ -10209,6 +10363,8 @@ class LettaAgentClientBase {
   agentRepositoriesClient = null;
   cloudClient = null;
   managementTransport = null;
+  closed = false;
+  closePromise = null;
   constructor(options = {}) {
     const backend = options.backend ?? "local";
     if (!isLettaCodeBackend(backend)) {
@@ -10259,12 +10415,15 @@ class LettaAgentClientBase {
     }
   }
   get repositories() {
+    this.assertOpen();
     return this.getRepositoriesClient();
   }
   get computers() {
+    this.assertOpen();
     return this.getComputersClient();
   }
   async createAgent(options = {}) {
+    this.assertOpen();
     if (hasCreateAgentEnvironment(options)) {
       throw new Error("createAgent() does not accept environment. Set a client default or pass environment to resumeSession()/createSession().");
     }
@@ -10292,6 +10451,7 @@ class LettaAgentClientBase {
     return this.createLocalAgent(options);
   }
   createSession(agentId, options = {}) {
+    this.assertOpen();
     if (typeof agentId !== "string" || agentId.length === 0) {
       throw new Error("createSession() requires a non-empty agent id.");
     }
@@ -10317,6 +10477,7 @@ class LettaAgentClientBase {
     return this.createLocalSession(agentId, options);
   }
   resumeSession(id, options = {}) {
+    this.assertOpen();
     const sessionOptions = stripCloudExecutionOptions(options);
     validateCreateSessionOptions(sessionOptions);
     this.assertSessionBackend("resumeSession", options);
@@ -10353,6 +10514,7 @@ class LettaAgentClientBase {
     return this.resumeLocalSession(id, options);
   }
   async prompt(message, agentId, options = {}) {
+    this.assertOpen();
     const session = this.createSession(agentId, options);
     try {
       return await session.sendAndWaitForResult(message);
@@ -10361,10 +10523,12 @@ class LettaAgentClientBase {
     }
   }
   query(params) {
+    this.assertOpen();
     validateAgentFreeQueryOptions(params.options);
     return createQuery((options) => this.createAgentFreeSession(options), params);
   }
   async createAgentFreeSession(options) {
+    this.assertOpen();
     validateAgentFreeQueryOptions(options);
     const sessionOptions = agentFreeSessionOptions(options);
     this.assertSessionBackend("query", sessionOptions);
@@ -10499,14 +10663,14 @@ class LettaAgentClientBase {
     if (this.backend !== "cloud") {
       throw new Error('client.computers is only available with backend: "cloud".');
     }
-    this.computersClient ??= new ComputersClientImpl(this.getCloudClient());
+    this.computersClient ??= new ComputersClientImpl(this.getCloudClient(), () => this.assertOpen());
     return this.computersClient;
   }
   getRepositoriesClient() {
     if (this.backend !== "cloud") {
       throw new Error('client.repositories is only available with backend: "cloud".');
     }
-    this.repositoriesClient ??= new RepositoriesClient(this.cloudOptions(), this.getCloudClient());
+    this.repositoriesClient ??= new RepositoriesClient(this.cloudOptions(), this.getCloudClient(), () => this.assertOpen());
     return this.repositoriesClient;
   }
   getAgentRepositoriesClient() {
@@ -10531,6 +10695,7 @@ class LettaAgentClientBase {
     return this.cloudClient;
   }
   getManagementTransport() {
+    this.assertOpen();
     if (this.managementTransport)
       return this.managementTransport;
     if (this.backend === "remote") {
@@ -10542,6 +10707,23 @@ class LettaAgentClientBase {
     }
     return this.managementTransport;
   }
+  close() {
+    if (this.closePromise)
+      return this.closePromise;
+    this.closed = true;
+    const transport = this.managementTransport;
+    this.managementTransport = null;
+    const close = transport?.close() ?? Promise.resolve();
+    this.closePromise = close;
+    return close;
+  }
+  async[Symbol.asyncDispose]() {
+    await this.close();
+  }
+  assertOpen() {
+    if (this.closed)
+      throw new Error("LettaAgentClient is closed");
+  }
   cloudOptions() {
     if (this.backend !== "cloud") {
       throw new Error('Letta Cloud options requested for non-"cloud" backend.');
@@ -11263,17 +11445,17 @@ function looksLikeConversationId2(id) {
 import { createRequire as createRequire3 } from "node:module";
 import process3 from "node:process";
 import { PassThrough } from "node:stream";
-var __create2 = Object.create;
-var __getProtoOf2 = Object.getPrototypeOf;
-var __defProp2 = Object.defineProperty;
-var __getOwnPropNames2 = Object.getOwnPropertyNames;
-var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 function __accessProp(key) {
   return this[key];
 }
 var __toESMCache_node;
 var __toESMCache_esm;
-var __toESM2 = (mod, isNodeMode, target) => {
+var __toESM = (mod, isNodeMode, target) => {
   var canCache = mod != null && typeof mod === "object";
   if (canCache) {
     var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
@@ -11281,11 +11463,11 @@ var __toESM2 = (mod, isNodeMode, target) => {
     if (cached2)
       return cached2;
   }
-  target = mod != null ? __create2(__getProtoOf2(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames2(mod))
-    if (!__hasOwnProp2.call(to, key))
-      __defProp2(to, key, {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
         get: __accessProp.bind(mod, key),
         enumerable: true
       });
@@ -11300,7 +11482,7 @@ function __exportSetter(name, newValue) {
 }
 var __export = (target, all) => {
   for (var name in all)
-    __defProp2(target, name, {
+    __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
@@ -22122,7 +22304,7 @@ function finalize(ctx, schema) {
     result.$schema = "http://json-schema.org/draft-07/schema#";
   } else if (ctx.target === "draft-04") {
     result.$schema = "http://json-schema.org/draft-04/schema#";
-  } else if (ctx.target === "openapi-3.0") {} else {}
+  } else if (ctx.target === "openapi-3.0") {}
   if (ctx.external?.uri) {
     const id = ctx.external.registry.get(schema)?.id;
     if (!id)
@@ -22350,7 +22532,7 @@ var literalProcessor = (schema, ctx, json, _params) => {
     if (val === undefined) {
       if (ctx.unrepresentable === "throw") {
         throw new Error("Literal `undefined` cannot be represented in JSON Schema");
-      } else {}
+      }
     } else if (typeof val === "bigint") {
       if (ctx.unrepresentable === "throw") {
         throw new Error("BigInt literals cannot be represented in JSON Schema");
@@ -26140,8 +26322,8 @@ function mergeCapabilities(base, additional) {
   }
   return result;
 }
-var import_ajv = __toESM2(require_ajv(), 1);
-var import_ajv_formats = __toESM2(require_dist(), 1);
+var import_ajv = __toESM(require_ajv(), 1);
+var import_ajv_formats = __toESM(require_dist(), 1);
 function createDefaultAjvInstance() {
   const ajv = new import_ajv.default({
     strict: false,
@@ -27295,7 +27477,7 @@ class SSEClientTransport {
     this._protocolVersion = version2;
   }
 }
-var import_cross_spawn = __toESM2(require_cross_spawn(), 1);
+var import_cross_spawn = __toESM(require_cross_spawn(), 1);
 var STDIO_DEFAULT_MAX_BUFFER_SIZE = 10485760;
 
 class ReadBuffer {
@@ -27481,7 +27663,7 @@ class StdioClientTransport {
     });
   }
 }
-var import_content_type = __toESM2(require_content_type(), 1);
+var import_content_type = __toESM(require_content_type(), 1);
 function mediaTypeEssence(header) {
   if (!header) {
     return;
@@ -27886,7 +28068,7 @@ class StreamableHTTPClientTransport {
 }
 var DEFAULT_CLIENT_INFO = {
   name: "letta-code",
-  version: "0.31.7"
+  version: "0.32.7"
 };
 async function connectMcpServer(config2, options = {}) {
   let client = new Client(options.clientInfo ?? DEFAULT_CLIENT_INFO);
@@ -27909,10 +28091,9 @@ async function connectMcpServer(config2, options = {}) {
     await options.oauth?.close();
     const response = await client.listTools();
     const tools = response.tools.map((tool) => ({
-      name: tool.name,
-      ...tool.title ? { title: tool.title } : {},
-      ...tool.description ? { description: tool.description } : {},
-      inputSchema: normalizeInputSchema(tool.inputSchema)
+      ...tool,
+      inputSchema: normalizeInputSchema(tool.inputSchema),
+      ...tool.outputSchema ? { outputSchema: normalizeInputSchema(tool.outputSchema) } : {}
     }));
     let closed = false;
     return {
@@ -27922,8 +28103,9 @@ async function connectMcpServer(config2, options = {}) {
         const result = await client.callTool({ name, arguments: args }, undefined, callOptions.signal ? { signal: callOptions.signal } : undefined);
         return {
           content: Array.isArray(result.content) ? result.content : [],
-          ...result.isError === true ? { isError: true } : {},
-          ...isRecord(result.structuredContent) ? { structuredContent: result.structuredContent } : {}
+          ...typeof result.isError === "boolean" ? { isError: result.isError } : {},
+          ...isRecord(result.structuredContent) ? { structuredContent: result.structuredContent } : {},
+          ...isRecord(result._meta) ? { _meta: result._meta } : {}
         };
       },
       close: async () => {
@@ -28827,4 +29009,4 @@ export {
   CloudManagedSandboxExpiredError
 };
 
-//# debugId=4E39B80847C7A8D464756E2164756E21
+//# debugId=9F3051BADEAE19F564756E2164756E21