@yanlinglabs/winter-agent-runtime 0.0.27 → 0.0.29

package/dist/index.js

@@ -53,7 +53,8 @@ import {
   DEFAULT_CLASSIFIER_TIMEOUT_MS2,
   createModelClassifier2,
   selectClassifierRoute2
-} from "./index-9qgkpv56.js";
+} from "./index-jz5d90c6.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.29";
 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.
  *

package/dist/subagents/child-handle.d.ts

@@ -328,6 +328,14 @@ export interface ParentMcpState {
      * `JP($n, Y2(yr.mcp.tools.concat(pn)))`, dump byte 18016381).
      */
     visibleServerNames?: () => readonly string[];
+    /**
+     * WS-24 (fix round 3): the parent run's own `EngineOptions.mcpServerRenames` -- `{ actual: declared }`
+     * for every server in its scope that runs under a name other than the one it was declared with. A
+     * renamed server is in `visibleServerNames` above, so a descendant can call it; the descendant merges
+     * these into its own renames, so session rules and hooks written against the declared name keep
+     * governing it at every depth.
+     */
+    serverRenames?: Readonly<Record<string, string>>;
 }
 export interface ParentRuleMirror {
     allow: string[];

package/dist/testing.js

@@ -3,7 +3,8 @@ import {
   runEngine2,
   echoProvider2,
   resolveEngineSession2
-} from "./index-9qgkpv56.js";
+} from "./index-jz5d90c6.js";
+import"./index-8jgwp1px.js";
 import"./index-bef62z3r.js";
 import {
   registerDefaultChildEngineFactory,
@@ -11,7 +12,7 @@ import {
   buildProductionWiring,
   withAutoSkillPermissions,
   restoreChildRoster
-} from "./index-584yahed.js";
+} from "./index-gmxxtqpe.js";
 import {
   Queue
 } from "./index-97t2rmtf.js";

package/dist/tools/registry.d.ts

@@ -297,6 +297,12 @@ export declare function registerMcpServerTools(server: string, incomingTools: re
  * servers that run can see (engine.ts's `computeAdvertisedPartition`).
  */
 export declare function mcpServerOwningTool(canonicalName: string): string | undefined;
+/**
+ * WS-24: does a live MCP server currently hold registrations under `server`? A subagent's own
+ * object-form server must not take a name some other lifecycle in this process is registered under --
+ * see subagents/child-engine.ts's `allocateChildScopedServers`.
+ */
+export declare function mcpServerHasRegistrations(server: string): boolean;
 export declare function unregisterMcpServerTools(server: string): void;
 export interface LoadedToolSet {
     isLoaded(name: string): boolean;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const RUNTIME_VERSION = "0.0.27";
+export declare const RUNTIME_VERSION = "0.0.29";

package/dist/version.js

@@ -1,5 +1,5 @@
 // src/version.ts
-var RUNTIME_VERSION = "0.0.27";
+var RUNTIME_VERSION = "0.0.29";
 export {
   RUNTIME_VERSION
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yanlinglabs/winter-agent-runtime",
-  "version": "0.0.27",
+  "version": "0.0.29",
   "license": "MIT",
   "type": "module",
   "engines": {
@@ -45,6 +45,10 @@
     "./version": {
       "types": "./dist/version.d.ts",
       "default": "./dist/version.js"
+    },
+    "./mcp-client": {
+      "types": "./dist/mcp-client.d.ts",
+      "default": "./dist/mcp-client.js"
     }
   },
   "files": [
@@ -65,9 +69,9 @@
     "@modelcontextprotocol/client": "^2.1.0",
     "ajv": "^8.20.0",
     "ignore": "7.0.5",
-    "@yanlinglabs/winter-provider-runtime": "0.0.27",
-    "@yanlinglabs/winter-agent-sdk": "0.0.27",
-    "@yanlinglabs/winter-provider-catalog": "0.0.27"
+    "@yanlinglabs/winter-agent-sdk": "0.0.29",
+    "@yanlinglabs/winter-provider-catalog": "0.0.29",
+    "@yanlinglabs/winter-provider-runtime": "0.0.29"
   },
   "devDependencies": {
     "@modelcontextprotocol/server": "^2.1.0"