@dudousxd/nestjs-agent-opencode 0.0.0-stage → 0.1.1

package/dist/durable/index.js

@@ -0,0 +1,3109 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/engine.ts
+import { Logger as Logger3 } from "@nestjs/common";
+
+// src/host.ts
+var InMemoryOpenCodeSessionStore = class {
+  static {
+    __name(this, "InMemoryOpenCodeSessionStore");
+  }
+  refs = /* @__PURE__ */ new Map();
+  async get(threadId) {
+    return this.refs.get(threadId) ?? null;
+  }
+  async set(threadId, ref) {
+    this.refs.set(threadId, ref);
+  }
+};
+
+// src/mcp.controller.ts
+import { Body, Controller, Delete, Get, Inject, Post, Req, Res } from "@nestjs/common";
+
+// src/tokens.ts
+var OPENCODE_HOST = /* @__PURE__ */ Symbol.for("@dudousxd/nestjs-agent-opencode:host");
+var OPENCODE_SESSIONS = /* @__PURE__ */ Symbol.for("@dudousxd/nestjs-agent-opencode:sessions");
+var OPENCODE_OPTIONS = /* @__PURE__ */ Symbol.for("@dudousxd/nestjs-agent-opencode:options");
+var OPENCODE_TURNS = /* @__PURE__ */ Symbol.for("@dudousxd/nestjs-agent-opencode:turns");
+var OPENCODE_MCP_ENDPOINT = /* @__PURE__ */ Symbol.for("@dudousxd/nestjs-agent-opencode:mcp-endpoint");
+var OPENCODE_TOOLS_TOKENS = /* @__PURE__ */ Symbol.for("@dudousxd/nestjs-agent-opencode:tools-tokens");
+
+// src/mcp.controller.ts
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+function notAllowed(res) {
+  res.statusCode = 405;
+  res.setHeader("allow", "POST");
+  res.setHeader("content-type", "application/json");
+  res.end(JSON.stringify({
+    error: "method not allowed"
+  }));
+}
+__name(notAllowed, "notAllowed");
+var OpenCodeMcpController = class {
+  static {
+    __name(this, "OpenCodeMcpController");
+  }
+  endpoint;
+  constructor(endpoint) {
+    this.endpoint = endpoint;
+  }
+  async post(req, res, body) {
+    await this.endpoint.handle(req, res, body);
+  }
+  get(res) {
+    notAllowed(res);
+  }
+  delete(res) {
+    notAllowed(res);
+  }
+};
+_ts_decorate([
+  Post(),
+  _ts_param(0, Req()),
+  _ts_param(1, Res()),
+  _ts_param(2, Body()),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof IncomingMessage === "undefined" ? Object : IncomingMessage,
+    typeof ServerResponse === "undefined" ? Object : ServerResponse,
+    Object
+  ]),
+  _ts_metadata("design:returntype", Promise)
+], OpenCodeMcpController.prototype, "post", null);
+_ts_decorate([
+  Get(),
+  _ts_param(0, Res()),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof ServerResponse === "undefined" ? Object : ServerResponse
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], OpenCodeMcpController.prototype, "get", null);
+_ts_decorate([
+  Delete(),
+  _ts_param(0, Res()),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof ServerResponse === "undefined" ? Object : ServerResponse
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], OpenCodeMcpController.prototype, "delete", null);
+OpenCodeMcpController = _ts_decorate([
+  Controller("opencode/mcp"),
+  _ts_param(0, Inject(OPENCODE_MCP_ENDPOINT)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof OpenCodeMcpEndpoint === "undefined" ? Object : OpenCodeMcpEndpoint
+  ])
+], OpenCodeMcpController);
+
+// src/mcp.ts
+import { createHash, createHmac, randomBytes, timingSafeEqual } from "crypto";
+import { REMEMBER_TOOL_DESCRIPTION, REMEMBER_TOOL_NAME, ToolNotFoundError, rememberInputSchema, schemaExtensionOf } from "@dudousxd/nestjs-agent-core";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { toJsonSchemaCompat } from "@modelcontextprotocol/sdk/server/zod-json-schema-compat.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+
+// src/turn.ts
+import { encodeStreamEvent, settleElicitation } from "@dudousxd/nestjs-agent-core";
+import { ConflictException } from "@nestjs/common";
+
+// src/forms.ts
+import { validateElicitationAnswer } from "@dudousxd/nestjs-agent-core";
+function toQuestion(field) {
+  const required = field.required === true ? {
+    required: true
+  } : {};
+  const base = {
+    id: field.key,
+    prompt: field.title || field.key,
+    ...field.description && field.description !== field.title ? {
+      description: field.description
+    } : {}
+  };
+  if (field.options !== void 0 && field.options.length > 0) {
+    return {
+      ...base,
+      options: field.options.map((o) => ({
+        value: String(o.value),
+        label: String(o.label ?? o.value)
+      })),
+      input: {
+        type: "select",
+        ...required
+      },
+      ...field.type === "array" ? {
+        multiple: true
+      } : {},
+      ...field.custom === true ? {
+        allowFreeText: true
+      } : {}
+    };
+  }
+  const type = field.type === "number" || field.type === "integer" ? "number" : field.type === "boolean" ? "boolean" : "text";
+  return {
+    ...base,
+    input: {
+      type,
+      ...required
+    }
+  };
+}
+__name(toQuestion, "toQuestion");
+function formFields(form) {
+  return (form.fields ?? []).filter((f) => typeof f === "object" && f !== null && typeof f.key === "string");
+}
+__name(formFields, "formFields");
+function toElicitation(id, form) {
+  const questions = formFields(form).map(toQuestion);
+  const first = questions[0];
+  const title = form.title;
+  const preamble = title && title !== "Questions" && title !== first?.prompt && title !== first?.description ? title : void 0;
+  return {
+    id,
+    source: "ask",
+    ...preamble ? {
+      preamble
+    } : {},
+    questions
+  };
+}
+__name(toElicitation, "toElicitation");
+var FormAnswerError = class extends Error {
+  static {
+    __name(this, "FormAnswerError");
+  }
+};
+function toFormAnswer(form, answers = {}) {
+  const out = {};
+  for (const field of formFields(form)) {
+    const question = toQuestion(field);
+    const values = answers[field.key] ?? question.defaults ?? [];
+    const problem = validateElicitationAnswer(question, values);
+    if (problem) throw new FormAnswerError(`answers["${field.key}"] ${problem}`);
+    const present = values.filter((v) => v !== "");
+    const [value] = present;
+    if (value === void 0) continue;
+    if (question.multiple) out[field.key] = present;
+    else if (question.input?.type === "number") out[field.key] = Number(value);
+    else if (question.input?.type === "boolean") out[field.key] = value === "true";
+    else out[field.key] = value;
+  }
+  return out;
+}
+__name(toFormAnswer, "toFormAnswer");
+
+// src/turn.ts
+var ASK_TOOL_NAME = "ask";
+var FAILED_STATUSES = /* @__PURE__ */ new Set([
+  "error",
+  "failed",
+  "denied",
+  "cancelled"
+]);
+function emptySegment() {
+  return {
+    text: "",
+    reasoning: "",
+    reasoningMs: 0,
+    calls: [],
+    results: [],
+    ui: []
+  };
+}
+__name(emptySegment, "emptySegment");
+function isDecision(reply) {
+  return typeof reply.approved === "boolean";
+}
+__name(isDecision, "isDecision");
+var OpenCodeReplyMismatchError = class extends ConflictException {
+  static {
+    __name(this, "OpenCodeReplyMismatchError");
+  }
+  runId;
+  toolCallId;
+  constructor(runId, toolCallId) {
+    super(`Tool call "${toolCallId}" on run "${runId}" is waiting for an approve/reject, not for answers`), this.runId = runId, this.toolCallId = toolCallId;
+    this.name = "OpenCodeReplyMismatchError";
+  }
+};
+function permissionArgs(req) {
+  const metadata = req.metadata ?? {};
+  const nested = metadata.input ?? metadata.args;
+  if (nested !== null && typeof nested === "object") return nested;
+  return metadata;
+}
+__name(permissionArgs, "permissionArgs");
+var HIDDEN_TOOLS = /* @__PURE__ */ new Set([
+  "question"
+]);
+function errorText(error, fallback) {
+  if (typeof error === "string" && error.length > 0) return error;
+  const message = error?.message;
+  return typeof message === "string" && message.length > 0 ? message : fallback;
+}
+__name(errorText, "errorText");
+var OpenCodeTurn = class {
+  static {
+    __name(this, "OpenCodeTurn");
+  }
+  a;
+  /** Serializes the handling of events, so frames and rows land in the order OpenCode sent them. */
+  chain = Promise.resolve();
+  segment = emptySegment();
+  tools = /* @__PURE__ */ new Map();
+  /** Results already persisted per message, so a late settlement adds to them rather than replacing. */
+  messageResults = /* @__PURE__ */ new Map();
+  asked = /* @__PURE__ */ new Set();
+  /** Calls of {@link HIDDEN_TOOLS}, by id. */
+  hidden = /* @__PURE__ */ new Set();
+  milestones = [];
+  waiting;
+  usage = {
+    inputTokens: 0,
+    outputTokens: 0
+  };
+  costUsd;
+  stepOpen = false;
+  sawText = false;
+  separator = false;
+  reasoningSince;
+  wroteMessage = false;
+  ended = false;
+  stepError;
+  constructor(a) {
+    this.a = a;
+  }
+  get sessionId() {
+    return this.a.sessionId;
+  }
+  get finished() {
+    return this.ended;
+  }
+  /** Feed one of the session's events. */
+  handle(event) {
+    this.enqueue(() => this.onEvent(event));
+  }
+  /** End the turn as failed without an event (the prompt was refused, the stream is gone). */
+  fail(error) {
+    this.enqueue(() => this.end({
+      status: "failed",
+      error
+    }));
+  }
+  /**
+  * A component a tool pushed (`ctx.emitUi`, through the MCP surface): streamed as a `ui` frame and
+  * persisted on the message being written, in the order it arrived. Pushing the same id again
+  * replaces it.
+  */
+  pushUi(component) {
+    return new Promise((resolve, reject) => {
+      this.chain = this.chain.then(async () => {
+        await this.step();
+        const ui = this.segment.ui;
+        const at = ui.findIndex((c) => c.id === component.id);
+        if (at >= 0) ui[at] = component;
+        else ui.push(component);
+        await this.write({
+          kind: "ui",
+          ...component
+        });
+      }).then(resolve, reject);
+    });
+  }
+  /** The next milestone: one already reached, or the next one to come. */
+  next() {
+    const ready = this.milestones.shift();
+    if (ready !== void 0) return Promise.resolve(ready);
+    return new Promise((resolve) => {
+      this.waiting = resolve;
+    });
+  }
+  /** Whether a milestone is waiting to be taken. */
+  hasMilestone() {
+    return this.milestones.length > 0;
+  }
+  /**
+  * Requests OpenCode raised while nobody listened (this process started after them, or the event
+  * stream dropped): its open permissions and forms, handled as if their events had just arrived.
+  * One already recorded in the store is reported without being recorded or streamed again.
+  */
+  async catchUp() {
+    const { client, sessionId } = this.a;
+    const permissions = await client.permission.list?.({
+      sessionID: sessionId
+    }) ?? [];
+    const forms = await client.session.form.list?.({
+      sessionID: sessionId
+    }) ?? [];
+    await new Promise((resolve) => {
+      this.enqueue(async () => {
+        for (const p of permissions) await this.onPermission(p, true);
+        for (const f of forms) await this.onForm(f, true);
+        resolve();
+      });
+    });
+  }
+  /**
+  * Hand a person's answer to what the turn asked, and let OpenCode go on. `tellOpenCode: false`
+  * only settles the call (stream and store): the request died with a restarted server, and the
+  * new session is told the answer in its prompt instead.
+  */
+  decide(ask, reply, opts = {}) {
+    const tell = opts.tellOpenCode ?? true;
+    return new Promise((resolve, reject) => {
+      this.chain = this.chain.then(() => ask.kind === "approval" ? this.decided(ask, reply, tell) : this.answered(ask, reply, tell)).then(resolve, reject);
+    });
+  }
+  reach(milestone) {
+    const waiting = this.waiting;
+    if (waiting !== void 0) {
+      this.waiting = void 0;
+      waiting(milestone);
+    } else {
+      this.milestones.push(milestone);
+    }
+  }
+  enqueue(work) {
+    this.chain = this.chain.then(work).catch((error) => {
+      this.a.logger.error(`run ${this.a.runId}: ${errorText(error, "event handling failed")}`);
+      if (!this.ended) {
+        this.ended = true;
+        this.reach({
+          kind: "finished",
+          outcome: {
+            status: "failed",
+            error: errorText(error, "event handling failed")
+          }
+        });
+      }
+    });
+  }
+  async write(event) {
+    await this.a.writer.write(encodeStreamEvent(event));
+  }
+  async step() {
+    if (this.stepOpen) return;
+    this.stepOpen = true;
+    await this.write({
+      kind: "step-start"
+    });
+  }
+  endReasoning() {
+    if (this.reasoningSince === void 0) return;
+    this.segment.reasoningMs += Date.now() - this.reasoningSince;
+    this.reasoningSince = void 0;
+  }
+  tool(id, name = "tool") {
+    let state = this.tools.get(id);
+    if (state === void 0) {
+      state = {
+        name,
+        announced: false,
+        available: false,
+        settled: false,
+        input: {},
+        innerAnnounced: /* @__PURE__ */ new Set(),
+        innerSettled: /* @__PURE__ */ new Set()
+      };
+      this.tools.set(id, state);
+      this.segment.calls.push({
+        id,
+        name,
+        input: state.input,
+        kind: "read"
+      });
+    }
+    return state;
+  }
+  async announce(id, name) {
+    const state = this.tool(id, name);
+    if (!state.announced) {
+      state.announced = true;
+      await this.write({
+        kind: "tool-input-start",
+        id,
+        name: state.name,
+        toolKind: "read"
+      });
+    }
+    return state;
+  }
+  async makeAvailable(id) {
+    const state = await this.announce(id, this.tools.get(id)?.name ?? "tool");
+    if (!state.available) {
+      state.available = true;
+      await this.write({
+        kind: "tool-input-available",
+        id,
+        name: state.name,
+        input: state.input,
+        toolKind: "read"
+      });
+    }
+    return state;
+  }
+  setInput(id, input, name) {
+    const state = this.tool(id, name);
+    if (input === null || typeof input !== "object") return;
+    Object.assign(state.input, input);
+  }
+  async innerCalls(parentId, raw) {
+    if (!Array.isArray(raw)) return;
+    const parent = this.tool(parentId);
+    for (const [index, call] of raw.entries()) {
+      const id = `${parentId}.${index}`;
+      const name = String(call?.tool ?? "tool");
+      const input = call?.input !== null && typeof call?.input === "object" ? call.input : {};
+      if (!parent.innerAnnounced.has(index)) {
+        parent.innerAnnounced.add(index);
+        this.segment.calls.push({
+          id,
+          name,
+          input,
+          kind: "read",
+          parentId
+        });
+        await this.write({
+          kind: "tool-input-available",
+          id,
+          name,
+          input,
+          toolKind: "read",
+          parentId
+        });
+      }
+      const status = String(call?.status ?? "").toLowerCase();
+      if (parent.innerSettled.has(index) || status === "running" || status === "pending" || !status) {
+        continue;
+      }
+      parent.innerSettled.add(index);
+      if (FAILED_STATUSES.has(status)) {
+        this.segment.results.push({
+          id,
+          name,
+          output: {
+            status
+          },
+          error: status
+        });
+        await this.write({
+          kind: "tool-output-error",
+          id,
+          error: status
+        });
+      } else {
+        this.segment.results.push({
+          id,
+          name,
+          output: {
+            status
+          }
+        });
+        await this.write({
+          kind: "tool-output",
+          id,
+          output: {
+            status
+          }
+        });
+      }
+    }
+  }
+  async onEvent(e) {
+    if (this.ended) return;
+    const d = e.data ?? {};
+    switch (e.type) {
+      case "session.text.delta": {
+        const delta = typeof d.delta === "string" ? d.delta : "";
+        if (!delta) return;
+        this.endReasoning();
+        if (!this.sawText && !delta.trim()) return;
+        await this.step();
+        const text = this.separator && this.sawText ? `
+
+${delta}` : delta;
+        this.separator = false;
+        this.sawText = true;
+        this.segment.text += text;
+        await this.write({
+          kind: "text",
+          text
+        });
+        return;
+      }
+      case "session.text.ended":
+        this.separator = true;
+        return;
+      case "session.reasoning.delta": {
+        const delta = typeof d.delta === "string" ? d.delta : "";
+        if (!delta) return;
+        this.reasoningSince ??= Date.now();
+        await this.step();
+        this.segment.reasoning += delta;
+        await this.write({
+          kind: "reasoning",
+          text: delta
+        });
+        return;
+      }
+      case "session.tool.input.started":
+        this.endReasoning();
+        if (HIDDEN_TOOLS.has(String(d.name))) {
+          this.hidden.add(String(d.id));
+          return;
+        }
+        await this.step();
+        await this.announce(String(d.id), String(d.name ?? "tool"));
+        return;
+      case "session.tool.called":
+        if (this.hidden.has(String(d.id))) return;
+        await this.step();
+        this.setInput(String(d.id), d.input, typeof d.name === "string" ? d.name : void 0);
+        await this.makeAvailable(String(d.id));
+        return;
+      case "session.skill.activated": {
+        const name = String(d.id ?? d.name ?? "skill");
+        const id = `skill:${name}:${this.tools.size}`;
+        await this.step();
+        await this.announce(id, "skill");
+        this.setInput(id, {
+          name
+        });
+        await this.makeAvailable(id);
+        await this.settleTool(id, true);
+        return;
+      }
+      case "session.tool.progress":
+        if (this.hidden.has(String(d.id))) return;
+        await this.step();
+        await this.makeAvailable(String(d.id));
+        await this.innerCalls(String(d.id), d.metadata?.toolCalls);
+        return;
+      case "session.tool.success":
+      case "session.tool.failed": {
+        const id = String(d.id);
+        if (this.hidden.has(id)) return;
+        await this.step();
+        await this.makeAvailable(id);
+        await this.innerCalls(id, d.metadata?.toolCalls);
+        await this.settleTool(id, e.type === "session.tool.success", errorText(d.error, "tool failed"));
+        return;
+      }
+      case "session.step.ended":
+        this.endReasoning();
+        await this.stepEnded(d);
+        return;
+      case "session.step.failed":
+        this.stepError = errorText(d.error, "the model call failed");
+        return;
+      case "session.renamed":
+        if (typeof d.title === "string" && d.title.trim()) {
+          await this.a.store.setTitle(this.a.input.threadId, d.title.trim());
+          await this.write({
+            kind: "title",
+            title: d.title.trim()
+          });
+        }
+        return;
+      case "permission.asked":
+        await this.onPermission(d, false);
+        return;
+      case "form.created":
+        await this.onForm(d.form ?? d, false);
+        return;
+      case "session.execution.succeeded":
+        await this.end({
+          status: "succeeded"
+        });
+        return;
+      case "session.execution.failed":
+        await this.end({
+          status: "failed",
+          error: errorText(d.error, this.stepError ?? "the execution failed")
+        });
+        return;
+      case "session.execution.interrupted":
+        await this.end({
+          status: "interrupted"
+        });
+        return;
+      default:
+        return;
+    }
+  }
+  async settleTool(id, ok, error = "failed") {
+    const state = this.tool(id);
+    if (state.settled) return;
+    state.settled = true;
+    if (ok) {
+      this.segment.results.push({
+        id,
+        name: state.name,
+        output: {
+          ok: true
+        }
+      });
+      await this.write({
+        kind: "tool-output",
+        id,
+        output: {
+          ok: true
+        }
+      });
+    } else {
+      this.segment.results.push({
+        id,
+        name: state.name,
+        output: {
+          ok: false
+        },
+        error
+      });
+      await this.write({
+        kind: "tool-output-error",
+        id,
+        error
+      });
+    }
+  }
+  async stepEnded(d) {
+    const usage = {
+      inputTokens: Number(d.tokens?.input) || 0,
+      outputTokens: Number(d.tokens?.output) || 0,
+      ...Number(d.tokens?.cache?.read) ? {
+        cacheReadTokens: Number(d.tokens.cache.read)
+      } : {},
+      ...Number(d.tokens?.cache?.write) ? {
+        cacheWriteTokens: Number(d.tokens.cache.write)
+      } : {}
+    };
+    const costUsd = typeof d.cost === "number" ? d.cost : void 0;
+    this.usage.inputTokens += usage.inputTokens;
+    this.usage.outputTokens += usage.outputTokens;
+    if (costUsd !== void 0) this.costUsd = (this.costUsd ?? 0) + costUsd;
+    await this.a.store.recordUsage({
+      threadId: this.a.input.threadId,
+      actorRef: this.a.input.actor.id,
+      modelId: this.a.modelLabel,
+      purpose: "chat",
+      usage,
+      ...costUsd !== void 0 ? {
+        costUsd
+      } : {}
+    });
+    if (!this.stepOpen) return;
+    this.stepOpen = false;
+    await this.write({
+      kind: "step-finish",
+      usage,
+      costUsd: costUsd ?? null,
+      ...this.segment.reasoningMs > 0 ? {
+        reasoningMs: this.segment.reasoningMs
+      } : {},
+      model: this.a.modelLabel
+    });
+  }
+  /**
+  * Persist what the turn produced since the last flush as one assistant message — the message a
+  * call put to a person hangs on, or the turn's last one. Returns its id.
+  */
+  async flush(final) {
+    this.endReasoning();
+    const s = this.segment;
+    const empty = !s.text && !s.reasoning && s.calls.length === 0 && s.ui.length === 0;
+    if (empty && !(final && !this.wroteMessage)) return void 0;
+    this.segment = emptySegment();
+    const message = await this.a.store.appendMessage({
+      threadId: this.a.input.threadId,
+      role: "assistant",
+      content: s.text,
+      runId: this.a.runId,
+      ...final ? {
+        usage: {
+          ...this.usage,
+          ...this.costUsd !== void 0 ? {
+            costUsd: this.costUsd
+          } : {}
+        }
+      } : {},
+      ...this.a.input.agentName !== void 0 ? {
+        agentName: this.a.input.agentName
+      } : {},
+      ...this.a.input.persona !== void 0 ? {
+        persona: this.a.input.persona
+      } : {},
+      ...s.reasoning ? {
+        reasoning: s.reasoning,
+        reasoningMs: s.reasoningMs
+      } : {},
+      ...s.calls.length > 0 ? {
+        toolCalls: s.calls
+      } : {},
+      ...s.results.length > 0 ? {
+        toolResults: s.results
+      } : {},
+      ...s.ui.length > 0 ? {
+        ui: s.ui
+      } : {}
+    });
+    this.wroteMessage = true;
+    this.messageResults.set(message.id, [
+      ...s.results
+    ]);
+    return message.id;
+  }
+  /** A request recorded by an earlier process (a turn resumed after a restart). */
+  async alreadyRecorded(id) {
+    return (await this.a.store.toolCallApproval?.(id) ?? null) !== null;
+  }
+  /** The persisted assistant message carrying call `id`, so its result lands on the same message. */
+  async messageOf(id) {
+    const thread = await this.a.store.getThread(this.a.input.threadId);
+    return thread?.messages.find((m) => m.toolCalls?.some((call) => call.id === id))?.id;
+  }
+  async onPermission(req, recovering) {
+    if (this.asked.has(req.id)) return;
+    this.asked.add(req.id);
+    const { client, sessionId, input, store } = this.a;
+    const action = String(req.action);
+    const args = permissionArgs(req);
+    if (recovering && await this.alreadyRecorded(req.id)) {
+      const state = await store.toolCallApproval?.(req.id);
+      const messageId2 = await this.messageOf(req.id);
+      this.reach({
+        kind: "ask",
+        ask: {
+          kind: "approval",
+          id: req.id,
+          action,
+          approver: state?.approver ?? "requester",
+          ...state?.expiresAt ? {
+            expiresAt: state.expiresAt
+          } : {},
+          ...messageId2 !== void 0 ? {
+            messageId: messageId2
+          } : {}
+        },
+        ...state?.expiresAt ? {
+          timeoutMs: Math.max(0, Date.parse(state.expiresAt) - Date.now())
+        } : {}
+      });
+      return;
+    }
+    await this.step();
+    const requirement = await this.a.approvalFor(action);
+    const remembered = requirement.required ? (await store.rememberedApprovals?.(input.threadId) ?? []).includes(action) : false;
+    if (!requirement.required || remembered) {
+      this.a.onGranted?.(action, req.id);
+      await client.permission.reply({
+        sessionID: sessionId,
+        requestID: req.id,
+        decision: "once"
+      });
+      this.segment.calls.push({
+        id: req.id,
+        name: action,
+        input: args,
+        kind: "action"
+      });
+      this.segment.results.push({
+        id: req.id,
+        name: action,
+        output: {
+          approved: true
+        }
+      });
+      await this.write({
+        kind: "tool-input-available",
+        id: req.id,
+        name: action,
+        input: args,
+        toolKind: "action"
+      });
+      await this.write({
+        kind: "approval-settled",
+        id: req.id,
+        status: "approved",
+        approver: requirement.approver,
+        decidedVia: remembered ? "remembered" : "policy",
+        ...remembered ? {
+          remember: true
+        } : {}
+      });
+      await this.write({
+        kind: "tool-output",
+        id: req.id,
+        output: {
+          approved: true
+        }
+      });
+      return;
+    }
+    const ttlMs = requirement.ttlMs !== void 0 && Number.isFinite(requirement.ttlMs) && requirement.ttlMs > 0 ? Math.floor(requirement.ttlMs) : void 0;
+    const expiresAt = ttlMs !== void 0 ? new Date(Date.now() + ttlMs).toISOString() : void 0;
+    this.segment.calls.push({
+      id: req.id,
+      name: action,
+      input: args,
+      kind: "action"
+    });
+    const messageId = await this.flush(false);
+    await store.recordToolCall({
+      toolCallId: req.id,
+      messageId,
+      toolName: action,
+      toolType: "action",
+      input: args,
+      status: "pending_approval",
+      runId: this.a.runId,
+      approver: requirement.approver,
+      ...expiresAt !== void 0 ? {
+        expiresAt
+      } : {}
+    });
+    await this.write({
+      kind: "tool-input-available",
+      id: req.id,
+      name: action,
+      input: args,
+      toolKind: "action"
+    });
+    await this.write({
+      kind: "approval-requested",
+      id: req.id,
+      approver: requirement.approver,
+      ...expiresAt !== void 0 ? {
+        expiresAt
+      } : {}
+    });
+    this.reach({
+      kind: "ask",
+      ask: {
+        kind: "approval",
+        id: req.id,
+        action,
+        approver: requirement.approver,
+        messageId,
+        ...expiresAt !== void 0 ? {
+          expiresAt
+        } : {}
+      },
+      ...ttlMs !== void 0 ? {
+        timeoutMs: ttlMs
+      } : {}
+    });
+  }
+  async decided(ask, reply, tell) {
+    if (!isDecision(reply)) throw new OpenCodeReplyMismatchError(this.a.runId, ask.id);
+    const decision = reply;
+    const { client, sessionId, store } = this.a;
+    const { id, action } = ask;
+    const status = decision.approved ? "approved" : decision.expired ? "expired" : "rejected";
+    if (decision.approved) this.a.onGranted?.(action, id);
+    if (tell) await client.permission.reply({
+      sessionID: sessionId,
+      requestID: id,
+      decision: decision.approved ? "once" : "reject",
+      ...decision.approved ? {} : {
+        message: decision.expired ? "Nobody approved this action in time, so it was not run." : `The user denied this action${decision.reason ? `: ${decision.reason}` : ""}. Do not retry it; tell the user what you would have done.`
+      }
+    });
+    const result = decision.approved ? {
+      id,
+      name: action,
+      output: {
+        approved: true
+      }
+    } : {
+      id,
+      name: action,
+      output: {
+        rejected: true,
+        ...decision.reason ? {
+          reason: decision.reason
+        } : {}
+      },
+      error: decision.expired ? "approval expired" : "rejected by the user",
+      denied: true,
+      ...decision.expired ? {
+        expired: true
+      } : {}
+    };
+    await store.updateToolCall({
+      toolCallId: id,
+      status: decision.approved ? "executed" : status === "expired" ? "expired" : "rejected",
+      output: result.output,
+      ...result.error !== void 0 ? {
+        error: result.error
+      } : {},
+      ...decision.executedByRef !== void 0 ? {
+        executedByRef: decision.executedByRef
+      } : {},
+      ...decision.remember === true ? {
+        remember: true
+      } : {},
+      ...decision.decidedVia !== void 0 ? {
+        decidedVia: decision.decidedVia
+      } : {}
+    });
+    await this.addResult(ask.messageId, result);
+    await this.write({
+      kind: "approval-settled",
+      id,
+      status,
+      approver: ask.approver,
+      ...decision.executedByRef !== void 0 ? {
+        decidedBy: decision.executedByRef
+      } : {},
+      ...decision.decidedVia !== void 0 ? {
+        decidedVia: decision.decidedVia
+      } : {},
+      ...decision.remember === true ? {
+        remember: true
+      } : {},
+      ...decision.reason !== void 0 ? {
+        reason: decision.reason
+      } : {}
+    });
+    if (decision.approved) await this.write({
+      kind: "tool-output",
+      id,
+      output: {
+        approved: true
+      }
+    });
+    else await this.write({
+      kind: "tool-output-denied",
+      id,
+      ...decision.expired ? {
+        reason: "approval expired"
+      } : decision.reason ? {
+        reason: decision.reason
+      } : {}
+    });
+  }
+  async onForm(form, recovering) {
+    if (this.asked.has(form.id)) return;
+    this.asked.add(form.id);
+    const request = toElicitation(form.id, form);
+    if (recovering && await this.alreadyRecorded(form.id)) {
+      const messageId2 = await this.messageOf(form.id);
+      this.reach({
+        kind: "ask",
+        ask: {
+          kind: "form",
+          id: form.id,
+          form,
+          request,
+          ...messageId2 !== void 0 ? {
+            messageId: messageId2
+          } : {}
+        }
+      });
+      return;
+    }
+    const input = {
+      ...request.preamble !== void 0 ? {
+        preamble: request.preamble
+      } : {},
+      questions: request.questions
+    };
+    await this.step();
+    this.segment.calls.push({
+      id: form.id,
+      name: ASK_TOOL_NAME,
+      input,
+      kind: "ask"
+    });
+    const messageId = await this.flush(false);
+    await this.a.store.recordToolCall({
+      toolCallId: form.id,
+      messageId,
+      toolName: ASK_TOOL_NAME,
+      toolType: "action",
+      input,
+      status: "pending_approval",
+      runId: this.a.runId
+    });
+    await this.write({
+      kind: "elicitation",
+      id: form.id,
+      request
+    });
+    this.reach({
+      kind: "ask",
+      ask: {
+        kind: "form",
+        id: form.id,
+        form,
+        request,
+        messageId
+      }
+    });
+  }
+  async answered(ask, reply, tell) {
+    const { client, sessionId } = this.a;
+    const { form, request } = ask;
+    const answer = isDecision(reply) ? {
+      answers: {},
+      skipped: true
+    } : reply;
+    if (!tell) {
+    } else if (answer.skipped === true) {
+      await client.session.form.cancel({
+        sessionID: sessionId,
+        formID: form.id
+      });
+    } else {
+      await client.session.form.reply({
+        sessionID: sessionId,
+        formID: form.id,
+        answer: toFormAnswer(form, answer.answers)
+      });
+    }
+    const result = settleElicitation(request, answer);
+    await this.a.store.updateToolCall({
+      toolCallId: form.id,
+      status: result.skipped ? "rejected" : "executed",
+      output: result,
+      ...result.skipped ? {
+        error: "skipped by the user"
+      } : {},
+      ...answer.answeredByRef !== void 0 ? {
+        executedByRef: answer.answeredByRef
+      } : {},
+      ...answer.answeredVia !== void 0 ? {
+        decidedVia: answer.answeredVia
+      } : {}
+    });
+    await this.addResult(ask.messageId, {
+      id: form.id,
+      name: ASK_TOOL_NAME,
+      output: result
+    });
+    await this.write({
+      kind: "tool-output",
+      id: form.id,
+      output: result
+    });
+  }
+  async addResult(messageId, result) {
+    if (messageId === void 0) return;
+    let known = this.messageResults.get(messageId);
+    if (known === void 0) {
+      const thread = await this.a.store.getThread(this.a.input.threadId);
+      known = [
+        ...thread?.messages.find((m) => m.id === messageId)?.toolResults ?? []
+      ];
+    }
+    const results = [
+      ...known.filter((r) => r.id !== result.id),
+      result
+    ];
+    this.messageResults.set(messageId, results);
+    await this.a.store.setMessageToolResults(messageId, results);
+  }
+  async end(outcome) {
+    if (this.ended) return;
+    this.ended = true;
+    if (outcome.status !== "failed" || this.segment.text || this.segment.calls.length > 0 || this.segment.ui.length > 0) {
+      await this.flush(true);
+    }
+    if (this.stepOpen) {
+      this.stepOpen = false;
+      await this.write({
+        kind: "step-finish"
+      });
+    }
+    this.reach({
+      kind: "finished",
+      outcome
+    });
+  }
+};
+
+// src/mcp.ts
+var LOOP_SERVED_KINDS = /* @__PURE__ */ new Set([
+  "agent",
+  "ask",
+  "skill",
+  "memory"
+]);
+var b64url = /* @__PURE__ */ __name((data) => Buffer.from(data).toString("base64url"), "b64url");
+var OpenCodeToolsTokens = class {
+  static {
+    __name(this, "OpenCodeToolsTokens");
+  }
+  ttlMs;
+  key;
+  constructor(secret, ttlMs) {
+    this.ttlMs = ttlMs;
+    this.key = createHash("sha256").update("aviary:opencode:tools\0").update(secret ?? randomBytes(32).toString("hex")).digest();
+  }
+  mint(actor, server, now = Date.now()) {
+    const claims = {
+      v: 1,
+      actor,
+      server,
+      exp: now + this.ttlMs
+    };
+    const body = b64url(JSON.stringify(claims));
+    return `${body}.${this.sign(body)}`;
+  }
+  verify(token, now = Date.now()) {
+    const [body, signature, extra] = token.split(".");
+    if (body === void 0 || signature === void 0 || extra !== void 0) return null;
+    const expected = Buffer.from(this.sign(body));
+    const given = Buffer.from(signature);
+    if (expected.length !== given.length || !timingSafeEqual(expected, given)) return null;
+    try {
+      const claims = JSON.parse(Buffer.from(body, "base64url").toString("utf8"));
+      if (claims?.v !== 1 || typeof claims.server !== "string" || typeof claims.exp !== "number" || typeof claims.actor?.id !== "string" || claims.exp <= now) {
+        return null;
+      }
+      return claims;
+    } catch {
+      return null;
+    }
+  }
+  sign(body) {
+    return createHmac("sha256", this.key).update(body).digest("base64url");
+  }
+};
+function isZodSchema(schema) {
+  return schema["~standard"].vendor === "zod";
+}
+__name(isZodSchema, "isZodSchema");
+function toInputSchema(schema) {
+  const extension = schemaExtensionOf(schema);
+  if (extension !== void 0) {
+    const base = toInputSchema(extension.base);
+    const properties = {
+      ...base.properties ?? {},
+      ...extension.properties
+    };
+    return {
+      ...base,
+      properties
+    };
+  }
+  let converted;
+  if (isZodSchema(schema)) converted = toJsonSchemaCompat(schema);
+  else {
+    const converter = schema["~standard"].jsonSchema;
+    if (typeof converter?.input === "function") converted = converter.input();
+  }
+  if (converted === void 0) return {
+    type: "object",
+    properties: {},
+    additionalProperties: true
+  };
+  const { type: _type, ...rest } = converted;
+  return {
+    ...rest,
+    type: "object"
+  };
+}
+__name(toInputSchema, "toInputSchema");
+var asText = /* @__PURE__ */ __name((output) => typeof output === "string" ? output : JSON.stringify(output), "asText");
+var OpenCodeToolRefusedError = class extends Error {
+  static {
+    __name(this, "OpenCodeToolRefusedError");
+  }
+  name = "OpenCodeToolRefusedError";
+};
+var OpenCodeMcpEndpoint2 = class {
+  static {
+    __name(this, "OpenCodeMcpEndpoint");
+  }
+  turns;
+  tokens;
+  constructor(turns, tokens) {
+    this.turns = turns;
+    this.tokens = tokens;
+  }
+  /** The claims of a request's bearer token, or `null`. */
+  authenticate(authorization) {
+    const header = Array.isArray(authorization) ? authorization[0] : authorization;
+    const match = /^Bearer\s+(.+)$/i.exec(header ?? "");
+    const token = match?.[1]?.trim();
+    return token ? this.tokens.verify(token) : null;
+  }
+  async handle(req, res, body) {
+    const claims = this.authenticate(req.headers.authorization);
+    if (claims === null) {
+      res.statusCode = 401;
+      res.setHeader("WWW-Authenticate", 'Bearer error="invalid_token"');
+      res.setHeader("content-type", "application/json");
+      res.end(JSON.stringify({
+        error: "unauthorized"
+      }));
+      return;
+    }
+    const server = this.server(claims);
+    const transport = new StreamableHTTPServerTransport({
+      enableJsonResponse: true
+    });
+    res.on("close", () => {
+      void transport.close();
+      void server.close();
+    });
+    try {
+      await server.connect(transport);
+      await transport.handleRequest(req, res, body);
+    } catch (error) {
+      if (!res.headersSent) {
+        res.statusCode = 500;
+        res.setHeader("content-type", "application/json");
+        res.end(JSON.stringify({
+          jsonrpc: "2.0",
+          error: {
+            code: -32603,
+            message: errorText(error, "Internal error")
+          },
+          id: null
+        }));
+      }
+    }
+  }
+  /** One MCP server for one request, answering as the token's actor. */
+  server(claims) {
+    const server = new Server({
+      name: "aviary-opencode",
+      version: "1.0.0"
+    }, {
+      capabilities: {
+        tools: {}
+      }
+    });
+    const { actor } = claims;
+    const call = /* @__PURE__ */ __name((meta, requestId) => this.turns.callContext({
+      actor,
+      serverKey: claims.server,
+      requestId: String(requestId ?? ""),
+      meta
+    }), "call");
+    server.setRequestHandler(ListToolsRequestSchema, async (request, extra) => {
+      const turn = await call(request.params?._meta, extra.requestId);
+      const input = turn?.input ?? {};
+      const allowed = turn !== void 0 ? this.turns.allowedTools(turn.input) : void 0;
+      const definitions = (await this.turns.registry.definitionsFor(actor, this.turns.rolesPolicyFor(input), allowed)).filter((definition) => !LOOP_SERVED_KINDS.has(definition.kind));
+      const tools = definitions.map((definition) => ({
+        name: definition.name,
+        description: definition.description,
+        inputSchema: toInputSchema(definition.inputSchema),
+        annotations: {
+          readOnlyHint: definition.kind === "read"
+        }
+      }));
+      if (this.turns.memoryWritable()) {
+        tools.push({
+          name: REMEMBER_TOOL_NAME,
+          description: REMEMBER_TOOL_DESCRIPTION,
+          inputSchema: toInputSchema(rememberInputSchema),
+          annotations: {
+            readOnlyHint: false
+          }
+        });
+      }
+      return {
+        tools
+      };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+      const { name, arguments: args } = request.params;
+      try {
+        const turn = await call(request.params._meta, extra.requestId);
+        if (turn === void 0) {
+          throw new OpenCodeToolRefusedError("This endpoint serves OpenCode turns: no turn of yours is running on this session.");
+        }
+        const output = name === REMEMBER_TOOL_NAME && this.turns.memoryWritable() ? await this.remember(turn, args) : await this.invoke(turn, actor, name, args, String(extra.requestId ?? ""));
+        return {
+          content: [
+            {
+              type: "text",
+              text: asText(output)
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: errorText(error, "the tool failed")
+            }
+          ],
+          isError: true
+        };
+      }
+    });
+    return server;
+  }
+  async invoke(turn, actor, name, args, requestId) {
+    const { registry } = this.turns;
+    const spec = registry.spec(name);
+    if (spec === void 0 || LOOP_SERVED_KINDS.has(spec.kind)) throw new ToolNotFoundError(name);
+    const allowed = this.turns.allowedTools(turn.input);
+    if (allowed !== void 0 && !allowed.includes(name)) throw new ToolNotFoundError(name);
+    if (spec.kind === "action" && !await this.turns.spendApproval(turn.runId, name, turn.input)) {
+      throw new OpenCodeToolRefusedError(`"${name}" is an action and nobody approved this call; ask for the permission first.`);
+    }
+    return registry.invoke(name, args ?? {}, {
+      actor,
+      threadId: turn.ctx.threadId,
+      runId: turn.runId,
+      requestId: `mcp:${turn.runId}:${requestId}`,
+      emitUi: turn.ctx.emitUi,
+      ...turn.input.agentName !== void 0 ? {
+        agentName: turn.input.agentName
+      } : {},
+      ...turn.input.persona !== void 0 ? {
+        persona: turn.input.persona
+      } : {},
+      ...turn.input.pageContext !== void 0 ? {
+        pageContext: turn.input.pageContext
+      } : {}
+    }, this.turns.rolesPolicyFor(turn.input), allowed !== void 0 ? {
+      allowedTools: allowed
+    } : {});
+  }
+  /** `remember`: one fact, at the actor's own scope only — as the loop serves it. */
+  async remember(turn, args) {
+    const parsed = await rememberInputSchema["~standard"].validate(args ?? {});
+    if (parsed.issues !== void 0) {
+      throw new OpenCodeToolRefusedError(`remember: ${parsed.issues.map((issue) => issue.message).join("; ")}`);
+    }
+    return this.turns.remember(parsed.value, turn);
+  }
+};
+
+// src/runner.ts
+import { RunCancelledError } from "@dudousxd/nestjs-agent-core";
+import { Inject as Inject3, Injectable as Injectable2 } from "@nestjs/common";
+
+// src/turns.ts
+import { randomUUID } from "crypto";
+import { AGENT_CHAT_QUEUE } from "@dudousxd/nestjs-agent";
+import { AGENT_DEPS_FACTORY, AGENT_MEMORY, AGENT_SINK, AGENT_SKILLS, AGENT_STORE, AGENT_TOOL_REGISTRY, DEFAULT_MAX_FACT_CHARS, DefaultApprovalPolicy, RUN_ENDED_BEFORE_TOOL_CALL, actorScope, buildMemoryBlock, defaultScopeResolver, encodeStreamEvent as encodeStreamEvent2, memoryWriteVerdict, publishAgentRunFailed, releaseThreadRun, resolveMemoryDigest, resolveSkillCatalog, streamFailure } from "@dudousxd/nestjs-agent-core";
+import { Inject as Inject2, Injectable, Logger as Logger2, Optional } from "@nestjs/common";
+
+// src/event-hub.ts
+import { Logger } from "@nestjs/common";
+function sessionOf(event) {
+  const id = event.data?.sessionID ?? event.data?.form?.sessionID;
+  return typeof id === "string" ? id : void 0;
+}
+__name(sessionOf, "sessionOf");
+var DEFAULT_CONNECT_TIMEOUT_MS = 1e4;
+var OpenCodeEventHub = class _OpenCodeEventHub {
+  static {
+    __name(this, "OpenCodeEventHub");
+  }
+  options;
+  logger = new Logger(_OpenCodeEventHub.name);
+  streams = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /**
+  * Listen to one session's events on a server. Resolves once the server's stream is open (its first
+  * event arrived), or after the connect timeout — the turn's safety nets cover a stream that is
+  * slow to open.
+  */
+  async listen(serverKey, client, sessionId, listener) {
+    const stream = this.streamFor(serverKey, client);
+    let set = stream.listeners.get(sessionId);
+    if (set === void 0) {
+      set = /* @__PURE__ */ new Set();
+      stream.listeners.set(sessionId, set);
+    }
+    set.add(listener);
+    await stream.ready;
+    return () => {
+      const live = this.streams.get(serverKey) ?? stream;
+      const current = live.listeners.get(sessionId);
+      current?.delete(listener);
+      if (current?.size === 0) live.listeners.delete(sessionId);
+      if (live.listeners.size === 0 && this.streams.get(serverKey) === live) {
+        live.controller.abort();
+        this.streams.delete(serverKey);
+      }
+    };
+  }
+  close() {
+    for (const stream of this.streams.values()) stream.controller.abort();
+    this.streams.clear();
+  }
+  /**
+  * The server's stream, opened on `client`. A different client for a known key (the host
+  * replaced the connection, e.g. a new sandbox under the same key) moves every listener to a stream
+  * on the new one: the old connection may be dead, and its sessions would never hear back.
+  */
+  streamFor(serverKey, client) {
+    const existing = this.streams.get(serverKey);
+    if (existing !== void 0 && existing.client === client) return existing;
+    existing?.controller.abort();
+    const controller = new AbortController();
+    let opened;
+    const ready = new Promise((resolve) => {
+      opened = resolve;
+    });
+    const timeoutMs = this.options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+    const timer = setTimeout(() => {
+      this.logger.warn(`event stream of ${serverKey} not open after ${timeoutMs}ms; going on`);
+      opened();
+    }, timeoutMs);
+    timer.unref?.();
+    void ready.then(() => clearTimeout(timer));
+    controller.signal.addEventListener("abort", () => opened(), {
+      once: true
+    });
+    const stream = {
+      client,
+      controller,
+      listeners: existing?.listeners ?? /* @__PURE__ */ new Map(),
+      ready
+    };
+    this.streams.set(serverKey, stream);
+    void this.pump(serverKey, stream, client, opened);
+    return stream;
+  }
+  async pump(serverKey, stream, client, opened) {
+    let backoff = 500;
+    while (!stream.controller.signal.aborted) {
+      try {
+        const events = client.event.subscribe({
+          signal: stream.controller.signal
+        });
+        for await (const event of events) {
+          opened();
+          backoff = 500;
+          const sessionId = sessionOf(event);
+          if (sessionId === void 0) continue;
+          for (const listener of stream.listeners.get(sessionId) ?? []) {
+            try {
+              listener(event);
+            } catch (error) {
+              this.logger.error(`listener failed: ${error.message}`);
+            }
+          }
+        }
+      } catch (error) {
+        if (stream.controller.signal.aborted) return;
+        this.logger.warn(`event stream of ${serverKey} dropped: ${error.message}`);
+      }
+      if (stream.controller.signal.aborted) return;
+      await new Promise((resolve) => setTimeout(resolve, backoff).unref?.());
+      backoff = Math.min(backoff * 2, 1e4);
+    }
+  }
+};
+
+// src/turns.ts
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata2(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+var DEFAULT_TURN_TIMEOUT_MS = 30 * 6e4;
+var DEFAULT_TOOLS_TTL_MS = 7 * 24 * 60 * 6e4;
+var OpenCodeTurns = class {
+  static {
+    __name(this, "OpenCodeTurns");
+  }
+  host;
+  sessions;
+  settings;
+  store;
+  sink;
+  deps;
+  registry;
+  skills;
+  memory;
+  queue;
+  toolsTokens;
+  logger = new Logger2("OpenCodeTurns");
+  events = new OpenCodeEventHub();
+  live = /* @__PURE__ */ new Map();
+  /** Actions approved per run, and the approvals the MCP endpoint already spent. */
+  grants = /* @__PURE__ */ new Map();
+  spent = /* @__PURE__ */ new Set();
+  /** When the tools endpoint was last registered for a location (`server|boot|directory|actor`). */
+  toolsIssued = /* @__PURE__ */ new Map();
+  constructor(host, sessions, settings, store, sink, deps, registry, skills, memory, queue, toolsTokens2) {
+    this.host = host;
+    this.sessions = sessions;
+    this.settings = settings;
+    this.store = store;
+    this.sink = sink;
+    this.deps = deps;
+    this.registry = registry;
+    this.skills = skills;
+    this.memory = memory;
+    this.queue = queue;
+    this.toolsTokens = toolsTokens2;
+  }
+  /** The tools server's name in OpenCode. */
+  get toolsServer() {
+    return this.settings.tools?.server ?? "aviary";
+  }
+  /** The roles policy a turn's tools are gated by (the agent's own). */
+  rolesPolicyFor(input) {
+    return this.deps.forAgent(input.agentName).rolesPolicy;
+  }
+  /** The tools a turn may reach: the agent's allow-list, narrowed by its persona's. */
+  allowedTools(input) {
+    const deps = this.deps.forAgent(input.agentName);
+    const agent = deps.toolAllowList;
+    const persona = input.persona !== void 0 ? deps.personas?.find((p) => p.id === input.persona)?.allowedTools : void 0;
+    if (agent === void 0) return persona === void 0 ? void 0 : [
+      ...persona
+    ];
+    if (persona === void 0) return [
+      ...agent
+    ];
+    return agent.filter((name) => persona.includes(name));
+  }
+  /**
+  * Whether the tools endpoint serves `remember`: the module's tools are served and the memory
+  * provider writes. Served by the engine's own endpoint only — never put in the module's shared
+  * registry, where every MCP client and the `/tools` catalog would see it.
+  */
+  memoryWritable() {
+    return this.settings.tools !== void 0 && this.memory?.provider.write !== void 0;
+  }
+  /** `remember` for a turn: one fact, at the actor's own scope only — as the loop serves it. */
+  async remember(input, turn) {
+    const memory = this.memory;
+    const write = memory?.provider.write?.bind(memory.provider);
+    if (memory === void 0 || write === void 0) return "Memory is read-only here.";
+    const max = memory.maxFactChars ?? DEFAULT_MAX_FACT_CHARS;
+    if (input.fact.length > max) return `Not recorded: a fact is at most ${max} characters.`;
+    const actor = turn.input.actor;
+    const scopeCtx = {
+      actor,
+      threadId: turn.ctx.threadId,
+      ...turn.input.agentName !== void 0 ? {
+        agentName: turn.input.agentName
+      } : {}
+    };
+    const scopes = await (memory.scopes ?? defaultScopeResolver).resolve(scopeCtx);
+    const scope = actorScope(actor);
+    const verdict = memoryWriteVerdict({
+      scope,
+      scopes,
+      actor,
+      author: {
+        kind: "agent"
+      }
+    });
+    if (!verdict.allowed) return `Not recorded: ${verdict.reason}`;
+    await write({
+      key: input.key,
+      text: input.fact,
+      scope,
+      origin: {
+        author: "agent",
+        actorRef: actor.id,
+        threadId: turn.ctx.threadId,
+        runId: turn.runId
+      },
+      ctx: scopeCtx
+    });
+    return `Recorded "${input.key}".`;
+  }
+  /**
+  * The turn a tool call over the engine's MCP endpoint belongs to, or `undefined` when it belongs
+  * to none — which the endpoint refuses: it exists only to serve turns. OpenCode names its session in
+  * every call's `_meta` (`ai.opencode/sessionID`); the call is that session's running turn's, and
+  * only when the endpoint's caller is the person that turn runs for, on the server the token was
+  * issued for. A session this process is not following is found through OpenCode (`session.get` →
+  * the thread it was created for → the thread's running turn); its components still reach the
+  * stream, as a message of their own.
+  */
+  async callContext(call) {
+    const sessionId = sessionOfMeta(call.meta);
+    if (sessionId === void 0) return void 0;
+    const scope = /* @__PURE__ */ __name((runId2) => `${runId2}:${call.requestId || randomUUID()}`, "scope");
+    for (const [runId2, live] of this.live) {
+      if (live.handle.sessionId !== sessionId) continue;
+      if (live.input.actor.id !== call.actor.id || live.handle.serverKey !== call.serverKey) {
+        return void 0;
+      }
+      return {
+        input: live.input,
+        runId: runId2,
+        ctx: {
+          threadId: live.input.threadId,
+          runId: runId2,
+          emitUi: uiEmitter(scope(runId2), async (component) => {
+            await live.turn.pushUi(component);
+            await this.uiPushed(live.input, runId2, component);
+          })
+        }
+      };
+    }
+    const threadId = await this.threadOfSession(call.actor, sessionId);
+    if (threadId === void 0) return void 0;
+    if (await this.store.ownerOfThread(threadId) !== call.actor.id) return void 0;
+    const known = await this.sessions.get(threadId);
+    if (known === null || known.sessionId !== sessionId || known.serverKey !== call.serverKey) {
+      return void 0;
+    }
+    const runId = await this.activeRun(threadId);
+    if (runId === null) return void 0;
+    const input = {
+      threadId,
+      actor: call.actor,
+      userText: "",
+      ...known.agentName !== void 0 ? {
+        agentName: known.agentName
+      } : {},
+      ...known.persona !== void 0 ? {
+        persona: known.persona
+      } : {}
+    };
+    return {
+      input,
+      runId,
+      ctx: {
+        threadId,
+        runId,
+        emitUi: uiEmitter(scope(runId), async (component) => {
+          const writer = await this.sink.open(runId);
+          await writer.write(encodeStreamEvent2({
+            kind: "ui",
+            ...component
+          }));
+          await this.store.appendMessage({
+            threadId,
+            role: "assistant",
+            content: "",
+            runId,
+            ui: [
+              component
+            ]
+          });
+          await this.uiPushed(input, runId, component);
+        })
+      }
+    };
+  }
+  /**
+  * Spend one approval of `tool` in `runId` — what the MCP endpoint asks before it runs an `action`.
+  * OpenCode asks the person (or the policy answers) before it calls an action tool; the endpoint
+  * runs it only against an approval this engine saw granted, so a caller that skipped OpenCode's
+  * permission rules (a model in code mode that read the endpoint's headers, anything else that got
+  * hold of the token) cannot run an action unapproved. One approval, one call. The approval is the
+  * run's own: live in this process, else read off the run's persisted calls (spent marks are kept
+  * per process).
+  */
+  async spendApproval(runId, tool, input) {
+    const names = /* @__PURE__ */ new Set([
+      tool,
+      `${this.toolsServer}.${tool}`,
+      `${this.toolsServer}_${tool}`
+    ]);
+    const local = (this.grants.get(runId) ?? []).find((grant) => names.has(grant.action) && !this.spent.has(grant.id));
+    if (local !== void 0) {
+      this.spent.add(local.id);
+      return true;
+    }
+    const thread = await this.store.getThread(input.threadId);
+    for (const message of thread?.messages ?? []) {
+      if (message.runId !== runId) continue;
+      for (const call of message.toolCalls ?? []) {
+        if (!names.has(call.name) || this.spent.has(call.id)) continue;
+        const result = message.toolResults?.find((r) => r.id === call.id);
+        const approved = result?.output?.approved === true;
+        if (approved) {
+          this.spent.add(call.id);
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  async activeRun(threadId) {
+    if (this.store.activeRunForThread !== void 0) return this.store.activeRunForThread(threadId);
+    return (await this.store.getThread(threadId))?.activeRunId ?? null;
+  }
+  async uiPushed(input, runId, component) {
+    await this.host.onUi?.({
+      input,
+      runId,
+      component
+    }).catch((error) => {
+      this.logger.warn(`onUi failed: ${errorText(error, "error")}`);
+    });
+  }
+  /**
+  * Push a component into the run an OpenCode session is serving, for the host's own trusted
+  * callers (no caller check — {@link callContext} is the one for MCP requests). `false` when no run
+  * is live on that session.
+  */
+  async pushToSession(sessionId, component) {
+    for (const [runId, live] of this.live) {
+      if (live.handle.sessionId !== sessionId) continue;
+      await live.turn.pushUi(component);
+      await this.uiPushed(live.input, runId, component);
+      return true;
+    }
+    return false;
+  }
+  /** The runs this process is following now (an updater drains on it). */
+  liveRuns() {
+    return [
+      ...this.live.keys()
+    ];
+  }
+  async threadOfSession(actor, sessionId) {
+    try {
+      const server = await this.host.server(actor);
+      const info = await server.client.session.get?.({
+        sessionID: sessionId
+      });
+      const threadId = info?.metadata?.threadId;
+      return typeof threadId === "string" ? threadId : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  onApplicationShutdown() {
+    for (const live of this.live.values()) live.stop();
+    this.live.clear();
+    this.events.close();
+  }
+  // ---- begin ---------------------------------------------------------------------------------
+  /**
+  * Persist the user message (or rewind the thread for a regenerate), find or create the thread's
+  * session, and refresh what the session is told this turn. Safe to run again for the same run (a
+  * durable `begin` re-run after a crash): the run's user message is written once.
+  */
+  async begin(runId, input) {
+    const earlier = await this.prepareThread(runId, input);
+    const server = await this.host.server(input.actor);
+    const known = await this.sessions.get(input.threadId);
+    const reusable = known !== null && known.serverKey === server.key && known.bootId === server.bootId && (await this.host.reuse?.({
+      input,
+      runId,
+      session: known
+    }) ?? true);
+    let handle;
+    let created = false;
+    if (known !== null && reusable) {
+      handle = {
+        sessionId: known.sessionId,
+        serverKey: known.serverKey,
+        ...known.bootId !== void 0 ? {
+          bootId: known.bootId
+        } : {},
+        ...known.directory !== void 0 ? {
+          directory: known.directory
+        } : {}
+      };
+      if (input.regenerate === true) await this.revertLastExchange(server.client, handle.sessionId);
+      await this.addTools(input, server, handle.directory, false);
+    } else {
+      handle = await this.createSession(runId, input, server, earlier);
+      created = true;
+    }
+    if (created || known?.agentName !== input.agentName || known?.persona !== input.persona) {
+      await this.sessions.set(input.threadId, {
+        ...handle,
+        ...input.agentName !== void 0 ? {
+          agentName: input.agentName
+        } : {},
+        ...input.persona !== void 0 ? {
+          persona: input.persona
+        } : {}
+      });
+    }
+    await this.host.beforePrompt?.({
+      input,
+      runId,
+      sessionId: handle.sessionId,
+      client: server.client,
+      created
+    });
+    await this.refreshInstructions(runId, input, server.client, handle.sessionId);
+    return handle;
+  }
+  async createSession(runId, input, server, earlier, note) {
+    const { client } = server;
+    const context = {
+      input,
+      runId
+    };
+    const spec = await this.host.session(context);
+    const directory = spec.location?.directory;
+    const skills = await this.writeSkills(input, client, directory);
+    const sessionId = (await client.session.create({
+      ...spec,
+      permissions: [
+        ...spec.permissions ?? [],
+        ...this.toolRules(input),
+        ...skills.map((name) => ({
+          action: "skill",
+          resource: name,
+          effect: "allow"
+        }))
+      ],
+      metadata: {
+        ...spec.metadata ?? {},
+        threadId: input.threadId
+      }
+    })).id;
+    const handle = {
+      sessionId,
+      serverKey: server.key,
+      ...server.bootId !== void 0 ? {
+        bootId: server.bootId
+      } : {},
+      ...directory !== void 0 ? {
+        directory
+      } : {}
+    };
+    await this.sessions.set(input.threadId, handle);
+    await this.addTools(input, server, directory, true);
+    await this.host.prepare?.({
+      ...context,
+      sessionId,
+      client
+    });
+    const transcript = transcriptOf(earlier, this.settings.historyMessages ?? 20);
+    if (transcript || note) {
+      await client.session.instructions.entry.put({
+        sessionID: sessionId,
+        key: "aviary.history",
+        value: [
+          transcript ? `The conversation so far (continue it; do not repeat it):
+${transcript}` : "",
+          note ?? ""
+        ].filter(Boolean).join("\n\n")
+      });
+    }
+    return handle;
+  }
+  /** The user message, as the loop persists it (or, on a regenerate, the thread rewound to it). */
+  async prepareThread(runId, input) {
+    const thread = await this.store.getThread(input.threadId);
+    const messages = thread?.messages ?? [];
+    if (input.regenerate === true) {
+      let lastUser = -1;
+      for (let i = messages.length - 1; i >= 0; i -= 1) if (messages[i]?.role === "user") {
+        lastUser = i;
+        break;
+      }
+      const firstDropped = messages[lastUser + 1];
+      if (firstDropped !== void 0) await this.store.truncateFrom(input.threadId, firstDropped.id);
+      return messages.slice(0, Math.max(lastUser, 0));
+    }
+    const mine = messages.findIndex((m) => m.role === "user" && m.runId === runId);
+    if (mine >= 0) return messages.slice(0, mine);
+    await this.store.appendMessage({
+      threadId: input.threadId,
+      role: "user",
+      content: input.userText,
+      runId,
+      ...input.persona !== void 0 ? {
+        persona: input.persona
+      } : {},
+      ...input.attachments !== void 0 ? {
+        attachments: input.attachments
+      } : {}
+    });
+    if (thread !== null && (thread.title === "" || thread.title === "New chat")) {
+      await this.store.setTitle(input.threadId, titleOf(input.userText));
+    }
+    return messages;
+  }
+  /** Rewind the session to before its last user message, so the regenerated answer replaces it. */
+  async revertLastExchange(client, sessionId) {
+    if (client.message === void 0 || client.session.revert === void 0) return;
+    const page = await client.message.list({
+      sessionID: sessionId,
+      order: "desc",
+      limit: 50
+    });
+    const last = page.data.find((m) => m.type === "user");
+    if (last === void 0) return;
+    await client.session.revert.stage({
+      sessionID: sessionId,
+      messageID: last.id,
+      files: false
+    });
+    await client.session.revert.commit({
+      sessionID: sessionId
+    });
+  }
+  /** The agent's prompt, the memory block and the host's entries — refreshed every turn. */
+  async refreshInstructions(runId, input, client, sessionId) {
+    const memory = await this.memoryBlock(input);
+    const entries = {
+      [this.settings.systemKey ?? "aviary.system"]: await this.systemPrompt(input),
+      ...memory !== void 0 ? {
+        "aviary.memory": memory
+      } : {},
+      ...await this.host.instructions?.({
+        input,
+        runId,
+        sessionId
+      }) ?? {}
+    };
+    for (const [key, value] of Object.entries(entries)) {
+      await client.session.instructions.entry.put({
+        sessionID: sessionId,
+        key,
+        value
+      });
+    }
+  }
+  /** The agent's base prompt (`@Agent({ systemPrompt })` / `@SystemPrompt()`) and the contributors. */
+  async systemPrompt(input) {
+    const deps = this.deps.forAgent(input.agentName);
+    const ctx = {
+      actor: input.actor,
+      agentName: input.agentName ?? "default",
+      ...input.pageContext !== void 0 ? {
+        pageContext: input.pageContext
+      } : {},
+      ...input.uiCapabilities !== void 0 ? {
+        uiCapabilities: input.uiCapabilities
+      } : {}
+    };
+    const base = typeof deps.systemPrompt === "function" ? await deps.systemPrompt(ctx) : deps.systemPrompt;
+    const sections = [
+      base
+    ];
+    for (const contribute of deps.promptContributors) {
+      const section = await contribute(ctx);
+      if (section) sections.push(section);
+    }
+    return sections.filter(Boolean).join("\n\n");
+  }
+  scopeContext(input) {
+    return {
+      actor: input.actor,
+      threadId: input.threadId,
+      ...input.agentName !== void 0 ? {
+        agentName: input.agentName
+      } : {},
+      ...input.pageContext !== void 0 ? {
+        pageContext: input.pageContext
+      } : {}
+    };
+  }
+  /** What is on file about the actor (`forRoot({ memory })`); writable when `remember` is served. */
+  async memoryBlock(input) {
+    const memory = this.memory;
+    if (memory === void 0) return void 0;
+    const ctx = this.scopeContext(input);
+    const scopes = await (memory.scopes ?? defaultScopeResolver).resolve(ctx);
+    const records = await memory.provider.list({
+      scopes,
+      ctx
+    });
+    const digest = resolveMemoryDigest({
+      records,
+      scopes,
+      ...memory.maxMemories !== void 0 ? {
+        maxMemories: memory.maxMemories
+      } : {}
+    });
+    if (digest.entries.length === 0) return void 0;
+    return buildMemoryBlock({
+      entries: digest.entries,
+      writable: this.memoryWritable(),
+      partial: digest.omitted > 0
+    });
+  }
+  /**
+  * The module's skills (`forRoot({ skills })` / `@Skill`) as `SKILL.md` files under the session's
+  * directory, where OpenCode's own `skill` tool finds them. Returns the names written.
+  */
+  async writeSkills(input, client, directory) {
+    const skills = this.skills;
+    if (skills === void 0 || client.file === void 0 || directory === void 0) return [];
+    const ctx = this.scopeContext(input);
+    const scopes = await (skills.scopes ?? defaultScopeResolver).resolve(ctx);
+    const summaries = await skills.provider.list({
+      scopes,
+      ctx
+    });
+    const { entries } = resolveSkillCatalog(summaries, scopes, skills.maxSkills);
+    const dir = this.settings.skillsDir ?? ".opencode/skills";
+    const written = [];
+    for (const entry of entries) {
+      const body = await skills.provider.load({
+        name: entry.name,
+        scope: entry.scope,
+        ctx
+      });
+      if (body === null) continue;
+      const file = `---
+name: ${entry.name}
+description: ${JSON.stringify(entry.description)}
+---
+
+${body}
+`;
+      await client.file.write({
+        location: {
+          directory
+        },
+        path: `${dir}/${entry.name}/SKILL.md`,
+        payload: new TextEncoder().encode(file)
+      });
+      written.push(entry.name);
+    }
+    return written;
+  }
+  /**
+  * Permission rules for the module's tools: the MCP server allowed as a whole (OpenCode offers a
+  * server's tools only when the server itself is allowed), then each `action` tool asked — the last
+  * matching rule wins, so an action still lands on an approval card. Tools outside the agent's
+  * (and persona's) allow-list, and the kinds only the loop serves, are denied. The endpoint enforces
+  * all of it again on every call: these rules are what OpenCode offers, not what keeps a call out.
+  */
+  toolRules(input) {
+    if (this.settings.tools === void 0) return [];
+    const server = this.toolsServer;
+    const allow = this.allowedTools(input);
+    const both = /* @__PURE__ */ __name((name) => [
+      `${server}.${name}`,
+      `${server}_${name}`
+    ], "both");
+    const rules = [
+      {
+        action: `${server}*`,
+        resource: "*",
+        effect: "allow"
+      }
+    ];
+    for (const spec of this.registry.allSpecs()) {
+      const offered = (allow === void 0 || allow.includes(spec.name)) && !LOOP_SERVED_KINDS.has(spec.kind);
+      if (offered && spec.kind === "read") continue;
+      const effect = offered && spec.kind === "action" ? "ask" : "deny";
+      for (const action of both(spec.name)) rules.push({
+        action,
+        resource: "*",
+        effect
+      });
+    }
+    return rules;
+  }
+  /**
+  * Register the tools endpoint at the session's location, with a bearer token for the turn's actor
+  * on this server. On a new session always; on a kept one when this process has not registered it
+  * yet or its token is half-way through its life.
+  */
+  async addTools(input, server, directory, fresh) {
+    const tools = this.settings.tools;
+    const tokens = this.toolsTokens;
+    if (tools === void 0 || tokens == null) return;
+    const { client } = server;
+    if (client.mcp === void 0) {
+      this.logger.warn("`tools` is set but the OpenCode client cannot add MCP servers (`mcp.add`)");
+      return;
+    }
+    const key = `${server.key}|${server.bootId ?? ""}|${directory ?? ""}|${input.actor.id}`;
+    const issued = this.toolsIssued.get(key);
+    const ttl = tools.ttlMs ?? DEFAULT_TOOLS_TTL_MS;
+    if (!fresh && issued !== void 0 && Date.now() - issued < ttl / 2) return;
+    await client.mcp.add({
+      server: this.toolsServer,
+      ...directory !== void 0 ? {
+        location: {
+          directory
+        }
+      } : {},
+      config: {
+        type: "remote",
+        url: tools.url,
+        headers: {
+          Authorization: `Bearer ${tokens.mint(input.actor, server.key)}`
+        },
+        oauth: false
+      }
+    });
+    this.toolsIssued.set(key, Date.now());
+  }
+  // ---- prompt / observe / reply --------------------------------------------------------------
+  /** Start listening to the session (so nothing it says is missed), then send the user message. */
+  async prompt(runId, input, handle) {
+    const live = await this.ensureLive(runId, input, handle, false);
+    try {
+      const prompt = await this.host.promptFor?.({
+        input,
+        runId,
+        sessionId: handle.sessionId
+      }) ?? {
+        text: input.userText,
+        ...input.attachments?.length && this.host.files ? {
+          files: await this.host.files({
+            input,
+            runId
+          })
+        } : {}
+      };
+      await live.client.session.prompt({
+        sessionID: handle.sessionId,
+        text: prompt.text,
+        ...prompt.files?.length ? {
+          files: prompt.files
+        } : {}
+      });
+    } catch (error) {
+      live.turn.fail(`OpenCode refused the message: ${error.message}`);
+    }
+  }
+  /**
+  * Wait for the turn's next milestone. In a process that was not following the turn (a resumed
+  * durable run), the turn is rebuilt and first catches up on requests OpenCode raised meanwhile;
+  * `session.wait` is the safety net for a terminal event that was missed.
+  */
+  async observe(runId, input, handle) {
+    const live = await this.ensureLive(runId, input, handle, true);
+    const { turn, client } = live;
+    if (turn.hasMilestone()) return this.reached(runId, input, handle, await turn.next());
+    let done = false;
+    const next = turn.next().then((milestone) => {
+      done = true;
+      return milestone;
+    });
+    const timeoutMs = this.settings.turnTimeoutMs ?? DEFAULT_TURN_TIMEOUT_MS;
+    const timer = setTimeout(() => {
+      if (!done) turn.fail("Timed out waiting for OpenCode.");
+    }, timeoutMs);
+    timer.unref?.();
+    if (client.session.wait !== void 0) {
+      void client.session.wait({
+        sessionID: handle.sessionId
+      }).then(() => new Promise((resolve) => setTimeout(resolve, 2e3))).then(async () => {
+        if (done || turn.finished) return;
+        await turn.catchUp().catch(() => void 0);
+        await new Promise((resolve) => setImmediate(resolve));
+        if (!done && !turn.finished) turn.handle({
+          type: "session.execution.succeeded",
+          data: {
+            sessionID: handle.sessionId
+          }
+        });
+      }).catch(() => void 0);
+    }
+    try {
+      return await this.reached(runId, input, handle, await next);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  /**
+  * Hand a person's answer back to OpenCode. When the server restarted while the turn waited, the
+  * request is gone with it: a new session is opened, told what the person decided, and prompted
+  * to go on.
+  */
+  async reply(runId, input, handle, ask, reply) {
+    const server = await this.host.server(input.actor);
+    if (server.key !== handle.serverKey || server.bootId !== handle.bootId) {
+      return this.continueAfterRestart(runId, input, server, ask, reply);
+    }
+    const live = await this.ensureLive(runId, input, handle, false);
+    await live.turn.decide(ask, reply);
+    return handle;
+  }
+  async continueAfterRestart(runId, input, server, ask, reply) {
+    const approved = "approved" in reply && reply.approved === true;
+    const note = ask.kind === "approval" ? approved ? `The user approved the action ${ask.action} you asked permission for. Continue the task.` : `The user did not approve the action ${ask.action}. Continue without it and explain.` : `The user answered your question: ${JSON.stringify("answers" in reply ? reply.answers : {})}. Continue.`;
+    const thread = await this.store.getThread(input.threadId);
+    const handle = await this.createSession(runId, input, server, thread?.messages ?? [], note);
+    await this.refreshInstructions(runId, input, server.client, handle.sessionId);
+    this.drop(runId);
+    const live = await this.ensureLive(runId, input, handle, false);
+    await live.turn.decide(ask, reply, {
+      tellOpenCode: false
+    });
+    await live.client.session.prompt({
+      sessionID: handle.sessionId,
+      text: note
+    });
+    return handle;
+  }
+  /** Interrupt the thread's session (cancel). */
+  async interrupt(input) {
+    const known = await this.sessions.get(input.threadId);
+    if (known === null) return;
+    const server = await this.host.server(input.actor);
+    if (server.key !== known.serverKey || server.bootId !== known.bootId) return;
+    await server.client.session.interrupt({
+      sessionID: known.sessionId
+    });
+  }
+  async ensureLive(runId, input, handle, catchUp) {
+    const current = this.live.get(runId);
+    if (current !== void 0 && current.handle.sessionId === handle.sessionId) return current;
+    current?.stop();
+    const server = await this.host.server(input.actor);
+    const deps = this.deps.forAgent(input.agentName);
+    const policy = deps.approvalPolicy ?? new DefaultApprovalPolicy();
+    const writer = await this.sink.open(input.sinkRunId ?? runId);
+    const turn = new OpenCodeTurn({
+      runId,
+      input,
+      client: server.client,
+      sessionId: handle.sessionId,
+      writer,
+      store: this.store,
+      approvalFor: /* @__PURE__ */ __name(async (action) => policy.requirementFor({
+        name: action,
+        kind: "action"
+      }, input.actor, {
+        threadId: input.threadId,
+        runId,
+        ...input.agentName !== void 0 ? {
+          agentName: input.agentName
+        } : {}
+      }), "approvalFor"),
+      modelLabel: input.model ?? "opencode",
+      logger: this.logger,
+      onGranted: /* @__PURE__ */ __name((action, id) => {
+        const grants = this.grants.get(runId) ?? [];
+        grants.push({
+          action,
+          id
+        });
+        this.grants.set(runId, grants);
+      }, "onGranted")
+    });
+    const stop = await this.events.listen(server.key, server.client, handle.sessionId, (event) => turn.handle(event));
+    const live = {
+      turn,
+      input,
+      handle,
+      client: server.client,
+      stop
+    };
+    this.live.set(runId, live);
+    if (catchUp && current === void 0) await turn.catchUp().catch(() => void 0);
+    return live;
+  }
+  /** Stop following a run in this process. */
+  drop(runId) {
+    this.live.get(runId)?.stop();
+    this.live.delete(runId);
+  }
+  /** Stop following a run and drop the approvals it was granted: it is over. */
+  forget(runId) {
+    this.drop(runId);
+    for (const grant of this.grants.get(runId) ?? []) this.spent.delete(grant.id);
+    this.grants.delete(runId);
+  }
+  // ---- settle --------------------------------------------------------------------------------
+  /** A person was asked something: tell the host (cards in other channels, wake-ups). */
+  async reached(runId, input, handle, milestone) {
+    if (milestone.kind === "ask" && this.host.onAsk !== void 0) {
+      await this.host.onAsk({
+        input,
+        runId,
+        sessionId: handle.sessionId,
+        ask: milestone.ask
+      }).catch((error) => this.logger.warn(`onAsk failed: ${errorText(error, "error")}`));
+    }
+    return milestone;
+  }
+  /** What the run produced, as the host's settle hooks see it. */
+  async runResult(runId, input, outcome, durationMs) {
+    const thread = await this.store.getThread(input.threadId);
+    const messages = (thread?.messages ?? []).filter((m) => m.role === "assistant" && m.runId === runId);
+    const usage = {
+      inputTokens: 0,
+      outputTokens: 0,
+      costUsd: 0
+    };
+    for (const m of messages) {
+      usage.inputTokens += m.usage?.inputTokens ?? 0;
+      usage.outputTokens += m.usage?.outputTokens ?? 0;
+      usage.costUsd += m.usage?.costUsd ?? 0;
+    }
+    return {
+      runId,
+      input,
+      outcome,
+      text: messages.map((m) => m.content).filter(Boolean).join("\n\n"),
+      messages,
+      usage,
+      durationMs
+    };
+  }
+  /**
+  * The host's last word on the answer before the stream ends: components to append (a guardrail
+  * notice), or, for a failed run, the error the person reads instead of OpenCode's.
+  */
+  async amend(writer, result) {
+    if (this.host.beforeSettle === void 0) return {};
+    let amendment = {};
+    try {
+      amendment = await this.host.beforeSettle(result) ?? {};
+    } catch (error) {
+      this.logger.warn(`beforeSettle failed: ${errorText(error, "error")}`);
+    }
+    const ui = amendment.ui ?? [];
+    const last = result.messages.at(-1);
+    if (ui.length > 0) {
+      for (const component of ui) await writer.write(encodeStreamEvent2({
+        kind: "ui",
+        ...component
+      }));
+      if (last !== void 0) await this.store.setMessageUi?.(last.id, [
+        ...last.ui ?? [],
+        ...ui
+      ]);
+    }
+    return amendment;
+  }
+  /** Delivery, telemetry, spend: after the run settled. Errors are the host's, never the run's. */
+  async settled(result) {
+    try {
+      await this.host.onSettled?.(result);
+    } catch (error) {
+      this.logger.warn(`onSettled failed: ${errorText(error, "error")}`);
+    }
+  }
+  /** End the run's stream and bookkeeping for how its execution ended. */
+  async settle(runId, input, outcome, durationMs) {
+    if (outcome.status === "failed") {
+      await this.settleFailed(runId, input, outcome.error, durationMs);
+      return;
+    }
+    this.forget(runId);
+    const writer = await this.sink.open(runId);
+    const result = await this.runResult(runId, input, outcome, durationMs);
+    await this.amend(writer, result);
+    if (outcome.status === "interrupted") {
+      this.logger.log(`agent run ${runId} cancelled`);
+      await Promise.resolve(this.store.failUnsettledToolCalls?.(runId, RUN_ENDED_BEFORE_TOOL_CALL)).catch(() => 0);
+      await this.handoff(writer, input, runId, "cancelled");
+      await releaseThreadRun(this.store, input.threadId, runId);
+      await writer.write(encodeStreamEvent2({
+        kind: "cancelled"
+      }));
+      await writer.end();
+      await this.store.recordRunEnd?.({
+        runId,
+        status: "cancelled",
+        durationMs
+      });
+    } else {
+      await this.handoff(writer, input, runId, "completed");
+      await releaseThreadRun(this.store, input.threadId, runId);
+      await writer.end();
+      await this.store.recordRunEnd?.({
+        runId,
+        status: "completed",
+        durationMs
+      });
+    }
+    await this.settled(result);
+  }
+  async settleFailed(runId, input, error, durationMs = 0) {
+    this.forget(runId);
+    const writer = await this.sink.open(runId);
+    const result = await this.runResult(runId, input, {
+      status: "failed",
+      error
+    }, durationMs);
+    const worded = (await this.amend(writer, result)).error;
+    const message = worded ?? streamFailure(new Error(error)).message;
+    this.logger.error(`agent run ${runId} failed: ${error}`);
+    publishAgentRunFailed({
+      runId,
+      code: "opencode_failed",
+      message: error
+    });
+    await this.store.recordRunEnd?.({
+      runId,
+      status: "failed",
+      errorCode: "opencode_failed",
+      errorMessage: error
+    });
+    await Promise.resolve(this.store.failUnsettledToolCalls?.(runId, RUN_ENDED_BEFORE_TOOL_CALL)).catch(() => 0);
+    await this.handoff(writer, input, runId, "failed", error);
+    await releaseThreadRun(this.store, input.threadId, runId);
+    await writer.fail({
+      code: "opencode_failed",
+      message
+    });
+    await this.settled({
+      ...result,
+      outcome: {
+        status: "failed",
+        error: worded ?? error
+      }
+    });
+  }
+  /** Starts the next queued message of the thread; set by the runner (it owns `start`). */
+  startNext;
+  /** As `InlineAgentRunner`: hand the thread to its next queued message, and say so on the stream. */
+  async handoff(writer, input, runId, outcome, error) {
+    const queue = this.queue;
+    const startNext = this.startNext;
+    if (queue === void 0 || !queue.supported || startNext === void 0) return;
+    if (input.sinkRunId !== void 0 || input.deliverTo !== void 0) return;
+    try {
+      const frame = await queue.handoff({
+        threadId: input.threadId,
+        runId,
+        outcome,
+        ...error !== void 0 ? {
+          error
+        } : {}
+      }, (next, nextRunId) => startNext(next, nextRunId));
+      if (frame !== void 0) await writer.write(encodeStreamEvent2(frame));
+    } catch (failure) {
+      this.logger.error(`could not advance the queue of thread ${input.threadId} after run ${runId}: ${failure instanceof Error ? failure.message : String(failure)}`);
+    }
+  }
+};
+OpenCodeTurns = _ts_decorate2([
+  Injectable(),
+  _ts_param2(0, Inject2(OPENCODE_HOST)),
+  _ts_param2(1, Inject2(OPENCODE_SESSIONS)),
+  _ts_param2(2, Inject2(OPENCODE_OPTIONS)),
+  _ts_param2(3, Inject2(AGENT_STORE)),
+  _ts_param2(4, Inject2(AGENT_SINK)),
+  _ts_param2(5, Inject2(AGENT_DEPS_FACTORY)),
+  _ts_param2(6, Inject2(AGENT_TOOL_REGISTRY)),
+  _ts_param2(7, Optional()),
+  _ts_param2(7, Inject2(AGENT_SKILLS)),
+  _ts_param2(8, Optional()),
+  _ts_param2(8, Inject2(AGENT_MEMORY)),
+  _ts_param2(9, Optional()),
+  _ts_param2(9, Inject2(AGENT_CHAT_QUEUE)),
+  _ts_param2(10, Optional()),
+  _ts_param2(10, Inject2(OPENCODE_TOOLS_TOKENS)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof OpenCodeHost === "undefined" ? Object : OpenCodeHost,
+    typeof OpenCodeSessionStore === "undefined" ? Object : OpenCodeSessionStore,
+    typeof OpenCodeEngineSettings === "undefined" ? Object : OpenCodeEngineSettings,
+    typeof AgentStore === "undefined" ? Object : AgentStore,
+    typeof TokenStreamSink === "undefined" ? Object : TokenStreamSink,
+    typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory,
+    typeof ToolRegistry === "undefined" ? Object : ToolRegistry,
+    typeof SkillsConfig === "undefined" ? Object : SkillsConfig,
+    typeof MemoryConfig === "undefined" ? Object : MemoryConfig,
+    typeof ChatQueueService === "undefined" ? Object : ChatQueueService,
+    Object
+  ])
+], OpenCodeTurns);
+function titleOf(text) {
+  const trimmed = text.trim().replace(/\s+/g, " ");
+  return trimmed.length > 60 ? `${trimmed.slice(0, 57)}...` : trimmed || "New chat";
+}
+__name(titleOf, "titleOf");
+function transcriptOf(messages, limit) {
+  return messages.filter((m) => (m.role === "user" || m.role === "assistant") && m.content.trim()).slice(-limit).map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.content.slice(0, 2e3)}`).join("\n");
+}
+__name(transcriptOf, "transcriptOf");
+var SESSION_META_KEY = "ai.opencode/sessionID";
+function sessionOfMeta(meta) {
+  const value = meta?.[SESSION_META_KEY];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+__name(sessionOfMeta, "sessionOfMeta");
+function uiEmitter(scope, push) {
+  let next = 0;
+  return async (component, props, options = {}) => {
+    if (typeof component !== "string" || component.length === 0) {
+      throw new Error("emitUi: component must be a non-empty string");
+    }
+    if (typeof props !== "object" || props === null || Array.isArray(props)) {
+      throw new Error("emitUi: props must be a JSON object");
+    }
+    const id = options.id ?? `${scope}:ui:${next++}`;
+    await push({
+      id,
+      component,
+      props: JSON.parse(JSON.stringify(props)),
+      ...options.version !== void 0 ? {
+        version: options.version
+      } : {}
+    });
+    return {
+      id
+    };
+  };
+}
+__name(uiEmitter, "uiEmitter");
+
+// src/runner.ts
+function _ts_decorate3(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+function _ts_metadata3(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata3, "_ts_metadata");
+function _ts_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_ts_param");
+var OpenCodeAgentRunner = class {
+  static {
+    __name(this, "OpenCodeAgentRunner");
+  }
+  turns;
+  settings;
+  live = /* @__PURE__ */ new Set();
+  cancelled = /* @__PURE__ */ new Set();
+  pending = /* @__PURE__ */ new Map();
+  constructor(turns, settings) {
+    this.turns = turns;
+    this.settings = settings;
+    turns.startNext = (next, runId) => this.start(next, {
+      runId
+    });
+  }
+  runIdFor(input) {
+    return this.settings.runId?.(input) ?? crypto.randomUUID();
+  }
+  async isRunActive(runId) {
+    if (this.live.has(runId)) return true;
+    for (const key of this.pending.keys()) if (key.startsWith(`${runId}:`)) return true;
+    return false;
+  }
+  async start(input, options = {}) {
+    const runId = options.runId ?? this.runIdFor(input);
+    this.live.add(runId);
+    void this.run(runId, input).finally(() => {
+      this.live.delete(runId);
+      this.cancelled.delete(runId);
+      for (const key of [
+        ...this.pending.keys()
+      ]) if (key.startsWith(`${runId}:`)) this.pending.delete(key);
+    });
+    return {
+      runId
+    };
+  }
+  /**
+  * Deliver a person's reply. Answers addressed at an approval are refused
+  * ({@link OpenCodeReplyMismatchError}, a 409) and the approval keeps waiting: they say nothing
+  * about whether the action should run.
+  */
+  async signal(runId, toolCallId, reply) {
+    const key = `${runId}:${toolCallId}`;
+    const waiter = this.pending.get(key);
+    if (waiter === void 0) return;
+    if (waiter.on === "approval" && !isDecision(reply)) {
+      throw new OpenCodeReplyMismatchError(runId, toolCallId);
+    }
+    this.pending.delete(key);
+    waiter.resolve(reply);
+  }
+  /**
+  * Stop the run: what it waits on a person for is dropped, and OpenCode is interrupted — it answers
+  * `session.execution.interrupted`, which settles the run as cancelled.
+  */
+  async cancel(runId) {
+    this.cancelled.add(runId);
+    for (const [key, waiter] of [
+      ...this.pending
+    ]) {
+      if (!key.startsWith(`${runId}:`)) continue;
+      this.pending.delete(key);
+      waiter.reject(new RunCancelledError());
+    }
+    const input = this.inputs.get(runId);
+    if (input !== void 0) await this.turns.interrupt(input).catch(() => void 0);
+  }
+  inputs = /* @__PURE__ */ new Map();
+  async run(runId, input) {
+    const started = Date.now();
+    this.inputs.set(runId, input);
+    try {
+      let handle = await this.turns.begin(runId, input);
+      if (this.cancelled.has(runId)) throw new RunCancelledError();
+      await this.turns.prompt(runId, input, handle);
+      for (; ; ) {
+        const milestone = await this.turns.observe(runId, input, handle);
+        if (milestone.kind === "finished") {
+          await this.turns.settle(runId, input, milestone.outcome, Date.now() - started);
+          return;
+        }
+        const reply = await this.park(runId, milestone.ask.id, milestone.ask.kind === "approval" ? "approval" : "answers", milestone.timeoutMs);
+        handle = await this.turns.reply(runId, input, handle, milestone.ask, reply);
+      }
+    } catch (error) {
+      if (error instanceof RunCancelledError) {
+        await this.turns.interrupt(input).catch(() => void 0);
+        await this.turns.settle(runId, input, {
+          status: "interrupted"
+        }, Date.now() - started);
+        return;
+      }
+      await this.turns.settleFailed(runId, input, errorText(error, "the turn failed"));
+    } finally {
+      this.inputs.delete(runId);
+    }
+  }
+  /** Wait for a person's answer; a lapsed approval answers itself as expired. */
+  park(runId, toolCallId, on, timeoutMs) {
+    const key = `${runId}:${toolCallId}`;
+    const waiting = new Promise((resolve, reject) => {
+      this.pending.set(key, {
+        on,
+        resolve,
+        reject
+      });
+    });
+    if (timeoutMs === void 0) return waiting;
+    let timer;
+    const lapse = new Promise((resolve) => {
+      timer = setTimeout(() => {
+        if (!this.pending.has(key)) return;
+        this.pending.delete(key);
+        resolve({
+          approved: false,
+          expired: true
+        });
+      }, timeoutMs);
+      timer.unref?.();
+    });
+    return Promise.race([
+      waiting,
+      lapse
+    ]).finally(() => clearTimeout(timer));
+  }
+};
+OpenCodeAgentRunner = _ts_decorate3([
+  Injectable2(),
+  _ts_param3(1, Inject3(OPENCODE_OPTIONS)),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof OpenCodeTurns === "undefined" ? Object : OpenCodeTurns,
+    typeof OpenCodeEngineSettings === "undefined" ? Object : OpenCodeEngineSettings
+  ])
+], OpenCodeAgentRunner);
+
+// src/engine.ts
+function isInstance(value, method) {
+  return typeof value === "object" && value !== null && typeof value[method] === "function";
+}
+__name(isInstance, "isInstance");
+function bind(token, value, method) {
+  if (isInstance(value, method)) return [
+    {
+      provide: token,
+      useValue: value
+    }
+  ];
+  if (typeof value === "function") {
+    return [
+      value,
+      {
+        provide: token,
+        useExisting: value
+      }
+    ];
+  }
+  return [
+    {
+      provide: token,
+      useExisting: value
+    }
+  ];
+}
+__name(bind, "bind");
+function openCodeControllers(options) {
+  return options.tools !== void 0 ? [
+    OpenCodeMcpController
+  ] : [];
+}
+__name(openCodeControllers, "openCodeControllers");
+var DEFAULT_TOOLS_TTL_MS2 = 7 * 24 * 60 * 6e4;
+function toolsTokens(settings) {
+  const tools = settings.tools;
+  if (tools === void 0) return null;
+  if (tools.secret === void 0) {
+    new Logger3("OpenCodeEngine").warn("`tools` has no `secret`: the tools endpoint signs its tokens with a per-process secret, so it only works with one process (and sessions lose their tools on a restart until their next turn).");
+  }
+  return new OpenCodeToolsTokens(tools.secret, tools.ttlMs ?? DEFAULT_TOOLS_TTL_MS2);
+}
+__name(toolsTokens, "toolsTokens");
+function openCodeProviders(options) {
+  const { host, sessions, ...settings } = options;
+  return [
+    ...bind(OPENCODE_HOST, host, "server"),
+    ...bind(OPENCODE_SESSIONS, sessions ?? new InMemoryOpenCodeSessionStore(), "get"),
+    {
+      provide: OPENCODE_OPTIONS,
+      useValue: settings
+    },
+    {
+      provide: OPENCODE_TOOLS_TOKENS,
+      useFactory: /* @__PURE__ */ __name(() => toolsTokens(settings), "useFactory")
+    },
+    OpenCodeTurns,
+    {
+      provide: OPENCODE_TURNS,
+      useExisting: OpenCodeTurns
+    },
+    {
+      provide: OPENCODE_MCP_ENDPOINT,
+      useFactory: /* @__PURE__ */ __name((turns, tokens) => tokens === null ? null : new OpenCodeMcpEndpoint2(turns, tokens), "useFactory"),
+      inject: [
+        OpenCodeTurns,
+        OPENCODE_TOOLS_TOKENS
+      ]
+    }
+  ];
+}
+__name(openCodeProviders, "openCodeProviders");
+
+// src/durable/runner.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { AGENT_STORE as AGENT_STORE2 } from "@dudousxd/nestjs-agent-core";
+import { RUN_GATEWAY as RUN_GATEWAY2, WorkflowService } from "@dudousxd/nestjs-durable";
+import { isWorkflowControlFlowSignal as isWorkflowControlFlowSignal2 } from "@dudousxd/nestjs-durable-core";
+import { Inject as Inject5, Injectable as Injectable4, Logger as Logger4 } from "@nestjs/common";
+
+// src/durable/workflow.ts
+import { RUN_GATEWAY, Workflow } from "@dudousxd/nestjs-durable";
+import { SignalTimeoutError, isWorkflowControlFlowSignal } from "@dudousxd/nestjs-durable-core";
+import { Inject as Inject4, Injectable as Injectable3, Optional as Optional2 } from "@nestjs/common";
+function _ts_decorate4(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate4, "_ts_decorate");
+function _ts_metadata4(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata4, "_ts_metadata");
+function _ts_param4(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param4, "_ts_param");
+var OPENCODE_RUN_WORKFLOW = "agent.opencode.run";
+function decisionToken(runId, toolCallId) {
+  return `tool:${runId}:${toolCallId}`;
+}
+__name(decisionToken, "decisionToken");
+var OpenCodeRunWorkflow = class {
+  static {
+    __name(this, "OpenCodeRunWorkflow");
+  }
+  turns;
+  runs;
+  constructor(turns, runs) {
+    this.turns = turns;
+    this.runs = runs;
+  }
+  async run(ctx, input) {
+    try {
+      const begun = await ctx.localStep("begin", async () => ({
+        handle: await this.turns.begin(ctx.runId, input),
+        startedAt: Date.now()
+      }));
+      let handle = begun.handle;
+      await ctx.localStep("prompt", async () => {
+        await this.turns.prompt(ctx.runId, input, handle);
+        return true;
+      });
+      for (let n = 0; ; n += 1) {
+        const milestone = await ctx.localStep(`observe:${n}`, () => this.turns.observe(ctx.runId, input, handle));
+        if (milestone.kind === "finished") {
+          await ctx.localStep("finish", async () => {
+            if (await this.cancelled(ctx.runId)) this.turns.drop(ctx.runId);
+            else await this.turns.settle(ctx.runId, input, milestone.outcome, Date.now() - begun.startedAt);
+            return true;
+          });
+          return {
+            outcome: milestone.outcome.status
+          };
+        }
+        let reply;
+        try {
+          reply = await ctx.waitForSignal(decisionToken(ctx.runId, milestone.ask.id), milestone.timeoutMs !== void 0 ? {
+            timeoutMs: milestone.timeoutMs
+          } : void 0);
+        } catch (error) {
+          if (!(error instanceof SignalTimeoutError)) throw error;
+          reply = {
+            approved: false,
+            expired: true
+          };
+        }
+        const ask = milestone.ask;
+        handle = await ctx.localStep(`reply:${n}`, () => this.turns.reply(ctx.runId, input, handle, ask, reply));
+      }
+    } catch (error) {
+      if (isWorkflowControlFlowSignal(error)) throw error;
+      await ctx.localStep("fail", async () => {
+        await this.turns.settleFailed(ctx.runId, input, errorText(error, "the turn failed"));
+        return true;
+      });
+      return {
+        outcome: "failed"
+      };
+    }
+  }
+  async cancelled(runId) {
+    try {
+      const status = (await this.runs?.getRunDetail(runId))?.run.status;
+      return status === "cancelling" || status === "cancelled";
+    } catch {
+      return false;
+    }
+  }
+};
+OpenCodeRunWorkflow = _ts_decorate4([
+  Injectable3(),
+  Workflow({
+    name: OPENCODE_RUN_WORKFLOW,
+    version: "1"
+  }),
+  _ts_param4(1, Optional2()),
+  _ts_param4(1, Inject4(RUN_GATEWAY)),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof OpenCodeTurns === "undefined" ? Object : OpenCodeTurns,
+    typeof RunGateway === "undefined" ? Object : RunGateway
+  ])
+], OpenCodeRunWorkflow);
+
+// src/durable/runner.ts
+function _ts_decorate5(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate5, "_ts_decorate");
+function _ts_metadata5(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata5, "_ts_metadata");
+function _ts_param5(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param5, "_ts_param");
+function isRunInput(value) {
+  return typeof value === "object" && value !== null && typeof value.threadId === "string" && typeof value.actor === "object";
+}
+__name(isRunInput, "isRunInput");
+var DurableOpenCodeAgentRunner = class _DurableOpenCodeAgentRunner {
+  static {
+    __name(this, "DurableOpenCodeAgentRunner");
+  }
+  workflows;
+  runs;
+  turns;
+  settings;
+  host;
+  store;
+  logger = new Logger4(_DurableOpenCodeAgentRunner.name);
+  constructor(workflows, runs, turns, settings, host, store) {
+    this.workflows = workflows;
+    this.runs = runs;
+    this.turns = turns;
+    this.settings = settings;
+    this.host = host;
+    this.store = store;
+    turns.startNext = (next, runId) => this.start(next, {
+      runId
+    });
+  }
+  runIdFor(input) {
+    return this.settings.runId?.(input) ?? randomUUID2();
+  }
+  async start(input, options = {}) {
+    const runId = options.runId ?? this.runIdFor(input);
+    const durable = this.settings.durable;
+    const startOptions = {
+      ...await durable?.start?.(input, runId) ?? {},
+      ...await this.host.startOptions?.(input, runId) ?? {}
+    };
+    try {
+      await this.workflows.start(OpenCodeRunWorkflow, input, runId, startOptions);
+    } catch (error) {
+      if (isWorkflowControlFlowSignal2(error)) return {
+        runId
+      };
+      throw this.host.startError?.(error, input) ?? durable?.startError?.(error, input) ?? error;
+    }
+    return {
+      runId
+    };
+  }
+  async isRunActive(runId) {
+    try {
+      const status = (await this.runs.getRunDetail(runId))?.run.status;
+      return !(status === "completed" || status === "failed" || status === "cancelled" || status === "dead");
+    } catch {
+      return true;
+    }
+  }
+  /**
+  * Signal a person's reply into the run. Answers addressed at an approval (a call recorded with an
+  * approver; questions have none) are refused ({@link OpenCodeReplyMismatchError}, a 409) before
+  * they reach the workflow, which would otherwise spend its wait on them.
+  */
+  async signal(runId, toolCallId, reply) {
+    if (!isDecision(reply)) {
+      const call = await this.store.toolCallApproval?.(toolCallId);
+      if (call != null && call.approver !== null) {
+        throw new OpenCodeReplyMismatchError(runId, toolCallId);
+      }
+    }
+    await this.workflows.signal(decisionToken(runId, toolCallId), reply);
+  }
+  /**
+  * Interrupt OpenCode, cancel the run in the runtime (a run parked on a person never runs its body
+  * again), and settle it here: the queue, the thread, the `cancelled` frame and the run row.
+  */
+  async cancel(runId) {
+    this.logger.log(`cancelling agent run ${runId}`);
+    const input = await this.runs.getRunDetail(runId).then((detail) => detail?.run.input).catch(() => void 0);
+    if (isRunInput(input)) await this.turns.interrupt(input).catch(() => void 0);
+    await this.runs.cancel(runId, {
+      compensate: true
+    });
+    if (isRunInput(input)) await this.turns.settle(runId, input, {
+      status: "interrupted"
+    }, 0);
+  }
+};
+DurableOpenCodeAgentRunner = _ts_decorate5([
+  Injectable4(),
+  _ts_param5(1, Inject5(RUN_GATEWAY2)),
+  _ts_param5(3, Inject5(OPENCODE_OPTIONS)),
+  _ts_param5(4, Inject5(OPENCODE_HOST)),
+  _ts_param5(5, Inject5(AGENT_STORE2)),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof WorkflowService === "undefined" ? Object : WorkflowService,
+    typeof RunGateway === "undefined" ? Object : RunGateway,
+    typeof OpenCodeTurns === "undefined" ? Object : OpenCodeTurns,
+    typeof OpenCodeEngineSettings === "undefined" ? Object : OpenCodeEngineSettings,
+    typeof OpenCodeHost === "undefined" ? Object : OpenCodeHost,
+    typeof AgentStore === "undefined" ? Object : AgentStore
+  ])
+], DurableOpenCodeAgentRunner);
+
+// src/durable/index.ts
+function openCodeDurable(options) {
+  return {
+    name: "opencode-durable",
+    providers: [
+      ...openCodeProviders(options),
+      OpenCodeRunWorkflow,
+      DurableOpenCodeAgentRunner
+    ],
+    runner: DurableOpenCodeAgentRunner,
+    exports: [
+      OpenCodeTurns,
+      OPENCODE_TURNS
+    ],
+    controllers: openCodeControllers(options)
+  };
+}
+__name(openCodeDurable, "openCodeDurable");
+export {
+  DurableOpenCodeAgentRunner,
+  OPENCODE_RUN_WORKFLOW,
+  OpenCodeRunWorkflow,
+  decisionToken,
+  openCodeDurable
+};
+//# sourceMappingURL=index.js.map