@yanlinglabs/winter-agent-runtime 0.0.27 → 0.0.28

package/dist/{index-584yahed.js → index-mqj4x0fn.js}

@@ -12,6 +12,7 @@ import {
   getRegisteredTool,
   listRegisteredTools,
   rebrandStandingServerTools,
+  mcpServerHasRegistrations,
   STRUCTURED_OUTPUT_TOOL_NAME,
   looksLikeCommand,
   registerChildEngineFactory,
@@ -86,7 +87,7 @@ import {
   providerCredentialRef2,
   createModelClassifier2,
   selectClassifierRoute2
-} from "./index-9qgkpv56.js";
+} from "./index-mftq279y.js";
 import {
   createInMemoryChannel2
 } from "./index-97t2rmtf.js";
@@ -473,6 +474,64 @@ async function cleanupWorkspace(workspace) {
 }
 
 // src/subagents/child-engine.ts
+var liveChildScopedServerNames = new Set;
+var GENERATION_TEARDOWN_WAIT_MS = 5000;
+function renameMcpReference(entry, renames) {
+  for (const [declared, actual] of renames) {
+    const prefix = `mcp__${declared}`;
+    if (entry === prefix || entry.startsWith(`${prefix}__`) || entry.startsWith(`${prefix}(`))
+      return `mcp__${actual}${entry.slice(prefix.length)}`;
+  }
+  return;
+}
+function allocateChildScopedServers(declared, parentVisible, prefer, parentDeclared) {
+  const claimed = [];
+  const inUse = (name) => liveChildScopedServerNames.has(name) || parentVisible.has(name) || mcpServerHasRegistrations(name);
+  const servers = {};
+  const actual = new Map;
+  const notes = [];
+  const claim = (name) => {
+    liveChildScopedServerNames.add(name);
+    claimed.push(name);
+  };
+  for (const [name, cfg] of Object.entries(declared)) {
+    if (cfg.type === "sdk") {
+      if (inUse(name)) {
+        notes.push(parentVisible.has(name) && parentDeclared?.[name]?.type === "sdk" ? `mcpServers declares the in-process server "${name}", which this session already has -- the session's "${name}" is used` : parentVisible.has(name) ? `mcpServers declares the in-process server "${name}", but this session's "${name}" is a different server -- this agent's own in-process "${name}" is not connected, and the session's is what this agent sees` : `mcpServers declares the in-process server "${name}", which another agent in this session is using -- this agent's own in-process "${name}" is not connected`);
+        continue;
+      }
+      claim(name);
+      servers[name] = cfg;
+      actual.set(name, name);
+      continue;
+    }
+    const free = (candidate) => !inUse(candidate) && (candidate === name || !(candidate in declared));
+    let pick = prefer?.get(name);
+    if (pick === undefined || !free(pick))
+      pick = free(name) ? name : undefined;
+    for (let n = 2;pick === undefined; n++)
+      if (free(`${name}_${n}`))
+        pick = `${name}_${n}`;
+    claim(pick);
+    servers[pick] = cfg;
+    actual.set(name, pick);
+    if (pick !== name)
+      notes.push(`mcpServers declares "${name}", which is already in use in this session -- this agent's own "${name}" is connected as "${pick}" (its tools are named mcp__${pick}__<tool>)`);
+  }
+  let released = false;
+  return {
+    servers,
+    actual,
+    notes,
+    release: () => {
+      if (released)
+        return;
+      released = true;
+      for (const name of claimed)
+        liveChildScopedServerNames.delete(name);
+    }
+  };
+}
 function createChildEngineFactory(deps) {
   return (runCtx) => ({
     spawn(req, inherit) {
@@ -487,8 +546,20 @@ async function spawnChildEngine(req, inherit, runCtx, deps) {
   const env = deps.env ?? process.env;
   const { depth: spawnDepth } = checkAndRegisterSpawn({ parentKey: runCtx.parentAgentId ?? runCtx.parentSessionId, childKey: agentId, env, ...deps.parentBrand !== undefined ? { brand: deps.parentBrand } : {} });
   let spawnRegistered = true;
+  let pendingServerRelease;
   try {
-    let startGeneration = function(config, initialMessages, liveText, agentSystemPrompt) {
+    let startGeneration = function(config, initialMessages, liveText, agentSystemPrompt, servers) {
+      const ownServers = Object.keys(servers.servers).length > 0;
+      if (ownServers)
+        config = { ...config, mcpServers: servers.servers };
+      const renames = [...servers.actual].filter(([declared, actual]) => declared !== actual);
+      if (renames.length > 0 && config.disallowedTools !== undefined) {
+        const carried = config.disallowedTools.flatMap((entry) => {
+          const renamed = renameMcpReference(entry, renames);
+          return renamed !== undefined ? [entry, renamed] : [entry];
+        });
+        config = { ...config, disallowedTools: [...new Set(carried)] };
+      }
       const channel = createInMemoryChannel2();
       currentSink = channel.host.output;
       const startedAt = Date.now();
@@ -675,48 +746,63 @@ async function spawnChildEngine(req, inherit, runCtx, deps) {
           }
         };
       })();
-      runEngine2({
-        config,
-        contextAccountant: childAccountant,
-        ...childProvider.identity !== undefined ? { providerIdentity: childProvider.identity } : {},
-        input: channel.runtime.input,
-        output: snapshottingOutput,
-        provider: childProvider.provider,
-        ...agentSystemPrompt !== undefined && agentSystemPrompt.length > 0 ? { agentSystemPrompt } : {},
-        ...req.fork === true && inherit.requestLayout !== undefined ? { exactRequestLayout: inherit.requestLayout } : {},
-        subagentHooks: {
-          agentType: req.agentType ?? req.builtinAgentType ?? (req.fork === true ? "fork" : "general-purpose"),
-          agentTranscriptPath: childStore !== undefined && childDurableRoot !== undefined ? transcriptPath : ""
-        },
-        ...req.definition?.omitProjectContext === true ? { omitProjectContext: true } : {},
-        ...writer !== undefined ? { store: writer } : {},
-        ...initialMessages.length > 0 ? { initialMessages } : {},
-        ...!hasChildScopedMcpServers && parentMcp?.stateSource !== undefined ? { mcpServerStateSource: parentMcp.stateSource } : {},
-        ...!hasChildScopedMcpServers && parentMcp?.controlSeam !== undefined ? { mcpControlSeam: parentMcp.controlSeam } : {},
-        ...parentMcp?.visibleServerNames !== undefined ? { inheritedMcpServerNames: parentMcp.visibleServerNames } : {},
-        ...deps.systemPromptAssembler !== undefined ? { systemPromptAssembler: deps.systemPromptAssembler } : {},
-        ...deps.skillListing !== undefined ? { skillListing: deps.skillListing } : {},
-        ...deps.describeModel !== undefined ? { describeModel: deps.describeModel } : {},
-        ...deps.priceUsage !== undefined ? {
-          priceUsage: (modelKey, usage) => deps.priceUsage(modelKey === resolvedModel.effectiveModel && childProvider.identity !== undefined ? childProvider.identity.modelKey : modelKey, usage)
-        } : {},
-        ...deps.usageRowFacts !== undefined ? {
-          usageRowFacts: (modelKey) => deps.usageRowFacts(modelKey === resolvedModel.effectiveModel && childProvider.identity !== undefined ? childProvider.identity.modelKey : modelKey)
-        } : {},
-        ...runCtx.recordDescendantCost !== undefined ? { onPricedGeneration: runCtx.recordDescendantCost } : {},
-        ...runCtx.budgetExceeded !== undefined ? { ancestorBudgetExceeded: () => runCtx.budgetExceeded() } : {},
-        ...deps.resolveAuxiliaryModel !== undefined ? { resolveAuxiliaryModel: deps.resolveAuxiliaryModel } : {},
-        ...deps.resolveToolSecret !== undefined ? { resolveToolSecret: deps.resolveToolSecret } : {},
-        ...deps.settingsRules !== undefined ? { settingsRules: deps.settingsRules } : {},
-        ...childDurableRoot !== undefined ? { winterHome: childDurableRoot } : {},
-        ...deps.structuredOutput !== undefined ? { structuredOutput: deps.structuredOutput } : {},
-        ...deps.extraHookEntries !== undefined ? { extraHookEntries: deps.extraHookEntries } : {},
-        ...ownCompactionController !== undefined ? { compactionController: ownCompactionController } : {},
-        env
-      }).catch((err) => {
-        const reason = err instanceof Error && err.message.length > 0 ? err.message : String(err ?? "");
-        settle("failed", reason.length > 0 ? `child engine exited: ${reason}` : "child engine process exited unexpectedly");
-      });
+      let handedOver = false;
+      try {
+        lastGenerationDone = runEngine2({
+          config,
+          contextAccountant: childAccountant,
+          ...childProvider.identity !== undefined ? { providerIdentity: childProvider.identity } : {},
+          input: channel.runtime.input,
+          output: snapshottingOutput,
+          provider: childProvider.provider,
+          ...agentSystemPrompt !== undefined && agentSystemPrompt.length > 0 ? { agentSystemPrompt } : {},
+          ...req.fork === true && inherit.requestLayout !== undefined ? { exactRequestLayout: inherit.requestLayout } : {},
+          subagentHooks: {
+            agentType: req.agentType ?? req.builtinAgentType ?? (req.fork === true ? "fork" : "general-purpose"),
+            agentTranscriptPath: childStore !== undefined && childDurableRoot !== undefined ? transcriptPath : ""
+          },
+          ...req.definition?.omitProjectContext === true ? { omitProjectContext: true } : {},
+          ...writer !== undefined ? { store: writer } : {},
+          ...initialMessages.length > 0 ? { initialMessages } : {},
+          ...!ownServers && parentMcp?.stateSource !== undefined ? { mcpServerStateSource: parentMcp.stateSource } : {},
+          ...!ownServers && parentMcp?.controlSeam !== undefined ? { mcpControlSeam: parentMcp.controlSeam } : {},
+          ...(() => {
+            const merged = { ...parentMcp?.serverRenames ?? {}, ...Object.fromEntries(renames.map(([declared, actual]) => [actual, declared])) };
+            return Object.keys(merged).length > 0 ? { mcpServerRenames: merged } : {};
+          })(),
+          ...parentMcp?.visibleServerNames !== undefined ? { inheritedMcpServerNames: ownServerNames.size === 0 ? parentMcp.visibleServerNames : () => parentMcp.visibleServerNames().filter((name) => !ownServerNames.has(name)) } : {},
+          ...deps.systemPromptAssembler !== undefined ? { systemPromptAssembler: deps.systemPromptAssembler } : {},
+          ...deps.skillListing !== undefined ? { skillListing: deps.skillListing } : {},
+          ...deps.describeModel !== undefined ? { describeModel: deps.describeModel } : {},
+          ...deps.priceUsage !== undefined ? {
+            priceUsage: (modelKey, usage) => deps.priceUsage(modelKey === resolvedModel.effectiveModel && childProvider.identity !== undefined ? childProvider.identity.modelKey : modelKey, usage)
+          } : {},
+          ...deps.usageRowFacts !== undefined ? {
+            usageRowFacts: (modelKey) => deps.usageRowFacts(modelKey === resolvedModel.effectiveModel && childProvider.identity !== undefined ? childProvider.identity.modelKey : modelKey)
+          } : {},
+          ...runCtx.recordDescendantCost !== undefined ? { onPricedGeneration: runCtx.recordDescendantCost } : {},
+          ...runCtx.budgetExceeded !== undefined ? { ancestorBudgetExceeded: () => runCtx.budgetExceeded() } : {},
+          ...deps.resolveAuxiliaryModel !== undefined ? { resolveAuxiliaryModel: deps.resolveAuxiliaryModel } : {},
+          ...deps.resolveToolSecret !== undefined ? { resolveToolSecret: deps.resolveToolSecret } : {},
+          ...deps.settingsRules !== undefined ? { settingsRules: deps.settingsRules } : {},
+          ...childDurableRoot !== undefined ? { winterHome: childDurableRoot } : {},
+          ...deps.structuredOutput !== undefined ? { structuredOutput: deps.structuredOutput } : {},
+          ...deps.extraHookEntries !== undefined ? { extraHookEntries: deps.extraHookEntries } : {},
+          ...ownCompactionController !== undefined ? { compactionController: ownCompactionController } : {},
+          env
+        }).catch((err) => {
+          const reason = err instanceof Error && err.message.length > 0 ? err.message : String(err ?? "");
+          settle("failed", reason.length > 0 ? `child engine exited: ${reason}` : "child engine process exited unexpectedly");
+        }).finally(servers.release).then(() => {
+          return;
+        }, () => {
+          return;
+        });
+        handedOver = true;
+      } finally {
+        if (!handedOver)
+          servers.release();
+      }
       channel.host.output.write({ type: "user", text: liveText });
     }, resolveParentRules = function() {
       const live = runCtx.getParentRules?.();
@@ -807,7 +893,8 @@ async function spawnChildEngine(req, inherit, runCtx, deps) {
       for (const [name, cfg] of Object.entries(spec))
         childScopedMcpServers[name] = cfg;
     }
-    const hasChildScopedMcpServers = Object.keys(childScopedMcpServers).length > 0;
+    const ownServerNames = new Set(Object.entries(childScopedMcpServers).filter(([, cfg]) => cfg.type !== "sdk").map(([name]) => name));
+    const parentVisibleServers = () => new Set(parentMcp?.visibleServerNames?.() ?? []);
     const workspaceResult = await createWorkspace({
       parentCwd: inherit.sessionRoot,
       ...req.isolation !== undefined ? { isolation: req.isolation } : {},
@@ -852,6 +939,8 @@ async function spawnChildEngine(req, inherit, runCtx, deps) {
     let currentSink;
     let currentSettle;
     let currentUsage;
+    let lastGenerationDone = Promise.resolve();
+    let pendingResume;
     const baseConfig = {
       sessionId: runCtx.parentSessionId,
       cwd: workspace.root,
@@ -877,13 +966,15 @@ async function spawnChildEngine(req, inherit, runCtx, deps) {
       ...deps.parentSandbox !== undefined ? { sandbox: deps.parentSandbox } : {},
       ...req.definition?.maxTurns !== undefined ? { maxTurns: req.definition.maxTurns } : {},
       ...req.outputFormat !== undefined ? { outputFormat: req.outputFormat } : {},
-      ...inherit.outputStyle !== undefined ? { outputStyle: inherit.outputStyle } : {},
-      ...hasChildScopedMcpServers ? { mcpServers: childScopedMcpServers } : {}
+      ...inherit.outputStyle !== undefined ? { outputStyle: inherit.outputStyle } : {}
     };
     const initialMessages = buildForkInitialMessages(inherit, req.parentToolUseId);
     const resolvedSystemPrompt = [inherit.systemPrompt, req.fork === true ? undefined : req.definition?.prompt].filter((s) => s !== undefined && s.length > 0).join(`
 
 `);
+    let serverAllocation = allocateChildScopedServers(childScopedMcpServers, parentVisibleServers(), undefined, parentMcp?.declaredServers);
+    pendingServerRelease = serverAllocation.release;
+    definitionWarnings.push(...serverAllocation.notes);
     const firstTurnText = req.fork === true ? buildForkDirectiveText({ prompt: req.prompt, ...req.isolation === "worktree" ? { worktree: { parentRoot: inherit.sessionRoot, worktreeRoot: workspace.root } } : {} }) : [req.definition?.initialPrompt, req.prompt, definitionWarnings.length > 0 ? `
 [winter: ${definitionWarnings.join("; ")}]` : undefined].filter((s) => s !== undefined && s.length > 0).join(`
 
@@ -987,7 +1078,18 @@ async function spawnChildEngine(req, inherit, runCtx, deps) {
           writer?.writeMetadata({ ...record });
         }
         record.status = "running";
-        startGeneration(generationConfig(resumeMode), rebuilt, msg.body, resolvedSystemPrompt);
+        const previous = serverAllocation.actual;
+        const ticket = { stopped: false };
+        pendingResume = ticket;
+        await Promise.race([lastGenerationDone, new Promise((resolve) => setTimeout(resolve, GENERATION_TEARDOWN_WAIT_MS).unref?.())]);
+        pendingResume = undefined;
+        if (ticket.stopped)
+          return { status: "unavailable", messageId: msg.messageId, retryable: false, reason: `child ${agentId} was stopped while resuming` };
+        serverAllocation = allocateChildScopedServers(childScopedMcpServers, parentVisibleServers(), previous, parentMcp?.declaredServers);
+        const moved = [...serverAllocation.actual].filter(([declared, name]) => previous.get(declared) !== name).map(([declared, name]) => `this agent's own "${declared}" is now connected as "${name}" (its tools are named mcp__${name}__<tool>)`);
+        startGeneration(generationConfig(resumeMode), rebuilt, moved.length > 0 ? `${msg.body}
+
+[winter: ${moved.join("; ")}]` : msg.body, resolvedSystemPrompt, serverAllocation);
         return { status: "resumed_and_delivered", messageId: msg.messageId };
       },
       async result() {
@@ -996,6 +1098,12 @@ async function spawnChildEngine(req, inherit, runCtx, deps) {
       async stop() {
         if (record.status !== "running")
           return;
+        if (pendingResume !== undefined) {
+          pendingResume.stopped = true;
+          record.status = "stopped";
+          writer?.writeMetadata({ ...record });
+          return;
+        }
         currentSettle?.("stopped", "stopped by request");
       },
       usage() {
@@ -1005,12 +1113,14 @@ async function spawnChildEngine(req, inherit, runCtx, deps) {
     try {
       req.onSpawned?.(handle);
     } catch {}
-    startGeneration(generationConfig(inherit.policy.effectiveMode), initialMessages, firstTurnText, resolvedSystemPrompt);
+    startGeneration(generationConfig(inherit.policy.effectiveMode), initialMessages, firstTurnText, resolvedSystemPrompt, serverAllocation);
     spawnRegistered = false;
+    pendingServerRelease = undefined;
     return handle;
   } catch (err) {
     if (spawnRegistered)
       releaseSpawn(agentId);
+    pendingServerRelease?.();
     throw err;
   }
 }
@@ -1305,7 +1415,8 @@ async function foldProviderStream(stream, sink) {
             ...event.cacheWriteTokens !== undefined ? { cacheWriteTokens: event.cacheWriteTokens } : {},
             ...event.cacheWrite1hTokens !== undefined ? { cacheWrite1hTokens: event.cacheWrite1hTokens } : {},
             ...event.cacheMiss !== undefined ? { cacheMiss: event.cacheMiss } : {},
-            ...event.thinkingBlocksDropped !== undefined ? { thinkingBlocksDropped: event.thinkingBlocksDropped } : {}
+            ...event.thinkingBlocksDropped !== undefined ? { thinkingBlocksDropped: event.thinkingBlocksDropped } : {},
+            ...event.reasoningTokens !== undefined ? { reasoningTokens: event.reasoningTokens } : {}
           };
           break;
         case "retry":
@@ -1902,7 +2013,8 @@ function buildSessionProvider(opts) {
       classifier = createModelClassifier2({
         provider: buildProvider(classifierResolved, classifierRouteRaw.authRef !== undefined ? { authRef: classifierRouteRaw.authRef } : {}),
         model: classifierResolved.providerModelId,
-        ...config.brand !== undefined ? { instructionsFile: config.brand.instructionsFile } : {}
+        ...config.brand !== undefined ? { instructionsFile: config.brand.instructionsFile } : {},
+        forcedToolChoiceUnsupported: classifierResolved.descriptor?.unsupportedParameters.includes("tool_choice.tool") === true
       });
     } catch (err) {
       classifier = undefined;
@@ -1915,7 +2027,8 @@ function buildSessionProvider(opts) {
     classifier = createModelClassifier2({
       provider: buildProvider(resolved),
       model: resolved.providerModelId,
-      ...config.brand !== undefined ? { instructionsFile: config.brand.instructionsFile } : {}
+      ...config.brand !== undefined ? { instructionsFile: config.brand.instructionsFile } : {},
+      forcedToolChoiceUnsupported: resolved.descriptor?.unsupportedParameters.includes("tool_choice.tool") === true
     });
     classifierIdentity = { modelKey: resolved.modelKey };
   }
@@ -3009,55 +3122,6 @@ function memoryDirFor(input) {
   return join6(input.storeHome ?? input.home, "projects", memoryProjectKeyFor(input.cwd, input.env), "memory");
 }
 
-// src/context/plan-mode.ts
-import { DEFAULT_PLANS_DIRECTORY } from "@yanlinglabs/winter-agent-sdk";
-var PLAN_MODE_ENFORCEMENT = [
-  "This session is in PLAN MODE. Writes are withheld: file edits, file creation and state-changing shell commands are refused by the permission engine until the plan is approved. This is enforcement, not etiquette — attempting one wastes a turn and changes nothing.",
-  "Reading is unrestricted. Investigate as thoroughly as the plan needs: read files, search, run read-only commands, and inspect whatever settles an open question."
-].join(`
-
-`);
-var DEFAULT_PLAN_BODY = [
-  "Produce a plan the user can approve or correct without having to guess what you intend.",
-  "Ground it in what you actually found. A plan that names the real files, the real functions and the real call sites is reviewable; one written from assumption is a proposal to find out later.",
-  "Say what will change and where, in the order it will happen, and name anything you deliberately are NOT changing when a reader might expect otherwise.",
-  "Call out the parts that are irreversible, that touch data, or that you are least sure about — those are the parts the user is being asked to approve.",
-  "Keep it proportionate. A one-file change needs a short paragraph, not a document; a migration needs the detail.",
-  "If investigation shows the request cannot work as stated, say so and propose the alternative instead of planning around the problem."
-].join(`
-
-`);
-var PLAN_MODE_PROTOCOL = [
-  "When the plan is ready, present it and call the `ExitPlanMode` tool with it. Do not begin implementing first: leaving plan mode is the user's decision, and the tool call is how you ask for it.",
-  "If the user responds with corrections rather than approval, revise the plan and ask again — you are still in plan mode until they say otherwise."
-].join(`
-
-`);
-var PLANS_DIRECTORY_MAX_CHARS = 200;
-var PLANS_DIRECTORY_PATTERN = /^[A-Za-z0-9 ._~/-]+$/;
-function renderablePlansDirectory(raw, fallback) {
-  if (raw.length === 0 || raw.length > PLANS_DIRECTORY_MAX_CHARS)
-    return fallback;
-  if (!PLANS_DIRECTORY_PATTERN.test(raw))
-    return fallback;
-  if (raw.trim().length === 0)
-    return fallback;
-  return raw;
-}
-function renderPlanModeBlock(input) {
-  const host = input.hostPlanBody?.trim();
-  const body = host === undefined || host.length === 0 ? DEFAULT_PLAN_BODY : host;
-  return [
-    "## Plan mode",
-    PLAN_MODE_ENFORCEMENT,
-    body,
-    PLAN_MODE_PROTOCOL,
-    `If the user asks for the plan as a file, write it under ${renderablePlansDirectory(input.plansDirectory, input.plansDirectoryFallback ?? DEFAULT_PLANS_DIRECTORY)}.`
-  ].join(`
-
-`);
-}
-
 // src/context/assembler.ts
 function isPresetOption(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && value.type === "preset";
@@ -3145,11 +3209,6 @@ function createSystemPromptAssembler(deps = {}) {
         ...region.callerDynamicBlocks,
         styleBody,
         input.agentPrompt,
-        input.planMode ? renderPlanModeBlock({
-          plansDirectory: config.plansDirectory ?? settings?.plansDirectory ?? `${brand.projectDirName}/plans`,
-          plansDirectoryFallback: `${brand.projectDirName}/plans`,
-          ...input.hostPlanBody !== undefined ? { hostPlanBody: input.hostPlanBody } : {}
-        }) : undefined,
         region.excludeDynamicSections || memoryDir === undefined ? undefined : renderAutoMemorySection(memoryDir, brand.instructionsFile),
         region.excludeDynamicSections ? undefined : renderEnvironmentSection(environment)
       ];
@@ -3208,6 +3267,15 @@ function createSystemPromptAssembler(deps = {}) {
           entries.push(["auto memory", renderAutoMemoryContextValue(memoryDir, brand.instructionsFile)]);
       }
       return entries;
+    },
+    planModeInput(input) {
+      const config = input.config;
+      const { settings, brand } = resolveContext(deps, input);
+      return {
+        plansDirectory: config.plansDirectory ?? settings?.plansDirectory ?? `${brand.projectDirName}/plans`,
+        plansDirectoryFallback: `${brand.projectDirName}/plans`,
+        ...input.hostPlanBody !== undefined ? { hostPlanBody: input.hostPlanBody } : {}
+      };
     }
   };
 }
@@ -5384,7 +5452,8 @@ function describeCatalogModel(catalog, model, providerId) {
     ...row.inlineToolDefinitions !== undefined ? { toolChanges: "inline" } : row.midConversationToolChanges !== undefined ? { toolChanges: "reference" } : {},
     ...row.clientToolSearch?.value === true ? { clientToolSearch: true } : {},
     ...row.additionalToolsItem?.value === true ? { additionalToolsItem: true } : {},
-    ...row.allowedToolsChoice?.value === true ? { allowedToolsChoice: true } : {}
+    ...row.allowedToolsChoice?.value === true ? { allowedToolsChoice: true } : {},
+    ...row.undeclaredToolCalls?.value === true ? { undeclaredToolCalls: true } : {}
   };
   const description = {
     ...row.displayName.length > 0 ? { displayName: row.displayName } : {},

package/dist/index.js

@@ -53,7 +53,8 @@ import {
   DEFAULT_CLASSIFIER_TIMEOUT_MS2,
   createModelClassifier2,
   selectClassifierRoute2
-} from "./index-9qgkpv56.js";
+} from "./index-mftq279y.js";
+import"./index-8jgwp1px.js";
 import"./index-bef62z3r.js";
 import {
   createInMemoryChannel2

package/dist/mcp/client.d.ts

@@ -1,7 +1,22 @@
 import type { McpServerConfigForProcessTransport, McpVersionNegotiation } from "@yanlinglabs/winter-agent-sdk";
 import { type InProcessMcpServer } from "./transports/sdk.js";
 import { type ElicitationAsker } from "./elicitation.js";
-export type McpConnectErrorCode = "timeout" | "spawn_failed" | "handshake_failed" | "needs_auth" | "unknown";
+/**
+ * WHY a connection attempt failed -- a category, not a message (the message is for humans; this is what
+ * the state board's `errorCode`, the web search backend and the `'auto'` legacy retry read).
+ *
+ * WS-24 split two causes out of `handshake_failed`, which a failed version negotiation used to land in
+ * whatever had gone wrong:
+ *  - `version_mismatch`: the server and this client share no protocol version -- a `{pin}` the server
+ *    did not offer, or a server that named the versions it speaks and none is ours. Retrying cannot
+ *    help, so the `'auto'` legacy retry never spends a second connection on it.
+ *  - `transport_closed`: the server ended the connection under the attempt -- a stdio server that
+ *    exited by itself (on the `server/discover` probe, or during `initialize`). Observed on the
+ *    transport (`WinterStdioTransport.exitedOnItsOwn`), never inferred from message text.
+ * A probe that went unanswered is `timeout` and a probe answered with an HTTP error keeps
+ * `handshake_failed` plus its `httpStatus`, as before.
+ */
+export type McpConnectErrorCode = "timeout" | "spawn_failed" | "handshake_failed" | "version_mismatch" | "transport_closed" | "needs_auth" | "unknown";
 export declare class McpConnectError extends Error {
     readonly code: McpConnectErrorCode;
     /**

package/dist/mcp/test-fixtures.d.ts

@@ -59,6 +59,8 @@ export declare function stdioFixtureCommand(): {
 export declare function pingFixtureCommand(opts?: {
     label?: string;
     delayMs?: number;
+    onProbe?: "answer" | "silent" | "exit";
+    spawnLog?: string;
 }): {
     command: string;
     args: string[];

package/dist/mcp/transports/stdio.d.ts

@@ -20,11 +20,30 @@ export declare class WinterStdioTransport implements Transport {
     private child;
     private readonly readBuffer;
     private stderrTailBuffer;
+    private exitedOnItsOwnFlag;
     onclose?: () => void;
     onerror?: (error: Error) => void;
     onmessage?: (message: JSONRPCMessage) => void;
     constructor(opts: WinterStdioTransportOptions);
     get pid(): number | null;
+    /**
+     * WS-24: the running child's stderr stream (`null` before `start()` and after exit) -- the shape of
+     * the SDK's own `StdioClientTransport.stderr`. Declared for one reason: the v2 client decides how to
+     * read a `server/discover` probe by DUCK TYPING (`"stderr" in transport && "pid" in transport` ->
+     * "stdio"), and only as stdio does an unanswered probe settle the LEGACY era on the same pipe (a
+     * server that ignores unknown methods keeps its one process); read as "http", the silence is an outage
+     * and `connectMcpServer`'s legacy retry has to respawn the server. `client.test.ts` pins the single
+     * spawn, so a future client that stops recognising this transport fails there, not silently. Nothing
+     * reads from the stream through this getter: the tail below stays the one reader.
+     */
+    get stderr(): NodeJS.ReadableStream | null;
+    /**
+     * WS-24: the server exited BY ITSELF -- its process closed while this transport still held it, never
+     * through `close()` (which lets go of the child before killing it). This is how `connectMcpServer`
+     * tells a server that died under the attempt (`transport_closed`: e.g. one that exits on the
+     * `server/discover` probe) from one the client tore down after a failed attempt of its own.
+     */
+    get exitedOnItsOwn(): boolean;
     start(): Promise<void>;
     get stderrTail(): string;
     private withStderrTail;

package/dist/mcp-client.d.ts

@@ -0,0 +1,28 @@
+import type { McpServerConfigForProcessTransport } from "@yanlinglabs/winter-agent-sdk";
+import { type ConnectedMcpClient } from "./mcp/client.js";
+import type { ElicitationAsker } from "./mcp/elicitation.js";
+export { McpConnectError, resolveVersionNegotiation, type ConnectedMcpClient, type McpConnectErrorCode, type McpToolInfo, type McpToolAnnotationsInfo, type McpResourceInfo, type McpResourceContent, type McpToolCallResult, } from "./mcp/client.js";
+export { createElicitationAsker, type ElicitationAction, type ElicitationAsker, type ElicitationRequestPayload, type ElicitationResultPayload, type ElicitationSender, } from "./mcp/elicitation.js";
+/**
+ * What a HOST connects with -- deliberately narrower than the runtime's own options: no in-process
+ * (`type: "sdk"`) server (a host that has the server object in hand does not need a protocol client to
+ * reach it), no redirect refusal (the runtime's web search backend's concern) and no list-changed hook
+ * (the runtime's lifecycle owns re-registration). Everything it references is exported from here or from
+ * `@yanlinglabs/winter-agent-sdk`, so this subpath's declarations reach into nothing private.
+ */
+export interface ConnectMcpServerOptions {
+    /** The server's name: prefixes its diagnostics and is `ConnectedMcpClient.serverName`. */
+    name: string;
+    /** A stdio, Streamable HTTP or SSE server config (with its optional `versionNegotiation`). */
+    config: Exclude<McpServerConfigForProcessTransport, {
+        type: "sdk";
+    }>;
+    /** The connection attempt's whole budget, in ms (never a tool call's timeout). */
+    connectTimeoutMs: number;
+    /** Answers a server's elicitation; `createElicitationAsker(undefined)` declines every one deterministically. */
+    elicitationAsk: ElicitationAsker;
+    /** REQUIRED for a stdio server: the directory it starts in (never the host process's cwd by default). */
+    cwd?: string;
+}
+/** Connect ONE MCP server and return its live client. Rejects with a typed `McpConnectError` (see its `code`). */
+export declare function connectMcpServer(opts: ConnectMcpServerOptions): Promise<ConnectedMcpClient>;

package/dist/mcp-client.js

@@ -0,0 +1,23 @@
+import {
+  createElicitationAsker2,
+  McpConnectError2,
+  resolveVersionNegotiation2,
+  connectMcpServer2
+} from "./index-8jgwp1px.js";
+
+// src/mcp-client.ts
+function connectMcpServer(opts) {
+  return connectMcpServer2({
+    name: opts.name,
+    config: opts.config,
+    connectTimeoutMs: opts.connectTimeoutMs,
+    elicitationAsk: opts.elicitationAsk,
+    ...opts.cwd !== undefined ? { cwd: opts.cwd } : {}
+  });
+}
+export {
+  McpConnectError2 as McpConnectError,
+  connectMcpServer,
+  createElicitationAsker2 as createElicitationAsker,
+  resolveVersionNegotiation2 as resolveVersionNegotiation
+};

package/dist/permissions/paths.d.ts

@@ -18,6 +18,11 @@ export interface SymlinkBothEndsResult {
 }
 export declare function resolveRealTarget(path: string): string;
 export declare function resolveSymlinkTargetChain(path: string): string | undefined;
+export interface SymlinkEnds {
+    target: string;
+    chainTarget: string | undefined;
+}
+export declare function resolveSymlinkEnds(path: string): SymlinkEnds;
 export declare function checkSymlinkBothEnds(path: string, matcher: (candidatePath: string) => boolean): SymlinkBothEndsResult;
 export declare function matchFileRuleAtBothEnds(pattern: string, opts: MatchFileRuleOptions): boolean;
 export interface FileRuleEntry {

package/dist/process-groups.d.ts

@@ -0,0 +1,22 @@
+/** Which spawn site a group came from -- for diagnostics only; the host treats every group alike. */
+export type ProcessGroupKind = "command" | "mcp_stdio" | "hook" | "workflow";
+export interface ProcessGroupChange {
+    op: "add" | "remove";
+    pgid: number;
+    kind: ProcessGroupKind;
+}
+/**
+ * Record `pgid` (the pid of a child spawned `detached: true`, i.e. its group leader) as live. Returns
+ * the release, which is idempotent -- a spawn site may reach its "the leader is gone" point by more
+ * than one path (`close` after `error`, an explicit `close()` racing the exit event).
+ */
+export declare function trackProcessGroup(pgid: number, kind: ProcessGroupKind): () => void;
+/** Every group currently recorded as live, oldest first. */
+export declare function liveProcessGroups(): ReadonlyArray<{
+    pgid: number;
+    kind: ProcessGroupKind;
+}>;
+/** Observe every add/remove from now on. Returns the unsubscribe. */
+export declare function onProcessGroupChange(listener: (change: ProcessGroupChange) => void): () => void;
+/** Test seam: forget everything (a test that spawns and kills in one realm must not see another test's groups). */
+export declare function resetProcessGroupsForTest(): void;

package/dist/provider/classifier/model-classifier.d.ts

@@ -23,6 +23,18 @@ export interface ModelClassifierOptions {
     maxContextChars?: number;
     /** P7a fix wave (item 5, M-1): the running brand's instructions file, so the classifier prompt labels the operator's own file correctly. */
     instructionsFile?: string;
+    /**
+     * WS-24 (M-1 fix round): whether this row's descriptor lists `tool_choice.tool` in its
+     * `unsupportedParameters` -- the SAME evidence `resolveToolChoice` (`adapters/anthropic/
+     * messages.ts`) gates its forced-choice-to-`auto` downgrade on (today: the anthropic/console Opus
+     * 5.5 and Fable 5.1 rows). ONLY on such a row does a text reply get the text-fallback path
+     * (`collapseTextFallback`): the request's own forced `tool_choice` is a documented lie for it, so a
+     * text reply is the expected shape of an honest answer, not a misbehaving model. Everywhere else, a
+     * text reply IS a misbehaving model (a real forced choice reached it and it ignored the tool
+     * anyway) and stays `no_tool_call` -- never given a chance to recover, which would otherwise let
+     * ANY model's ordinary refusal-to-call-the-tool quietly become a verdict. Defaults to `false`.
+     */
+    forcedToolChoiceUnsupported?: boolean;
     /**
      * Test seam: observes what was actually sent and what came back, WITHOUT the classifier logging
      * anything itself. Nothing in this file writes to a log — a permission review's request contains

package/dist/store/dialect.d.ts

@@ -478,7 +478,7 @@ export declare class TranscriptWriter implements SessionPersistence {
     private dialectRecord;
     static readBack(store: SessionStore, key: SessionKey): Promise<SessionStoreEntry[]>;
 }
-export declare const RUNTIME_ENGINE_VERSION = "0.0.27";
+export declare const RUNTIME_ENGINE_VERSION = "0.0.28";
 export interface ResolvedEngineSession {
     config: RuntimeConfig;
     store: SessionPersistence | undefined;

package/dist/store/provider-state.d.ts

@@ -21,7 +21,20 @@ export declare const PROVIDER_STATE_SUBPATH: "provider-state";
  * they cannot drift from what the deletion transaction actually removes.
  */
 export { PROVIDER_STATE_FILE_SUFFIX };
-export type ProviderStateKind = "origin" | "native-state" | "summary" | "handoff" | "reasoning-blocks" | "effort" | "tool-epoch" | "tool-changes" | "decoration";
+export type ProviderStateKind = "origin" | "native-state" | "summary" | "handoff" | "reasoning-blocks" | "effort" | "tool-epoch" | "tool-changes" | "decoration" | "feature-rejected";
+/**
+ * WS-24: the request features an API can refuse once and the session then stops sending, on that
+ * provider+model: the per-message effort beta, a mid-conversation tool change, OpenAI's client
+ * `tool_search`, and `tool_choice: allowed_tools`.
+ */
+export declare const REJECTABLE_FEATURES: readonly ["per-message-effort", "tool-changes", "client-tool-search", "allowed-tools"];
+export type RejectableFeature = (typeof REJECTABLE_FEATURES)[number];
+/** WS-24: every `feature-rejected` record, as `{provider, model, feature}` -- anchor presence is deliberately not consulted (see the kind's note above). */
+export declare function rejectedFeaturesFrom(records: readonly ProviderStateRecord[]): Array<{
+    provider: string;
+    model: string;
+    feature: RejectableFeature;
+}>;
 /**
  * One sidecar record. The envelope (`type`/`uuid`/`timestamp`) plus R6-7's own payload fields.
  *