norns-sdk 0.0.0-stage → 0.2.0

package/dist/index.cjs

@@ -0,0 +1,1666 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_MODEL: () => DEFAULT_MODEL,
+  GardDestroyedError: () => GardDestroyedError,
+  JoinError: () => JoinError,
+  NornsApiError: () => NornsApiError,
+  NornsClient: () => NornsClient,
+  NornsError: () => NornsError,
+  NornsTimeoutError: () => NornsTimeoutError,
+  NornsWorker: () => NornsWorker,
+  NotFoundError: () => NotFoundError,
+  StreamClosedError: () => StreamClosedError,
+  consoleLogger: () => consoleLogger,
+  defineAgent: () => defineAgent,
+  inferProvider: () => inferProvider,
+  jsonSchema: () => import_ai4.jsonSchema,
+  silentLogger: () => silentLogger,
+  tool: () => tool
+});
+module.exports = __toCommonJS(index_exports);
+var import_ai4 = require("ai");
+
+// src/agent.ts
+var DEFAULT_MODEL = "claude-sonnet-5";
+var SUBAGENT_CONVERSATIONS = ["per_launch", "per_parent"];
+function defineAgent(options) {
+  const name = options.name?.trim();
+  if (!name) throw new Error("defineAgent(): name is required");
+  const tools = options.tools ?? [];
+  const known = new Set(tools.map((t) => t.name));
+  if (known.size !== tools.length) {
+    throw new Error(`Agent '${name}': tool names must be unique`);
+  }
+  if (options.allowedTools) {
+    const unknown = options.allowedTools.filter((n) => !known.has(n));
+    if (unknown.length > 0) {
+      throw new Error(
+        `Agent '${name}': allowedTools names ${JSON.stringify(unknown)} are not in its tools (${JSON.stringify([...known].sort())}); built-ins are always available and need no entry`
+      );
+    }
+  }
+  if (options.subagentConversation !== void 0 && !SUBAGENT_CONVERSATIONS.includes(options.subagentConversation)) {
+    throw new Error(
+      `Agent '${name}': subagentConversation must be one of ${SUBAGENT_CONVERSATIONS.join(", ")}`
+    );
+  }
+  if (options.maxTokens !== void 0 && !(Number.isInteger(options.maxTokens) && options.maxTokens > 0)) {
+    throw new Error(`Agent '${name}': maxTokens must be a positive integer`);
+  }
+  return Object.freeze({
+    name,
+    purpose: options.purpose,
+    model: options.model ?? DEFAULT_MODEL,
+    systemPrompt: options.systemPrompt ?? "",
+    tools: Object.freeze([...tools]),
+    mode: options.mode ?? "task",
+    checkpointPolicy: options.checkpointPolicy ?? "on_tool_call",
+    contextStrategy: options.contextStrategy ?? "sliding_window",
+    contextWindow: options.contextWindow ?? 20,
+    maxSteps: options.maxSteps ?? 50,
+    onFailure: options.onFailure ?? "retry_last_step",
+    contextPolicy: options.contextPolicy,
+    maxTokens: options.maxTokens,
+    allowedTools: options.allowedTools ? Object.freeze([...options.allowedTools]) : void 0,
+    subagents: options.subagents,
+    subagentConversation: options.subagentConversation
+  });
+}
+function agentBody(agent) {
+  const modelConfig = {
+    mode: agent.mode,
+    checkpoint_policy: agent.checkpointPolicy,
+    context_strategy: agent.contextStrategy,
+    context_window: agent.contextWindow,
+    on_failure: agent.onFailure,
+    context_policy: agent.contextPolicy ? { compact_at: agent.contextPolicy.compactAt, keep: agent.contextPolicy.keep } : null,
+    max_tokens: agent.maxTokens ?? null
+  };
+  if (agent.allowedTools) {
+    modelConfig.tools = { mode: "allowlist", allowed_tools: [...agent.allowedTools] };
+  }
+  if (agent.subagents) {
+    const s = agent.subagents;
+    const policy = {};
+    if (s.mode !== void 0) policy.mode = s.mode;
+    if (s.allowedAgents !== void 0) policy.allowed_agents = [...s.allowedAgents];
+    if (s.allowListAgents !== void 0) policy.allow_list_agents = s.allowListAgents;
+    if (s.maxDepth !== void 0) policy.max_depth = s.maxDepth;
+    modelConfig.subagents = policy;
+  }
+  if (agent.subagentConversation) {
+    modelConfig.subagent_conversation = agent.subagentConversation;
+  }
+  const body = {
+    name: agent.name,
+    system_prompt: agent.systemPrompt,
+    status: "idle",
+    model: agent.model,
+    max_steps: agent.maxSteps,
+    model_config: modelConfig
+  };
+  if (agent.purpose !== void 0) body.purpose = agent.purpose;
+  return body;
+}
+function agentList(agents) {
+  const items = Array.isArray(agents) ? [...agents] : [agents];
+  if (items.length === 0) throw new Error("A worker needs at least one agent");
+  const seen = /* @__PURE__ */ new Set();
+  const dupes = /* @__PURE__ */ new Set();
+  for (const a of items) {
+    if (seen.has(a.name)) dupes.add(a.name);
+    seen.add(a.name);
+  }
+  if (dupes.size > 0) {
+    throw new Error(
+      `Agent names must be unique on one worker: ${JSON.stringify([...dupes].sort())}`
+    );
+  }
+  return items;
+}
+function toolsByName(agents) {
+  const tools = /* @__PURE__ */ new Map();
+  const owners = /* @__PURE__ */ new Map();
+  for (const agent of agents) {
+    for (const t of agent.tools) {
+      const existing = tools.get(t.name);
+      if (existing === void 0) {
+        tools.set(t.name, t);
+        owners.set(t.name, agent.name);
+      } else if (existing !== t) {
+        throw new Error(
+          `Agents '${owners.get(t.name)}' and '${agent.name}' have different tools named '${t.name}'; tools are dispatched by name, so share one definition or rename one`
+        );
+      }
+    }
+  }
+  return tools;
+}
+
+// src/client.ts
+var import_phoenix = require("phoenix");
+
+// src/async-queue.ts
+var AsyncQueue = class {
+  #values = [];
+  #waiters = [];
+  #done = false;
+  #error = void 0;
+  push(value) {
+    if (this.#done) return;
+    const waiter = this.#waiters.shift();
+    if (waiter) waiter.resolve({ value, done: false });
+    else this.#values.push(value);
+  }
+  close() {
+    if (this.#done) return;
+    this.#done = true;
+    for (const w of this.#waiters.splice(0)) w.resolve({ value: void 0, done: true });
+  }
+  fail(error) {
+    if (this.#done) return;
+    this.#done = true;
+    this.#error = error;
+    for (const w of this.#waiters.splice(0)) w.reject(error);
+  }
+  get closed() {
+    return this.#done;
+  }
+  next() {
+    if (this.#values.length > 0) {
+      return Promise.resolve({ value: this.#values.shift(), done: false });
+    }
+    if (this.#done) {
+      return this.#error !== void 0 ? Promise.reject(this.#error) : Promise.resolve({ value: void 0, done: true });
+    }
+    return new Promise((resolve, reject) => this.#waiters.push({ resolve, reject }));
+  }
+  [Symbol.asyncIterator]() {
+    return { next: () => this.next() };
+  }
+};
+
+// src/errors.ts
+var NornsError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "NornsError";
+  }
+};
+var NornsApiError = class extends NornsError {
+  status;
+  body;
+  constructor(status, body, message) {
+    super(message ?? `Norns API error ${status}: ${describeBody(body)}`);
+    this.name = "NornsApiError";
+    this.status = status;
+    this.body = body;
+  }
+};
+var NotFoundError = class extends NornsApiError {
+  constructor(what, body = void 0) {
+    super(404, body, `${what} not found`);
+    this.name = "NotFoundError";
+  }
+};
+var NornsTimeoutError = class extends NornsError {
+  constructor(message) {
+    super(message);
+    this.name = "NornsTimeoutError";
+  }
+};
+var JoinError = class extends NornsError {
+  reason;
+  code;
+  constructor(reason, code) {
+    super(`worker join rejected: ${reason}${code ? ` (${code})` : ""}`);
+    this.name = "JoinError";
+    this.reason = reason;
+    this.code = code;
+  }
+};
+var GardDestroyedError = class extends NornsError {
+  constructor(gard) {
+    super(`gard ${gard ?? "?"} was destroyed`);
+    this.name = "GardDestroyedError";
+  }
+};
+var StreamClosedError = class extends NornsError {
+  reason;
+  constructor(reason) {
+    super(`stream closed before the run finished: ${describeBody(reason)}`);
+    this.name = "StreamClosedError";
+    this.reason = reason;
+  }
+};
+function describeBody(body) {
+  if (typeof body === "string") return body;
+  if (body && typeof body === "object" && "error" in body) {
+    const err = body.error;
+    return typeof err === "string" ? err : JSON.stringify(err);
+  }
+  if (body instanceof Error) return body.message;
+  try {
+    return JSON.stringify(body);
+  } catch {
+    return String(body);
+  }
+}
+function errorMessage(err) {
+  if (err instanceof Error) return err.message;
+  return describeBody(err);
+}
+
+// src/types.ts
+var TERMINAL_EVENTS = /* @__PURE__ */ new Set(["completed", "error"]);
+
+// src/client.ts
+var WAIT_STOPS = /* @__PURE__ */ new Set(["completed", "failed", "error", "waiting"]);
+var NornsClient = class {
+  url;
+  #apiKey;
+  #fetch;
+  #transport;
+  #socketOptions;
+  constructor(options = {}) {
+    this.url = resolveUrl(options.url);
+    this.#apiKey = resolveApiKey(options.apiKey);
+    this.#fetch = options.fetch ?? globalThis.fetch;
+    this.#transport = options.transport;
+    this.#socketOptions = options.socketOptions ?? {};
+  }
+  // --- Agents ---
+  agents = {
+    list: async () => {
+      const res = await this.#request("GET", "/api/v1/agents");
+      return res.data.map(parseAgent);
+    },
+    /** By id, or by name. */
+    get: async (agent) => {
+      if (typeof agent === "number") {
+        const res = await this.#request(
+          "GET",
+          `/api/v1/agents/${agent}`
+        );
+        return parseAgent(res.data);
+      }
+      const found = (await this.agents.list()).find((a) => a.name === agent);
+      if (!found) throw new NotFoundError(`Agent '${agent}'`);
+      return found;
+    },
+    /**
+     * Create the agent, or update it to match the definition if it exists,
+     * so code changes are always picked up. The worker does this on start.
+     */
+    ensure: async (definition) => {
+      const body = agentBody(definition);
+      const existing = (await this.agents.list()).find((a) => a.name === definition.name);
+      if (existing) {
+        const res2 = await this.#request(
+          "PUT",
+          `/api/v1/agents/${existing.id}`,
+          { body }
+        );
+        return parseAgent(res2.data);
+      }
+      const res = await this.#request("POST", "/api/v1/agents", {
+        body
+      });
+      return parseAgent(res.data);
+    }
+  };
+  // --- Messages ---
+  /**
+   * Send a message to an agent. Returns at once with the run id, or, with
+   * `wait`, once the run completes, fails, or parks on a question.
+   */
+  async sendMessage(agent, content, options = {}) {
+    const agentId = await this.#resolveAgentId(agent);
+    const runId = await this.#post(agentId, content, options);
+    if (!options.wait) {
+      return {
+        runId,
+        status: "accepted",
+        output: null,
+        conversationKey: options.conversationKey,
+        isWaiting: false,
+        waitingFor: null
+      };
+    }
+    const run = await this.#waitForRun(runId, options.timeoutMs ?? 3e4, options.signal);
+    return {
+      runId,
+      status: run.status,
+      output: run.output,
+      conversationKey: options.conversationKey,
+      isWaiting: run.status === "waiting",
+      waitingFor: run.waitingFor
+    };
+  }
+  /**
+   * Send a message and iterate the run's events as they happen, until it
+   * completes or errors.
+   *
+   *     for await (const event of client.stream("researcher", "Summarise this")) {
+   *       if (event.type === "completed") console.log(event.data.output);
+   *     }
+   */
+  async *stream(agent, content, options = {}) {
+    const agentId = await this.#resolveAgentId(agent);
+    const runId = await this.#post(agentId, content, options);
+    yield* this.#watch(agentId, runId, options);
+  }
+  // --- Runs ---
+  runs = {
+    get: async (runId) => {
+      const res = await this.#request(
+        "GET",
+        `/api/v1/runs/${runId}`
+      );
+      return parseRun(res.data);
+    },
+    /**
+     * The tenant's runs, most recent first. Use it to find runs nobody holds
+     * a handle to, above all the ones parked on an `ask_human` question:
+     *
+     *     for (const run of await client.runs.list({ status: "waiting" })) {
+     *       console.log(run.id, run.waitingFor?.question);
+     *     }
+     *
+     * `status` and `agentId` filter the page the server returned, so a
+     * narrow filter over a busy tenant may need a larger `limit`.
+     */
+    list: async (options = {}) => {
+      const res = await this.#request("GET", "/api/v1/runs", {
+        query: { limit: options.limit ?? 50 }
+      });
+      let runs = res.data.map(parseRun);
+      if (options.status) runs = runs.filter((r) => r.status === options.status);
+      if (options.agentId !== void 0) runs = runs.filter((r) => r.agentId === options.agentId);
+      return runs;
+    },
+    events: async (runId) => {
+      const res = await this.#request(
+        "GET",
+        `/api/v1/runs/${runId}/events`
+      );
+      return res.data.map(parseEvent);
+    },
+    /**
+     * Answer a run parked on an `ask_human` question. Sending the agent a
+     * normal message does the same and is usually what a chat client wants;
+     * this targets one specific run.
+     */
+    reply: async (runId, answer) => {
+      await this.#request("POST", `/api/v1/runs/${runId}/reply`, { body: { answer } });
+    },
+    /** Re-run a finished or failed run's message. Returns the new run id. */
+    retry: async (runId) => {
+      const res = await this.#request("POST", `/api/v1/runs/${runId}/retry`);
+      return res.run_id;
+    },
+    /** Iterate an existing run's events as they happen, until it finishes. */
+    watch: (runId, options = {}) => {
+      const self = this;
+      return (async function* () {
+        const run = await self.runs.get(runId);
+        yield* self.#watch(run.agentId, runId, options);
+      })();
+    }
+  };
+  // --- Conversations ---
+  conversations = {
+    list: async (agent) => {
+      const agentId = await this.#resolveAgentId(agent);
+      const res = await this.#request(
+        "GET",
+        `/api/v1/agents/${agentId}/conversations`
+      );
+      return res.data.map(parseConversation);
+    },
+    get: async (agent, key) => {
+      const agentId = await this.#resolveAgentId(agent);
+      const res = await this.#request(
+        "GET",
+        `/api/v1/agents/${agentId}/conversations/${encodeURIComponent(key)}`
+      );
+      return parseConversation(res.data);
+    },
+    /** Reset a conversation: its history is gone, the next message starts fresh. */
+    delete: async (agent, key) => {
+      const agentId = await this.#resolveAgentId(agent);
+      await this.#request(
+        "DELETE",
+        `/api/v1/agents/${agentId}/conversations/${encodeURIComponent(key)}`
+      );
+    }
+  };
+  // --- Internals ---
+  async #resolveAgentId(agent) {
+    return typeof agent === "number" ? agent : (await this.agents.get(agent)).id;
+  }
+  async #post(agentId, content, options) {
+    const body = { content };
+    if (options.conversationKey !== void 0) body.conversation_key = options.conversationKey;
+    if (options.context !== void 0) body.context = options.context;
+    if (options.gardId !== void 0) body.gard_id = options.gardId;
+    const res = await this.#request(
+      "POST",
+      `/api/v1/agents/${agentId}/messages`,
+      {
+        body,
+        signal: options.signal
+      }
+    );
+    return res.run_id;
+  }
+  // Poll until the run stops progressing. "waiting" is not terminal, but
+  // the agent is parked on a question and will not move until someone
+  // answers, so it ends the wait too.
+  async #waitForRun(runId, timeoutMs, signal) {
+    const deadline = Date.now() + timeoutMs;
+    let interval = 500;
+    while (Date.now() < deadline) {
+      const run = await this.runs.get(runId);
+      if (WAIT_STOPS.has(run.status)) return run;
+      await sleep(Math.min(interval, Math.max(deadline - Date.now(), 0)), signal);
+      interval = Math.min(interval * 1.5, 3e3);
+    }
+    throw new NornsTimeoutError(`Run ${runId} did not complete within ${timeoutMs}ms`);
+  }
+  async *#watch(agentId, runId, options) {
+    const idle = options.idleTimeoutMs ?? 12e4;
+    const queue = new AsyncQueue();
+    const socket = new import_phoenix.Socket(`${wsBase(this.url)}/socket`, {
+      params: { token: this.#apiKey },
+      ...this.#transport ? { transport: this.#transport } : {},
+      ...this.#socketOptions
+    });
+    let timer;
+    const touch = () => {
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(
+        () => queue.fail(new NornsTimeoutError(`No event for ${idle}ms on run ${runId}`)),
+        idle
+      );
+    };
+    const onAbort = () => queue.fail(options.signal?.reason ?? abortError());
+    socket.onError((err) => queue.fail(new StreamClosedError(err)));
+    socket.onClose((ev) => queue.fail(new StreamClosedError(ev)));
+    const channel = socket.channel(`agent:${agentId}`, { run_id: runId });
+    channel.onMessage = (event, payload) => {
+      if (!event.startsWith("phx_") && !event.startsWith("chan_reply_") && event !== "heartbeat") {
+        if (payload?.run_id === void 0 || payload.run_id === runId) {
+          queue.push({ type: event, data: payload });
+          touch();
+        }
+      }
+      return payload;
+    };
+    channel.join().receive(
+      "error",
+      (resp) => queue.fail(new NornsError(`Could not join agent:${agentId}: ${JSON.stringify(resp)}`))
+    ).receive(
+      "timeout",
+      () => queue.fail(new NornsTimeoutError(`Joining agent:${agentId} timed out`))
+    );
+    if (options.signal?.aborted) onAbort();
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    socket.connect();
+    touch();
+    try {
+      for await (const event of queue) {
+        yield event;
+        if (TERMINAL_EVENTS.has(event.type)) return;
+      }
+    } finally {
+      if (timer) clearTimeout(timer);
+      options.signal?.removeEventListener("abort", onAbort);
+      queue.close();
+      socket.disconnect();
+    }
+  }
+  async #request(method, path, options = {}) {
+    const url = new URL(this.url + path);
+    for (const [k, v] of Object.entries(options.query ?? {})) url.searchParams.set(k, String(v));
+    const headers = {
+      authorization: `Bearer ${this.#apiKey}`,
+      accept: "application/json"
+    };
+    if (options.body !== void 0) headers["content-type"] = "application/json";
+    const res = await this.#fetch(url, {
+      method,
+      headers,
+      body: options.body === void 0 ? void 0 : JSON.stringify(options.body),
+      signal: options.signal
+    });
+    const text = await res.text();
+    const json = text === "" ? void 0 : safeParse(text);
+    if (!res.ok) {
+      if (res.status === 404) throw new NotFoundError(`${method} ${path}`, json ?? text);
+      throw new NornsApiError(res.status, json ?? text);
+    }
+    return json;
+  }
+};
+function resolveUrl(url) {
+  const value = url ?? process.env.NORNS_URL;
+  if (!value) throw new NornsError("Norns URL missing: pass `url` or set NORNS_URL");
+  return value.replace(/\/+$/, "");
+}
+function resolveApiKey(apiKey) {
+  const value = apiKey ?? process.env.NORNS_API_KEY;
+  if (!value) throw new NornsError("Norns API key missing: pass `apiKey` or set NORNS_API_KEY");
+  return value;
+}
+function wsBase(url) {
+  return url.replace(/^http:\/\//, "ws://").replace(/^https:\/\//, "wss://");
+}
+function safeParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function abortError() {
+  return new DOMException("The operation was aborted", "AbortError");
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) return reject(signal.reason ?? abortError());
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    function onAbort() {
+      clearTimeout(timer);
+      reject(signal?.reason ?? abortError());
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function parseWaitingFor(data) {
+  if (!data || typeof data !== "object") return null;
+  const w = data;
+  return {
+    question: String(w.question ?? ""),
+    toolCallId: String(w.tool_call_id ?? ""),
+    askedAt: typeof w.asked_at === "string" ? w.asked_at : void 0
+  };
+}
+function parseRun(r) {
+  return {
+    id: r.id,
+    agentId: r.agent_id,
+    conversationId: r.conversation_id ?? null,
+    parentRunId: r.parent_run_id ?? null,
+    gardId: r.gard_id ?? null,
+    status: r.status,
+    triggerType: r.trigger_type ?? "message",
+    input: r.input ?? {},
+    output: r.output ?? null,
+    waitingFor: parseWaitingFor(r.waiting_for),
+    failureMetadata: r.failure_metadata ?? {},
+    inputTokens: r.input_tokens ?? 0,
+    outputTokens: r.output_tokens ?? 0,
+    cost: r.cost ?? null,
+    insertedAt: r.inserted_at,
+    updatedAt: r.updated_at ?? r.inserted_at
+  };
+}
+function parseEvent(e) {
+  return {
+    id: e.id,
+    sequence: e.sequence,
+    eventType: e.event_type,
+    payload: e.payload ?? {},
+    source: e.source ?? "",
+    insertedAt: e.inserted_at
+  };
+}
+function parseAgent(a) {
+  return {
+    id: a.id,
+    name: a.name,
+    purpose: a.purpose ?? null,
+    status: a.status ?? "active",
+    model: a.model ?? "",
+    systemPrompt: a.system_prompt ?? "",
+    maxSteps: a.max_steps ?? 50,
+    contextStrategy: a.context_strategy ?? "sliding_window",
+    contextWindow: a.context_window ?? 20,
+    archivedAt: a.archived_at ?? null,
+    insertedAt: a.inserted_at,
+    updatedAt: a.updated_at ?? a.inserted_at
+  };
+}
+function parseConversation(c) {
+  return {
+    id: c.id,
+    agentId: c.agent_id,
+    key: c.key,
+    summary: c.summary ?? null,
+    messageCount: c.message_count ?? 0,
+    tokenEstimate: c.token_estimate ?? 0,
+    insertedAt: c.inserted_at,
+    updatedAt: c.updated_at ?? c.inserted_at
+  };
+}
+
+// src/logger.ts
+var consoleLogger = {
+  debug() {
+  },
+  info: (message, ...rest) => console.log(`[norns] ${message}`, ...rest),
+  warn: (message, ...rest) => console.warn(`[norns] ${message}`, ...rest),
+  error: (message, ...rest) => console.error(`[norns] ${message}`, ...rest)
+};
+var silentLogger = {
+  debug() {
+  },
+  info() {
+  },
+  warn() {
+  },
+  error() {
+  }
+};
+function resolveLogger(logger) {
+  if (logger === null) return silentLogger;
+  return logger ?? consoleLogger;
+}
+
+// src/models.ts
+var PROVIDER_PACKAGES = {
+  anthropic: "@ai-sdk/anthropic",
+  openai: "@ai-sdk/openai",
+  google: "@ai-sdk/google",
+  mistral: "@ai-sdk/mistral"
+};
+function inferProvider(model) {
+  const sep = model.search(/[/:]/);
+  if (sep > 0) {
+    const provider = model.slice(0, sep);
+    if (provider in PROVIDER_PACKAGES || /^[a-z][a-z0-9-]*$/.test(provider)) {
+      return { provider, modelId: model.slice(sep + 1) };
+    }
+  }
+  const lower = model.toLowerCase();
+  if (lower.startsWith("claude")) return { provider: "anthropic", modelId: model };
+  if (/^(gpt|o[1-9]|chatgpt|text-)/.test(lower)) return { provider: "openai", modelId: model };
+  if (lower.startsWith("gemini")) return { provider: "google", modelId: model };
+  if (/^(mistral|codestral|ministral|pixtral|magistral)/.test(lower)) {
+    return { provider: "mistral", modelId: model };
+  }
+  return { provider: "anthropic", modelId: model };
+}
+function defaultModelResolver() {
+  const cache = /* @__PURE__ */ new Map();
+  return (model) => {
+    let pending = cache.get(model);
+    if (!pending) {
+      pending = loadModel(model);
+      cache.set(model, pending);
+      pending.catch(() => cache.delete(model));
+    }
+    return pending;
+  };
+}
+async function loadModel(model) {
+  const { provider, modelId } = inferProvider(model);
+  const pkg = PROVIDER_PACKAGES[provider] ?? `@ai-sdk/${provider}`;
+  let mod;
+  try {
+    mod = await import(pkg);
+  } catch (err) {
+    throw new Error(
+      `No provider for model '${model}': install ${pkg} (npm install ${pkg}), or pass \`models\` to the worker to resolve models yourself`,
+      { cause: err }
+    );
+  }
+  const instance = findProvider(mod, provider);
+  if (!instance) {
+    throw new Error(`${pkg} exports no provider instance; pass \`models\` to the worker`);
+  }
+  return instance(modelId);
+}
+function findProvider(mod, provider) {
+  const named = mod[provider];
+  if (typeof named === "function") return named;
+  for (const value of Object.values(mod)) {
+    if (typeof value === "function" && "languageModel" in value) return value;
+  }
+  return void 0;
+}
+function toResolver(models) {
+  if (models === void 0) return defaultModelResolver();
+  if (typeof models === "function") return models;
+  return (id) => models.languageModel(id);
+}
+
+// src/tool.ts
+var import_ai = require("ai");
+var EMPTY_SCHEMA = { type: "object", properties: {} };
+function tool(options) {
+  const name = options.name?.trim();
+  if (!name) throw new Error("tool(): name is required");
+  if (!options.description?.trim()) throw new Error(`tool('${name}'): description is required`);
+  if (typeof options.execute !== "function") {
+    throw new Error(`tool('${name}'): execute must be a function`);
+  }
+  let inputSchema = EMPTY_SCHEMA;
+  let validate;
+  if (options.input !== void 0) {
+    const schema = (0, import_ai.asSchema)(toFlexible(options.input));
+    const json = schema.jsonSchema;
+    if (isPromiseLike(json)) {
+      throw new Error(`tool('${name}'): input schema must resolve synchronously`);
+    }
+    inputSchema = stripMeta(json);
+    if (schema.validate) {
+      const run = schema.validate;
+      validate = async (value) => {
+        const result = await run(value);
+        return result.success ? { success: true, value: result.value } : { success: false, error: result.error };
+      };
+    }
+  }
+  const execute = options.execute;
+  return Object.freeze({
+    name,
+    description: options.description.trim(),
+    inputSchema,
+    sideEffect: options.sideEffect ?? false,
+    validate,
+    execute: async (input, context) => execute(input, context)
+  });
+}
+function toolRegistration(t) {
+  return {
+    name: t.name,
+    description: t.description,
+    input_schema: t.inputSchema,
+    side_effect: t.sideEffect
+  };
+}
+function stringifyToolOutput(value) {
+  if (value === void 0 || value === null) return "";
+  if (typeof value === "string") return value;
+  return JSON.stringify(value);
+}
+function toFlexible(input) {
+  if (isRawJsonSchema(input)) return (0, import_ai.jsonSchema)(input);
+  return input;
+}
+function isRawJsonSchema(value) {
+  if (typeof value !== "object" || value === null) return false;
+  if ("~standard" in value || "_zod" in value || "_def" in value || "jsonSchema" in value) {
+    return false;
+  }
+  return true;
+}
+function isPromiseLike(value) {
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+function stripMeta(schema) {
+  const { $schema: _ignored, ...rest } = schema;
+  return rest;
+}
+
+// src/worker.ts
+var import_node_crypto = require("crypto");
+var import_ai3 = require("ai");
+var import_phoenix2 = require("phoenix");
+
+// src/completed-calls.ts
+var import_node_fs = require("fs");
+var import_node_os = require("os");
+var import_node_path = require("path");
+var MAX_REMEMBERED_RESULTS = 512;
+var CompletedCalls = class {
+  #path;
+  #limit;
+  #entries = /* @__PURE__ */ new Map();
+  #logger;
+  constructor(path, logger, limit = MAX_REMEMBERED_RESULTS) {
+    this.#path = path;
+    this.#limit = limit;
+    this.#logger = logger;
+    this.#load();
+  }
+  get path() {
+    return this.#path;
+  }
+  get size() {
+    return this.#entries.size;
+  }
+  has(key) {
+    return this.#entries.has(key);
+  }
+  get(key) {
+    const entry = this.#entries.get(key);
+    return entry ? { ...entry } : void 0;
+  }
+  add(key, result) {
+    this.#entries.delete(key);
+    this.#entries.set(key, result);
+    while (this.#entries.size > this.#limit) {
+      const oldest = this.#entries.keys().next().value;
+      if (oldest === void 0) break;
+      this.#entries.delete(oldest);
+    }
+    this.#save();
+  }
+  #load() {
+    if (!this.#path) return;
+    let raw;
+    try {
+      raw = (0, import_node_fs.readFileSync)(this.#path, "utf8");
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        this.#logger.warn(
+          `Could not read ${this.#path} (${err.message}); starting with no memory of completed calls`
+        );
+      }
+      return;
+    }
+    try {
+      const data = JSON.parse(raw);
+      for (const [key, value] of Object.entries(data)) {
+        if (value && typeof value === "object") this.#entries.set(key, value);
+      }
+    } catch (err) {
+      this.#logger.warn(
+        `Could not parse ${this.#path} (${err.message}); starting with no memory of completed calls`
+      );
+    }
+  }
+  #save() {
+    if (!this.#path) return;
+    try {
+      (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(this.#path), { recursive: true });
+      const tmp = `${this.#path}.tmp`;
+      (0, import_node_fs.writeFileSync)(tmp, JSON.stringify(Object.fromEntries(this.#entries)));
+      (0, import_node_fs.renameSync)(tmp, this.#path);
+    } catch (err) {
+      this.#logger.warn(
+        `Could not write ${this.#path} (${err.message}); completed calls will not survive a restart`
+      );
+      this.#path = void 0;
+    }
+  }
+};
+function completedCallsPath(workerId, stateDir) {
+  const base = stateDir === void 0 ? process.env.NORNS_STATE_DIR : stateDir;
+  if (base === "" || base === null) return void 0;
+  const root = base ?? (0, import_node_path.join)((0, import_node_os.tmpdir)(), "norns-worker-state");
+  const safe = workerId.replace(/[^A-Za-z0-9_.-]/g, "_").slice(0, 120);
+  return (0, import_node_path.join)(root, `${safe}.completed.json`);
+}
+
+// src/format.ts
+var import_ai2 = require("ai");
+function composeSystemPrompt(task) {
+  let prompt = task.system_prompt ?? "";
+  if (typeof task.summary === "string" && task.summary !== "") {
+    prompt += `
+
+Summary of earlier conversation: ${task.summary}`;
+  }
+  if (task.date) prompt += `
+
+Current date: ${task.date}.`;
+  return prompt;
+}
+function composeCompactionPrompt(task) {
+  let prompt = task.system_prompt ?? "";
+  if (typeof task.summary === "string" && task.summary !== "") {
+    prompt += `
+
+Summary of earlier conversation: ${task.summary}`;
+  }
+  return prompt;
+}
+var COMPACTION_INSTRUCTION = "Write a summary of the conversation so far for your own future reference. You will continue the same task with only this summary and the most recent messages, so keep every fact you would need: the task and its constraints, decisions made and why, files and identifiers touched, what was tried and failed, what remains to be done, and anything the user asked for that is not finished. Fold in the earlier summary if there is one. Write prose or terse notes, no preamble, no commentary about summarising.";
+function compactionMessages(task) {
+  return [
+    ...renderMessages(task.messages ?? []),
+    { role: "user", content: COMPACTION_INSTRUCTION }
+  ];
+}
+function renderMessage(msg) {
+  if (!msg.kind) return msg;
+  const { kind, data, ...rest } = msg;
+  return { ...rest, content: renderKind(kind, data ?? {}, msg.content) };
+}
+function renderMessages(messages) {
+  return messages.map(renderMessage);
+}
+function renderKind(kind, data, content) {
+  switch (kind) {
+    case "inherited_context":
+      return `[Inherited context from parent agent]
+${encode(content)}`;
+    case "timer_completed":
+      return "Timer completed.";
+    case "tool_denied":
+      return `Tool '${data.tool_name}' is not in this agent's allowed tools.`;
+    case "subagent_denied":
+      if (data.reason === "disabled") return "This agent is not permitted to launch sub-agents.";
+      if (data.reason === "max_depth") {
+        return `Sub-agent nesting limit reached (max depth ${data.max_depth}). Do the work in this agent instead of delegating further.`;
+      }
+      return `Agent '${data.agent_name}' is not in this agent's allowed sub-agents.`;
+    case "subagent_list_denied":
+      return "Listing agents is not permitted for this agent.";
+    case "subagent_not_found":
+      return `Agent '${data.agent_name}' not found`;
+    case "subagent_self":
+      return "Cannot launch self as a sub-agent";
+    case "subagent_missing":
+      return `Sub-agent run ${data.run_id} no longer exists, so its result cannot be recovered.`;
+    case "subagent_busy":
+      return `Agent '${data.agent_name}' is still working on an earlier task for this conversation. Wait for its result before giving it another.`;
+    case "subagent_launch_failed":
+      return `Failed to launch agent '${data.agent_name}': ${data.reason}`;
+    case "subagent_completed":
+      return JSON.stringify({ run_id: data.run_id, status: "completed", output: content ?? "" });
+    case "subagent_failed":
+      return JSON.stringify({ run_id: data.run_id, status: "failed", error: content ?? "" });
+    case "list_agents":
+      return JSON.stringify(data.agents ?? []);
+    default:
+      return content === void 0 || content === null || content === "" ? encode(data) : encode(content);
+  }
+}
+function encode(value) {
+  return typeof value === "string" ? value : JSON.stringify(value ?? null);
+}
+var TOOL_RESULT_CAP = 200;
+function messagesForTask(task) {
+  const rendered = renderMessages(task.messages ?? []);
+  return task.context_policy ? rendered : elideOldToolResults(rendered);
+}
+function elideOldToolResults(messages) {
+  if (messages.length <= 4) return messages;
+  const old = messages.slice(0, -2);
+  const recent = messages.slice(-2);
+  return [
+    ...old.map(
+      (msg) => msg.role === "tool" && typeof msg.content === "string" && msg.content.length > TOOL_RESULT_CAP ? { ...msg, content: `${msg.content.slice(0, TOOL_RESULT_CAP)}...(truncated)` } : msg
+    ),
+    ...recent
+  ];
+}
+var DEFAULT_MAX_TOKENS = 8192;
+function maxTokens(task) {
+  const v = task.max_tokens;
+  return typeof v === "number" && Number.isInteger(v) && v > 0 ? v : DEFAULT_MAX_TOKENS;
+}
+function finalOutput(messages, content) {
+  const text = typeof content === "string" ? content : "";
+  if (text.trim() !== "") return text;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (m?.role === "assistant" && typeof m.content === "string" && m.content.trim() !== "") {
+      return m.content;
+    }
+  }
+  return text;
+}
+var CACHE_CONTROL = { anthropic: { cacheControl: { type: "ephemeral" } } };
+function toInstructions(system) {
+  if (system === "") return void 0;
+  return { role: "system", content: system, providerOptions: CACHE_CONTROL };
+}
+function toModelMessages(messages) {
+  const out = [];
+  for (const msg of messages) {
+    const converted = toModelMessage(msg);
+    const last2 = out[out.length - 1];
+    if (converted.role === "tool" && last2?.role === "tool") {
+      last2.content = [...last2.content, ...converted.content];
+    } else {
+      out.push(converted);
+    }
+  }
+  const last = out[out.length - 1];
+  if (last) last.providerOptions = CACHE_CONTROL;
+  return out;
+}
+function toModelMessage(msg) {
+  switch (msg.role) {
+    case "system":
+      return { role: "system", content: encode(msg.content ?? "") };
+    case "assistant": {
+      const text = typeof msg.content === "string" ? msg.content : encode(msg.content ?? "");
+      const calls = msg.tool_calls ?? [];
+      if (calls.length === 0) return { role: "assistant", content: text };
+      return {
+        role: "assistant",
+        content: [
+          ...text !== "" ? [{ type: "text", text }] : [],
+          ...calls.map((tc) => ({
+            type: "tool-call",
+            toolCallId: tc.id,
+            toolName: tc.name,
+            input: parseArguments(tc.arguments)
+          }))
+        ]
+      };
+    }
+    case "tool": {
+      const value = encode(msg.content ?? "");
+      return {
+        role: "tool",
+        content: [
+          {
+            type: "tool-result",
+            toolCallId: msg.tool_call_id ?? "",
+            toolName: msg.name ?? "",
+            output: msg.is_error ? { type: "error-text", value } : { type: "text", value }
+          }
+        ]
+      };
+    }
+    default:
+      return { role: "user", content: encode(msg.content ?? "") };
+  }
+}
+function parseArguments(args) {
+  if (typeof args !== "string") return args ?? {};
+  try {
+    return JSON.parse(args);
+  } catch {
+    return { raw: args };
+  }
+}
+function toToolSet(tools) {
+  const set = {};
+  for (const t of tools) {
+    set[t.name] = (0, import_ai2.tool)({
+      description: t.description ?? "",
+      inputSchema: (0, import_ai2.jsonSchema)(t.parameters ?? t.input_schema ?? { type: "object", properties: {} })
+    });
+  }
+  return set;
+}
+function fromGenerateResult(result) {
+  const out = {
+    status: "ok",
+    content: result.text ?? "",
+    finish_reason: neutralFinishReason(result.finishReason, result.toolCalls.length > 0),
+    usage: neutralUsage(result.usage)
+  };
+  if (result.response?.modelId) out.model = result.response.modelId;
+  if (result.toolCalls.length > 0) {
+    out.tool_calls = result.toolCalls.map((tc) => ({
+      id: tc.toolCallId,
+      name: tc.toolName,
+      arguments: tc.input ?? {}
+    }));
+  }
+  return out;
+}
+function neutralFinishReason(reason, hasToolCalls) {
+  if (hasToolCalls) return "tool_call";
+  switch (reason) {
+    case "tool-calls":
+      return "tool_call";
+    case "length":
+      return "length";
+    case "error":
+      return "error";
+    default:
+      return "stop";
+  }
+}
+function neutralUsage(usage) {
+  const details = usage?.inputTokenDetails;
+  const read = details?.cacheReadTokens ?? 0;
+  const write = details?.cacheWriteTokens ?? 0;
+  const total = usage?.inputTokens ?? 0;
+  const noCache = details?.noCacheTokens;
+  const input = noCache !== void 0 ? Math.max(total, noCache + read + write) : total;
+  const out = { input_tokens: input, output_tokens: usage?.outputTokens ?? 0 };
+  if (read > 0) out.cache_read_tokens = read;
+  if (write > 0) out.cache_write_tokens = write;
+  return out;
+}
+
+// src/history-cache.ts
+var HistoryCache = class {
+  #runs = /* @__PURE__ */ new Map();
+  #maxRuns;
+  constructor(maxRuns = 256) {
+    this.#maxRuns = maxRuns;
+  }
+  /** The task with `messages` filled in, or `undefined` on a miss. */
+  resolve(task) {
+    if (task.purpose === "compact") return task;
+    const runId = task.run_id;
+    const delta = task.messages_delta;
+    if (delta === void 0) {
+      if (runId !== void 0 && Array.isArray(task.messages)) this.#remember(runId, task.messages);
+      return task;
+    }
+    const previous = runId === void 0 ? void 0 : this.#runs.get(runId);
+    if (runId === void 0 || previous === void 0 || previous.length !== delta.base_count) {
+      return void 0;
+    }
+    const messages = [...previous.slice(delta.drop), ...delta.append];
+    this.#remember(runId, messages);
+    const resolved = { ...task, messages };
+    delete resolved.messages_delta;
+    return resolved;
+  }
+  /** Forget everything: a new connection gets the full history anyway. */
+  clear() {
+    this.#runs.clear();
+  }
+  /** How many runs are held; for tests. */
+  get size() {
+    return this.#runs.size;
+  }
+  #remember(runId, messages) {
+    this.#runs.delete(runId);
+    this.#runs.set(runId, messages);
+    while (this.#runs.size > this.#maxRuns) {
+      const oldest = this.#runs.keys().next().value;
+      if (oldest === void 0) break;
+      this.#runs.delete(oldest);
+    }
+  }
+};
+
+// src/worker.ts
+var TOPIC = "worker:lobby";
+var NornsWorker = class {
+  url;
+  workerId;
+  gard;
+  #apiKey;
+  #agents;
+  #tools;
+  #capabilities;
+  #claimToken;
+  #shutdownTimeoutMs;
+  #handleSignals;
+  #logger;
+  #stateDir;
+  #transport;
+  #socketOptions;
+  #client;
+  #resolveModel;
+  #inFlight = /* @__PURE__ */ new Set();
+  #history = new HistoryCache();
+  #state = "idle";
+  #socket;
+  #channel;
+  #completed;
+  #starting;
+  #signalHandler;
+  #stopped;
+  #settleStopped;
+  constructor(options) {
+    this.url = resolveUrl(options.url);
+    this.#apiKey = resolveApiKey(options.apiKey);
+    this.#agents = agentList(options.agents);
+    this.#tools = toolsByName(this.#agents);
+    this.#capabilities = options.capabilities ?? ["llm", "tools"];
+    if (this.#capabilities.length === 0)
+      throw new NornsError("A worker needs at least one capability");
+    this.#logger = resolveLogger(options.logger);
+    this.#stateDir = options.stateDir;
+    this.#transport = options.transport;
+    this.#socketOptions = options.socketOptions ?? {};
+    this.#handleSignals = options.handleSignals ?? true;
+    this.#resolveModel = toResolver(options.models);
+    this.workerId = options.workerId ?? process.env.NORNS_WORKER_ID ?? `ts-worker-${(0, import_node_crypto.randomBytes)(4).toString("hex")}`;
+    this.gard = options.gard ?? process.env.NORNS_GARD;
+    this.#claimToken = options.claimToken ?? process.env.NORNS_GARD_CLAIM_TOKEN;
+    const envTimeout = Number(process.env.NORNS_SHUTDOWN_TIMEOUT);
+    this.#shutdownTimeoutMs = options.shutdownTimeoutMs ?? (Number.isFinite(envTimeout) && envTimeout > 0 ? envTimeout * 1e3 : 3e4);
+    this.#client = new NornsClient({ url: this.url, apiKey: this.#apiKey, fetch: options.fetch });
+    this.#stopped = new Promise((resolve, reject) => {
+      this.#settleStopped = { resolve, reject };
+    });
+    this.#stopped.catch(() => {
+    });
+  }
+  /** The agents this worker serves. */
+  get agents() {
+    return this.#agents;
+  }
+  get state() {
+    return this.#state;
+  }
+  /**
+   * Settles once the worker has stopped: resolves after a drain, rejects
+   * with `JoinError` or `GardDestroyedError` when it was forced off.
+   */
+  get stopped() {
+    return this.#stopped;
+  }
+  /**
+   * Register the agents, connect, and join. Resolves once Norns has accepted
+   * the worker; rejects with `JoinError` when it never will (bad claim
+   * token, destroyed gard). A server that is down is retried until it is up.
+   */
+  start() {
+    if (this.#state !== "idle") throw new NornsError("start() may only be called once");
+    this.#state = "starting";
+    this.#starting = this.#start().then(
+      () => {
+        if (this.#state === "starting") this.#state = "running";
+      },
+      (err) => {
+        this.#fail(err);
+        throw err;
+      }
+    );
+    return this.#starting;
+  }
+  async #start() {
+    for (const agent of this.#agents) {
+      const info = await this.#client.agents.ensure(agent);
+      this.#logger.info(`Registered agent '${agent.name}' (id=${info.id})`);
+    }
+    if (this.#capabilities.includes("llm")) {
+      for (const model of new Set(this.#agents.map((a) => a.model))) {
+        await this.#resolveModel(model);
+      }
+    }
+    this.#completed = new CompletedCalls(
+      completedCallsPath(this.workerId, this.#stateDir),
+      this.#logger
+    );
+    await this.#connect();
+    this.#installSignalHandlers();
+  }
+  #connect() {
+    const socket = new import_phoenix2.Socket(`${wsBase(this.url)}/worker`, {
+      params: { token: this.#apiKey },
+      logger: (kind, msg, data) => this.#logger.debug(`phoenix ${kind}: ${msg}`, data),
+      ...this.#transport ? { transport: this.#transport } : {},
+      ...this.#socketOptions
+    });
+    this.#socket = socket;
+    socket.onOpen(() => {
+      this.#logger.info(`Connected to ${this.url}`);
+      this.#history.clear();
+    });
+    socket.onError((err) => {
+      if (this.#state === "starting" || this.#state === "running") {
+        this.#logger.warn(`Connection error (${errorMessage(err)}); retrying`);
+      }
+    });
+    socket.onClose(() => {
+      if (this.#state === "running") {
+        this.#logger.warn("Disconnected from Norns; reconnecting");
+        this.#abortInFlight("socket closed");
+      }
+    });
+    const channel = socket.channel(TOPIC, this.#joinParams());
+    this.#channel = channel;
+    channel.on(
+      "llm_task",
+      (task) => this.#spawn(task.task_id, (s) => this.#runLlm(task, s))
+    );
+    channel.on(
+      "tool_task",
+      (task) => this.#spawn(task.task_id, (s) => this.#runTool(task, s))
+    );
+    channel.on("gard_destroyed", () => {
+      this.#logger.error("This worker's gard was destroyed; shutting down");
+      this.#fail(new GardDestroyedError(this.gard));
+    });
+    channel.onError((reason) => {
+      if (this.#state === "running")
+        this.#logger.warn(`Channel error (${errorMessage(reason)}); rejoining`);
+    });
+    return new Promise((resolve, reject) => {
+      let joined = false;
+      channel.join().receive("ok", () => {
+        if (joined) {
+          this.#logger.info(`Worker ${this.workerId} rejoined`);
+          return;
+        }
+        joined = true;
+        this.#logger.info(
+          this.gard !== void 0 ? `Worker ${this.workerId} ready (gard ${this.gard})` : `Worker ${this.workerId} ready`
+        );
+        resolve();
+      }).receive("error", (resp) => {
+        const reason = resp?.reason ?? "join rejected";
+        if (reason === "already_claimed") {
+          this.#logger.warn("Gard claim rejected: already_claimed; retrying");
+          return;
+        }
+        const err = new JoinError(reason, resp?.code);
+        this.#fail(err);
+        reject(err);
+      }).receive("timeout", () => this.#logger.warn("Join timed out; retrying"));
+      socket.connect();
+    });
+  }
+  #joinParams() {
+    const params = {
+      worker_id: this.workerId,
+      tools: [...this.#tools.values()].map(toolRegistration),
+      capabilities: this.#capabilities,
+      // This worker keeps the history it was last sent per run, so Norns may
+      // send later steps as the change only (HistoryCache).
+      features: ["message_cache"]
+    };
+    if (this.gard !== void 0) {
+      params.gard = this.gard;
+      params.claim_token = this.#claimToken ?? null;
+    }
+    return params;
+  }
+  /**
+   * Drain and stop: tell Norns to send no more work, finish the tasks in
+   * flight (up to the shutdown timeout), report them, leave. Tasks still
+   * running at the deadline are dropped and Norns re-dispatches them.
+   */
+  async stop() {
+    if (this.#state === "idle") {
+      this.#state = "stopped";
+      this.#settleStopped.resolve();
+      return;
+    }
+    if (this.#state === "starting") {
+      try {
+        await this.#starting;
+      } catch {
+        return;
+      }
+    }
+    if (this.#state !== "running") return this.#stopped;
+    this.#state = "draining";
+    const channel = this.#channel;
+    const socket = this.#socket;
+    this.#logger.info(
+      `Draining: ${this.#inFlight.size} in-flight task(s), up to ${this.#shutdownTimeoutMs / 1e3}s`
+    );
+    if (channel) {
+      await new Promise((resolve) => {
+        channel.push("drain", {}, 5e3).receive("ok", () => resolve()).receive("error", (resp) => {
+          this.#logger.warn(
+            `Could not send drain (${errorMessage(resp)}); Norns will re-dispatch on disconnect`
+          );
+          resolve();
+        }).receive("timeout", () => resolve());
+      });
+    }
+    const deadline = Date.now() + this.#shutdownTimeoutMs;
+    while (this.#inFlight.size > 0 && Date.now() < deadline) {
+      await Promise.race([
+        Promise.allSettled([...this.#inFlight].map((t) => t.done)),
+        sleep(deadline - Date.now())
+      ]);
+    }
+    if (this.#inFlight.size > 0) {
+      this.#logger.warn(
+        `${this.#inFlight.size} task(s) still running at the deadline; dropping them, Norns will re-dispatch`
+      );
+      this.#abortInFlight("shutdown deadline");
+    } else {
+      this.#logger.info("Drained; leaving");
+    }
+    if (channel) {
+      await new Promise((resolve) => {
+        channel.leave(5e3).receive("ok", () => resolve()).receive("timeout", () => resolve());
+      });
+    }
+    if (socket) await new Promise((resolve) => socket.disconnect(() => resolve()));
+    this.#teardown();
+    this.#state = "stopped";
+    this.#logger.info("Worker stopped.");
+    this.#settleStopped.resolve();
+  }
+  /**
+   * Expose a service port for the dashboard. Only in a gard: the gard is
+   * inferred from the connection. Call it from a tool after starting a
+   * service.
+   */
+  async registerPort(internalPort, options = {}) {
+    if (this.gard === void 0)
+      throw new NornsError("registerPort requires the worker to be in a gard");
+    const channel = this.#channel;
+    if (channel?.state !== "joined") {
+      throw new NornsError("registerPort requires a connected worker");
+    }
+    const payload = {
+      internal_port: internalPort,
+      name: options.name ?? "",
+      protocol: options.protocol ?? "http"
+    };
+    if (options.url) payload.url = options.url;
+    return new Promise((resolve, reject) => {
+      channel.push("register_port", payload, 1e4).receive(
+        "ok",
+        (resp) => resolve({ id: resp.id, internalPort: resp.internal_port, url: resp.url ?? null })
+      ).receive(
+        "error",
+        (resp) => reject(new NornsError(`register_port rejected: ${errorMessage(resp?.reason ?? resp)}`))
+      ).receive("timeout", () => reject(new NornsError("register_port timed out")));
+    });
+  }
+  // --- Tasks ---
+  // Each task runs on its own: a slow tool or LLM call must not hold up the
+  // others on this connection (parallel tool calls, other runs).
+  #spawn(taskId, run) {
+    const controller = new AbortController();
+    const entry = { taskId, controller, done: Promise.resolve() };
+    entry.done = (async () => {
+      try {
+        const result = await run(controller.signal);
+        this.#deliver(taskId, result);
+      } catch (err) {
+        this.#logger.error(`Task ${taskId} failed unexpectedly: ${errorMessage(err)}`);
+        this.#deliver(taskId, { status: "error", error: errorMessage(err) });
+      } finally {
+        this.#inFlight.delete(entry);
+      }
+    })();
+    this.#inFlight.add(entry);
+  }
+  #deliver(taskId, result) {
+    const channel = this.#channel;
+    if (channel?.state !== "joined") {
+      this.#logger.warn(
+        `Could not deliver result for task ${taskId} (not joined); Norns re-dispatches it on reconnect`
+      );
+      return;
+    }
+    channel.push("tool_result", { ...result, task_id: taskId }).receive(
+      "error",
+      (resp) => this.#logger.warn(`Server rejected result for ${taskId}: ${errorMessage(resp)}`)
+    );
+  }
+  async #runLlm(received, signal) {
+    const task = this.#history.resolve(received);
+    if (task === void 0) {
+      this.#logger.info(
+        "LLM task arrived as a delta on an unknown base; asking for the full history"
+      );
+      return { status: "error", error: "message_cache_miss" };
+    }
+    const model = task.model ?? "?";
+    const tools = task.tools ?? [];
+    this.#logger.info(
+      `LLM call \u2192 ${model} (${task.messages?.length ?? 0} messages, ${tools.length} tools)`
+    );
+    const result = await this.#callModel(task, signal);
+    this.#logger.info(
+      `LLM done \u2192 ${result.status === "ok" ? result.finish_reason : `error: ${result.error}`}`
+    );
+    return result;
+  }
+  async #callModel(task, signal) {
+    try {
+      const model = await this.#resolveModel(
+        task.model ?? this.#agents[0]?.model ?? "claude-sonnet-5"
+      );
+      if (task.purpose === "compact") {
+        const result2 = await (0, import_ai3.generateText)({
+          model,
+          instructions: toInstructions(composeCompactionPrompt(task)),
+          messages: toModelMessages(compactionMessages(task)),
+          maxOutputTokens: maxTokens(task),
+          abortSignal: signal
+        });
+        const out2 = fromGenerateResult(result2);
+        return {
+          status: "ok",
+          content: out2.content,
+          finish_reason: "stop",
+          usage: out2.usage,
+          model: out2.model
+        };
+      }
+      const neutral = messagesForTask(task);
+      const toolSet = toToolSet(task.tools ?? []);
+      const result = await (0, import_ai3.generateText)({
+        model,
+        instructions: toInstructions(composeSystemPrompt(task)),
+        messages: toModelMessages(neutral),
+        tools: Object.keys(toolSet).length > 0 ? toolSet : void 0,
+        maxOutputTokens: maxTokens(task),
+        abortSignal: signal
+      });
+      const out = fromGenerateResult(result);
+      out.final_output = finalOutput(neutral, out.content);
+      return out;
+    } catch (err) {
+      this.#logger.error(`LLM error: ${errorMessage(err)}`);
+      return { status: "error", error: errorMessage(err) };
+    }
+  }
+  async #runTool(task, signal) {
+    const name = task.tool_name ?? "?";
+    this.#logger.info(`Tool call \u2192 ${name}`);
+    const result = await this.#executeTool(task, signal);
+    const preview = (result.status === "ok" ? result.result : result.error).slice(0, 80);
+    this.#logger.info(`Tool done \u2192 ${name}: ${result.status} ${preview}`);
+    return result;
+  }
+  // A key on the task means Norns considers the call side-effecting and has
+  // named it. It cannot know whether the effect landed, so if the result
+  // never reached it, it asks again; this worker answers from what it kept
+  // rather than doing the thing twice.
+  async #executeTool(task, signal) {
+    const key = task.idempotency_key;
+    const completed = this.#completed;
+    if (key && completed?.has(key)) {
+      this.#logger.info(`Tool ${task.tool_name}: already done (${key}), reusing the result`);
+      return completed.get(key);
+    }
+    const tool2 = this.#tools.get(task.tool_name);
+    if (!tool2) return { status: "error", error: `Unknown tool: ${task.tool_name}` };
+    let input = task.input ?? {};
+    if (tool2.validate) {
+      const checked = await tool2.validate(input);
+      if (!checked.success) {
+        return {
+          status: "error",
+          error: `Invalid input for ${tool2.name}: ${checked.error.message}`
+        };
+      }
+      input = checked.value;
+    }
+    const context = {
+      taskId: task.task_id,
+      runId: task.run_id,
+      agentId: task.agent_id,
+      idempotencyKey: key,
+      signal,
+      worker: this
+    };
+    try {
+      const output = await tool2.execute(input, context);
+      const result = { status: "ok", result: stringifyToolOutput(output) };
+      if (key) completed?.add(key, { ...result, duplicate: true });
+      return result;
+    } catch (err) {
+      this.#logger.error(`Tool ${tool2.name} failed: ${errorMessage(err)}`);
+      return { status: "error", error: errorMessage(err) };
+    }
+  }
+  // --- Lifecycle plumbing ---
+  #abortInFlight(reason) {
+    for (const t of this.#inFlight) t.controller.abort(new NornsError(reason));
+  }
+  // Forced off: a fatal join, a destroyed gard. Nothing to drain.
+  #fail(err) {
+    if (this.#state === "stopped") return;
+    this.#state = "stopped";
+    this.#abortInFlight("worker stopped");
+    this.#teardown();
+    this.#socket?.disconnect();
+    this.#settleStopped.reject(err);
+  }
+  #teardown() {
+    if (this.#signalHandler) {
+      process.off("SIGINT", this.#signalHandler);
+      process.off("SIGTERM", this.#signalHandler);
+      this.#signalHandler = void 0;
+    }
+  }
+  #installSignalHandlers() {
+    if (!this.#handleSignals) return;
+    this.#signalHandler = (signal) => {
+      if (this.#state !== "running") {
+        this.#logger.warn(`Received ${signal} again: exiting now`);
+        process.exit(130);
+      }
+      this.#logger.info(`Received ${signal}: shutting down`);
+      void this.stop();
+    };
+    process.on("SIGINT", this.#signalHandler);
+    process.on("SIGTERM", this.#signalHandler);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_MODEL,
+  GardDestroyedError,
+  JoinError,
+  NornsApiError,
+  NornsClient,
+  NornsError,
+  NornsTimeoutError,
+  NornsWorker,
+  NotFoundError,
+  StreamClosedError,
+  consoleLogger,
+  defineAgent,
+  inferProvider,
+  jsonSchema,
+  silentLogger,
+  tool
+});
+//# sourceMappingURL=index.cjs.map