@caspian2026/agent-sdk 0.0.9 → 0.0.11

package/dist/cli.js

@@ -33,7 +33,7 @@ async function main() {
   if (false) {}
   if (process.argv[2] === "--claude-in-chrome-mcp") {
     profileCheckpoint("cli_claude_in_chrome_mcp_path");
-    const { runClaudeInChromeMcpServer } = await import("./chunk-ay5fvc2r.js");
+    const { runClaudeInChromeMcpServer } = await import("./chunk-6ebvysef.js");
     await runClaudeInChromeMcpServer();
     return;
   } else if (process.argv[2] === "--chrome-native-host") {
@@ -43,7 +43,7 @@ async function main() {
     return;
   } else if (process.argv[2] === "--computer-use-mcp") {
     profileCheckpoint("cli_computer_use_mcp_path");
-    const { runComputerUseMcpServer } = await import("./chunk-jqfrz5g9.js");
+    const { runComputerUseMcpServer } = await import("./chunk-vdk9b74d.js");
     await runComputerUseMcpServer();
     return;
   }
@@ -62,11 +62,11 @@ async function main() {
   const hasTmuxFlag = args.includes("--tmux") || args.includes("--tmux=classic");
   if (hasTmuxFlag && (args.includes("-w") || args.includes("--worktree") || args.some((a) => a.startsWith("--worktree=")))) {
     profileCheckpoint("cli_tmux_worktree_fast_path");
-    const { enableConfigs } = await import("./chunk-rjq5nf1c.js");
+    const { enableConfigs } = await import("./chunk-yrqx3p9k.js");
     enableConfigs();
     const { isWorktreeModeEnabled } = await import("./chunk-pwwa7s62.js");
     if (isWorktreeModeEnabled()) {
-      const { execIntoTmuxWorktree } = await import("./chunk-0gpem3pk.js");
+      const { execIntoTmuxWorktree } = await import("./chunk-hkgb5y9f.js");
       const result = await execIntoTmuxWorktree(args);
       if (result.handled) {
         return;
@@ -83,7 +83,7 @@ async function main() {
   const { startCapturingEarlyInput } = await import("./chunk-etdt1xz3.js");
   startCapturingEarlyInput();
   profileCheckpoint("cli_before_main_import");
-  const { main: cliMain } = await import("./chunk-35nft36d.js");
+  const { main: cliMain } = await import("./chunk-pp8nrx40.js");
   profileCheckpoint("cli_after_main_import");
   await cliMain();
   profileCheckpoint("cli_after_main_complete");

package/dist/gateway/index.js

@@ -22,7 +22,6 @@ function parseJsonRpc(line) {
 
 // src/entrypoints/gateway/sessionRouter.ts
 import { Worker } from "node:worker_threads";
-import { createHash } from "node:crypto";
 var DEFAULT_MAX_SESSIONS = 16;
 var DEFAULT_IDLE_TTL_MS = 10 * 60 * 1000;
 var IDLE_CHECK_INTERVAL_MS = 60 * 1000;
@@ -35,6 +34,8 @@ class SessionRouter {
   onWorkerMessage;
   onWorkerExit;
   idleTimer = null;
+  pendingReady = new Map;
+  pendingUpdate = new Map;
   constructor(options) {
     this.workerPath = options.workerPath;
     this.maxSessions = options.maxSessions ?? DEFAULT_MAX_SESSIONS;
@@ -47,12 +48,17 @@ class SessionRouter {
   }
   async create(sessionKey, config) {
     if (this.sessions.has(sessionKey)) {
-      throw new Error(`Session already exists: ${sessionKey}`);
+      process.stderr.write(`[SessionRouter] Session already exists, destroying old: ${sessionKey}
+`);
+      await this.destroy(sessionKey);
     }
     if (this.sessions.size >= this.maxSessions) {
+      process.stderr.write(`[SessionRouter] Max sessions reached, evicting LRU session
+`);
       this.evictLRU();
     }
-    const configHash = computeConfigHash(config);
+    process.stderr.write(`[SessionRouter] Creating worker for session: ${sessionKey}
+`);
     const worker = new Worker(this.workerPath, {
       workerData: config
     });
@@ -60,26 +66,42 @@ class SessionRouter {
       sessionKey,
       worker,
       sessionId: null,
-      configHash,
       lastActive: new Date,
-      created: new Date
+      created: new Date,
+      destroyed: false
     };
     worker.on("message", (msg) => {
       if (msg.type === "ready") {
         entry.sessionId = msg.session_id;
+        this.pendingReady.get(sessionKey)?.resolve();
+        this.pendingReady.delete(sessionKey);
+      }
+      if (msg.type === "updated") {
+        this.pendingUpdate.get(sessionKey)?.resolve();
+        this.pendingUpdate.delete(sessionKey);
       }
       entry.lastActive = new Date;
       this.onWorkerMessage(sessionKey, msg);
     });
     worker.on("exit", (code) => {
       this.sessions.delete(sessionKey);
-      this.onWorkerExit(sessionKey, code);
+      if (!entry.destroyed) {
+        process.stderr.write(`[SessionRouter] Worker exited unexpectedly for session: ${sessionKey}, code: ${code}
+`);
+        this.onWorkerExit(sessionKey, code);
+      } else {
+        process.stderr.write(`[SessionRouter] Worker destroyed for session: ${sessionKey}, code: ${code}
+`);
+      }
     });
     worker.on("error", (err) => {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[SessionRouter] Worker thread error for session: ${sessionKey} - ${errMsg}
+`);
       this.onWorkerMessage(sessionKey, {
         type: "error",
         session_key: sessionKey,
-        error: `Worker thread error: ${err.message}`
+        error: `Worker thread error: ${errMsg}`
       });
     });
     this.sessions.set(sessionKey, entry);
@@ -90,9 +112,6 @@ class SessionRouter {
   has(sessionKey) {
     return this.sessions.has(sessionKey);
   }
-  getConfigHash(sessionKey) {
-    return this.sessions.get(sessionKey)?.configHash;
-  }
   send(sessionKey, msg) {
     const entry = this.sessions.get(sessionKey);
     if (!entry)
@@ -104,14 +123,62 @@ class SessionRouter {
     const entry = this.sessions.get(sessionKey);
     if (!entry)
       return;
+    process.stderr.write(`[SessionRouter] Destroying worker for session: ${sessionKey}
+`);
+    this.pendingReady.get(sessionKey)?.reject(new Error("Session destroyed"));
+    this.pendingReady.delete(sessionKey);
+    this.pendingUpdate.get(sessionKey)?.reject(new Error("Session destroyed"));
+    this.pendingUpdate.delete(sessionKey);
     this.sessions.delete(sessionKey);
+    entry.destroyed = true;
     entry.worker.postMessage({ type: "destroy" });
+    const exitPromise = new Promise((resolve) => {
+      entry.worker.once("exit", () => resolve());
+    });
+    const timeout = new Promise((resolve) => setTimeout(resolve, 2000));
+    await Promise.race([exitPromise, timeout]);
     await entry.worker.terminate();
   }
   async destroyAll() {
     const keys = [...this.sessions.keys()];
     await Promise.all(keys.map((k) => this.destroy(k)));
   }
+  waitForReady(sessionKey, timeoutMs = 30000) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingReady.delete(sessionKey);
+        reject(new Error(`Session creation timed out after ${timeoutMs / 1000}s`));
+      }, timeoutMs);
+      this.pendingReady.set(sessionKey, {
+        resolve: () => {
+          clearTimeout(timer);
+          resolve();
+        },
+        reject: (err) => {
+          clearTimeout(timer);
+          reject(err);
+        }
+      });
+    });
+  }
+  waitForUpdate(sessionKey, timeoutMs = 15000) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingUpdate.delete(sessionKey);
+        reject(new Error(`Session update timed out after ${timeoutMs / 1000}s`));
+      }, timeoutMs);
+      this.pendingUpdate.set(sessionKey, {
+        resolve: () => {
+          clearTimeout(timer);
+          resolve();
+        },
+        reject: (err) => {
+          clearTimeout(timer);
+          reject(err);
+        }
+      });
+    });
+  }
   get activeCount() {
     return this.sessions.size;
   }
@@ -128,10 +195,16 @@ class SessionRouter {
     const now = Date.now();
     const toEvict = [];
     for (const [key, entry] of this.sessions) {
+      if (this.pendingReady.has(key))
+        continue;
       if (now - entry.lastActive.getTime() > this.idleTtlMs) {
         toEvict.push(key);
       }
     }
+    if (toEvict.length > 0) {
+      process.stderr.write(`[SessionRouter] Evicting ${toEvict.length} idle session(s): ${toEvict.join(", ")}
+`);
+    }
     for (const key of toEvict) {
       this.destroy(key).catch(() => {});
     }
@@ -140,29 +213,20 @@ class SessionRouter {
     let oldest = null;
     let oldestTime = Infinity;
     for (const [key, entry] of this.sessions) {
+      if (this.pendingReady.has(key))
+        continue;
       if (entry.lastActive.getTime() < oldestTime) {
         oldestTime = entry.lastActive.getTime();
         oldest = key;
       }
     }
     if (oldest) {
+      process.stderr.write(`[SessionRouter] Evicting LRU session: ${oldest}
+`);
       this.destroy(oldest).catch(() => {});
     }
   }
 }
-function computeConfigHash(config) {
-  const parts = [
-    config.session.model ?? "",
-    config.session.cwd ?? "",
-    config.session.systemPrompt ?? "",
-    config.session.appendSystemPrompt ?? "",
-    config.session.permissionMode ?? "",
-    config.permission.mode ?? "",
-    ...(config.permission.allowed_tools ?? []).sort(),
-    ...(config.permission.denied_tools ?? []).sort()
-  ];
-  return createHash("sha256").update(JSON.stringify(parts)).digest("hex").slice(0, 16);
-}
 
 // src/entrypoints/gateway/index.ts
 var __dirname2 = dirname(fileURLToPath(import.meta.url));
@@ -170,6 +234,7 @@ var WORKER_PATH = resolve(__dirname2, "worker.js");
 var outputBuffer = "";
 var drainResolve = null;
 var MAX_OUTPUT_BUFFER_SIZE = 10 * 1024 * 1024;
+var lastWorkerErrors = new Map;
 function notify(msg) {
   let line;
   try {
@@ -205,15 +270,22 @@ var router = new SessionRouter({
   onWorkerMessage: (sessionKey, msg) => {
     switch (msg.type) {
       case "ready":
-        notify({ method: "session.ready", params: { session_key: msg.session_key, session_id: msg.session_id } });
+        process.stderr.write(`[Gateway] Session ready: ${sessionKey}, sessionId: ${msg.session_id}
+`);
+        notify({ method: "session.ready", params: { session_key: msg.session_key, session_id: msg.session_id, state_session_id: msg.state_session_id } });
         break;
       case "stream":
         notify({ method: "session.stream", params: { session_key: msg.session_key, data: msg.data } });
         break;
       case "complete":
+        process.stderr.write(`[Gateway] Session complete: ${sessionKey}, sessionId: ${msg.session_id}
+`);
         notify({ method: "session.complete", params: { session_key: msg.session_key, session_id: msg.session_id } });
         break;
       case "error":
+        process.stderr.write(`[Gateway] Session error: ${sessionKey} - ${msg.error}
+`);
+        lastWorkerErrors.set(sessionKey, msg.error);
         notify({ method: "session.error", params: { session_key: msg.session_key, error: msg.error } });
         break;
       case "permission_request":
@@ -229,21 +301,31 @@ var router = new SessionRouter({
           }
         });
         break;
+      case "updated":
+        process.stderr.write(`[Gateway] Session updated: ${sessionKey}
+`);
+        break;
     }
   },
   onWorkerExit: (sessionKey, code) => {
-    notify({ method: "session.error", params: { session_key: sessionKey, error: `Worker exited with code ${code}` } });
+    const lastError = lastWorkerErrors.get(sessionKey);
+    const enrichedError = lastError ? `Worker exited with code ${code}. Last error: ${lastError}` : `Worker exited with code ${code}`;
+    process.stderr.write(`[Gateway] Worker exited: ${sessionKey}, code: ${code}. Last error: ${lastError || "none"}
+`);
+    notify({ method: "session.error", params: { session_key: sessionKey, error: enrichedError } });
+    lastWorkerErrors.delete(sessionKey);
   }
 });
 async function handleRequest(req) {
   switch (req.method) {
     case "session.create": {
-      const { session_key, config, permission, env } = req.params;
+      const { session_key, config, permission, env, resume } = req.params;
       const workerConfig = {
         sessionKey: session_key,
         session: config,
         permission,
-        env
+        env,
+        resume
       };
       try {
         await router.create(session_key, workerConfig);
@@ -284,6 +366,28 @@ async function handleRequest(req) {
       await router.destroy(session_key);
       break;
     }
+    case "session.update": {
+      const { session_key, config } = req.params;
+      if (!router.has(session_key)) {
+        notify({
+          method: "session.error",
+          params: { session_key, error: `Session not found: ${session_key}` }
+        });
+        break;
+      }
+      try {
+        const updatePromise = router.waitForUpdate(session_key);
+        router.send(session_key, { type: "update", config });
+        await updatePromise;
+        notify({ method: "session.updated", params: { session_key } });
+      } catch (err) {
+        notify({
+          method: "session.error",
+          params: { session_key, error: err instanceof Error ? err.message : String(err) }
+        });
+      }
+      break;
+    }
     case "session.permission_response": {
       const { session_key, request_id, result } = req.params;
       try {