@yanlinglabs/winter-agent-runtime 0.0.27

package/dist/index.js

@@ -0,0 +1,353 @@
+import {
+  createRpcBridge2,
+  registerTool2,
+  onCompaction2,
+  WinterPathsError2,
+  sessionTempDir2,
+  ensureTasksDir2,
+  resolveProjectDirName2,
+  DEFAULT_CONTEXT_WINDOW_TOKENS2,
+  createContextAccountant2,
+  runEngine2,
+  recordedProviderSystems2,
+  resetRecordedProviderSystems2,
+  echoProvider2,
+  scriptedProvider2,
+  stubExecutor2,
+  P5_FIXTURE_SKILL_NAME2,
+  P5_WORKFLOW_SCRIPT2,
+  isTestProviderName2,
+  testProviderByName2,
+  SUBAGENT_CHILD_PROBE_TEXT2,
+  MCP_SDK_TEST_SERVER_NAME2,
+  MCP_SDK_TEST_TOOL_NAME2,
+  BGTASK_TEST_TOOL_NAME2,
+  registerBgTaskTestTool2,
+  ResumeTargetError2,
+  ResumeTruncationError2,
+  findContinueTarget2,
+  findResumeTarget2,
+  toDialectEntries2,
+  truncateAt2,
+  rebuildProviderMessages2,
+  userEntry2,
+  winterMessageIdFor2,
+  assistantEntry2,
+  CLAUDE_COMPACT_SUMMARY_PREAMBLE2,
+  claudeCompactBoundaryEntry2,
+  claudeCompactSummaryEntry2,
+  TranscriptWriterError2,
+  TranscriptWriter2,
+  RUNTIME_ENGINE_VERSION2,
+  resolveEngineSession2,
+  resolveProductionWinterHome2,
+  providerCredentialRef2,
+  storeProviderCredential2,
+  deleteProviderCredential2,
+  validateProviderCredential2,
+  CLASSIFIER_TOOL_NAME2,
+  CLASSIFIER_VERDICT_SCHEMA2,
+  CLASSIFIER_NO_VERDICT_REASONS2,
+  DEFAULT_MAX_CONTEXT_CHARS2,
+  CLASSIFIER_SYSTEM_PROMPT2,
+  DEFAULT_CLASSIFIER_TIMEOUT_MS2,
+  createModelClassifier2,
+  selectClassifierRoute2
+} from "./index-9qgkpv56.js";
+import"./index-bef62z3r.js";
+import {
+  createInMemoryChannel2
+} from "./index-97t2rmtf.js";
+
+// src/runtime.ts
+async function runWinterRuntime(opts) {
+  const config = {
+    sessionId: opts.sessionId,
+    cwd: opts.cwd,
+    model: opts.model,
+    ...opts.permissionMode !== undefined ? { permissionMode: opts.permissionMode } : {},
+    ...opts.maxTurns !== undefined ? { maxTurns: opts.maxTurns } : {}
+  };
+  await runEngine2({
+    config,
+    input: opts.input,
+    output: opts.output,
+    provider: opts.provider,
+    tools: opts.tools ?? stubExecutor2,
+    ...opts.store !== undefined ? { store: opts.store } : {}
+  });
+}
+// src/provider/scenario-fake.ts
+import { serve } from "bun";
+var SCENARIO_MODELS = {
+  anthropic: "anthropic/claude-sonnet-5",
+  openaiResponses: "openai/gpt-4.1",
+  openaiChat: "deepseek/deepseek-v4-pro",
+  gemini: "google/gemini-2.5-flash"
+};
+var SCENARIO_TOOL_CALLING_NONE = "anthropic/claude-sonnet-4.5";
+var SCENARIO_CHILD_MODEL = "anthropic/claude-haiku-4-5-20251001";
+var SCENARIO_DELEGATE_MARKER = "winter-t10-delegate";
+var SCENARIO_CHILD_AGENT = "prober";
+var SCENARIO_TOOL_NAME = "Glob";
+var SCENARIO_TOOL_INPUT = { pattern: "*.winter-t10-no-such-file" };
+var SCENARIO_FIRST_TEXT = "checking the tree";
+var SCENARIO_FINAL_TEXT = "the provider scenario is done";
+var CREDENTIAL_HEADERS = new Set(["authorization", "x-api-key", "api-key", "x-goog-api-key", "proxy-authorization", "x-amz-security-token"]);
+function redactHeaderValue(name, value) {
+  if (!CREDENTIAL_HEADERS.has(name.toLowerCase()))
+    return value;
+  const space = value.indexOf(" ");
+  return space > 0 ? `${value.slice(0, space)} ***` : "***";
+}
+function sse(frames, eventNames) {
+  const body = frames.map((payload, i) => {
+    const event = eventNames?.[i];
+    return `${event !== undefined ? `event: ${event}
+` : ""}data: ${JSON.stringify(payload)}
+
+`;
+  }).join("");
+  return new Response(body, { headers: { "content-type": "text/event-stream", "cache-control": "no-cache" } });
+}
+var SCENARIO_CHILD_WIRE_ID = "claude-haiku-4-5-20251001";
+function anthropicFrames(withTool, delegating = false) {
+  const frames = [{ type: "message_start", message: { id: "msg_p6", type: "message", role: "assistant", model: "claude-sonnet-5", content: [], usage: { input_tokens: 7, output_tokens: 3 } } }];
+  const events = ["message_start"];
+  const push = (event, payload) => {
+    events.push(event);
+    frames.push(payload);
+  };
+  if (withTool) {
+    const toolName = delegating ? "Agent" : SCENARIO_TOOL_NAME;
+    const toolInput = delegating ? { subagent_type: SCENARIO_CHILD_AGENT, description: "r6-17 probe", prompt: "answer briefly" } : SCENARIO_TOOL_INPUT;
+    push("content_block_start", { type: "content_block_start", index: 0, content_block: { type: "text", text: "" } });
+    push("content_block_delta", { type: "content_block_delta", index: 0, delta: { type: "text_delta", text: SCENARIO_FIRST_TEXT } });
+    push("content_block_stop", { type: "content_block_stop", index: 0 });
+    push("content_block_start", { type: "content_block_start", index: 1, content_block: { type: "tool_use", id: "toolu_p6", name: toolName, input: {} } });
+    push("content_block_delta", { type: "content_block_delta", index: 1, delta: { type: "input_json_delta", partial_json: JSON.stringify(toolInput) } });
+    push("content_block_stop", { type: "content_block_stop", index: 1 });
+    push("message_delta", { type: "message_delta", delta: { stop_reason: "tool_use", stop_sequence: null }, usage: { output_tokens: 3 } });
+  } else {
+    push("content_block_start", { type: "content_block_start", index: 0, content_block: { type: "text", text: "" } });
+    push("content_block_delta", { type: "content_block_delta", index: 0, delta: { type: "text_delta", text: SCENARIO_FINAL_TEXT } });
+    push("content_block_stop", { type: "content_block_stop", index: 0 });
+    push("message_delta", { type: "message_delta", delta: { stop_reason: "end_turn", stop_sequence: null }, usage: { output_tokens: 4 } });
+  }
+  push("message_stop", { type: "message_stop" });
+  return { frames, events };
+}
+function responsesFrames(withTool) {
+  const out = [{ type: "response.created", response: { id: "resp_p6", model: "gpt-4.1", output: [] } }];
+  if (withTool) {
+    out.push({ type: "response.output_item.added", output_index: 0, item: { id: "msg_p6", type: "message", role: "assistant", content: [] } }, { type: "response.output_text.delta", item_id: "msg_p6", output_index: 0, content_index: 0, delta: SCENARIO_FIRST_TEXT }, { type: "response.output_item.done", output_index: 0, item: { id: "msg_p6", type: "message", role: "assistant", content: [{ type: "output_text", text: SCENARIO_FIRST_TEXT }] } }, { type: "response.output_item.added", output_index: 1, item: { id: "fc_p6", type: "function_call", call_id: "call_p6", name: SCENARIO_TOOL_NAME, arguments: "" } }, { type: "response.function_call_arguments.delta", item_id: "fc_p6", output_index: 1, delta: JSON.stringify(SCENARIO_TOOL_INPUT) }, { type: "response.output_item.done", output_index: 1, item: { id: "fc_p6", type: "function_call", call_id: "call_p6", name: SCENARIO_TOOL_NAME, arguments: JSON.stringify(SCENARIO_TOOL_INPUT) } });
+  } else {
+    out.push({ type: "response.output_item.added", output_index: 0, item: { id: "msg_p6b", type: "message", role: "assistant", content: [] } }, { type: "response.output_text.delta", item_id: "msg_p6b", output_index: 0, content_index: 0, delta: SCENARIO_FINAL_TEXT }, { type: "response.output_item.done", output_index: 0, item: { id: "msg_p6b", type: "message", role: "assistant", content: [{ type: "output_text", text: SCENARIO_FINAL_TEXT }] } });
+  }
+  out.push({ type: "response.completed", response: { id: "resp_p6", model: "gpt-4.1", status: "completed", usage: { input_tokens: 7, output_tokens: 4 }, output: [] } });
+  return out;
+}
+function chatFrames(withTool) {
+  const base = { id: "chatcmpl-p6", object: "chat.completion.chunk", model: "deepseek-v4-pro" };
+  const out = [{ ...base, choices: [{ index: 0, delta: { role: "assistant", content: "" } }] }];
+  if (withTool) {
+    out.push({ ...base, choices: [{ index: 0, delta: { content: SCENARIO_FIRST_TEXT } }] }, { ...base, choices: [{ index: 0, delta: { tool_calls: [{ index: 0, id: "call_p6", type: "function", function: { name: SCENARIO_TOOL_NAME, arguments: "" } }] } }] }, { ...base, choices: [{ index: 0, delta: { tool_calls: [{ index: 0, function: { arguments: JSON.stringify(SCENARIO_TOOL_INPUT) } }] } }] }, { ...base, choices: [{ index: 0, delta: {}, finish_reason: "tool_calls" }] });
+  } else {
+    out.push({ ...base, choices: [{ index: 0, delta: { content: SCENARIO_FINAL_TEXT } }] }, { ...base, choices: [{ index: 0, delta: {}, finish_reason: "stop" }] });
+  }
+  out.push({ ...base, choices: [], usage: { prompt_tokens: 7, completion_tokens: 4, total_tokens: 11 } });
+  return out;
+}
+function geminiFrames(withTool) {
+  const parts = withTool ? [{ text: SCENARIO_FIRST_TEXT }, { functionCall: { name: SCENARIO_TOOL_NAME, args: SCENARIO_TOOL_INPUT } }] : [{ text: SCENARIO_FINAL_TEXT }];
+  return [
+    {
+      candidates: [{ content: { role: "model", parts }, finishReason: "STOP", index: 0 }],
+      usageMetadata: { promptTokenCount: 7, candidatesTokenCount: 4, totalTokenCount: 11 },
+      modelVersion: "gemini-2.5-flash"
+    }
+  ];
+}
+function carriesToolResult(body) {
+  return body.includes("tool_result") || body.includes("function_call_output") || body.includes("functionResponse") || body.includes('"role":"tool"');
+}
+async function startScenarioFake(options = {}) {
+  const requests = [];
+  let lastWasScriptedRefusal = false;
+  const server = serve({
+    hostname: "127.0.0.1",
+    port: 0,
+    async fetch(req) {
+      const url = new URL(req.url);
+      const headers = {};
+      req.headers.forEach((value, name) => {
+        headers[name.toLowerCase()] = redactHeaderValue(name, value);
+      });
+      const body = req.method === "GET" || req.method === "HEAD" ? "" : await req.text();
+      requests.push({ method: req.method, path: url.pathname, search: url.search, headers, body });
+      if (options.failModel !== undefined && (body.includes(`"model":"${options.failModel.wireModel}"`) || url.pathname.includes(`/models/${options.failModel.wireModel}:`))) {
+        return new Response(JSON.stringify({ error: { message: "winter scenario fake: scripted failure for one model", type: "server_error" } }), {
+          status: options.failModel.status,
+          headers: { "content-type": "application/json", ...options.failModel.retryAfter !== undefined ? { "retry-after": options.failModel.retryAfter } : {} }
+        });
+      }
+      if (options.alwaysFailStatus !== undefined) {
+        return new Response(JSON.stringify({ error: { message: "winter scenario fake: scripted provider failure", type: "server_error" } }), {
+          status: options.alwaysFailStatus,
+          headers: { "content-type": "application/json", "retry-after": "0" }
+        });
+      }
+      if (options.firstAttemptStatus !== undefined && !lastWasScriptedRefusal && !carriesToolResult(body)) {
+        lastWasScriptedRefusal = true;
+        return new Response(JSON.stringify({ error: { message: "winter scenario fake: scripted first-attempt refusal", type: "rate_limit_error" } }), {
+          status: options.firstAttemptStatus,
+          headers: {
+            "content-type": "application/json",
+            "retry-after": "0",
+            "anthropic-ratelimit-requests-limit": "100",
+            "anthropic-ratelimit-requests-remaining": "0",
+            "x-ratelimit-limit-requests": "100",
+            "x-ratelimit-remaining-requests": "0"
+          }
+        });
+      }
+      lastWasScriptedRefusal = false;
+      const withTool = !carriesToolResult(body);
+      const isChild = body.includes(`"model":"${SCENARIO_CHILD_WIRE_ID}"`);
+      const delegating = withTool && !isChild && body.includes(SCENARIO_DELEGATE_MARKER);
+      if (url.pathname === "/v1/messages") {
+        const { frames, events } = anthropicFrames(withTool && !isChild, delegating);
+        if (options.dropAfterFirstEvent === true) {
+          const first = `event: ${events[0]}
+data: ${JSON.stringify(frames[0])}
+
+`;
+          const torn = new ReadableStream({
+            start(controller) {
+              controller.enqueue(new TextEncoder().encode(first));
+              setTimeout(() => controller.error(new Error("winter scenario fake: connection dropped after the first event")), 5);
+            }
+          });
+          return new Response(torn, { headers: { "content-type": "text/event-stream", "cache-control": "no-cache" } });
+        }
+        return sse(frames, events);
+      }
+      if (url.pathname === "/responses")
+        return sse(responsesFrames(withTool));
+      if (url.pathname === "/chat/completions")
+        return sse(chatFrames(withTool));
+      if (url.pathname.endsWith(":streamGenerateContent"))
+        return sse(geminiFrames(withTool));
+      return new Response(JSON.stringify({ error: { message: `winter scenario fake: no route for ${req.method} ${url.pathname}` } }), {
+        status: 404,
+        headers: { "content-type": "application/json" }
+      });
+    }
+  });
+  return {
+    url: `http://127.0.0.1:${server.port}`,
+    requests,
+    async close() {
+      await server.stop(true);
+    }
+  };
+}
+
+// src/index.ts
+import { resolveWinterHome } from "@yanlinglabs/winter-agent-sdk";
+import { transcriptProjectKey } from "@yanlinglabs/winter-agent-sdk";
+import { compatibilityKeys } from "@yanlinglabs/winter-agent-sdk";
+import {
+  WinterCompatibilitySessionStore,
+  WinterStoreError,
+  WinterStoreLeaseError,
+  DIALECT_RECORD_ENTRY_TYPE
+} from "@yanlinglabs/winter-agent-sdk";
+import {
+  PROTOCOL_VERSION,
+  encodeFrame,
+  decodeFrame,
+  splitFrames,
+  ProtocolError
+} from "@yanlinglabs/winter-agent-sdk";
+export {
+  BGTASK_TEST_TOOL_NAME2 as BGTASK_TEST_TOOL_NAME,
+  CLASSIFIER_NO_VERDICT_REASONS2 as CLASSIFIER_NO_VERDICT_REASONS,
+  CLASSIFIER_SYSTEM_PROMPT2 as CLASSIFIER_SYSTEM_PROMPT,
+  CLASSIFIER_TOOL_NAME2 as CLASSIFIER_TOOL_NAME,
+  CLASSIFIER_VERDICT_SCHEMA2 as CLASSIFIER_VERDICT_SCHEMA,
+  CLAUDE_COMPACT_SUMMARY_PREAMBLE2 as CLAUDE_COMPACT_SUMMARY_PREAMBLE,
+  DEFAULT_CLASSIFIER_TIMEOUT_MS2 as DEFAULT_CLASSIFIER_TIMEOUT_MS,
+  DEFAULT_CONTEXT_WINDOW_TOKENS2 as DEFAULT_CONTEXT_WINDOW_TOKENS,
+  DEFAULT_MAX_CONTEXT_CHARS2 as DEFAULT_MAX_CONTEXT_CHARS,
+  DIALECT_RECORD_ENTRY_TYPE,
+  MCP_SDK_TEST_SERVER_NAME2 as MCP_SDK_TEST_SERVER_NAME,
+  MCP_SDK_TEST_TOOL_NAME2 as MCP_SDK_TEST_TOOL_NAME,
+  P5_FIXTURE_SKILL_NAME2 as P5_FIXTURE_SKILL_NAME,
+  P5_WORKFLOW_SCRIPT2 as P5_WORKFLOW_SCRIPT,
+  PROTOCOL_VERSION,
+  ProtocolError,
+  RUNTIME_ENGINE_VERSION2 as RUNTIME_ENGINE_VERSION,
+  ResumeTargetError2 as ResumeTargetError,
+  ResumeTruncationError2 as ResumeTruncationError,
+  SCENARIO_CHILD_AGENT,
+  SCENARIO_CHILD_MODEL,
+  SCENARIO_CHILD_WIRE_ID,
+  SCENARIO_DELEGATE_MARKER,
+  SCENARIO_FINAL_TEXT,
+  SCENARIO_FIRST_TEXT,
+  SCENARIO_MODELS,
+  SCENARIO_TOOL_CALLING_NONE,
+  SCENARIO_TOOL_INPUT,
+  SCENARIO_TOOL_NAME,
+  SUBAGENT_CHILD_PROBE_TEXT2 as SUBAGENT_CHILD_PROBE_TEXT,
+  TranscriptWriter2 as TranscriptWriter,
+  TranscriptWriterError2 as TranscriptWriterError,
+  WinterCompatibilitySessionStore,
+  WinterPathsError2 as WinterPathsError,
+  WinterStoreError,
+  WinterStoreLeaseError,
+  assistantEntry2 as assistantEntry,
+  claudeCompactBoundaryEntry2 as claudeCompactBoundaryEntry,
+  claudeCompactSummaryEntry2 as claudeCompactSummaryEntry,
+  compatibilityKeys,
+  createContextAccountant2 as createContextAccountant,
+  createInMemoryChannel2 as createInMemoryChannel,
+  createModelClassifier2 as createModelClassifier,
+  createRpcBridge2 as createRpcBridge,
+  decodeFrame,
+  deleteProviderCredential2 as deleteProviderCredential,
+  echoProvider2 as echoProvider,
+  encodeFrame,
+  ensureTasksDir2 as ensureTasksDir,
+  findContinueTarget2 as findContinueTarget,
+  findResumeTarget2 as findResumeTarget,
+  isTestProviderName2 as isTestProviderName,
+  onCompaction2 as onCompaction,
+  providerCredentialRef2 as providerCredentialRef,
+  rebuildProviderMessages2 as rebuildProviderMessages,
+  recordedProviderSystems2 as recordedProviderSystems,
+  registerBgTaskTestTool2 as registerBgTaskTestTool,
+  registerTool2 as registerTool,
+  resetRecordedProviderSystems2 as resetRecordedProviderSystems,
+  resolveEngineSession2 as resolveEngineSession,
+  resolveProductionWinterHome2 as resolveProductionWinterHome,
+  resolveProjectDirName2 as resolveProjectDirName,
+  resolveWinterHome,
+  runEngine2 as runEngine,
+  runWinterRuntime,
+  scriptedProvider2 as scriptedProvider,
+  selectClassifierRoute2 as selectClassifierRoute,
+  sessionTempDir2 as sessionTempDir,
+  splitFrames,
+  startScenarioFake,
+  storeProviderCredential2 as storeProviderCredential,
+  stubExecutor2 as stubExecutor,
+  testProviderByName2 as testProviderByName,
+  toDialectEntries2 as toDialectEntries,
+  transcriptProjectKey,
+  truncateAt2 as truncateAt,
+  userEntry2 as userEntry,
+  validateProviderCredential2 as validateProviderCredential,
+  winterMessageIdFor2 as winterMessageIdFor
+};

