@yanlinglabs/winter-agent-runtime 0.0.27 → 0.0.29

package/dist/index-8jgwp1px.js

@@ -0,0 +1,533 @@
+// src/process-groups.ts
+var live = new Map;
+var listeners = new Set;
+function notify(change) {
+  for (const listener of listeners) {
+    try {
+      listener(change);
+    } catch {}
+  }
+}
+function trackProcessGroup(pgid, kind) {
+  if (!Number.isInteger(pgid) || pgid <= 1)
+    return () => {};
+  const registration = { kind };
+  live.set(pgid, registration);
+  notify({ op: "add", pgid, kind });
+  let released = false;
+  return () => {
+    if (released)
+      return;
+    released = true;
+    if (live.get(pgid) !== registration)
+      return;
+    live.delete(pgid);
+    notify({ op: "remove", pgid, kind });
+  };
+}
+function liveProcessGroups() {
+  return [...live.entries()].map(([pgid, { kind }]) => ({ pgid, kind }));
+}
+function onProcessGroupChange(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+// src/mcp/elicitation.ts
+var MCP_ELICITATION_SUBTYPE = "mcp_elicitation";
+var DETERMINISTIC_DECLINE = { action: "decline" };
+function isElicitationAction(value) {
+  return value === "accept" || value === "decline" || value === "cancel";
+}
+function toResultPayload(raw) {
+  if (typeof raw !== "object" || raw === null)
+    return DETERMINISTIC_DECLINE;
+  const candidate = raw;
+  if (!isElicitationAction(candidate.action))
+    return DETERMINISTIC_DECLINE;
+  if (candidate.action !== "accept")
+    return { action: candidate.action };
+  const content = typeof candidate.content === "object" && candidate.content !== null ? candidate.content : undefined;
+  return content !== undefined ? { action: "accept", content } : { action: "accept" };
+}
+function createElicitationAsker2(sender) {
+  if (!sender) {
+    return async () => DETERMINISTIC_DECLINE;
+  }
+  return async (payload) => {
+    let raw;
+    try {
+      raw = await sender.request(MCP_ELICITATION_SUBTYPE, payload);
+    } catch {
+      return DETERMINISTIC_DECLINE;
+    }
+    return toResultPayload(raw);
+  };
+}
+function buildElicitationPayload(serverName, params) {
+  return {
+    serverName,
+    message: params.message,
+    ...params.mode !== undefined ? { mode: params.mode } : {},
+    ...params.url !== undefined ? { url: params.url } : {},
+    ...params.elicitationId !== undefined ? { elicitationId: params.elicitationId } : {},
+    ...params.requestedSchema !== undefined ? { requestedSchema: params.requestedSchema } : {}
+  };
+}
+function rawElicitParamsOf(params) {
+  const p = params;
+  return {
+    message: p.message,
+    ...p.mode !== undefined ? { mode: p.mode } : {},
+    ...typeof p.url === "string" ? { url: p.url } : {},
+    ...typeof p.elicitationId === "string" ? { elicitationId: p.elicitationId } : {},
+    ...p.requestedSchema !== undefined ? { requestedSchema: p.requestedSchema } : {}
+  };
+}
+function installElicitationHandler(client, serverName, ask) {
+  client.setRequestHandler("elicitation/create", async (request) => {
+    const payload = buildElicitationPayload(serverName, rawElicitParamsOf(request.params));
+    const result = await ask(payload);
+    if (result.content === undefined)
+      return { action: result.action };
+    const content = toWireElicitContent(result.content);
+    return content !== undefined ? { action: result.action, content } : { action: DETERMINISTIC_DECLINE.action };
+  });
+}
+function toWireElicitContent(content) {
+  const out = {};
+  for (const [key, value] of Object.entries(content)) {
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+      out[key] = value;
+    else if (Array.isArray(value) && value.every((v) => typeof v === "string"))
+      out[key] = value;
+    else
+      return;
+  }
+  return out;
+}
+
+// src/mcp/client.ts
+import { Client, ProtocolError, ProtocolErrorCode, SdkError, SdkErrorCode, SdkHttpError, SseError, UnauthorizedError, UnsupportedProtocolVersionError } from "@modelcontextprotocol/client";
+
+// src/mcp/transports/stdio.ts
+import { spawn } from "node:child_process";
+import { ReadBuffer, serializeMessage } from "@modelcontextprotocol/client";
+var STDIO_BASE_ENV_NAMES = ["HOME", "LOGNAME", "PATH", "SHELL", "TERM", "USER"];
+function buildStdioEnv(cfgEnv) {
+  const env = {};
+  for (const name of STDIO_BASE_ENV_NAMES) {
+    const value = process.env[name];
+    if (value !== undefined)
+      env[name] = value;
+  }
+  return { ...env, ...cfgEnv ?? {} };
+}
+var STDERR_TAIL_MAX_CHARS = 4096;
+
+class WinterStdioTransport {
+  opts;
+  child;
+  readBuffer = new ReadBuffer;
+  stderrTailBuffer = "";
+  exitedOnItsOwnFlag = false;
+  onclose;
+  onerror;
+  onmessage;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  get pid() {
+    return this.child?.pid ?? null;
+  }
+  get stderr() {
+    return this.child?.stderr ?? null;
+  }
+  get exitedOnItsOwn() {
+    return this.exitedOnItsOwnFlag;
+  }
+  async start() {
+    if (this.child) {
+      throw new Error("WinterStdioTransport already started");
+    }
+    return new Promise((resolve, reject) => {
+      const child = spawn(this.opts.command, this.opts.args ?? [], {
+        cwd: this.opts.cwd,
+        env: buildStdioEnv(this.opts.env),
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: false,
+        detached: true
+      });
+      this.child = child;
+      const releaseGroup = child.pid !== undefined ? trackProcessGroup(child.pid, "mcp_stdio") : () => {};
+      child.on("error", (error) => {
+        releaseGroup();
+        reject(this.withStderrTail(error));
+        this.onerror?.(error);
+      });
+      child.on("spawn", () => resolve());
+      child.on("close", () => {
+        releaseGroup();
+        if (this.child === child)
+          this.exitedOnItsOwnFlag = true;
+        this.child = undefined;
+        this.onclose?.();
+      });
+      child.stdin?.on("error", (error) => this.onerror?.(error));
+      child.stdout?.on("data", (chunk) => {
+        try {
+          this.readBuffer.append(chunk);
+          this.processReadBuffer();
+        } catch (error) {
+          this.onerror?.(error);
+          this.close().catch(() => {});
+        }
+      });
+      child.stdout?.on("error", (error) => this.onerror?.(error));
+      child.stderr?.on("data", (chunk) => {
+        this.stderrTailBuffer = (this.stderrTailBuffer + chunk.toString("utf8")).slice(-STDERR_TAIL_MAX_CHARS);
+      });
+    });
+  }
+  get stderrTail() {
+    return this.stderrTailBuffer;
+  }
+  withStderrTail(error) {
+    const tail = this.stderrTailBuffer.trim();
+    if (tail === "")
+      return error;
+    return new Error(`${error.message}
+--- server stderr (last ${tail.length} chars) ---
+${tail}`, { cause: error });
+  }
+  processReadBuffer() {
+    for (;; ) {
+      let message;
+      try {
+        message = this.readBuffer.readMessage();
+      } catch (error) {
+        this.onerror?.(error);
+        return;
+      }
+      if (message === null)
+        return;
+      this.onmessage?.(message);
+    }
+  }
+  async send(message) {
+    return new Promise((resolve, reject) => {
+      if (!this.child?.stdin) {
+        reject(new Error("WinterStdioTransport: not connected"));
+        return;
+      }
+      const json = serializeMessage(message);
+      if (this.child.stdin.write(json))
+        resolve();
+      else
+        this.child.stdin.once("drain", resolve);
+    });
+  }
+  async close() {
+    const child = this.child;
+    this.child = undefined;
+    if (!child || child.pid === undefined) {
+      this.readBuffer.clear();
+      return;
+    }
+    const pid = child.pid;
+    const exited = new Promise((resolve) => {
+      child.once("close", () => resolve());
+    });
+    try {
+      child.stdin?.end();
+    } catch {}
+    try {
+      process.kill(-pid, "SIGKILL");
+    } catch {}
+    await Promise.race([exited, new Promise((resolve) => setTimeout(resolve, 2000).unref?.())]);
+    this.readBuffer.clear();
+  }
+}
+function buildStdioTransport(cfg, cwd) {
+  return new WinterStdioTransport({
+    command: cfg.command,
+    cwd,
+    ...cfg.args !== undefined ? { args: cfg.args } : {},
+    ...cfg.env !== undefined ? { env: cfg.env } : {}
+  });
+}
+
+// src/mcp/transports/http.ts
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
+function buildHttpTransport(cfg, opts = {}) {
+  const requestInit = { ...cfg.headers !== undefined ? { headers: cfg.headers } : {}, ...opts.refuseRedirects === true ? { redirect: "error" } : {} };
+  const transport = new StreamableHTTPClientTransport(new URL(cfg.url), {
+    ...Object.keys(requestInit).length > 0 ? { requestInit } : {}
+  });
+  return transport;
+}
+
+// src/mcp/transports/sse.ts
+import { SSEClientTransport } from "@modelcontextprotocol/client";
+function buildSseTransport(cfg) {
+  const transport = new SSEClientTransport(new URL(cfg.url), {
+    ...cfg.headers !== undefined ? { requestInit: { headers: cfg.headers } } : {}
+  });
+  return transport;
+}
+
+// src/mcp/transports/sdk.ts
+import { InMemoryTransport } from "@modelcontextprotocol/client";
+async function buildSdkTransport(server) {
+  const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+  await server.connect(serverTransport);
+  return clientTransport;
+}
+
+// src/mcp/client.ts
+class McpConnectError2 extends Error {
+  code;
+  constructor(code, message, httpStatus) {
+    super(message);
+    this.name = "McpConnectError";
+    this.code = code;
+    if (httpStatus !== undefined)
+      Object.assign(this, { httpStatus });
+  }
+}
+function resolveVersionNegotiation2(config) {
+  if (config.type === "sdk")
+    return "legacy";
+  if (config.versionNegotiation !== undefined)
+    return config.versionNegotiation;
+  return config.type === "http" ? "auto" : "legacy";
+}
+function toSdkNegotiationMode(mode) {
+  return typeof mode === "string" ? mode : { pin: mode.pin };
+}
+function classifyConnectError(err, facts = { transportClosed: false, pinned: false }) {
+  if (err instanceof McpConnectError2)
+    return err;
+  if (err instanceof UnauthorizedError)
+    return new McpConnectError2("needs_auth", err.message);
+  if (err instanceof SdkError && err.code === SdkErrorCode.RequestTimeout)
+    return new McpConnectError2("timeout", err.message);
+  const httpStatus = err instanceof SdkHttpError ? err.status : err instanceof SseError && typeof err.code === "number" ? err.code : undefined;
+  if (err instanceof SdkHttpError || err instanceof SseError) {
+    return new McpConnectError2(httpStatus === 401 ? "needs_auth" : "handshake_failed", err.message, httpStatus);
+  }
+  if (err instanceof SdkError && err.code === SdkErrorCode.EraNegotiationFailed) {
+    if (facts.transportClosed)
+      return new McpConnectError2("transport_closed", err.message);
+    const cause = err.cause;
+    if (cause !== undefined && cause !== err)
+      return classifyConnectError(cause, facts);
+    return new McpConnectError2(facts.pinned ? "version_mismatch" : "handshake_failed", err.message);
+  }
+  if (err instanceof UnsupportedProtocolVersionError)
+    return new McpConnectError2("version_mismatch", err.message);
+  if (err instanceof ProtocolError)
+    return new McpConnectError2("handshake_failed", err.message);
+  const message = err instanceof Error ? err.message : String(err);
+  const code = err?.code;
+  if (code === "ENOENT" || code === "EACCES")
+    return new McpConnectError2("spawn_failed", message);
+  if (facts.transportClosed)
+    return new McpConnectError2("transport_closed", message);
+  return new McpConnectError2("unknown", message);
+}
+function raceConnect(client, transport, timeoutMs) {
+  let timer;
+  const outer = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new McpConnectError2("timeout", `mcp client: connection attempt exceeded ${timeoutMs}ms`)), timeoutMs);
+    timer.unref?.();
+  });
+  return Promise.race([client.connect(transport, { timeout: timeoutMs }), outer]).finally(() => {
+    if (timer !== undefined)
+      clearTimeout(timer);
+  });
+}
+function dedupeTools(tools) {
+  const seen = new Set;
+  const out = [];
+  for (const tool of tools) {
+    if (seen.has(tool.name)) {
+      console.error(`winter: mcp client: server reported duplicate tool name "${tool.name}" in one tools/list response -- keeping the first occurrence, dropping the rest`);
+      continue;
+    }
+    seen.add(tool.name);
+    out.push(tool);
+  }
+  return out;
+}
+var AUTO_PROBE_TIMEOUT_CAP_MS = 5000;
+function autoProbeTimeoutMs(connectTimeoutMs) {
+  return Math.max(1, Math.min(AUTO_PROBE_TIMEOUT_CAP_MS, Math.floor(connectTimeoutMs / 3)));
+}
+function retriesAsLegacy(err) {
+  if (err.code === "needs_auth" || err.code === "spawn_failed" || err.code === "version_mismatch")
+    return false;
+  return err.httpStatus !== 401 && err.httpStatus !== 403;
+}
+var announcedLegacyFallbacks = new Set;
+function announceLegacyFallback(name, transport, cause) {
+  const key = `${name}\x00${transport}\x00${cause.code}`;
+  if (announcedLegacyFallbacks.has(key))
+    return;
+  announcedLegacyFallbacks.add(key);
+  console.error(`winter: mcp: server "${name}" (${transport}) failed the 'auto' version probe (${cause.code}); connecting once more with 'legacy' -- set versionNegotiation: "legacy" on it to skip the probe`);
+}
+var MANUAL_LIST_MAX_PAGES = 64;
+async function listAllPagesManually(fetchPage, what) {
+  const out = [];
+  const seen = new Set;
+  let cursor;
+  for (let page = 0;page < MANUAL_LIST_MAX_PAGES; page++) {
+    let result;
+    try {
+      result = await fetchPage(cursor);
+    } catch (err) {
+      if (page === 0 && err instanceof ProtocolError && err.code === ProtocolErrorCode.MethodNotFound)
+        return [];
+      throw err;
+    }
+    out.push(...result.items);
+    const next = result.nextCursor;
+    if (next === undefined || seen.has(next))
+      return out;
+    seen.add(next);
+    cursor = next;
+  }
+  throw new Error(`mcp client: ${what} did not finish within ${MANUAL_LIST_MAX_PAGES} pages (the server's pagination never converged)`);
+}
+async function connectMcpServer2(opts) {
+  const mode = resolveVersionNegotiation2(opts.config);
+  if (mode !== "auto")
+    return connectOnce(opts, mode, opts.connectTimeoutMs);
+  const started = Date.now();
+  try {
+    return await connectOnce(opts, "auto", opts.connectTimeoutMs, autoProbeTimeoutMs(opts.connectTimeoutMs));
+  } catch (err) {
+    if (!(err instanceof McpConnectError2) || !retriesAsLegacy(err))
+      throw err;
+    const remaining = opts.connectTimeoutMs - (Date.now() - started);
+    if (remaining <= 0)
+      throw err;
+    announceLegacyFallback(opts.name, opts.config.type ?? "stdio", err);
+    return connectOnce(opts, "legacy", remaining);
+  }
+}
+async function connectOnce(opts, mode, connectTimeoutMs, probeTimeoutMs) {
+  const { name, config, elicitationAsk } = opts;
+  let transport;
+  try {
+    if (config.type === "sdk") {
+      if (!opts.inProcessServer) {
+        throw new McpConnectError2("spawn_failed", `mcp client: server "${name}" is configured as type "sdk" but no in-process server instance was supplied to connectMcpServer`);
+      }
+      transport = await buildSdkTransport(opts.inProcessServer);
+    } else if (config.type === "http") {
+      transport = buildHttpTransport(config, opts.refuseHttpRedirects === true ? { refuseRedirects: true } : {});
+    } else if (config.type === "sse") {
+      transport = buildSseTransport(config);
+    } else {
+      if (opts.cwd === undefined) {
+        throw new McpConnectError2("spawn_failed", `mcp client: stdio server "${name}" has no session cwd to start in; it is never started in the host process's cwd`);
+      }
+      transport = buildStdioTransport(config, opts.cwd);
+    }
+    const onToolListChanged = opts.onToolListChanged;
+    const client = new Client({ name: "winter", version: "0.0.1" }, {
+      capabilities: { elicitation: { form: {}, url: {} } },
+      versionNegotiation: { mode: toSdkNegotiationMode(mode), ...probeTimeoutMs !== undefined ? { probe: { timeoutMs: probeTimeoutMs } } : {} },
+      inputRequired: { autoFulfill: true },
+      ...onToolListChanged !== undefined ? {
+        listChanged: {
+          tools: {
+            autoRefresh: false,
+            onChanged: () => {
+              try {
+                onToolListChanged();
+              } catch (err) {
+                console.error(`winter: mcp client: server "${name}" tool-list-changed handler threw`, err);
+              }
+            }
+          }
+        }
+      } : {}
+    });
+    installElicitationHandler(client, name, elicitationAsk);
+    await raceConnect(client, transport, connectTimeoutMs);
+    const protocolVersion = client.getNegotiatedProtocolVersion();
+    let closed = false;
+    return {
+      serverName: name,
+      ...protocolVersion !== undefined ? { protocolVersion } : {},
+      async listTools() {
+        const rawTools = client.getServerCapabilities()?.tools !== undefined ? (await client.listTools(undefined, { cacheMode: "refresh" })).tools : await listAllPagesManually(async (cursor) => {
+          const page = await client.request({ method: "tools/list", ...cursor !== undefined ? { params: { cursor } } : {} });
+          return { items: page.tools, nextCursor: page.nextCursor };
+        }, "tools/list");
+        return dedupeTools(rawTools.map((t) => ({
+          name: t.name,
+          ...t.description !== undefined ? { description: t.description } : {},
+          inputSchema: t.inputSchema,
+          ...t.outputSchema !== undefined ? { outputSchema: t.outputSchema } : {},
+          ...t.annotations !== undefined ? { annotations: t.annotations } : {},
+          ...t._meta !== undefined ? { _meta: t._meta } : {}
+        })));
+      },
+      async listResources() {
+        const resources = client.getServerCapabilities()?.resources !== undefined ? (await client.listResources(undefined, { cacheMode: "refresh" })).resources : await listAllPagesManually(async (cursor) => {
+          const page = await client.request({ method: "resources/list", ...cursor !== undefined ? { params: { cursor } } : {} });
+          return { items: page.resources, nextCursor: page.nextCursor };
+        }, "resources/list");
+        return resources.map((r) => ({
+          uri: r.uri,
+          ...r.name !== undefined ? { name: r.name } : {},
+          ...r.description !== undefined ? { description: r.description } : {},
+          ...r.mimeType !== undefined ? { mimeType: r.mimeType } : {}
+        }));
+      },
+      async readResource(uri, readOpts) {
+        const result = await client.readResource({ uri }, { cacheMode: "refresh", ...readOpts?.timeoutMs !== undefined ? { timeout: readOpts.timeoutMs } : {} });
+        return result.contents.map((c) => {
+          const mimeType = "mimeType" in c && c.mimeType !== undefined ? c.mimeType : undefined;
+          if ("blob" in c) {
+            return { uri: c.uri, ...mimeType !== undefined ? { mimeType } : {}, blobBase64: c.blob };
+          }
+          return { uri: c.uri, ...mimeType !== undefined ? { mimeType } : {}, text: "text" in c ? c.text : "" };
+        });
+      },
+      async callTool(toolName, args, callOpts) {
+        const result = await client.callTool({ name: toolName, arguments: args }, callOpts?.timeoutMs !== undefined ? { timeout: callOpts.timeoutMs } : undefined);
+        return {
+          content: result.content ?? [],
+          ...result.isError === true ? { isError: true } : {}
+        };
+      },
+      async close() {
+        if (closed)
+          return;
+        closed = true;
+        await client.close();
+      }
+    };
+  } catch (err) {
+    const stderrTail = transport instanceof WinterStdioTransport ? transport.stderrTail.trim() : "";
+    const facts = { transportClosed: transport instanceof WinterStdioTransport && transport.exitedOnItsOwn, pinned: typeof mode === "object" };
+    try {
+      await transport.close();
+    } catch {}
+    const classified = classifyConnectError(err, facts);
+    if (stderrTail === "" || classified.message.includes(stderrTail))
+      throw classified;
+    throw new McpConnectError2(classified.code, `${classified.message}
+--- server stderr (last ${stderrTail.length} chars) ---
+${stderrTail}`, classified.httpStatus);
+  }
+}
+
+export { trackProcessGroup, liveProcessGroups, onProcessGroupChange, createElicitationAsker2, McpConnectError2, resolveVersionNegotiation2, connectMcpServer2 };

package/dist/{index-rkhh0457.js → index-eyddzcgs.js}

@@ -9,14 +9,14 @@ import {
   resolveEngineSession2,
   resolveProductionWinterHome2,
   resolveProductionStoreHome
-} from "./index-9qgkpv56.js";
+} from "./index-jz5d90c6.js";
 import {
   registerDefaultChildEngineFactory,
   loadResumedChain,
   buildProductionWiring,
   withAutoSkillPermissions,
   restoreChildRoster
-} from "./index-584yahed.js";
+} from "./index-gmxxtqpe.js";
 
 // src/embedded.ts
 import { splitFrames, encodeFrame } from "@yanlinglabs/winter-agent-sdk";