@tangle-network/agent-runtime 0.15.0 → 0.15.1

package/dist/index.js

@@ -1040,6 +1040,29 @@ var D1DurableRunStore = class {
     const row = await this.db.prepare("SELECT * FROM durable_events WHERE run_id = ? AND key = ?").bind(runId, key).first();
     return row ? rowToEventRecord(row) : void 0;
   }
+  async appendStreamEvent(input) {
+    const nowIso2 = new Date(this.now()).toISOString();
+    const res = await this.db.prepare(
+      `INSERT OR IGNORE INTO durable_stream_events (run_id, seq, event_id, payload_json, appended_at)
+         VALUES (
+           ?,
+           (SELECT COALESCE(MAX(seq), -1) + 1 FROM durable_stream_events WHERE run_id = ?),
+           ?, ?, ?
+         )`
+    ).bind(input.runId, input.runId, input.eventId, JSON.stringify(input.payload ?? null), nowIso2).run();
+    const accepted = (res.meta?.changes ?? 0) > 0;
+    const row = await this.db.prepare("SELECT * FROM durable_stream_events WHERE run_id = ? AND event_id = ?").bind(input.runId, input.eventId).first();
+    if (!row) throw new Error("durable-runs: appendStreamEvent failed to persist or read back");
+    return { accepted, record: rowToStreamEventRecord(row) };
+  }
+  async readStreamEvents(runId, afterSeq) {
+    const { results } = await this.db.prepare("SELECT * FROM durable_stream_events WHERE run_id = ? AND seq > ? ORDER BY seq").bind(runId, afterSeq ?? -1).all();
+    return results.map(rowToStreamEventRecord);
+  }
+  async setRunHandle(input) {
+    const nowIso2 = new Date(this.now()).toISOString();
+    await this.db.prepare("UPDATE durable_runs SET handle_json = ?, updated_at = ? WHERE run_id = ?").bind(JSON.stringify(input.handle), nowIso2, input.runId).run();
+  }
   async close() {
   }
   /** Inspect the currently-applied schema version. */
@@ -1069,7 +1092,17 @@ function rowToRunRecord(row) {
     leaseHolderId: row.lease_holder_id ?? void 0,
     leaseExpiresAt: row.lease_expires_at ?? void 0,
     outcome: row.outcome_json ? JSON.parse(row.outcome_json) : void 0,
-    stepCount: row.step_count
+    stepCount: row.step_count,
+    handle: row.handle_json ? JSON.parse(row.handle_json) : void 0
+  };
+}
+function rowToStreamEventRecord(row) {
+  return {
+    runId: row.run_id,
+    seq: row.seq,
+    eventId: row.event_id,
+    payload: row.payload_json ? JSON.parse(row.payload_json) : null,
+    appendedAt: row.appended_at
   };
 }
 function rowToStepRecord(row) {
@@ -1134,6 +1167,7 @@ var FileSystemDurableRunStore = class {
       await this.writeLease(input.runId, { workerId: input.workerId, leaseExpiresAt });
       await appendFile(join(dir, "steps.jsonl"), "", "utf8");
       await appendFile(join(dir, "events.jsonl"), "", "utf8");
+      await appendFile(join(dir, "stream-events.jsonl"), "", "utf8");
       return { run: record2, completedSteps: [], leaseExpiresAt };
     }
     const record = await this.readRun(input.runId);
@@ -1296,8 +1330,48 @@ var FileSystemDurableRunStore = class {
     }
     return void 0;
   }
+  async appendStreamEvent(input) {
+    const existing = await this.readStreamEventsRaw(input.runId);
+    const dup = existing.find((e) => e.eventId === input.eventId);
+    if (dup) return { accepted: false, record: dup };
+    const rec = {
+      runId: input.runId,
+      seq: existing.length,
+      eventId: input.eventId,
+      payload: input.payload,
+      appendedAt: new Date(this.now()).toISOString()
+    };
+    await appendFile(
+      join(this.runDir(input.runId), "stream-events.jsonl"),
+      `${JSON.stringify(rec)}
+`,
+      "utf8"
+    );
+    return { accepted: true, record: rec };
+  }
+  async readStreamEvents(runId, afterSeq) {
+    const cutoff = afterSeq ?? -1;
+    return (await this.readStreamEventsRaw(runId)).filter((e) => e.seq > cutoff);
+  }
+  async setRunHandle(input) {
+    const record = await this.readRun(input.runId);
+    record.handle = input.handle;
+    record.updatedAt = new Date(this.now()).toISOString();
+    await this.writeRun(record);
+  }
   async close() {
   }