package/dist/main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mcp/client.d.ts

@@ -0,0 +1,105 @@
+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";
+export declare class McpConnectError extends Error {
+    readonly code: McpConnectErrorCode;
+    /**
+     * The HTTP status an http/sse transport failed the handshake with, when there was one.
+     *
+     * Carried because the classification below is LOSSY on purpose (the state model needs only
+     * failed-vs-needsAuth) and the transport's message holds the response BODY, not the status -- so a
+     * direct caller that must tell a 429 from a 500 (the web search backend's anonymous tier answers a
+     * rate limit at `initialize`) had nothing to read. `declare` + conditional assignment so an error
+     * with no status has no own `httpStatus` key at all.
+     */
+    readonly httpStatus?: number;
+    constructor(code: McpConnectErrorCode, message: string, httpStatus?: number);
+}
+export interface McpToolAnnotationsInfo {
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    openWorldHint?: boolean;
+    title?: string;
+    idempotentHint?: boolean;
+}
+export interface McpToolInfo {
+    name: string;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+    annotations?: McpToolAnnotationsInfo;
+    _meta?: Record<string, unknown>;
+}
+export interface McpResourceInfo {
+    uri: string;
+    name?: string;
+    description?: string;
+    mimeType?: string;
+}
+export interface McpResourceContent {
+    uri: string;
+    mimeType?: string;
+    text?: string;
+    blobBase64?: string;
+}
+export interface McpToolCallResult {
+    content: unknown[];
+    isError?: boolean;
+}
+export interface ConnectedMcpClient {
+    readonly serverName: string;
+    /**
+     * The protocol revision this connection settled on: `2025-11-25` (or an older 2025-era revision a
+     * server counter-offered) on the legacy `initialize` handshake, `2026-07-28` when an `auto`/pinned
+     * `server/discover` probe selected the modern era. Read ONCE at connect -- a connection's era never
+     * changes after it is established (the v2 client resets it only on a fresh connect). Optional on
+     * the type so a hand-built fake (test-fixtures.ts's `createFakeConnectedMcpClient`) need not invent
+     * one.
+     */
+    readonly protocolVersion?: string;
+    listTools(): Promise<McpToolInfo[]>;
+    listResources(): Promise<McpResourceInfo[]>;
+    readResource(uri: string, opts?: {
+        timeoutMs?: number;
+    }): Promise<McpResourceContent[]>;
+    callTool(toolName: string, args: Record<string, unknown>, opts?: {
+        timeoutMs?: number;
+    }): Promise<McpToolCallResult>;
+    close(): Promise<void>;
+}
+export interface ConnectMcpServerOptions {
+    name: string;
+    config: McpServerConfigForProcessTransport;
+    connectTimeoutMs: number;
+    elicitationAsk: ElicitationAsker;
+    inProcessServer?: InProcessMcpServer;
+    /** `type: "http"` only: fail rather than follow a redirect -- see `buildHttpTransport`. For a direct caller whose headers carry a credential. */
+    refuseHttpRedirects?: boolean;
+    /**
+     * WS-23: the session cwd a STDIO server is spawned in. Optional on this options bag only because
+     * the other three transports have no process; a stdio config connected WITHOUT one is refused
+     * typed (`spawn_failed`) rather than spawned in the host process's cwd -- which, for an embedded
+     * session (one Worker per session inside a daemon), is the daemon's, not the session's.
+     */
+    cwd?: string;
+    /**
+     * Called when the connected server says its TOOL list changed (`notifications/tools/list_changed`
+     * on a legacy connection; the same notification over the auto-opened `subscriptions/listen` stream
+     * on a 2026-07-28 one). A SIGNAL, never a list: the v2 client is configured with
+     * `autoRefresh: false`, so this file never fetches or hands over a tool list of its own -- the
+     * caller (mcp/lifecycle.ts) re-queries through `listTools()` on its own staleness-guarded refresh
+     * path, which stays the ONE place a server's tools are (re-)registered. Only wired when the server
+     * advertises `tools.listChanged` (the v2 client skips the handler otherwise).
+     *
+     * No prompts/resources counterpart, deliberately: the runtime keeps no view of either to refresh.
+     * `listResources()`/`readResource()` below are live requests on every call (the bridge tools read
+     * through them), and Winter does not surface MCP prompts at all -- a handler for those two
+     * notifications would have nothing to update.
+     */
+    onToolListChanged?: () => void;
+}
+export declare function resolveVersionNegotiation(config: McpServerConfigForProcessTransport): McpVersionNegotiation;
+export declare const AUTO_PROBE_TIMEOUT_CAP_MS = 5000;
+export declare const MANUAL_LIST_MAX_PAGES = 64;
+export declare function connectMcpServer(opts: ConnectMcpServerOptions): Promise<ConnectedMcpClient>;

