@yanlinglabs/winter-agent-sdk 0.0.17 → 0.0.20

package/dist/index.d.ts

@@ -27,7 +27,7 @@ export { SDK_VERSION } from "./version.js";
 export { MESSAGING_CONTROL_SUBTYPES, MESSAGING_CONTROL_SUBTYPE_LIST, MESSAGING_HOST_REQUEST_SUBTYPES, MESSAGING_RUNTIME_REQUEST_SUBTYPES, resolveFacetTarget } from "./protocol/messaging.js";
 export { isRuntimeAddress, isGlobalAgentMessage, isDeliveryOutcome, isListedRuntimeObjectArray, isPermissionClassLabel, isMessagingDeliverRequest, isMessagingChildRequest, isMessagingSubscribeIdleRequest, isMessagingReadNotificationsRequest, isMessagingNotificationsPage, isMessagingIdleNoticePayload, isNotificationRecord, } from "./protocol/messaging.js";
 export type { MessagingControlSubtype, MessagingDeliverRequest, MessagingChildRequest, MessagingSubscribeIdleRequest, MessagingSenderClassResponse, MessagingReadNotificationsRequest, MessagingNotificationsPage, MessagingIdleNoticePayload, } from "./protocol/messaging.js";
-export type { ProtocolVersion, WinterFrame, SdkMessage as ProtocolSdkMessage, InitFrame, UserFrame, DataFrame, ControlRequestFrame, ControlResponseFrame, UnknownFrame, SDKHookStartedMessage, SDKHookProgressMessage, SDKHookResponseMessage, SDKPermissionDeniedMessage, SDKPermissionDenial, SDKTaskStartedMessage, SDKTaskNotificationMessage, SDKTaskUpdatedMessage, SDKTaskProgressMessage, SDKBackgroundTasksChangedMessage, SDKLocalCommandOutputMessage, BackgroundTaskMessage, SDKCompactBoundaryMessage, SDKSessionStateChangedMessage, WireContentBlock, WireStreamEvent, WireStreamEventDelta, SDKPartialAssistantMessage, SDKAssistantMessageError, SDKAPIRetryMessage, SDKRateLimitEvent, SDKRateLimitInfo, SDKAuthStatusMessage, SDKThinkingTokensMessage, SDKModelRefusalFallbackMessage, SDKModelRefusalNoFallbackMessage, SDKReasoningSummaryMessage, SDKModelSwitchMessage, SDKContinuityWarningMessage, } from "./protocol/frames.js";
+export type { ProtocolVersion, WinterFrame, SdkMessage as ProtocolSdkMessage, InitFrame, UserFrame, DataFrame, ControlRequestFrame, ControlResponseFrame, ControlCancelRequestFrame, WireResultUsage, UnknownFrame, SDKHookStartedMessage, SDKHookProgressMessage, SDKHookResponseMessage, SDKPermissionDeniedMessage, SDKPermissionDenial, SDKTaskStartedMessage, SDKTaskNotificationMessage, SDKTaskUpdatedMessage, SDKTaskProgressMessage, SDKBackgroundTasksChangedMessage, SDKLocalCommandOutputMessage, BackgroundTaskMessage, SDKCompactBoundaryMessage, SDKSessionStateChangedMessage, WireContentBlock, WireStreamEvent, WireStreamEventDelta, SDKPartialAssistantMessage, SDKAssistantMessageError, SDKAPIRetryMessage, SDKRateLimitEvent, SDKRateLimitInfo, SDKAuthStatusMessage, SDKThinkingTokensMessage, SDKModelRefusalFallbackMessage, SDKModelRefusalNoFallbackMessage, SDKReasoningSummaryMessage, SDKModelSwitchMessage, SDKContinuityWarningMessage, } from "./protocol/frames.js";
 export { resolveWinterHome, resolveKeychainServiceForProfile, isUnset } from "./paths/home.js";
 export { transcriptProjectKey, TRANSCRIPT_PROJECT_KEY_MAX_LENGTH, isVendorCompliantProjectKey } from "./paths/project-key.js";
 export { compatibilityKeys } from "./paths/keys.js";

package/dist/index.js

@@ -666,6 +666,7 @@ function query(args) {
     proc.stdin.write(encodeFrame(frame));
   }
   const controlRequestHandlers = new Map;
+  const incomingRequestAborts = new Map;
   async function handleIncomingControlRequest(cf) {
     try {
       const handler = controlRequestHandlers.get(cf.subtype);
@@ -678,8 +679,12 @@ function query(args) {
         });
         return;
       }