+  async readStreamEventsRaw(runId) {
+    const path = join(this.runDir(runId), "stream-events.jsonl");
+    if (!existsSync(path)) return [];
+    const content = await readFile(path, "utf8");
+    const out = [];
+    for (const line of content.split("\n")) {
+      if (!line) continue;
+      out.push(JSON.parse(line));
+    }
+    return out.sort((a, b) => a.seq - b.seq);
+  }
   /** @internal — used by tests to list runs in the store. */
   async _listRunIds() {
     if (!existsSync(this.root)) return [];
@@ -1393,7 +1467,7 @@ var InMemoryDurableRunStore = class {
         leaseExpiresAt,
         stepCount: 0
       };
-      state = { record, steps: /* @__PURE__ */ new Map(), events: /* @__PURE__ */ new Map() };
+      state = { record, steps: /* @__PURE__ */ new Map(), events: /* @__PURE__ */ new Map(), streamEvents: [] };
       this.runs.set(input.runId, state);
       return { run: { ...record }, completedSteps: [], leaseExpiresAt };
     }
@@ -1534,6 +1608,31 @@ var InMemoryDurableRunStore = class {
     const rec = state.events.get(key);
     return rec ? { ...rec } : void 0;
   }
+  async appendStreamEvent(input) {
+    const state = this.requireRun(input.runId);
+    const existing = state.streamEvents.find((e) => e.eventId === input.eventId);
+    if (existing) return { accepted: false, record: { ...existing } };
+    const rec = {
+      runId: input.runId,
+      seq: state.streamEvents.length,
+      eventId: input.eventId,
+      payload: input.payload,
+      appendedAt: new Date(this.now()).toISOString()
+    };
+    state.streamEvents.push(rec);
+    return { accepted: true, record: { ...rec } };
+  }
+  async readStreamEvents(runId, afterSeq) {
+    const state = this.runs.get(runId);
+    if (!state) return [];
+    const cutoff = afterSeq ?? -1;
+    return state.streamEvents.filter((e) => e.seq > cutoff).map((e) => ({ ...e }));
+  }
+  async setRunHandle(input) {
+    const state = this.requireRun(input.runId);
+    state.record.handle = { ...input.handle };
+    state.record.updatedAt = new Date(this.now()).toISOString();
+  }
   async close() {
     this.runs.clear();
   }
@@ -1793,7 +1892,7 @@ function cryptoRandomUuid() {
 }
 
 // src/durable/schema.ts
-var DURABLE_SCHEMA_VERSION = 1;
+var DURABLE_SCHEMA_VERSION = 2;
 var DURABLE_SCHEMA_SQL = `-- Durable-run substrate \u2014 versioned schema for D1 / SQLite.
 --
 -- Apply once per database. Subsequent migrations append; never rewrite a
@@ -1861,8 +1960,198 @@ CREATE TABLE IF NOT EXISTS durable_events (
 
 INSERT OR IGNORE INTO durable_schema_info (version, applied_at)
 VALUES (1, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'));
+
+-- \u2500\u2500 Migration v2 \u2014 durable event-stream log + run handle \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+-- Run once on a database created at v1. \`ALTER TABLE\` is not idempotent; the
+-- version trail in \`durable_schema_info\` is how migrations are sequenced \u2014
+-- never by blind re-execution of this block.
+--
+--   - \`durable_stream_events\` is the ordered, replayable per-run event log.
+--     \`seq\` is the store-assigned monotonic cursor; the UNIQUE index on
+--     (run_id, event_id) makes appends idempotent \u2014 a reconnecting adapter
+--     that re-yields a boundary event cannot double-log it.
+--   - \`durable_runs.handle_json\` is the pointer (sandbox + substrate run id +
+--     cursor) a fresh supervisor re-attaches by.
+
+ALTER TABLE durable_runs ADD COLUMN handle_json TEXT;
+
+CREATE TABLE IF NOT EXISTS durable_stream_events (
+  run_id       TEXT    NOT NULL,
+  seq          INTEGER NOT NULL,
+  event_id     TEXT    NOT NULL,
+  payload_json TEXT,
+  appended_at  TEXT    NOT NULL,
+  PRIMARY KEY (run_id, seq)
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_durable_stream_events_event_id
+  ON durable_stream_events(run_id, event_id);
+
+INSERT OR IGNORE INTO durable_schema_info (version, applied_at)
+VALUES (2, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'));
 `;
 