package/dist/mcp/control-seam.d.ts

@@ -0,0 +1,25 @@
+import type { McpServerConfigForProcessTransport } from "@yanlinglabs/winter-agent-sdk";
+export interface McpSetServersResult {
+    added: string[];
+    removed: string[];
+    errors: Record<string, string>;
+}
+export interface McpControlSeam {
+    reconnect(serverName: string): Promise<void>;
+    toggle(serverName: string, enabled: boolean): Promise<void>;
+    setServers(servers: Record<string, McpServerConfigForProcessTransport>): Promise<McpSetServersResult>;
+}
+export interface FakeMcpControlSeamCall {
+    reconnect: string[];
+    toggle: Array<{
+        serverName: string;
+        enabled: boolean;
+    }>;
+    setServers: Array<Record<string, McpServerConfigForProcessTransport>>;
+}
+export interface FakeMcpControlSeam extends McpControlSeam {
+    readonly calls: FakeMcpControlSeamCall;
+    setServersResult: McpSetServersResult;
+    failNextWith: Partial<Record<keyof McpControlSeam, Error>>;
+}
+export declare function createFakeMcpControlSeam(): FakeMcpControlSeam;

package/dist/mcp/control.d.ts

@@ -0,0 +1,5 @@
+import type { McpControlSeam } from "./control-seam.js";
+import type { McpLifecycleInternals } from "./lifecycle.js";
+export declare function createMcpControlSeam(internals: McpLifecycleInternals, opts?: {
+    reservedServerName?: string;
+}): McpControlSeam;

