@yanlinglabs/winter-agent-sdk 0.0.39 → 0.0.41

package/dist/index.js

@@ -429,13 +429,16 @@ function toWireMcpServers(servers) {
       name: cfg.name,
       ...cfg.timeout !== undefined ? { timeout: cfg.timeout } : {},
       ...isWinterMcpServerInstance(cfg.instance) ? { tools: cfg.instance.listTools() } : {},
-      ...cfg.toolNames !== undefined ? { toolNames: { ...cfg.toolNames } } : {}
+      ...cfg.toolNames !== undefined ? { toolNames: { ...cfg.toolNames } } : {},
+      ...cfg.toolLanes !== undefined ? { toolLanes: { ...cfg.toolLanes } } : {},
+      ...Array.isArray(cfg.concurrentTools) ? { concurrentTools: [...cfg.concurrentTools] } : {}
     } : cfg;
   }
   return out;
 }
+var ANSWERED_AFTER_CANCEL = new Set(["sdk_mcp_call"]);
 function makeSdkMcpCallHandler(mcpServers) {
-  return async (payload) => {
+  return async (payload, handlerCtx) => {
     const req = payload;
     const cfg = req.server !== undefined ? mcpServers[req.server] : undefined;
     if (!cfg || cfg.type !== "sdk") {
@@ -451,7 +454,7 @@ function makeSdkMcpCallHandler(mcpServers) {
       };
     }
     try {
-      const result = await cfg.instance.callTool(req.tool ?? "", req.arguments ?? {});
+      const result = await cfg.instance.callTool(req.tool ?? "", req.arguments ?? {}, ...handlerCtx !== undefined ? [{ signal: handlerCtx.signal }] : []);
       return { ok: true, payload: result };
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -895,7 +898,7 @@ function query(args) {
       incomingRequestAborts.set(cf.requestId, cancel);
       try {
         const result = await handler(cf.payload, { signal: cancel.signal });
-        if (cancel.signal.aborted)
+        if (cancel.signal.aborted && !ANSWERED_AFTER_CANCEL.has(cf.subtype))
           return;
         if (result.ok) {
           writeControlResponse({
@@ -908,7 +911,7 @@ function query(args) {
           writeControlResponse({ type: "control_response", requestId: cf.requestId, ok: false, error: result.error });
         }
       } catch (err) {
-        if (cancel.signal.aborted)
+        if (cancel.signal.aborted && !ANSWERED_AFTER_CANCEL.has(cf.subtype))
           return;
         const message = err instanceof Error ? err.message : String(err);
         writeControlResponse({ type: "control_response", requestId: cf.requestId, ok: false, error: { code: "handler_threw", message } });
@@ -1268,7 +1271,7 @@ function withTestKeychainRedirect(env) {
   return { ...env, [TEST_KEYCHAIN_ENV]: redirect };
 }
 // src/version.ts
-var SDK_VERSION = "0.0.39";
+var SDK_VERSION = "0.0.41";
 // src/paths/project-key.ts
 var TRANSCRIPT_PROJECT_KEY_MAX_LENGTH = 64;
 var VENDOR_PROJECT_KEY_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;

package/dist/options.d.ts

@@ -128,7 +128,16 @@ export interface WinterMcpServerInstance {
         };
         _meta?: Record<string, unknown>;
     }>;
-    callTool(name: string, args: Record<string, unknown>): Promise<{
+    /**
+     * `extra.signal` (SDK 0.0.40) is ABORTED when the runtime cancels the call (an interrupted turn sends
+     * `control_cancel_request`). A tool that holds an exclusive resource should stop promptly and then return:
+     * the runtime keeps the tool's concurrency lane held until this promise settles (or a bounded grace runs
+     * out), so the next call of that lane never overlaps a tool still running. Optional: an instance that
+     * ignores it behaves as before.
+     */
+    callTool(name: string, args: Record<string, unknown>, extra?: {
+        signal?: AbortSignal;
+    }): Promise<{
         content: unknown[];
         isError?: boolean;
     }>;

package/dist/protocol/config.d.ts

@@ -395,6 +395,34 @@ export interface McpSdkServerConfig {
      * host owns it.
      */
     toolNames?: Record<string, string>;
+    /**
+     * SDK 0.0.40, a Winter extension: CONCURRENCY LANES for some of this server's tools, keyed by the
+     * server's own tool name (`{ computer: "computer", browser: "browser" }`). A round's calls normally run
+     * one at a time unless the tool is read-only (`readOnlyHint: true`); a tool in a lane instead runs BESIDE
+     * the round's other calls, but never beside another call of the SAME lane -- calls of one lane run one at
+     * a time, in call order, across the round. Use it for a tool that holds one exclusive resource (a screen,
+     * a browser) yet is safe next to everything else. A call that is neither read-only nor in a lane is a
+     * barrier, exactly as before. A lane key is 1-64 characters of `[A-Za-z0-9_.:-]`; anything else is
+     * ignored. Only an in-process (`sdk`) server may declare lanes; the host vouches for its own tools.
+     */
+    toolLanes?: Record<string, string>;
+    /**
+     * SDK 0.0.41, a Winter extension: some of this server's tools, by the server's own tool name, that are
+     * SAFE TO RUN CONCURRENTLY without being read-only (`["session_spawn"]`). A round's calls normally run
+     * one at a time unless the tool is read-only (`readOnlyHint: true`); a tool listed here runs BESIDE the
+     * round's other concurrent calls (up to 10 at once), exactly like a read-only one -- several calls of it
+     * in one round run at the same time (claude runs several `Agent` calls of a round at once; this is the
+     * same thing for a host tool that starts work elsewhere).
+     *
+     * It is a SCHEDULING statement only. It never makes the tool read-only anywhere else: the tool's
+     * `annotations` are not touched, plan mode, permission evaluation, the hook input's `winter_mcp_server`
+     * and `canUseTool`'s `mcpServer` read the server's own `readOnlyHint` exactly as before. Use it only for a
+     * tool whose concurrent calls cannot interfere with each other (each call's work is its own); a tool
+     * that holds one exclusive resource belongs in a lane (`toolLanes`) instead. A tool named in BOTH is in
+     * its lane (the stricter answer). An entry that is not a string, or names no tool of this server, is
+     * ignored. Only an in-process (`sdk`) server may declare it; the host vouches for its own tools.
+     */
+    concurrentTools?: string[];
 }
 export type McpServerConfigForProcessTransport = McpStdioServerConfig | McpHttpServerConfig | McpSSEServerConfig | McpSdkServerConfig;
 export type AgentMcpServerSpec = string | Record<string, McpServerConfigForProcessTransport>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yanlinglabs/winter-agent-sdk",
-  "version": "0.0.39",
+  "version": "0.0.41",
   "license": "MIT",
   "type": "module",
   "engines": {
@@ -45,15 +45,15 @@
     }
   },
   "dependencies": {
-    "@yanlinglabs/winter-provider-catalog": "0.0.39"
+    "@yanlinglabs/winter-provider-catalog": "0.0.41"
   },
   "optionalDependencies": {
-    "@yanlinglabs/winter-agent-sdk-darwin-arm64": "0.0.39"
+    "@yanlinglabs/winter-agent-sdk-darwin-arm64": "0.0.41"
   },
   "devDependencies": {
     "@types/node": "^26.4.0",
-    "@yanlinglabs/winter-agent-runtime": "0.0.39",
-    "@yanlinglabs/winter-conformance": "0.0.39"
+    "@yanlinglabs/winter-conformance": "0.0.41",
+    "@yanlinglabs/winter-agent-runtime": "0.0.41"
   },
   "scripts": {}
 }