+      const cancel = new AbortController;
+      incomingRequestAborts.set(cf.requestId, cancel);
       try {
-        const result = await handler(cf.payload);
+        const result = await handler(cf.payload, { signal: cancel.signal });
+        if (cancel.signal.aborted)
+          return;
         if (result.ok) {
           writeControlResponse({
             type: "control_response",
@@ -691,19 +696,27 @@ function query(args) {
           writeControlResponse({ type: "control_response", requestId: cf.requestId, ok: false, error: result.error });
         }
       } catch (err) {
+        if (cancel.signal.aborted)
+          return;
         const message = err instanceof Error ? err.message : String(err);
         writeControlResponse({ type: "control_response", requestId: cf.requestId, ok: false, error: { code: "handler_threw", message } });
+      } finally {
+        incomingRequestAborts.delete(cf.requestId);
       }
     } catch {}
   }
   function makePermissionHandler(canUseTool) {
-    return async (payload) => {
+    return async (payload, handlerCtx) => {
       const req = payload;
       const controller = new AbortController;
       if (options.abortController?.signal.aborted)
         controller.abort();
       else
         options.abortController?.signal.addEventListener("abort", () => controller.abort(), { once: true });
+      if (handlerCtx?.signal.aborted === true)
+        controller.abort();
+      else
+        handlerCtx?.signal.addEventListener("abort", () => controller.abort(), { once: true });
       let result;
       try {
         result = await canUseTool(req.toolName, req.input, {
@@ -828,6 +841,13 @@ function query(args) {
               }
               continue;
             }
+            if (frame.type === "control_cancel_request") {
+              const cancelledId = frame.requestId ?? "";
+              const cancelled = incomingRequestAborts.get(cancelledId);
+              incomingRequestAborts.delete(cancelledId);
+              cancelled?.abort();
+              continue;
+            }
             if (frame.type === "control_request") {
               handleIncomingControlRequest(frame);
               continue;
@@ -1001,7 +1021,7 @@ function query(args) {
   return gen;
 }
 // src/version.ts
-var SDK_VERSION = "0.0.17";
+var SDK_VERSION = "0.0.20";
 // src/paths/project-key.ts
 var TRANSCRIPT_PROJECT_KEY_MAX_LENGTH = 64;
 var VENDOR_PROJECT_KEY_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
@@ -1044,13 +1064,41 @@ function resolveCanonical(raw) {
   }
 }
 function gitCommonRoot(resolvedCwd) {
+  let commonDir;
+  try {
+    const raw = runGit(["-C", resolvedCwd, "rev-parse", "--git-common-dir"]);
+    commonDir = platformNormalize(realpathSync(isAbsolute(raw) ? raw : resolvePath(resolvedCwd, raw)));
+  } catch {
+    return null;
+  }
+  const candidate = dirname2(commonDir);
+  if (isWithin(resolvedCwd, candidate))
+    return candidate;
+  if (registeredWorktrees(commonDir).some((worktree) => isWithin(resolvedCwd, worktree)))
+    return candidate;
+  const configured = configuredWorktree(commonDir);
+  if (configured !== null && isWithin(resolvedCwd, configured))
+    return configured;
+  return null;
+}
+function runGit(args) {
+  return execFileSync("git", args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+}
+function isWithin(path, dir) {
+  return path === dir || path.startsWith(dir.endsWith("/") ? dir : `${dir}/`);
+}
+function registeredWorktrees(commonDir) {
+  try {
+    return runGit(["--git-dir", commonDir, "worktree", "list", "--porcelain"]).split(`
+`).filter((line) => line.startsWith("worktree ")).map((line) => resolveCanonical(line.slice("worktree ".length)));
+  } catch {
+    return [];
+  }
+}
+function configuredWorktree(commonDir) {
   try {
-    const raw = execFileSync("git", ["-C", resolvedCwd, "rev-parse", "--git-common-dir"], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    }).trim();
-    const commonDir = isAbsolute(raw) ? raw : resolvePath(resolvedCwd, raw);
-    return platformNormalize(dirname2(realpathSync(commonDir)));
+    const raw = runGit(["--git-dir", commonDir, "config", "--get", "core.worktree"]);
+    return raw.length > 0 ? resolveCanonical(isAbsolute(raw) ? raw : resolvePath(commonDir, raw)) : null;
   } catch {
     return null;
   }

package/dist/options.d.ts

@@ -275,7 +275,9 @@ export interface Options {
     autoClassifier?: AutoClassifierConfig;
     /**
      * DISCLOSED WINTER option (P2 carry, wired in T10): the advisor/reviewer backend's model, same
-     * selection path. Its optional `authRef` (fix wave, Ruling E-1) is the advisor's OWN credential:
+     * selection path -- a provider-qualified tag (`<providerId>/<model>`) names its own provider, so a
+     * reviewer on another provider than the session's is just that tag plus that provider's credential
+     * (the `web.fetch.digestModel` shape). Its optional `authRef` (fix wave, Ruling E-1) is the advisor's OWN credential:
      * a target on another provider than the session's never inherits the session's -- it uses the
      * route's ref, else the target provider's own keychain record (`<providerId>:default`), else a
      * typed `no-credential-for-provider` refusal at its first generation.

package/dist/protocol/config.d.ts

@@ -473,6 +473,18 @@ export interface AutoClassifierConfig {
  * advisor's provider, the advisor's provider refuses with a typed `no-credential-for-provider`.
  */
 export interface AdvisorConfig {
+    /**
+     * The reviewer's model: a PROVIDER-QUALIFIED TAG (`<providerId>/<model>`, e.g.
+     * `codex-oauth/gpt-5.6-sol`) or a slot name, resolved through the SAME selection path as the
+     * session model -- exactly as `WebFetchConfig.digestModel` is.
+     *
+     * THE TAG IS THE PROVIDER IDENTITY; there is deliberately no second field for it. A qualified tag
+     * resolves under ITS OWN provider, never under the session's (`Options.provider`), so an advisor on
+     * another provider than the session's needs nothing but that tag and, in `authRef`, that provider's
+     * own credential. A host that splits the tag down to a bare model id before passing it has thrown
+     * the provider away: a bare id is read as a slot name or canonical id and resolved by the session's
+     * slot rules, which is a different question.
+     */
     model: string;
     authRef?: CredentialRef;
 }

package/dist/protocol/frames.d.ts

@@ -42,11 +42,56 @@ export interface ControlResponseFrame {
         message: string;
     };
 }
+/**
+ * Runtime -> host: "I stopped waiting for control_request `requestId`" (lane C, C2 -- claude parity:
+ * claude's structuredIO writes `control_cancel_request` when a pending request's signal aborts, e.g.
+ * a turn interrupted while a permission prompt is open). The host aborts the callback it is running
+ * for that request (`canUseTool`'s `signal`) and owes no response; one sent anyway is dropped.
+ */
+/**
+ * `result.usage`: claude's `NonNullableUsage` (every `BetaUsage` field, none null), carrying THIS
+ * turn's main-loop generations -- claude builds a fresh QueryEngine per prompt in SDK mode, so its
+ * `totalUsage` starts at EMPTY_USAGE each turn. The four token counts are real; the rest is filled the
+ * way the pinned binary's own EMPTY_USAGE fills a value it has no data for, and says so:
+ *   - `cache_creation`: every cache write Winter marks is the default 5-minute ephemeral one (the
+ *     adapters send `{type: "ephemeral"}` with no ttl), so `ephemeral_5m_input_tokens` equals
+ *     `cache_creation_input_tokens` and `ephemeral_1h_input_tokens` is 0;
+ *   - `server_tool_use`: Winter's WebSearch/WebFetch run client-side, never as billed server tools: 0/0;
+ *   - `output_tokens_details.thinking_tokens`: 0 -- providers' reasoning-token counts are not threaded
+ *     through Winter's usage yet (they are included in `output_tokens`);
+ *   - `service_tier: "standard"`, `inference_geo: ""`, `iterations: []`, `speed: "standard"`: the
+ *     pinned EMPTY_USAGE's own values.
+ */
+export interface WireResultUsage {
+    output_tokens_details: {
+        thinking_tokens: number;
+    };
+    input_tokens: number;
+    cache_creation_input_tokens: number;
+    cache_read_input_tokens: number;
+    output_tokens: number;
+    server_tool_use: {
+        web_search_requests: number;
+        web_fetch_requests: number;
+    };
+    service_tier: "standard" | "priority" | "batch";
+    cache_creation: {
+        ephemeral_1h_input_tokens: number;
+        ephemeral_5m_input_tokens: number;
+    };
+    inference_geo: string;
+    iterations: unknown[];
+    speed: "standard" | "fast";
+}
+export interface ControlCancelRequestFrame {
+    type: "control_cancel_request";
+    requestId: string;
+}
 export interface UnknownFrame {
     type: string;
     [k: string]: unknown;
 }
-export type WinterFrame = InitFrame | UserFrame | DataFrame | ControlRequestFrame | ControlResponseFrame | UnknownFrame;
+export type WinterFrame = InitFrame | UserFrame | DataFrame | ControlRequestFrame | ControlResponseFrame | ControlCancelRequestFrame | UnknownFrame;
 export interface SDKHookStartedMessage {
     type: "system";
     subtype: "hook_started";
@@ -618,6 +663,8 @@ export type SdkMessage = {
     structured_output?: unknown;
     terminal_reason?: "structured_output_retry_exhausted" | "api_error" | string;
     api_error_status?: number | null;
+    /** THIS turn's main-loop usage -- claude's `result.usage` (dist-session fixes C1); see `WireResultUsage`. */
+    usage?: WireResultUsage;
     permission_denials: SDKPermissionDenial[];
     [k: string]: unknown;
 } | {

package/dist/query.d.ts

@@ -21,7 +21,14 @@ export type ControlRequestHandlerResult = {
         message: string;
     };
 };
-export type ControlRequestHandler = (payload: unknown) => Promise<ControlRequestHandlerResult>;
+/**
+ * A handler for one runtime-originated control_request subtype. `ctx.signal` aborts when the runtime
+ * CANCELS the request (`control_cancel_request` -- lane C, C2, claude parity): the handler should stop
+ * waiting, and whatever it returns afterwards is not sent (the runtime already stopped waiting).
+ */
+export type ControlRequestHandler = (payload: unknown, ctx?: {
+    signal: AbortSignal;
+}) => Promise<ControlRequestHandlerResult>;
 export interface QueryInternal {
     registerControlRequestHandler(subtype: string, handler: ControlRequestHandler): void;
     respondPermission(requestId: string, result: PermissionResult): void;

package/package.json

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