@circuitwall/jarela 2.2.1 → 2.3.0

package/.next/standalone/.next/server/chunks/5120.js

@@ -0,0 +1,963 @@
+"use strict";
+exports.id = 5120;
+exports.ids = [3944,5120];
+exports.modules = {
+
+/***/ 3944:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   M6: () => (/* binding */ enqueueThreadRun),
+/* harmony export */   Zm: () => (/* binding */ QueueFullError),
+/* harmony export */   getQueueDepth: () => (/* binding */ getQueueDepth),
+/* harmony export */   vR: () => (/* binding */ QueueExpiredError)
+/* harmony export */ });
+/* unused harmony export __resetForTests */
+/* harmony import */ var _lib_utils_global_state__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15559);
+// Per-thread priority queue for agent runs.
+//
+// A thread can have one active run. Waiting interactive runs are selected
+// before waiting background runs, while FIFO order is preserved within each
+// lane. Different threads drain independently.
+//
+// In-memory + single-process. Multi-instance deployment would need a shared
+// lock (Redis, Postgres advisory locks) — explicitly out of scope.
+
+const queues = (0,_lib_utils_global_state__WEBPACK_IMPORTED_MODULE_0__/* .getOrCreateGlobal */ .X)("__jarela_thread_run_queues", ()=>new Map());
+const DEFAULT_MAX_DEPTH = 16;
+const sourceLanes = {
+    user: "interactive",
+    bridge: "interactive",
+    delegate: "interactive",
+    scheduler: "background",
+    watcher: "background",
+    trigger: "background",
+    extension: "background"
+};
+class QueueFullError extends Error {
+    constructor(thread_id, depth){
+        super(`Per-thread run queue full for thread ${thread_id} (depth=${depth})`);
+        this.name = "QueueFullError";
+    }
+}
+class QueueExpiredError extends Error {
+    constructor(thread_id, expiresAt){
+        super(`Queued run expired for thread ${thread_id} at ${expiresAt}`);
+        this.name = "QueueExpiredError";
+    }
+}
+function depth(queue) {
+    return (queue.active ? 1 : 0) + queue.interactive.length + queue.background.length;
+}
+function drain(thread_id, queue) {
+    if (queue.active) return;
+    const job = queue.interactive.shift() ?? queue.background.shift();
+    if (!job) {
+        if (queues.get(thread_id) === queue) queues.delete(thread_id);
+        return;
+    }
+    queue.active = job;
+    Promise.resolve().then(()=>{
+        if (job.expiresAt !== undefined && Date.now() >= job.expiresAt) {
+            throw new QueueExpiredError(thread_id, job.expiresAt);
+        }
+        return job.runner();
+    }).then((value)=>{
+        finish(thread_id, queue);
+        job.resolve(value);
+    }, (error)=>{
+        finish(thread_id, queue);
+        job.reject(error);
+    });
+}
+function finish(thread_id, queue) {
+    queue.active = undefined;
+    if (queues.get(thread_id) === queue) drain(thread_id, queue);
+}
+function enqueueThreadRun(thread_id, source, runner, options = {}) {
+    const queue = queues.get(thread_id) ?? {
+        interactive: [],
+        background: []
+    };
+    const currentDepth = depth(queue);
+    const max = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+    if (currentDepth >= max) {
+        throw new QueueFullError(thread_id, currentDepth);
+    }
+    const lane = options.lane ?? sourceLanes[source];
+    const position = queue.active ? 1 + queue.interactive.length + (lane === "background" ? queue.background.length : 0) : queue.interactive.length + (lane === "background" ? queue.background.length : 0);
+    let resolve;
+    let reject;
+    const result = new Promise((res, rej)=>{
+        resolve = res;
+        reject = rej;
+    });
+    const job = {
+        runner,
+        expiresAt: options.expiresAt,
+        resolve,
+        reject
+    };
+    queue[lane].push(job);
+    queues.set(thread_id, queue);
+    drain(thread_id, queue);
+    return {
+        result,
+        position
+    };
+}
+/** Current queue depth for a thread, including the active job. */ function getQueueDepth(thread_id) {
+    const queue = queues.get(thread_id);
+    return queue ? depth(queue) : 0;
+}
+/** Reset all queue state. Test-only — never call from production code. */ function __resetForTests() {
+    queues.clear();
+}
+
+
+/***/ }),
+
+/***/ 62174:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   $V: () => (/* binding */ getLatestMessageUsageForThread),
+/* harmony export */   kw: () => (/* binding */ getMessageUsageByIds),
+/* harmony export */   up: () => (/* binding */ recordMessageUsage)
+/* harmony export */ });
+/* harmony import */ var _lib_db__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(46);
+// ADR-0041. Immutable per-assistant-turn snapshot of LLM usage.
+//
+// Written once when an assistant turn is persisted (see
+// `persistAssistantMessage` in lib/agents/run-thread.ts). Never updated.
+// The dashboard reads this table in preference to recomputing tokens /
+// cost from `messages.content` + current agent_configs joins.
+
+function recordMessageUsage(input) {
+    const db = (0,_lib_db__WEBPACK_IMPORTED_MODULE_0__/* .getDb */ .Lf)();
+    const t = input.tier_usage ?? null;
+    db.prepare(`INSERT OR IGNORE INTO message_usage (
+       message_id, thread_id, agent_id, agent_name, provider, model_id,
+       model_config_name, input_tokens, output_tokens,
+       input_rate_usd_per_mtok, output_rate_usd_per_mtok, cost_usd, created_at,
+       hot_tokens, warm_tokens, facts_tokens, overhead_tokens,
+       hot_budget_tokens, warm_budget_tokens, facts_budget_tokens, context_window_tokens,
+       cache_creation_input_tokens, cache_read_input_tokens, thinking_tokens
+     ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`).run(input.message_id, input.thread_id, input.agent_id, input.agent_name, input.provider, input.model_id, input.model_config_name, input.input_tokens, input.output_tokens, input.input_rate_usd_per_mtok, input.output_rate_usd_per_mtok, input.cost_usd, new Date().toISOString(), t?.hot_tokens ?? null, t?.warm_tokens ?? null, t?.facts_tokens ?? null, t?.overhead_tokens ?? null, t?.hot_budget_tokens ?? null, t?.warm_budget_tokens ?? null, t?.facts_budget_tokens ?? null, t?.context_window_tokens ?? null, input.cache_creation_input_tokens ?? null, input.cache_read_input_tokens ?? null, input.thinking_tokens ?? null);
+}
+function getMessageUsageByIds(messageIds) {
+    const out = new Map();
+    if (messageIds.length === 0) return out;
+    const placeholders = messageIds.map(()=>"?").join(",");
+    const rows = (0,_lib_db__WEBPACK_IMPORTED_MODULE_0__/* .getDb */ .Lf)().prepare(`SELECT * FROM message_usage WHERE message_id IN (${placeholders})`).all(...messageIds);
+    for (const row of rows)out.set(row.message_id, row);
+    return out;
+}
+function getLatestMessageUsageForThread(threadId) {
+    return (0,_lib_db__WEBPACK_IMPORTED_MODULE_0__/* .getDb */ .Lf)().prepare("SELECT * FROM message_usage WHERE thread_id=? ORDER BY created_at DESC LIMIT 1").get(threadId) ?? null;
+}
+
+
+/***/ }),
+
+/***/ 66963:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  w: () => (/* binding */ getCheckpointer)
+});
+
+// EXTERNAL MODULE: external "node:path"
+var external_node_path_ = __webpack_require__(76760);
+// EXTERNAL MODULE: ./lib/db/data-dir.ts
+var data_dir = __webpack_require__(57477);
+// EXTERNAL MODULE: external "node:sqlite"
+var external_node_sqlite_ = __webpack_require__(80099);
+// EXTERNAL MODULE: ./node_modules/@langchain/langgraph-checkpoint/dist/index.js + 86 modules
+var dist = __webpack_require__(8808);
+;// ./lib/agents/sqlite-checkpoint-saver.ts
+
+
+// In-tree LangGraph checkpoint saver backed by node:sqlite.
+//
+// Schema-compatible drop-in replacement for SqliteSaver from
+// @langchain/langgraph-checkpoint-sqlite. The DDL is byte-identical so an
+// existing checkpoints.db keeps working without migration.
+const VALID_FILTER_KEYS = [
+    "source",
+    "step",
+    "parents"
+];
+function buildLatestSelect(includeCheckpointId) {
+    return `
+  SELECT
+    thread_id,
+    checkpoint_ns,
+    checkpoint_id,
+    parent_checkpoint_id,
+    type,
+    checkpoint,
+    metadata,
+    (
+      SELECT
+        json_group_array(
+          json_object(
+            'task_id', pw.task_id,
+            'channel', pw.channel,
+            'type', pw.type,
+            'value', CAST(pw.value AS TEXT)
+          )
+        )
+      FROM writes as pw
+      WHERE pw.thread_id = checkpoints.thread_id
+        AND pw.checkpoint_ns = checkpoints.checkpoint_ns
+        AND pw.checkpoint_id = checkpoints.checkpoint_id
+    ) as pending_writes,
+    (
+      SELECT
+        json_group_array(
+          json_object(
+            'type', ps.type,
+            'value', CAST(ps.value AS TEXT)
+          )
+        )
+      FROM writes as ps
+      WHERE ps.thread_id = checkpoints.thread_id
+        AND ps.checkpoint_ns = checkpoints.checkpoint_ns
+        AND ps.checkpoint_id = checkpoints.parent_checkpoint_id
+        AND ps.channel = '${dist/* TASKS */.n3}'
+      ORDER BY ps.idx
+    ) as pending_sends
+  FROM checkpoints
+  WHERE thread_id = ? AND checkpoint_ns = ? ${includeCheckpointId ? "AND checkpoint_id = ?" : "ORDER BY checkpoint_id DESC LIMIT 1"}`;
+}
+// node:sqlite rejects `undefined` parameter binds; coerce to null.
+function nv(v) {
+    return v === undefined ? null : v;
+}
+class NodeSqliteSaver extends dist/* BaseCheckpointSaver */.R1 {
+    constructor(db, serde){
+        super(serde), this.isSetup = false;
+        this.db = db;
+    }
+    static fromConnString(connStringOrLocalPath) {
+        return new NodeSqliteSaver(new external_node_sqlite_.DatabaseSync(connStringOrLocalPath));
+    }
+    setup() {
+        if (this.isSetup) return;
+        this.db.exec("PRAGMA journal_mode=WAL");
+        this.db.exec(`
+CREATE TABLE IF NOT EXISTS checkpoints (
+  thread_id TEXT NOT NULL,
+  checkpoint_ns TEXT NOT NULL DEFAULT '',
+  checkpoint_id TEXT NOT NULL,
+  parent_checkpoint_id TEXT,
+  type TEXT,
+  checkpoint BLOB,
+  metadata BLOB,
+  PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id)
+);`);
+        this.db.exec(`
+CREATE TABLE IF NOT EXISTS writes (
+  thread_id TEXT NOT NULL,
+  checkpoint_ns TEXT NOT NULL DEFAULT '',
+  checkpoint_id TEXT NOT NULL,
+  task_id TEXT NOT NULL,
+  idx INTEGER NOT NULL,
+  channel TEXT NOT NULL,
+  type TEXT,
+  value BLOB,
+  PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id, task_id, idx)
+);`);
+        this.withoutCheckpoint = this.db.prepare(buildLatestSelect(false));
+        this.withCheckpoint = this.db.prepare(buildLatestSelect(true));
+        this.isSetup = true;
+    }
+    txn(fn) {
+        this.db.exec("BEGIN");
+        try {
+            const result = fn();
+            this.db.exec("COMMIT");
+            return result;
+        } catch (err) {
+            try {
+                this.db.exec("ROLLBACK");
+            } catch  {
+            // ignore rollback failure; surface the original error
+            }
+            throw err;
+        }
+    }
+    async decodeRowState(row) {
+        const pendingWrites = await Promise.all(JSON.parse(String(row.pending_writes ?? "[]")).map(async (write)=>{
+            return [
+                write.task_id,
+                write.channel,
+                await this.serde.loadsTyped(write.type ?? "json", write.value ?? "")
+            ];
+        }));
+        const checkpoint = await this.serde.loadsTyped(row.type ?? "json", row.checkpoint);
+        if (checkpoint.v < 4 && row.parent_checkpoint_id != null) {
+            await this.migratePendingSends(checkpoint, row.thread_id, row.parent_checkpoint_id);
+        }
+        const metadata = await this.serde.loadsTyped(row.type ?? "json", row.metadata);
+        return {
+            pendingWrites,
+            checkpoint,
+            metadata
+        };
+    }
+    async getTuple(config) {
+        this.setup();
+        const { thread_id, checkpoint_ns = "", checkpoint_id } = config.configurable ?? {};
+        const args = [
+            nv(thread_id),
+            checkpoint_ns
+        ];
+        if (checkpoint_id) args.push(checkpoint_id);
+        const stmt = checkpoint_id ? this.withCheckpoint : this.withoutCheckpoint;
+        const row = stmt.get(...args);
+        if (row === undefined) return undefined;
+        let finalConfig = config;
+        if (!checkpoint_id) {
+            finalConfig = {
+                configurable: {
+                    thread_id: row.thread_id,
+                    checkpoint_ns,
+                    checkpoint_id: row.checkpoint_id
+                }
+            };
+        }
+        if (finalConfig.configurable?.thread_id === undefined || finalConfig.configurable?.checkpoint_id === undefined) {
+            throw new Error("Missing thread_id or checkpoint_id");
+        }
+        const { pendingWrites, checkpoint, metadata } = await this.decodeRowState(row);
+        return {
+            checkpoint,
+            config: finalConfig,
+            metadata,
+            parentConfig: row.parent_checkpoint_id ? {
+                configurable: {
+                    thread_id: row.thread_id,
+                    checkpoint_ns,
+                    checkpoint_id: row.parent_checkpoint_id
+                }
+            } : undefined,
+            pendingWrites
+        };
+    }
+    async *list(config, options) {
+        const { limit, before, filter } = options ?? {};
+        this.setup();
+        const thread_id = config.configurable?.thread_id;
+        const checkpoint_ns = config.configurable?.checkpoint_ns;
+        let sql = `
+      SELECT
+        thread_id,
+        checkpoint_ns,
+        checkpoint_id,
+        parent_checkpoint_id,
+        type,
+        checkpoint,
+        metadata,
+        (
+          SELECT
+            json_group_array(
+              json_object(
+                'task_id', pw.task_id,
+                'channel', pw.channel,
+                'type', pw.type,
+                'value', CAST(pw.value AS TEXT)
+              )
+            )
+          FROM writes as pw
+          WHERE pw.thread_id = checkpoints.thread_id
+            AND pw.checkpoint_ns = checkpoints.checkpoint_ns
+            AND pw.checkpoint_id = checkpoints.checkpoint_id
+        ) as pending_writes,
+        (
+          SELECT
+            json_group_array(
+              json_object(
+                'type', ps.type,
+                'value', CAST(ps.value AS TEXT)
+              )
+            )
+          FROM writes as ps
+          WHERE ps.thread_id = checkpoints.thread_id
+            AND ps.checkpoint_ns = checkpoints.checkpoint_ns
+            AND ps.checkpoint_id = checkpoints.parent_checkpoint_id
+            AND ps.channel = '${dist/* TASKS */.n3}'
+          ORDER BY ps.idx
+        ) as pending_sends
+      FROM checkpoints\n`;
+        const whereClause = [];
+        if (thread_id !== undefined && thread_id !== null) whereClause.push("thread_id = ?");
+        if (checkpoint_ns !== undefined && checkpoint_ns !== null) {
+            whereClause.push("checkpoint_ns = ?");
+        }
+        if (before?.configurable?.checkpoint_id !== undefined) {
+            whereClause.push("checkpoint_id < ?");
+        }
+        const sanitizedFilter = Object.fromEntries(Object.entries(filter ?? {}).filter(([key, value])=>value !== undefined && VALID_FILTER_KEYS.includes(key)));
+        whereClause.push(...Object.entries(sanitizedFilter).map(([key])=>`jsonb(CAST(metadata AS TEXT))->'$.${key}' = ?`));
+        if (whereClause.length > 0) sql += `WHERE\n  ${whereClause.join(" AND\n  ")}\n`;
+        sql += "\nORDER BY checkpoint_id DESC";
+        if (limit) sql += ` LIMIT ${parseInt(String(limit), 10)}`;
+        const args = [
+            thread_id,
+            checkpoint_ns,
+            before?.configurable?.checkpoint_id,
+            ...Object.values(sanitizedFilter).map((value)=>JSON.stringify(value))
+        ].filter((value)=>value !== undefined && value !== null);
+        const rows = this.db.prepare(sql).all(...args);
+        for (const row of rows){
+            const { pendingWrites, checkpoint, metadata } = await this.decodeRowState(row);
+            yield {
+                config: {
+                    configurable: {
+                        thread_id: row.thread_id,
+                        checkpoint_ns: row.checkpoint_ns,
+                        checkpoint_id: row.checkpoint_id
+                    }
+                },
+                checkpoint,
+                metadata,
+                parentConfig: row.parent_checkpoint_id ? {
+                    configurable: {
+                        thread_id: row.thread_id,
+                        checkpoint_ns: row.checkpoint_ns,
+                        checkpoint_id: row.parent_checkpoint_id
+                    }
+                } : undefined,
+                pendingWrites
+            };
+        }
+    }
+    async put(config, checkpoint, metadata) {
+        this.setup();
+        if (!config.configurable) throw new Error("Empty configuration supplied.");
+        const thread_id = config.configurable?.thread_id;
+        const checkpoint_ns = config.configurable?.checkpoint_ns ?? "";
+        const parent_checkpoint_id = config.configurable?.checkpoint_id;
+        if (!thread_id) {
+            throw new Error(`Missing "thread_id" field in passed "config.configurable".`);
+        }
+        const preparedCheckpoint = (0,dist/* copyCheckpoint */.IE)(checkpoint);
+        const [[type1, serializedCheckpoint], [type2, serializedMetadata]] = await Promise.all([
+            this.serde.dumpsTyped(preparedCheckpoint),
+            this.serde.dumpsTyped(metadata)
+        ]);
+        if (type1 !== type2) {
+            throw new Error("Failed to serialized checkpoint and metadata to the same type.");
+        }
+        this.db.prepare(`INSERT OR REPLACE INTO checkpoints (thread_id, checkpoint_ns, checkpoint_id, parent_checkpoint_id, type, checkpoint, metadata) VALUES (?, ?, ?, ?, ?, ?, ?)`).run(thread_id, checkpoint_ns, checkpoint.id, nv(parent_checkpoint_id), type1, serializedCheckpoint, serializedMetadata);
+        return {
+            configurable: {
+                thread_id,
+                checkpoint_ns,
+                checkpoint_id: checkpoint.id
+            }
+        };
+    }
+    async putWrites(config, writes, taskId) {
+        this.setup();
+        if (!config.configurable) throw new Error("Empty configuration supplied.");
+        if (!config.configurable?.thread_id) {
+            throw new Error("Missing thread_id field in config.configurable.");
+        }
+        if (!config.configurable?.checkpoint_id) {
+            throw new Error("Missing checkpoint_id field in config.configurable.");
+        }
+        const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO writes
+      (thread_id, checkpoint_ns, checkpoint_id, task_id, idx, channel, type, value)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        const rows = await Promise.all(writes.map(async (write, idx)=>{
+            const [type, serializedWrite] = await this.serde.dumpsTyped(write[1]);
+            return [
+                config.configurable?.thread_id,
+                config.configurable?.checkpoint_ns ?? "",
+                config.configurable?.checkpoint_id,
+                taskId,
+                idx,
+                write[0],
+                type,
+                serializedWrite
+            ];
+        }));
+        this.txn(()=>{
+            for (const row of rows)stmt.run(...row);
+        });
+    }
+    async deleteThread(threadId) {
+        this.setup();
+        this.txn(()=>{
+            this.db.prepare(`DELETE FROM checkpoints WHERE thread_id = ?`).run(threadId);
+            this.db.prepare(`DELETE FROM writes WHERE thread_id = ?`).run(threadId);
+        });
+    }
+    async migratePendingSends(checkpoint, threadId, parentCheckpointId) {
+        const row = this.db.prepare(`
+          SELECT
+            checkpoint_id,
+            json_group_array(
+              json_object(
+                'type', ps.type,
+                'value', CAST(ps.value AS TEXT)
+              )
+            ) as pending_sends
+          FROM writes as ps
+          WHERE ps.thread_id = ?
+            AND ps.checkpoint_id = ?
+            AND ps.channel = '${dist/* TASKS */.n3}'
+          ORDER BY ps.idx
+        `).get(threadId, parentCheckpointId);
+        const pendingSendsJson = String(row?.pending_sends ?? "[]");
+        const mutable = checkpoint;
+        mutable.channel_values ??= {};
+        mutable.channel_values[dist/* TASKS */.n3] = await Promise.all(JSON.parse(pendingSendsJson).map(({ type, value })=>this.serde.loadsTyped(type ?? "json", value ?? "")));
+        mutable.channel_versions[dist/* TASKS */.n3] = Object.keys(checkpoint.channel_versions).length > 0 ? (0,dist/* maxChannelVersion */.qU)(...Object.values(checkpoint.channel_versions)) : this.getNextVersion(undefined);
+    }
+}
+
+;// ./lib/agents/checkpointer.ts
+
+
+
+// Persistent graph state per thread_id. Multi-step plans, scratchpad messages,
+// and any pending tool-call sequence survive process restarts and resume on
+// the next agent.stream() with the same thread_id.
+//
+// Stored in a separate DB file (~/.jarela/checkpoints.db) so LangGraph
+// manages its own schema independently of our own migrations under
+// lib/db/. Both files use WAL mode via the same node:sqlite driver.
+const CHECKPOINT_PATH = (0,external_node_path_.join)((0,data_dir/* getDataDir */.o)(), "checkpoints.db");
+let _saver = null;
+function getCheckpointer() {
+    if (!_saver) {
+        _saver = NodeSqliteSaver.fromConnString(CHECKPOINT_PATH);
+    }
+    return _saver;
+}
+
+
+/***/ }),
+
+/***/ 68564:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   AD: () => (/* binding */ startRun),
+/* harmony export */   B1: () => (/* binding */ subscribe),
+/* harmony export */   Cs: () => (/* binding */ waitForRun),
+/* harmony export */   ES: () => (/* binding */ abortAllRuns),
+/* harmony export */   JH: () => (/* binding */ finishRun),
+/* harmony export */   KD: () => (/* binding */ abortRun),
+/* harmony export */   Mh: () => (/* binding */ getRun),
+/* harmony export */   QK: () => (/* binding */ drainSteering),
+/* harmony export */   mq: () => (/* binding */ broadcast),
+/* harmony export */   mx: () => (/* binding */ pushSteering)
+/* harmony export */ });
+/* unused harmony export waitForRunsToSettle */
+/* harmony import */ var _lib_env_config__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(67500);
+/* harmony import */ var _lib_utils_global_state__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(15559);
+
+
+// Read once at module init. JARELA_RUN_BUFFER_SIZE / JARELA_RUN_REGISTRY_TTL_MS
+// override the defaults.
+const MAX_BUFFERED = (0,_lib_env_config__WEBPACK_IMPORTED_MODULE_0__/* .getConfig */ .z)().runBufferSize;
+const RECENT_TTL_MS = (0,_lib_env_config__WEBPACK_IMPORTED_MODULE_0__/* .getConfig */ .z)().runRegistryTtlMs;
+// Idle (no-progress) ceiling and wall-clock ceiling: read fresh per-run
+// from getConfig() so non-restart-required env reloads take effect.
+function runIdleMs() {
+    return (0,_lib_env_config__WEBPACK_IMPORTED_MODULE_0__/* .getConfig */ .z)().runIdleMs;
+}
+function runMaxMs() {
+    return (0,_lib_env_config__WEBPACK_IMPORTED_MODULE_0__/* .getConfig */ .z)().runMaxMs;
+}
+const registryState = (0,_lib_utils_global_state__WEBPACK_IMPORTED_MODULE_1__/* .getOrCreateGlobal */ .X)("__jarela_active_run_registry", ()=>({
+        runs: new Map(),
+        waiters: new Map()
+    }));
+const runs = registryState.runs;
+// Cold-attach waiters: subscribers that opened a GET /run before the
+// server-side run actually called startRun (typical for triggers /
+// scheduler / watcher, which submit through `after()` + the per-thread
+// queue, so there's a real delay between the user clicking "Run now"
+// and the registry entry appearing). Resolved by `startRun` below.
+const waiters = registryState.waiters;
+/** Wait up to `timeoutMs` for a run to be registered on `thread_id`.
+ *  Resolves immediately with the current run if one is already active,
+ *  with the new run when `startRun` fires inside the window, or with
+ *  `null` on timeout. `timeoutMs <= 0` short-circuits to the current
+ *  state without waiting. Caller is responsible for closing the SSE
+ *  stream when this resolves null. */ function waitForRun(thread_id, timeoutMs) {
+    const existing = runs.get(thread_id);
+    if (existing) return Promise.resolve(existing);
+    if (timeoutMs <= 0) return Promise.resolve(null);
+    return new Promise((resolve)=>{
+        let set = waiters.get(thread_id);
+        if (!set) {
+            set = new Set();
+            waiters.set(thread_id, set);
+        }
+        const fn = (run)=>{
+            clearTimeout(timer);
+            resolve(run);
+        };
+        set.add(fn);
+        const timer = setTimeout(()=>{
+            const cur = waiters.get(thread_id);
+            cur?.delete(fn);
+            if (cur && cur.size === 0) waiters.delete(thread_id);
+            resolve(null);
+        }, timeoutMs);
+        timer.unref?.();
+    });
+}
+function startRun(thread_id, agent_id) {
+    // If a stale completed run exists, drop it before starting a new one.
+    const existing = runs.get(thread_id);
+    if (existing && existing.status === "running") {
+        throw new Error(`A run is already active for thread ${thread_id}`);
+    }
+    const now = Date.now();
+    const run = {
+        thread_id,
+        agent_id,
+        started_at: now,
+        finished_at: null,
+        status: "running",
+        events: [],
+        subscribers: new Set(),
+        final_text: "",
+        abort: new AbortController(),
+        last_chunk_at: now,
+        inflight_tools: new Set(),
+        tool_started_at: new Map(),
+        tool_time_ms_done: 0,
+        steering: [],
+        phase: "starting",
+        phase_label: "Starting…"
+    };
+    runs.set(thread_id, run);
+    // Wake any GET subscribers that attached before the run was registered.
+    const pending = waiters.get(thread_id);
+    if (pending) {
+        waiters.delete(thread_id);
+        for (const fn of pending){
+            try {
+                fn(run);
+            } catch  {}
+        }
+    }
+    scheduleIdleWatchdog(run);
+    scheduleMaxWatchdog(run);
+    return run;
+}
+// Synthesise a typed error chunk for the watchdog termination paths and
+// fan it out to subscribers BEFORE flipping `status` to "error". The order
+// matters: `broadcast()`'s status guard drops any chunk delivered after
+// `finishRun()` has run, so calling finishRun first would silently swallow
+// the error and the client's EventSource would just see the connection
+// close with no terminal event — bubble keeps spinning, no toast. Doing
+// it the other way around lets the client receive a real error event,
+// render a "Run timed out" toast, and (if the consumer wires it up)
+// trigger an auto-retry path. Followed by `done` so the consumer's
+// for-await loop can break cleanly without waiting for an EOF.
+function emitWatchdogTermination(run, code, message) {
+    if (run.status !== "running") return;
+    // Direct registry mutation so the broadcast goes through the regular
+    // path (subscribers + buffer + seq stamp) without re-entering any of
+    // the watchdog scheduling. Mirrors broadcast() but bypasses the
+    // status check we'd otherwise be racing against.
+    run.last_chunk_at = Date.now();
+    const errChunk = {
+        type: "error",
+        data: {
+            message,
+            code
+        }
+    };
+    if (run.events.length < MAX_BUFFERED) run.events.push(errChunk);
+    for (const fn of run.subscribers){
+        try {
+            fn(errChunk);
+        } catch  {}
+    }
+    // Pair with a synthetic `done` so the client's consume() loop breaks
+    // on a terminal event rather than waiting for the EventSource to close.
+    const doneChunk = {
+        type: "done",
+        data: {}
+    };
+    if (run.events.length < MAX_BUFFERED) run.events.push(doneChunk);
+    for (const fn of run.subscribers){
+        try {
+            fn(doneChunk);
+        } catch  {}
+    }
+}
+// Self-rearming idle watchdog. Fires when no chunk has arrived for
+// `idleMs`; otherwise reschedules itself for `(last_chunk_at + idleMs) -
+// now`. We never carry a handle on the run — the closure just bails if
+// the run is no longer the registry's entry or no longer running.
+function scheduleIdleWatchdog(run) {
+    const idleMs = runIdleMs();
+    const fireIn = Math.max(0, run.last_chunk_at + idleMs - Date.now());
+    setTimeout(()=>{
+        const cur = runs.get(run.thread_id);
+        if (cur !== run) return;
+        if (run.status !== "running") return;
+        const idle = Date.now() - run.last_chunk_at;
+        if (idle < idleMs) {
+            scheduleIdleWatchdog(run);
+            return;
+        }
+        if (run.inflight_tools.size > 0) {
+            // Tool execution in progress — silence here is the tool working,
+            // not a wedged provider stream. Skip the kill, re-check in idleMs.
+            // The tool_result will bump last_chunk_at when it lands.
+            setTimeout(()=>scheduleIdleWatchdog(run), idleMs).unref?.();
+            return;
+        }
+        console.warn(`[run-registry] idle watchdog: force-finishing stalled run for thread ${run.thread_id} after ${idle}ms of no progress`);
+        emitWatchdogTermination(run, "run_idle_timeout", `Run timed out — no progress for ${Math.round(idle / 1000)}s. The provider stream went silent before the agent finished. Try again, or split the request into smaller steps.`);
+        try {
+            run.abort.abort("run_idle_timeout");
+        } catch  {}
+        finishRun(run, "error");
+    }, fireIn).unref?.();
+}
+// Wall-clock elapsed minus time spent inside tool calls (both completed and
+// currently in flight). The wall-clock watchdog uses this so a 5-minute
+// shell exec or a slow MCP roundtrip doesn't burn the agent's budget;
+// tools enforce their own timeouts. See ActiveRun.tool_started_at for the
+// rationale.
+function effectiveElapsedMs(run, now) {
+    let inflightToolMs = 0;
+    for (const startedAt of run.tool_started_at.values()){
+        inflightToolMs += Math.max(0, now - startedAt);
+    }
+    return Math.max(0, now - run.started_at - run.tool_time_ms_done - inflightToolMs);
+}
+function scheduleMaxWatchdog(run) {
+    const max = runMaxMs();
+    const now = Date.now();
+    const fireIn = Math.max(0, max - effectiveElapsedMs(run, now));
+    setTimeout(()=>{
+        const cur = runs.get(run.thread_id);
+        if (cur !== run) return;
+        if (run.status !== "running") return;
+        const elapsed = effectiveElapsedMs(run, Date.now());
+        if (elapsed < max) {
+            // Tool time pushed the effective elapsed back below the ceiling —
+            // re-arm for the remaining budget. Without this, a tool that runs
+            // for longer than `max` between firing and resolving would let
+            // the next setTimeout overshoot.
+            scheduleMaxWatchdog(run);
+            return;
+        }
+        console.warn(`[run-registry] wall-clock watchdog: force-finishing run for thread ${run.thread_id} after ${elapsed}ms of agent time (excluding tool execution)`);
+        emitWatchdogTermination(run, "run_max_timeout", `Run exceeded the wall-clock limit (${Math.round(max / 1000)}s of agent time, excluding tool execution). The agent was force-stopped. Try a smaller scope or raise JARELA_RUN_MAX_MS if this is expected.`);
+        try {
+            run.abort.abort("run_watchdog_timeout");
+        } catch  {}
+        finishRun(run, "error");
+    }, fireIn).unref?.();
+}
+// Mirrors the labels hooks/useSSE.ts derives from the same chunks.
+function trackPhase(run, chunk) {
+    const data = chunk.data ?? {};
+    const set = (phase, label)=>{
+        run.phase = phase;
+        run.phase_label = label;
+    };
+    if (chunk.type === "status") {
+        const phase = typeof data.phase === "string" && data.phase ? data.phase : run.phase;
+        const label = typeof data.label === "string" && data.label.trim() ? data.label : "Thinking…";
+        set(phase, label);
+    } else if (chunk.type === "text_delta") {
+        set("responding", "Responding…");
+    } else if (chunk.type === "thinking_delta") {
+        if (run.inflight_tools.size === 0) set("thinking", "Thinking…");
+    } else if (chunk.type === "tool_call") {
+        const name = typeof data.name === "string" && data.name ? data.name : "tool";
+        set("tool", `Using ${name}…`);
+    } else if (chunk.type === "tool_result") {
+        const remaining = typeof data.id === "string" ? [
+            ...run.inflight_tools
+        ].filter((id)=>id !== data.id) : [
+            ...run.inflight_tools
+        ];
+        if (remaining.length === 0) set("thinking", "Thinking…");
+    }
+}
+function broadcast(run, chunk) {
+    // Identity-check: a superseded run must not smear trailing chunks onto
+    // the replacement entry in the registry.
+    if (runs.get(run.thread_id) !== run) return;
+    run.last_chunk_at = Date.now();
+    // Heartbeats exist solely to reset the idle watchdog when the provider
+    // is producing chunks that don't surface downstream (most commonly
+    // partial tool-call args while the model streams a large file_write
+    // body). The last_chunk_at bump above is the entire payload — don't
+    // buffer, don't fan out to subscribers, or the SSE wire would carry
+    // meaningless tick events.
+    if (chunk.type === "heartbeat") return;
+    trackPhase(run, chunk);
+    if (chunk.type === "text_delta") {
+        run.final_text += chunk.data.delta ?? "";
+    } else if (chunk.type === "reset_text") {
+        // Output-validator retry (ADR-0037) discarding a flagged completed
+        // reply — see StreamChunk in base.ts.
+        run.final_text = "";
+    } else if (chunk.type === "tool_call") {
+        const id = chunk.data.id;
+        if (id) {
+            run.inflight_tools.add(id);
+            run.tool_started_at.set(id, Date.now());
+        }
+    } else if (chunk.type === "tool_result") {
+        const id = chunk.data.id;
+        if (id) {
+            run.inflight_tools.delete(id);
+            const startedAt = run.tool_started_at.get(id);
+            if (startedAt !== undefined) {
+                run.tool_time_ms_done += Math.max(0, Date.now() - startedAt);
+                run.tool_started_at.delete(id);
+                // The tool just gave the agent its budget back; re-arm the
+                // wall-clock watchdog against the new effective elapsed.
+                scheduleMaxWatchdog(run);
+            }
+        }
+    }
+    if (run.events.length < MAX_BUFFERED) {
+        run.events.push(chunk);
+    }
+    for (const fn of run.subscribers){
+        try {
+            fn(chunk);
+        } catch  {}
+    }
+}
+function finishRun(run, status) {
+    // Identity-check: a stale run finishing late must not flip the
+    // replacement's status or evict it from the registry.
+    if (runs.get(run.thread_id) !== run) return;
+    run.status = status;
+    run.finished_at = Date.now();
+    // Drop subscribers — late attachers should NOT keep getting events on a
+    // dead run. They'll get the buffered events on subscribe and that's it.
+    run.subscribers.clear();
+    // Auto-evict after TTL so memory doesn't grow with every conversation.
+    setTimeout(()=>{
+        const cur = runs.get(run.thread_id);
+        if (cur === run) runs.delete(run.thread_id);
+    }, RECENT_TTL_MS).unref?.();
+}
+function getRun(thread_id) {
+    return runs.get(thread_id) ?? null;
+}
+// Signal the agent stream to cancel. The stream loop in the route is wired
+// to listen on the AbortController and exit early, emitting an error chunk
+// the client (and the queue-drain hook) can react to. Idempotent.
+function abortRun(thread_id, reason = "user_interrupted") {
+    const run = runs.get(thread_id);
+    if (!run || run.status !== "running") return false;
+    if (!run.abort.signal.aborted) {
+        try {
+            run.abort.abort(reason);
+        } catch  {}
+    }
+    return true;
+}
+// Queue a user message typed while `thread_id` is streaming (ADR-0080).
+// Returns false when there is nothing to steer, so the caller can fall back
+// to starting a fresh turn.
+function pushSteering(thread_id, text) {
+    const run = runs.get(thread_id);
+    if (!run || run.status !== "running" || run.abort.signal.aborted) return false;
+    const trimmed = text.trim();
+    if (!trimmed) return false;
+    run.steering.push(trimmed);
+    return true;
+}
+// Take everything queued so far, in arrival order. Deliberately not merged
+// into a summary — collapsing several messages loses the user's intent.
+function drainSteering(thread_id) {
+    const run = runs.get(thread_id);
+    if (!run || run.steering.length === 0) return [];
+    return run.steering.splice(0, run.steering.length);
+}
+// Abort every currently-running run. Used by the graceful-shutdown path so
+// LangGraph stream loops bail out instead of continuing past process exit.
+// Returns the number of runs that were signalled.
+function abortAllRuns(reason = "server_shutdown") {
+    let count = 0;
+    for (const run of runs.values()){
+        if (run.status !== "running") continue;
+        if (run.abort.signal.aborted) continue;
+        try {
+            run.abort.abort(reason);
+            count++;
+        } catch  {}
+    }
+    return count;
+}
+// Poll until every run has transitioned out of "running" (or until the
+// caller-supplied deadline elapses). Used during graceful shutdown after
+// `abortAllRuns()` so the stream `finally` blocks have a chance to flush
+// the trailing error chunk and call `finishRun()`. Resolves to the count
+// of runs still stuck in "running" when the deadline hit (0 = clean).
+async function waitForRunsToSettle(timeoutMs) {
+    const deadline = Date.now() + Math.max(0, timeoutMs);
+    while(Date.now() < deadline){
+        let stillRunning = 0;
+        for (const run of runs.values())if (run.status === "running") stillRunning++;
+        if (stillRunning === 0) return 0;
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+    }
+    let stillRunning = 0;
+    for (const run of runs.values())if (run.status === "running") stillRunning++;
+    return stillRunning;
+}
+// Replays buffered events synchronously, then subscribes for live ones.
+// Returns an unsubscribe fn. Caller is responsible for calling it.
+function subscribe(thread_id, onEvent) {
+    const run = runs.get(thread_id);
+    if (!run) return {
+        run: null,
+        unsubscribe: ()=>{}
+    };
+    // Replay buffered events first (so the new subscriber catches up).
+    for (const ev of run.events){
+        try {
+            onEvent(ev);
+        } catch  {}
+    }
+    if (run.status !== "running") {
+        return {
+            run,
+            unsubscribe: ()=>{}
+        };
+    }
+    run.subscribers.add(onEvent);
+    return {
+        run,
+        unsubscribe: ()=>{
+            run.subscribers.delete(onEvent);
+        }
+    };
+}
+
+
+/***/ })
+
+};
+;
+//# sourceMappingURL=5120.js.map