@letta-ai/letta-agent-sdk 0.8.79 → 0.8.80

package/dist/client-entry.js

@@ -9481,18 +9481,39 @@ function onceSocketEvent(socket, type, listener) {
   });
   return detach;
 }
-function waitForSocketOpen(socket) {
+function waitForSocketOpen(socket, timeoutMs) {
   if (socket.readyState === WEBSOCKET_OPEN_STATE) {
     return Promise.resolve();
   }
-  return new Promise((resolve, reject) => {
+  return new Promise((resolvePromise, rejectPromise) => {
+    let settled = false;
+    const resolve = () => {
+      if (settled)
+        return;
+      settled = true;
+      resolvePromise();
+    };
+    const reject = (error) => {
+      if (settled)
+        return;
+      settled = true;
+      rejectPromise(error);
+    };
     let detachOpen = () => {};
     let detachError = () => {};
+    let detachClose = () => {};
     let detachResponse = () => {};
     let detachBody = () => {};
+    let upgradeRejected = false;
+    const timer = timeoutMs > 0 ? setTimeout(() => {
+      cleanup();
+      reject(new Error(`App-server WebSocket failed to open: timed out after ${timeoutMs}ms`));
+    }, timeoutMs) : undefined;
     const cleanup = () => {
+      clearTimeout(timer);
       detachOpen();
       detachError();
+      detachClose();
       detachResponse();
       detachBody();
     };
@@ -9504,6 +9525,7 @@ function waitForSocketOpen(socket) {
       const onResponse = (_request, response) => {
         if (!response)
           return;
+        upgradeRejected = true;
         const request = _request;
         let body = Buffer.alloc(0);
         let finished = false;
@@ -9545,6 +9567,12 @@ function waitForSocketOpen(socket) {
       cleanup();
       reject(new Error(`App-server WebSocket failed to open: ${String(event)}`));
     });
+    detachClose = onceSocketEvent(socket, "close", () => {
+      if (upgradeRejected)
+        return;
+      cleanup();
+      reject(new Error("App-server WebSocket failed to open: closed before opening"));
+    });
   });
 }
 function rawEventData(event) {
@@ -9612,7 +9640,7 @@ class AppServerClient {
     });
   }
   async connect() {
-    await waitForSocketOpen(this.socket);
+    await waitForSocketOpen(this.socket, this.requestTimeoutMs);
     return this;
   }
   close() {
@@ -13236,6 +13264,7 @@ function externalToolGroups(tools) {
     return;
   return [
     {
+      capabilities: { external_tool_call_cancel: true },
       tools: tools.map((tool) => ({
         name: tool.name,
         label: tool.label,
@@ -13248,14 +13277,14 @@ function externalToolGroups(tools) {
 var MAX_REMEMBERED_EXTERNAL_TOOL_CALLS = 200;
 function createExternalToolCallHandler(externalTools, fallbackRuntime) {
   const calls = new Map;
-  const execute = async (request) => {
+  const execute = async (request, signal) => {
     const tool = externalTools.get(request.tool_name);
     if (!tool) {
       throw new Error(`Unknown external tool: ${request.tool_name}`);
     }
     const runtime = request.runtime ?? fallbackRuntime?.() ?? null;
     const context = runtime ? { toolCallId: request.tool_call_id, agentId: runtime.agent_id, conversationId: runtime.conversation_id } : undefined;
-    const result = await tool.execute(request.tool_call_id, request.input, undefined, undefined, context);
+    const result = await tool.execute(request.tool_call_id, request.input, signal, undefined, context);
     return {
       content: result.content.map((part) => ({
         type: part.type,
@@ -13266,15 +13295,15 @@ function createExternalToolCallHandler(externalTools, fallbackRuntime) {
       ...result.isError === true ? { is_error: true } : {}
     };
   };
-  return (request) => {
+  return (request, signal) => {
     const requestId = request.request_id;
     if (typeof requestId !== "string" || requestId.length === 0) {
-      return execute(request);
+      return execute(request, signal);
     }
     const existing = calls.get(requestId);
     if (existing)
       return existing;
-    const call = execute(request);
+    const call = execute(request, signal);
     calls.set(requestId, call);
     while (calls.size > MAX_REMEMBERED_EXTERNAL_TOOL_CALLS) {
       const oldest = calls.keys().next().value;
@@ -13285,6 +13314,49 @@ function createExternalToolCallHandler(externalTools, fallbackRuntime) {
     return call;
   };
 }
+function registerExternalToolCallHandler(client, handler) {
+  const pending = new Map;
+  const completed = new Set;
+  const remove = client.onMessage((raw, channel) => {
+    if (channel !== "control")
+      return;
+    const message = raw;
+    const requestId = message.request_id;
+    if (typeof requestId !== "string")
+      return;
+    if (message.type === "external_tool_call_cancel") {
+      const call = pending.get(requestId);
+      if (!call)
+        return;
+      call.finish({ error: "cancelled" });
+      call.controller.abort(message.reason);
+      return;
+    }
+    if (message.type !== "external_tool_call_request" || pending.has(requestId) || completed.has(requestId))
+      return;
+    const controller = new AbortController;
+    const finish = (response) => {
+      if (!pending.delete(requestId))
+        return;
+      completed.add(requestId);
+      if (completed.size > MAX_REMEMBERED_EXTERNAL_TOOL_CALLS)
+        completed.delete(completed.values().next().value);
+      client.send({ type: "external_tool_call_response", request_id: requestId, ...response });
+    };
+    pending.set(requestId, { controller, finish });
+    try {
+      Promise.resolve(handler(raw, controller.signal)).then((result) => finish({ result }), (error) => finish({ error: error instanceof Error ? error.message : String(error) }));
+    } catch (error) {
+      finish({ error: error instanceof Error ? error.message : String(error) });
+    }
+  });
+  return () => {
+    remove();
+    for (const call of pending.values())
+      call.controller.abort();
+    pending.clear();
+  };
+}
 
 // src/runtime-tool-policy.ts
 var RUNTIME_TOOL_POLICY_CAPABILITY = "runtime_tool_policy";
@@ -15109,7 +15181,7 @@ class AppServerSession extends RemoteClientSessionCore {
       getOptions: () => this.currentOptions()
     });
     if (this.externalTools.size > 0 || this.inheritedTools) {
-      this.removeExternalToolHandler = client.onExternalToolCall(createExternalToolCallHandler(this.externalTools, () => this.runtime));
+      this.removeExternalToolHandler = registerExternalToolCallHandler(client, createExternalToolCallHandler(this.externalTools, () => this.runtime));
     }
     try {
       await client.connect();
@@ -16214,7 +16286,7 @@ class CloudEnvironmentSession extends RemoteClientSessionCore {
       getOptions: () => this.currentOptions()
     });
     if (this.externalTools.size > 0) {
-      this.removeExternalToolHandler = client.onExternalToolCall(createExternalToolCallHandler(this.externalTools, () => this.runtime));
+      this.removeExternalToolHandler = registerExternalToolCallHandler(client, createExternalToolCallHandler(this.externalTools, () => this.runtime));
     }
   }
   cleanupTransportHandlers() {
@@ -16972,12 +17044,12 @@ class ToolRegistry {
       ...this.options.WebSocket ? { WebSocket: this.options.WebSocket } : {},
       ...this.options.requestTimeoutMs !== undefined ? { requestTimeoutMs: this.options.requestTimeoutMs } : {}
     }));
-    client.onExternalToolCall(async (request) => {
+    registerExternalToolCallHandler(client, async (request, signal) => {
       const runtime = request.runtime;
       const entry = runtime && [...this.entries].find((candidate) => candidate.runtimes.some((r) => runtimeKey(r) === runtimeKey(runtime)));
       if (!entry)
         throw new Error(`No tools registered for conversation ${runtime?.conversation_id}`);
-      return entry.call(request);
+      return entry.call(request, signal);
     });
     try {
       await client.connect();
@@ -18278,4 +18350,4 @@ export {
   CloudManagedSandboxExpiredError
 };
 
-//# debugId=6F04BC66F4049A5B64756E2164756E21
+//# debugId=56DE4B3DCF03FA0964756E2164756E21