package/dist/mcp/elicitation.d.ts

@@ -0,0 +1,35 @@
+import type { Client } from "@modelcontextprotocol/client";
+export interface ElicitationRequestPayload {
+    serverName: string;
+    message: string;
+    mode?: "form" | "url";
+    url?: string;
+    elicitationId?: string;
+    requestedSchema?: Record<string, unknown>;
+    title?: string;
+    displayName?: string;
+    description?: string;
+}
+export type ElicitationAction = "accept" | "decline" | "cancel";
+export interface ElicitationResultPayload {
+    action: ElicitationAction;
+    content?: Record<string, unknown>;
+}
+export declare const MCP_ELICITATION_SUBTYPE = "mcp_elicitation";
+export interface ElicitationSender {
+    request<T = unknown>(subtype: string, payload: unknown, opts?: {
+        timeoutMs?: number;
+    }): Promise<T>;
+}
+export type ElicitationAsker = (payload: ElicitationRequestPayload) => Promise<ElicitationResultPayload>;
+export declare function createElicitationAsker(sender: ElicitationSender | undefined): ElicitationAsker;
+interface RawElicitParams {
+    message: string;
+    mode?: "form" | "url" | undefined;
+    url?: string | undefined;
+    elicitationId?: string | undefined;
+    requestedSchema?: Record<string, unknown> | undefined;
+}
+export declare function buildElicitationPayload(serverName: string, params: RawElicitParams): ElicitationRequestPayload;
+export declare function installElicitationHandler(client: Client, serverName: string, ask: ElicitationAsker): void;
+export {};

package/dist/mcp/env.d.ts

@@ -0,0 +1,12 @@
+import type { DeferralActivation } from "../tools/registry.js";
+export type EnableToolSearchValue = DeferralActivation["enableToolSearch"];
+export interface McpEnvConfig {
+    enableToolSearch: EnableToolSearchValue;
+    connectionNonblocking: boolean;
+    connectTimeoutMs: number;
+    timeoutMs: number;
+    discoveryCache: boolean;
+    toolTimeoutMs?: number;
+    maxOutputTokens: number;
+}
+export declare function parseMcpEnvConfig(env: Readonly<Record<string, string | undefined>>): McpEnvConfig;