+// src/durable/supervisor.ts
+var TURN_STEP = 0;
+function runSupervisedTurn(options) {
+  const { store, runId, manifest, workerId, adapter } = options;
+  const leaseMs = options.leaseMs ?? 6e4;
+  const heartbeatMs = options.heartbeatMs ?? 3e4;
+  const intent = options.intent ?? "turn";
+  const now = options.now ?? (() => Date.now());
+  const inputHash = canonicalHash(manifest.input);
+  let mode = "fresh";
+  let finalRecord;
+  let currentHandle;
+  let leaseLost = false;
+  async function* drain(source) {
+    let lastRenew = now();
+    for await (const event of source) {
+      if (event.handle) {
+        currentHandle = event.handle;
+        await store.setRunHandle({ runId, handle: event.handle });
+      }
+      const { accepted } = await store.appendStreamEvent({
+        runId,
+        eventId: event.eventId,
+        payload: event.payload
+      });
+      if (now() - lastRenew >= heartbeatMs) {
+        const renewed = await store.renewLease({ runId, workerId, leaseMs });
+        if (!renewed.ok) {
+          leaseLost = true;
+          throw new Error(`durable-runs: lease lost on ${runId} \u2014 another supervisor took over`);
+        }
+        lastRenew = now();
+      }
+      if (accepted) yield event.payload;
+    }
+  }
+  async function* stream() {
+    const { run, completedSteps } = await store.startOrResume({
+      runId,
+      manifest,
+      workerId,
+      leaseMs
+    });
+    if (completedSteps.some((s) => s.stepIndex === TURN_STEP && s.status === "completed")) {
+      mode = "replayed";
+      for (const e of await store.readStreamEvents(runId)) yield e.payload;
+      finalRecord = await store.endRun({ runId, workerId, status: "completed" });
+      return;
+    }
+    const logged = await store.readStreamEvents(runId);
+    const priorHandle = run.handle;
+    const resumable = priorHandle !== void 0 && priorHandle.status === "running" && typeof priorHandle.runId === "string";
+    let source;
+    if (resumable && priorHandle) {
+      mode = "resumed";
+      currentHandle = priorHandle;
+      for (const e of logged) yield e.payload;
+      const cursor = logged.length > 0 ? logged[logged.length - 1].eventId : priorHandle.cursor;
+      source = adapter.attach(priorHandle, cursor);
+    } else {
+      mode = "fresh";
+      source = adapter.start();
+    }
+    await store.beginStep({ runId, stepIndex: TURN_STEP, intent, kind: "llm", inputHash });
+    try {
+      yield* drain(source);
+      const eventCount = (await store.readStreamEvents(runId)).length;
+      await store.completeStep({ runId, stepIndex: TURN_STEP, result: { eventCount } });
+      if (currentHandle && currentHandle.status === "running") {
+        await store.setRunHandle({ runId, handle: { ...currentHandle, status: "completed" } });
+      }
+      finalRecord = await store.endRun({
+        runId,
+        workerId,
+        status: "completed",
+        outcome: { notes: intent, metadata: { events: eventCount, mode } }
+      });
+    } catch (err) {
+      if (!leaseLost) {
+        await store.failStep({
+          runId,
+          stepIndex: TURN_STEP,
+          error: { message: err instanceof Error ? err.message : String(err) }
+        });
+        finalRecord = await store.endRun({ runId, workerId, status: "failed" });
+      }
+      throw err;
+    }
+  }
+  return {
+    stream: stream(),
+    mode: () => mode,
+    record: () => finalRecord
+  };
+}
+
+// src/durable/session-supervisor-do.ts
+var ACTIVE_RUN_KEY = "agent-runtime:active-run-id";
+async function drainHeadless(stream) {
+  let next = await stream.next();
+  while (!next.done) next = await stream.next();
+}
+function createSessionSupervisorDO(config) {
+  const orphanCheckMs = config.orphanCheckMs ?? 6e4;
+  const now = config.now ?? (() => Date.now());
+  return class {
+    constructor(state, env) {
+      this.state = state;
+      this.env = env;
+    }
+    state;
+    env;
+    async fetch(request) {
+      const opts = await config.resolveRun(request, this.env, this.state);
+      if (!opts) return new Response("no run for this request", { status: 404 });
+      await this.state.storage.put(ACTIVE_RUN_KEY, opts.runId);
+      await this.state.storage.setAlarm(now() + orphanCheckMs);
+      const supervised = runSupervisedTurn(opts);
+      const storage = this.state.storage;
+      const encoder2 = new TextEncoder();
+      const body = new ReadableStream({
+        async pull(controller) {
+          try {
+            const next = await supervised.stream.next();
+            if (next.done) {
+              await storage.delete(ACTIVE_RUN_KEY);
+              controller.close();
+              return;
+            }
+            controller.enqueue(encoder2.encode(config.encodeEvent(next.value)));
+          } catch (err) {
+            controller.error(err instanceof Error ? err : new Error(String(err)));
+          }
+        }
+      });
+      return new Response(body, {
+        headers: { "content-type": "text/event-stream", "cache-control": "no-cache" }
+      });
+    }
+    async alarm() {
+      const runId = await this.state.storage.get(ACTIVE_RUN_KEY);
+      if (!runId) return;
+      const opts = await config.resolveOrphan(runId, this.env, this.state);
+      if (!opts) {
+        await this.state.storage.delete(ACTIVE_RUN_KEY);
+        return;
+      }
+      try {
+        await drainHeadless(runSupervisedTurn(opts).stream);
+        await this.state.storage.delete(ACTIVE_RUN_KEY);
+      } catch (err) {
+        if (err instanceof DurableRunLeaseHeldError) {
+          await this.state.storage.setAlarm(now() + orphanCheckMs);
+          return;
+        }
+        await this.state.storage.delete(ACTIVE_RUN_KEY);
+      }
+    }
+  };
+}
+
 // src/durable/workflows.ts
 async function runOnWorkflowStep(workflowStep, input) {
   const stepCfg = input.stepConfig;
@@ -1983,6 +2272,85 @@ function classifyIntent(profile, message, opts = {}) {
   return { id: bestId, subagent: bestSubagent, score: bestScore, scores, evaluated };
 }
 
+// src/model-resolution.ts
+var DEFAULT_ROUTER_BASE_URL = "https://router.tangle.tools";
+function resolveRouterBaseUrl(env = {}) {
+  return (env.TANGLE_ROUTER_URL ?? env.TANGLE_ROUTER_BASE_URL ?? DEFAULT_ROUTER_BASE_URL).replace(/\/v1\/?$/, "").replace(/\/$/, "");
+}
+async function getModels(routerBaseUrl = DEFAULT_ROUTER_BASE_URL) {
+  const res = await fetch(`${routerBaseUrl}/v1/models`, {
+    headers: { Accept: "application/json" }
+  });
+  if (!res.ok) throw new Error(`router /v1/models ${res.status}`);
+  const body = await res.json();
+  return Array.isArray(body.data) ? body.data : [];
+}
+function withConfiguredModels(models, extraIds) {
+  const known = new Set(models.map((model) => model.id));
+  const extra = extraIds.map((id) => cleanModelId(id)).filter((id) => id !== void 0 && !known.has(id)).map(
+    (id) => ({
+      id,
+      name: id,
+      description: "Configured chat model for this environment.",
+      architecture: {
+        modality: "text->text",
+        input_modalities: ["text"],
+        output_modalities: ["text"]
+      }
+    })
+  );
+  return extra.length > 0 ? [...extra, ...models] : models;
+}
+function cleanModelId(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function resolveChatModel(candidates, fallback) {
+  for (const candidate of candidates) {
+    const model = cleanModelId(candidate.model);
+    if (model) return { source: candidate.source, model };
+  }
+  return fallback;
+}
+var WELL_FORMED_MODEL_ID = /^[A-Za-z0-9._/@:-]+$/;
+function isWellFormedModelId(modelId) {
+  return modelId.length <= 200 && WELL_FORMED_MODEL_ID.test(modelId);
+}
+function catalogIdsForModel(model) {
+  const ids = /* @__PURE__ */ new Set();
+  const id = cleanModelId(model.id);
+  if (id) ids.add(id);
+  const provider = cleanModelId(model._provider) ?? cleanModelId(model.provider);
+  if (provider && id && !id.includes("/")) ids.add(`${provider}/${id}`);
+  return [...ids];
+}
+async function validateChatModelId(modelId, options = {}) {
+  const {
+    allowlist = [],
+    routerBaseUrl = DEFAULT_ROUTER_BASE_URL,
+    loadModels = getModels
+  } = options;
+  const cleaned = cleanModelId(modelId);
+  if (!cleaned) return { succeeded: false, error: "Model id must be a non-empty string." };
+  if (!isWellFormedModelId(cleaned)) {
+    return { succeeded: false, error: `Model id is malformed: ${cleaned}` };
+  }
+  if (allowlist.some((id) => cleanModelId(id) === cleaned)) {
+    return { succeeded: true, value: cleaned };
+  }
+  let catalog;
+  try {
+    catalog = await loadModels(routerBaseUrl);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { succeeded: false, error: `Could not validate model catalog: ${message}` };
+  }
+  const ids = new Set(catalog.flatMap(catalogIdsForModel));
+  if (!ids.has(cleaned)) return { succeeded: false, error: `Model is not available: ${cleaned}` };
+  return { succeeded: true, value: cleaned };
+}
+
 // src/profile-conformance.ts
 var DEFAULT_SHELL_CAPS = [
   "bash",
@@ -3187,6 +3555,7 @@ export {
   ChatTurnError,
   ConfigError,
   D1DurableRunStore,
+  DEFAULT_ROUTER_BASE_URL,
   DURABLE_SCHEMA_SQL,
   DURABLE_SCHEMA_VERSION,
   DurableAwaitEventTimeoutError,
@@ -3209,25 +3578,31 @@ export {
   canonicalHash,
   canonicalJson,
   classifyIntent,
+  cleanModelId,
   composeTurnProfile,
   createIterableBackend,
   createOpenAICompatibleBackend,
   createRuntimeEventCollector,
   createRuntimeStreamEventCollector,
   createSandboxPromptBackend,
+  createSessionSupervisorDO,
   createTraceBridge,
   decideKnowledgeReadiness,
   deriveWorkerId,
   durableChatTurnEngine,
   encodeServerSentEvent,
+  getModels,
   manifestHash,
   readinessServerSentEvent,
+  resolveChatModel,
+  resolveRouterBaseUrl,
   runAgentTask,
   runAgentTaskStream,
   runChatTurn,
   runDurable,
   runDurableTurn,
   runOnWorkflowStep,
+  runSupervisedTurn,
   runtimeStreamServerSentEvent,
   sandboxAsChatTurnTarget,
   sanitizeAgentRuntimeEvent,
@@ -3236,6 +3611,8 @@ export {
   startRuntimeRun,
   stepId,
   summarizeAgentTaskRun,
-  toAgentEvalTrace
+  toAgentEvalTrace,
+  validateChatModelId,
+  withConfiguredModels
 };
 //# sourceMappingURL=index.js.map