@yanlinglabs/winter-agent-runtime 0.0.27

package/dist/index-bef62z3r.js

@@ -0,0 +1,437 @@
+// src/workflows/journal.ts
+import { appendFileSync, mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+function promptKey(prompt, opts) {
+  return JSON.stringify([prompt, opts ?? null]);
+}
+
+class RunJournal {
+  path;
+  constructor(dir, runId) {
+    const runDir = join(dir, runId);
+    mkdirSync(runDir, { recursive: true, mode: 448 });
+    this.path = join(runDir, "journal.jsonl");
+  }
+  append(promptKeyValue, value) {
+    this.appendRaw(JSON.stringify({ promptKey: promptKeyValue, value }) + `
+`);
+  }
+  appendRaw(line) {
+    appendFileSync(this.path, line);
+  }
+  load() {
+    let raw;
+    try {
+      raw = readFileSync(this.path, "utf8");
+    } catch {
+      return [];
+    }
+    const out = [];
+    for (const line of raw.split(`
+`)) {
+      if (line.trim() === "")
+        continue;
+      try {
+        const parsed = JSON.parse(line);
+        if (typeof parsed?.promptKey === "string")
+          out.push(parsed);
+      } catch {}
+    }
+    return out;
+  }
+}
+
+// src/workflows/semaphore.ts
+import { cpus } from "node:os";
+var DEFAULT_MAX_CONCURRENCY = 16;
+function resolveConcurrencyCap(cpuCount = cpus().length) {
+  return Math.max(1, Math.min(DEFAULT_MAX_CONCURRENCY, cpuCount - 2));
+}
+function makeSemaphore(max) {
+  const permits = Math.max(1, Math.floor(max));
+  let active = 0;
+  const queue = [];
+  return {
+    acquire: () => new Promise((resolve) => {
+      if (active < permits) {
+        active++;
+        resolve();
+      } else {
+        queue.push(resolve);
+      }
+    }),
+    release: () => {
+      active--;
+      const next = queue.shift();
+      if (next) {
+        active++;
+        next();
+      }
+    }
+  };
+}
+
+// src/workflows/script-api.ts
+var AsyncFunction = Object.getPrototypeOf(async function() {}).constructor;
+var guardedMath = new Proxy(Math, {
+  get(target, prop, receiver) {
+    if (prop === "random") {
+      return () => {
+        throw new Error("Math.random is withheld for determinism (WS-11 §1.6) -- pass a seed via args");
+      };
+    }
+    return Reflect.get(target, prop, receiver);
+  }
+});
+var GuardedDate = new Proxy(Date, {
+  get(target, prop, receiver) {
+    if (prop === "now") {
+      return () => {
+        throw new Error("Date.now is withheld for determinism (WS-11 §1.6) -- pass timestamps via args");
+      };
+    }
+    return Reflect.get(target, prop, receiver);
+  },
+  construct(target, argsList, newTarget) {
+    if (argsList.length === 0) {
+      throw new Error("argless new Date() is withheld for determinism (WS-11 §1.6) -- pass a timestamp via args");
+    }
+    const instance = Reflect.construct(target, argsList, newTarget);
+    try {
+      Object.defineProperty(instance, "constructor", { value: GuardedDate, writable: true, configurable: true, enumerable: false });
+    } catch {}
+    return instance;
+  }
+});
+function transformSource(source) {
+  return source.replace(/\bexport\s+(?:const|let|var)\s+meta\s*=/, "__META__.value =").replace(/^[ \t]*export\s+/gm, "");
+}
+var DYNAMIC_IMPORT_RE = /\bimport\s*[(.]/;
+function assertNoDynamicImport(body) {
+  if (DYNAMIC_IMPORT_RE.test(body)) {
+    throw new Error("`import` is not available to a workflow script -- no filesystem, process, network or import access (WS-11 §1.6); pass what the script needs through `args`");
+  }
+}
+async function runWorkflowScript(deps) {
+  const sem = makeSemaphore(deps.concurrency);
+  const journal = deps.resumeJournal ?? [];
+  const state = { callIndex: 0, diverged: false, dispatched: 0, completed: 0, budget: deps.budget };
+  function budgetView() {
+    return {
+      get total() {
+        return state.budget.total;
+      },
+      spent: () => state.budget.spent,
+      remaining: () => state.budget.total === null ? Infinity : Math.max(0, state.budget.total - state.budget.spent)
+    };
+  }
+  async function agent(prompt, opts) {
+    const index = state.callIndex++;
+    const key = promptKey(String(prompt), opts);
+    const cached = journal[index];
+    if (!state.diverged && cached !== undefined && cached.promptKey === key)
+      return cached.value;
+    if (!state.diverged) {
+      state.diverged = true;
+      deps.reportCachedPrefix?.(index);
+    }
+    if (state.dispatched >= deps.totalAgentCap) {
+      throw new Error(`workflow exceeded the per-run agent cap (${deps.totalAgentCap}) -- ${state.completed} completed before the stop`);
+    }
+    if (state.budget.total !== null && state.budget.spent >= state.budget.total) {
+      throw new Error(`workflow budget exhausted: ${state.budget.spent} of ${state.budget.total} tokens spent -- further agent() calls are refused (WS-11 §1.6)`);
+    }
+    state.dispatched++;
+    await sem.acquire();
+    let outcome;
+    try {
+      outcome = await deps.agent(String(prompt), opts);
+    } finally {
+      sem.release();
+      state.completed++;
+    }
+    if (outcome.budget !== undefined)
+      state.budget = outcome.budget;
+    if (!outcome.ok)
+      throw new Error(outcome.error);
+    return outcome.value;
+  }
+  function assertItemCap(kind, count) {
+    if (count > deps.maxItemsPerCall) {
+      throw new Error(`${kind}() was given ${count} items, over the per-call limit of ${deps.maxItemsPerCall} (WS-11 §1.6) -- split the work across calls`);
+    }
+  }
+  async function parallel(thunks) {
+    const list = Array.from(thunks ?? []);
+    assertItemCap("parallel", list.length);
+    return Promise.all(list.map(async (thunk) => {
+      try {
+        return await thunk();
+      } catch {
+        return null;
+      }
+    }));
+  }
+  async function pipeline(items, ...stages) {
+    const list = Array.from(items ?? []);
+    assertItemCap("pipeline", list.length);
+    return Promise.all(list.map(async (item, index) => {
+      let current = item;
+      try {
+        for (const stage of stages)
+          current = await stage(current, item, index);
+        return current;
+      } catch {
+        return null;
+      }
+    }));
+  }
+  async function runBody(source, args, depth) {
+    const metaCell = { value: undefined };
+    const nested = async (nameOrRef, childArgs) => {
+      if (depth >= 1) {
+        throw new Error("workflow() nesting is one level deep -- a nested workflow cannot call workflow() itself (WS-11 §1.6)");
+      }
+      const ref = typeof nameOrRef === "string" ? { name: nameOrRef } : nameOrRef;
+      const resolved = await deps.resolveWorkflow(ref, childArgs);
+      if (!resolved.ok)
+        throw new Error(resolved.error);
+      const child = await runBody(resolved.source, childArgs, depth + 1);
+      return child.result;
+    };
+    const scope = {
+      agent,
+      parallel,
+      pipeline,
+      phase: (title) => deps.phase(String(title)),
+      log: (message) => deps.log(String(message)),
+      budget: budgetView(),
+      workflow: nested,
+      args,
+      __META__: metaCell,
+      JSON,
+      Math: guardedMath,
+      Date: GuardedDate,
+      Array,
+      Object,
+      String,
+      Number,
+      Boolean,
+      Promise,
+      RegExp,
+      Map,
+      Set,
+      Error,
+      Symbol,
+      console: {
+        log: (...parts) => deps.log(parts.map(stringifyLogPart).join(" ")),
+        info: (...parts) => deps.log(parts.map(stringifyLogPart).join(" ")),
+        warn: (...parts) => deps.log(parts.map(stringifyLogPart).join(" ")),
+        error: (...parts) => deps.log(parts.map(stringifyLogPart).join(" ")),
+        debug: (...parts) => deps.log(parts.map(stringifyLogPart).join(" "))
+      },
+      Bun: undefined,
+      process: undefined,
+      performance: undefined,
+      crypto: undefined,
+      require: undefined,
+      module: undefined,
+      exports: undefined,
+      fetch: undefined,
+      globalThis: undefined,
+      self: undefined,
+      global: undefined,
+      XMLHttpRequest: undefined,
+      WebSocket: undefined,
+      Worker: undefined,
+      Function: undefined
+    };
+    const names = Object.keys(scope);
+    const body = transformSource(source);
+    assertNoDynamicImport(body);
+    const compiled = new AsyncFunction(...names, `"use strict";
+${body}`);
+    const result = await compiled(...names.map((n) => scope[n]));
+    return { meta: metaCell.value, result };
+  }
+  const outcome = await runBody(deps.source, deps.args, 0);
+  if (!state.diverged && journal.length > 0)
+    deps.reportCachedPrefix?.(state.callIndex);
+  return outcome;
+}
+function stringifyLogPart(part) {
+  if (typeof part === "string")
+    return part;
+  try {
+    return JSON.stringify(part) ?? String(part);
+  } catch {
+    return String(part);
+  }
+}
+
+// src/workflows/bridge.ts
+function splitNdjson(buffer) {
+  const lines = [];
+  let rest = buffer;
+  for (;; ) {
+    const idx = rest.indexOf(`
+`);
+    if (idx < 0)
+      break;
+    const line = rest.slice(0, idx);
+    rest = rest.slice(idx + 1);
+    if (line.trim() !== "")
+      lines.push(line);
+  }
+  return { lines, rest };
+}
+function encodeNdjson(value) {
+  return JSON.stringify(value) + `
+`;
+}
+
+// src/workflows/subprocess-entry.ts
+var WORKFLOW_WORKER_ARGV_FLAG2 = "__workflow-worker";
+var WORKFLOW_WORKER_BRIDGE_FLAG2 = "--bridge";
+var WORKFLOW_WORKER_NOT_IMPLEMENTED_EXIT_CODE2 = 78;
+var WORKFLOW_WORKER_BROKEN_EXIT_CODE2 = 70;
+async function workflowWorkerMain2(argv, io) {
+  if (!argv.includes(WORKFLOW_WORKER_BRIDGE_FLAG2)) {
+    io.stderr.write(`winter: ${WORKFLOW_WORKER_ARGV_FLAG2} was invoked without ${WORKFLOW_WORKER_BRIDGE_FLAG2}; there is no parent driving the bridge, so there is nothing to run
+`);
+    return WORKFLOW_WORKER_NOT_IMPLEMENTED_EXIT_CODE2;
+  }
+  const lines = new LineQueue(io.stdin);
+  const writes = [];
+  const post = (message) => {
+    writes.push(writeAndFlush(io.stdout, encodeNdjson(message)));
+  };
+  let init;
+  try {
+    const first = await lines.next();
+    if (first === undefined)
+      throw new Error("stdin closed before the init line arrived");
+    init = JSON.parse(first);
+    if (typeof init?.source !== "string")
+      throw new Error("the init line carries no `source`");
+  } catch (err) {
+    io.stderr.write(`winter: workflow worker could not read its init line: ${errorText(err)}
+`);
+    return WORKFLOW_WORKER_BROKEN_EXIT_CODE2;
+  }
+  let nextCallId = 1;
+  const pending = new Map;
+  const call = (build) => new Promise((resolve) => {
+    const callId = nextCallId++;
+    pending.set(callId, resolve);
+    post(build(callId));
+  });
+  const pump = (async () => {
+    for (;; ) {
+      const line = await lines.next();
+      if (line === undefined)
+        return;
+      let response;
+      try {
+        response = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const settle = pending.get(response.callId);
+      if (settle === undefined)
+        continue;
+      pending.delete(response.callId);
+      settle(response);
+    }
+  })();
+  pump.then(() => {
+    for (const [callId, settle] of pending) {
+      pending.delete(callId);
+      settle({ callId, ok: false, error: "the workflow host closed the bridge" });
+    }
+  });
+  const agent = async (prompt, opts) => {
+    const response = await call((callId) => ({ op: "agent", callId, prompt, ...opts !== undefined ? { opts } : {} }));
+    return response.ok ? { ok: true, value: response.value, ...response.budget !== undefined ? { budget: response.budget } : {} } : { ok: false, error: response.error, ...response.budget !== undefined ? { budget: response.budget } : {} };
+  };
+  const resolveWorkflow = async (ref, args) => {
+    const response = await call((callId) => ({ op: "workflow", callId, ref, ...args !== undefined ? { args } : {} }));
+    if (!response.ok)
+      return { ok: false, error: response.error };
+    const source = response.value?.source;
+    if (typeof source !== "string")
+      return { ok: false, error: `the workflow host returned no source for ${JSON.stringify(ref)}` };
+    return { ok: true, source };
+  };
+  try {
+    const { result } = await runWorkflowScript({
+      source: init.source,
+      args: init.args,
+      concurrency: init.concurrency,
+      totalAgentCap: init.totalAgentCap,
+      maxItemsPerCall: init.maxItemsPerCall,
+      budget: init.budget,
+      agent,
+      resolveWorkflow,
+      phase: (title) => post({ op: "phase", title }),
+      log: (message) => post({ op: "log", message }),
+      reportCachedPrefix: (count) => post({ op: "resumed", cachedPrefix: count }),
+      ...init.resumeJournal !== undefined ? { resumeJournal: init.resumeJournal } : {}
+    });
+    post({ op: "done", result });
+  } catch (err) {
+    post({ op: "error", message: errorText(err) });
+  }
+  await Promise.all(writes);
+  return 0;
+}
+function errorText(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function writeAndFlush(stream, chunk) {
+  return new Promise((resolve) => {
+    stream.write(chunk, () => resolve());
+  });
+}
+
+class LineQueue {
+  buffer = "";
+  ready = [];
+  waiters = [];
+  ended = false;
+  constructor(stream) {
+    stream.on("data", (chunk) => {
+      this.buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      const { lines, rest } = splitNdjson(this.buffer);
+      this.buffer = rest;
+      for (const line of lines)
+        this.push(line);
+    });
+    const end = () => {
+      this.ended = true;
+      while (this.waiters.length > 0)
+        this.waiters.shift()(undefined);
+    };
+    stream.on("end", end);
+    stream.on("close", end);
+    stream.on("error", end);
+    stream.resume();
+  }
+  push(line) {
+    const waiter = this.waiters.shift();
+    if (waiter)
+      waiter(line);
+    else
+      this.ready.push(line);
+  }
+  next() {
+    const queued = this.ready.shift();
+    if (queued !== undefined)
+      return Promise.resolve(queued);
+    if (this.ended)
+      return Promise.resolve(undefined);
+    return new Promise((resolve) => this.waiters.push(resolve));
+  }
+}
+
+export { promptKey, RunJournal, resolveConcurrencyCap, makeSemaphore, splitNdjson, encodeNdjson, WORKFLOW_WORKER_ARGV_FLAG2, WORKFLOW_WORKER_BRIDGE_FLAG2, WORKFLOW_WORKER_NOT_IMPLEMENTED_EXIT_CODE2, WORKFLOW_WORKER_BROKEN_EXIT_CODE2, workflowWorkerMain2 };

package/dist/index-rkhh0457.js

@@ -0,0 +1,187 @@
+import {
+  killAllTaskProcessGroups,
+  setHostWorkflowWorkerCommand,
+  runEngine2,
+  stubExecutor2,
+  isTestProviderName2,
+  testProviderForNamespace,
+  registerBgTaskTestTool2,
+  resolveEngineSession2,
+  resolveProductionWinterHome2,
+  resolveProductionStoreHome
+} from "./index-9qgkpv56.js";
+import {
+  registerDefaultChildEngineFactory,
+  loadResumedChain,
+  buildProductionWiring,
+  withAutoSkillPermissions,
+  restoreChildRoster
+} from "./index-584yahed.js";
+
+// src/embedded.ts
+import { splitFrames, encodeFrame } from "@yanlinglabs/winter-agent-sdk";
+import { WinterCompatibilitySessionStore, compatibilityKeys } from "@yanlinglabs/winter-agent-sdk";
+
+// src/embedded-protocol.ts
+var EMBEDDED_ABORT_END_INPUT_REQUEST_ID = "embedded-abort:end_input";
+var EMBEDDED_ABORT_INTERRUPT_REQUEST_ID = "embedded-abort:interrupt";
+
+// src/embedded.ts
+function parseConfigFromArgv(argv) {
+  if (!argv.includes("--run")) {
+    throw new Error("winter: expected '--run --config-json <json>' (missing --run)");
+  }
+  const idx = argv.indexOf("--config-json");
+  const raw = idx === -1 ? undefined : argv[idx + 1];
+  if (raw === undefined) {
+    throw new Error("winter: expected '--run --config-json <json>' (missing --config-json <json>)");
+  }
+  return JSON.parse(raw);
+}
+function resolveNamespacedTestProvider(name) {
+  if (name === "bgtask")
+    registerBgTaskTestTool2();
+  return testProviderForNamespace(name);
+}
+function assertRecognizedTestProviderEnv(env) {
+  const raw = env["WINTER_TEST_PROVIDER"];
+  if (raw === undefined || raw === "")
+    return;
+  const name = raw.startsWith("winter-test/") ? raw.slice("winter-test/".length) : raw;
+  if (name !== "echo" && !isTestProviderName2(name)) {
+    throw new Error(`winter: unrecognized WINTER_TEST_PROVIDER '${raw}'`);
+  }
+}
+var ABORTED = Symbol("aborted");
+function frameSource(input, aborted) {
+  return async function* () {
+    let carry = "";
+    const iterator = input[Symbol.asyncIterator]();
+    let sawAbort = false;
+    try {
+      while (true) {
+        const next = await Promise.race([iterator.next(), aborted]);
+        if (next === ABORTED) {
+          sawAbort = true;
+          break;
+        }
+        if (next.done)
+          return;
+        const split = splitFrames(next.value, carry);
+        carry = split.carry;
+        for (const frame of split.frames)
+          yield frame;
+      }
+    } catch {
+      return;
+    }
+    if (sawAbort) {
+      Promise.resolve(iterator.return?.()).catch(() => {});
+      yield { type: "control_request", requestId: EMBEDDED_ABORT_END_INPUT_REQUEST_ID, subtype: "end_input", payload: {} };
+      yield { type: "control_request", requestId: EMBEDDED_ABORT_INTERRUPT_REQUEST_ID, subtype: "interrupt", payload: {} };
+    }
+  }();
+}
+function isSyntheticAbortAck(frame) {
+  if (frame.type !== "control_response")
+    return false;
+  const id = frame.requestId;
+  return id === EMBEDDED_ABORT_END_INPUT_REQUEST_ID || id === EMBEDDED_ABORT_INTERRUPT_REQUEST_ID;
+}
+async function runEmbeddedSession2(opts) {
+  const { env, write, writeErr, signal } = opts;
+  let settleAborted;
+  const aborted = new Promise((resolve) => {
+    settleAborted = resolve;
+  });
+  const onAbort = () => {
+    try {
+      killAllTaskProcessGroups();
+    } catch {}
+    settleAborted(ABORTED);
+  };
+  if (signal?.aborted === true)
+    onAbort();
+  else
+    signal?.addEventListener("abort", onAbort, { once: true });
+  const restoreWorkflowCommand = opts.workflowWorkerCommand !== undefined ? setHostWorkflowWorkerCommand(opts.workflowWorkerCommand) : undefined;
+  const output = {
+    write(frame) {
+      if (isSyntheticAbortAck(frame))
+        return;
+      write(encodeFrame(frame));
+    },
+    end() {}
+  };
+  try {
+    const config = parseConfigFromArgv(opts.argv);
+    assertRecognizedTestProviderEnv(env);
+    const { config: effectiveConfig, store, initialMessages, approvalStore, autoStateStore } = await resolveEngineSession2({
+      config,
+      resolveWinterHome: () => resolveProductionWinterHome2(config, env),
+      resolveStoreHome: () => resolveProductionStoreHome(config, env),
+      env
+    });
+    const childWinterHome = resolveProductionWinterHome2(config, env);
+    const childDurableRoot = resolveProductionStoreHome(config, env) ?? childWinterHome;
+    const childStore = config.persistSession === false ? undefined : new WinterCompatibilitySessionStore({ winterHome: childDurableRoot });
+    const providerChain = await loadResumedChain(store, initialMessages);
+    const wiring = await buildProductionWiring({
+      config: effectiveConfig,
+      env,
+      winterHome: resolveProductionWinterHome2(config, env),
+      ...store !== undefined ? { persistence: store } : {},
+      provider: {
+        testProviders: resolveNamespacedTestProvider,
+        ...env["HOME"] !== undefined ? { home: env["HOME"] } : {},
+        chain: () => providerChain
+      }
+    });
+    const provider = wiring.providerWiring.provider;
+    for (const warning of wiring.warnings)
+      writeErr(`winter: ${warning}
+`);
+    registerDefaultChildEngineFactory({
+      provider,
+      config: effectiveConfig,
+      env,
+      warn: (line) => writeErr(`${line}
+`),
+      ...childStore !== undefined ? { store: childStore } : {},
+      ...childWinterHome !== undefined ? { winterHome: childWinterHome } : {},
+      ...wiring.config.storeHome !== undefined ? { storeHome: wiring.config.storeHome } : {},
+      ...wiring.childFactoryOptions
+    });
+    const restoredChildren = childStore !== undefined && config.forkSession !== true && (config.resume !== undefined || config.continue === true) ? await restoreChildRoster(childStore, { projectKey: compatibilityKeys(effectiveConfig.cwd).transcriptProjectKey, sessionId: effectiveConfig.sessionId }) : undefined;
+    try {
+      return await runEngine2({
+        config: withAutoSkillPermissions(wiring.config),
+        ...wiring.engineOptions,
+        input: frameSource(opts.input, aborted),
+        output,
+        provider,
+        unregisteredToolExecutor: stubExecutor2,
+        ...store !== undefined ? { store } : {},
+        ...initialMessages.length > 0 ? { initialMessages } : {},
+        ...approvalStore !== undefined ? { approvalStore } : {},
+        ...autoStateStore !== undefined ? { autoStateStore } : {},
+        env
+      });
+    } finally {
+      restoredChildren?.remove();
+      wiring.dispose();
+    }
+  } catch (err) {
+    const text = err instanceof Error ? err.stack ?? err.message : String(err);
+    try {
+      writeErr(`winter: fatal: ${text}
+`);
+    } catch {}
+    return 1;
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+    restoreWorkflowCommand?.();
+  }
+}
+
+export { runEmbeddedSession2 };

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+export { runWinterRuntime } from "./runtime.js";
+export { runEngine } from "./engine.js";
+export type { Provider, ProviderTurn, ProviderMessage, ContentBlock, ToolExecutor, SessionPersistence, EngineOptions, ProviderRequest, ProviderUsage, ContextAccountant, ContextAccountantOptions, } from "./engine.js";
+export { createContextAccountant, DEFAULT_CONTEXT_WINDOW_TOKENS } from "./engine.js";
+export { recordedProviderSystems, resetRecordedProviderSystems } from "./provider/mock.js";
+export { SCENARIO_FINAL_TEXT, SCENARIO_FIRST_TEXT, SCENARIO_CHILD_AGENT, SCENARIO_CHILD_MODEL, SCENARIO_CHILD_WIRE_ID, SCENARIO_DELEGATE_MARKER, SCENARIO_MODELS, SCENARIO_TOOL_CALLING_NONE, SCENARIO_TOOL_INPUT, SCENARIO_TOOL_NAME, startScenarioFake, } from "./provider/scenario-fake.js";
+export type { ScenarioFake, ScenarioFakeOptions, ScenarioRequest } from "./provider/scenario-fake.js";
+export { onCompaction } from "./tools/registry.js";
+export { createInMemoryChannel } from "./protocol/channel.js";
+export type { Duplex, FrameSource, FrameSink } from "./protocol/channel.js";
+export { createRpcBridge } from "./rpc/bridge.js";
+export type { RpcBridge } from "./rpc/bridge.js";
+export { echoProvider, scriptedProvider, stubExecutor, isTestProviderName, testProviderByName, registerBgTaskTestTool, BGTASK_TEST_TOOL_NAME, MCP_SDK_TEST_SERVER_NAME, SUBAGENT_CHILD_PROBE_TEXT, P5_FIXTURE_SKILL_NAME, P5_WORKFLOW_SCRIPT, MCP_SDK_TEST_TOOL_NAME, } from "./provider/mock.js";
+export type { TestProviderName } from "./provider/mock.js";
+export { registerTool } from "./tools/registry.js";
+export { resolveWinterHome } from "@yanlinglabs/winter-agent-sdk";
+export { transcriptProjectKey } from "@yanlinglabs/winter-agent-sdk";
+export { compatibilityKeys } from "@yanlinglabs/winter-agent-sdk";
+export type { CompatibilityKeys } from "@yanlinglabs/winter-agent-sdk";
+export { sessionTempDir, ensureTasksDir, WinterPathsError } from "./paths/temp.js";
+export type { SessionTempDirOptions, SessionTempDirPaths } from "./paths/temp.js";
+export { resolveProjectDirName } from "./paths/project-dir-name.js";
+export { WinterCompatibilitySessionStore, WinterStoreError, WinterStoreLeaseError, DIALECT_RECORD_ENTRY_TYPE, } from "@yanlinglabs/winter-agent-sdk";
+export type { SessionKey, SessionStoreEntry, SessionSummaryEntry, SessionStore } from "@yanlinglabs/winter-agent-sdk";
+export { userEntry, assistantEntry, winterMessageIdFor, claudeCompactBoundaryEntry, claudeCompactSummaryEntry, CLAUDE_COMPACT_SUMMARY_PREAMBLE, TranscriptWriter, TranscriptWriterError, RUNTIME_ENGINE_VERSION, resolveEngineSession, resolveProductionWinterHome, } from "./store/dialect.js";
+export type { Block, Chain, SessionCtx, DialectEntryBase, UserEntryOpts, TranscriptWriterOptions, ResolvedEngineSession, ClaudeCompactMetadata } from "./store/dialect.js";
+export { findContinueTarget, findResumeTarget, truncateAt, toDialectEntries, rebuildProviderMessages, ResumeTargetError, ResumeTruncationError } from "./store/resume.js";
+export type { DialectEntry } from "./store/resume.js";
+export { PROTOCOL_VERSION, encodeFrame, decodeFrame, splitFrames, ProtocolError, } from "@yanlinglabs/winter-agent-sdk";
+export type { ProtocolVersion, WinterFrame, ProtocolSdkMessage as SdkMessage, InitFrame, UserFrame, DataFrame, ControlRequestFrame, ControlResponseFrame, UnknownFrame, RuntimeConfig, } from "@yanlinglabs/winter-agent-sdk";
+export { deleteProviderCredential, providerCredentialRef, storeProviderCredential, validateProviderCredential } from "./provider/credential-api.js";
+export type { ProviderCredentialLocator, ProviderCredentialRef, StoreProviderCredentialInput } from "./provider/credential-api.js";
+export { createModelClassifier, selectClassifierRoute, DEFAULT_CLASSIFIER_TIMEOUT_MS } from "./provider/classifier/model-classifier.js";
+export type { ClassifierRoute, ClassifierRouteConfig, ModelClassifierOptions } from "./provider/classifier/model-classifier.js";
+export { CLASSIFIER_TOOL_NAME, CLASSIFIER_NO_VERDICT_REASONS, CLASSIFIER_VERDICT_SCHEMA } from "./provider/classifier/verdict-schema.js";
+export type { ClassifierNoVerdictReason } from "./provider/classifier/verdict-schema.js";
+export { CLASSIFIER_SYSTEM_PROMPT, DEFAULT_MAX_CONTEXT_CHARS } from "./provider/classifier/prompt.js";