@flue/sdk 0.4.1 → 0.5.0

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { A as SessionStore, C as PromptUsage, D as SessionData, E as SandboxFactory, F as TaskOptions, I as ThinkingLevel, L as ToolDef, M as ShellResult, N as Skill, O as SessionEnv, P as SkillOptions, R as ToolParameters, S as PromptResultResponse, T as Role, _ as FlueSessions, a as BashLike, b as PromptOptions, c as BuildPlugin, d as FlueAgent, f as FlueContext, g as FlueSession, h as FlueFs, i as BashFactory, j as ShellOptions, k as SessionOptions, l as CallHandle, m as FlueEventCallback, n as AgentInfo, o as BuildContext, p as FlueEvent, r as AgentInit, s as BuildOptions, t as AgentConfig, u as FileStat, v as ModelConfig, x as PromptResponse, y as PromptModel } from "./types-BAmV4f3Q.mjs";
+import { A as SessionStore, C as PromptUsage, D as SessionData, E as SandboxFactory, F as TaskOptions, I as ThinkingLevel, L as ToolDef, M as ShellResult, N as Skill, O as SessionEnv, P as SkillOptions, R as ToolParameters, S as PromptResultResponse, T as Role, _ as FlueSessions, a as BashLike, b as PromptOptions, c as BuildPlugin, d as FlueContext, f as FlueEvent, g as FlueSession, h as FlueHarness, i as BashFactory, j as ShellOptions, k as SessionOptions, l as CallHandle, m as FlueFs, n as AgentInfo, o as BuildContext, p as FlueEventCallback, r as AgentInit, s as BuildOptions, t as AgentConfig, u as FileStat, v as ModelConfig, x as PromptResponse, y as PromptModel } from "./types-Cdcq_ET2.mjs";
 import { AgentTool, AgentToolResult } from "@mariozechner/pi-agent-core";
 
 //#region src/build.d.ts
@@ -112,7 +112,7 @@ interface TaskToolParams {
 }
 interface TaskToolResultDetails {
   taskId: string;
-  sessionId: string;
+  session: string;
   messageId?: string;
   role?: string;
   cwd?: string;
@@ -135,4 +135,4 @@ declare class ResultUnavailableError extends Error {
   constructor(reason: string, assistantText: string);
 }
 //#endregion
-export { type AgentConfig, type AgentInfo, type AgentInit, BUILTIN_TOOL_NAMES, type BashFactory, type BashLike, type BuildContext, type BuildOptions, type BuildPlugin, type CallHandle, DEFAULT_DEV_PORT, type DevOptions, type FileStat, type FlueAgent, type FlueContext, type FlueEvent, type FlueEventCallback, type FlueFs, type FlueSession, type FlueSessions, type ModelConfig, type PromptModel, type PromptOptions, type PromptResponse, type PromptResultResponse, type PromptUsage, ResultUnavailableError, type Role, type SandboxFactory, type SessionData, type SessionEnv, type SessionOptions, type SessionStore, type ShellOptions, type ShellResult, type Skill, type SkillOptions, type TaskOptions, type ThinkingLevel, type ToolDef, type ToolParameters, build, createTools, dev, parseEnvFiles, resolveEnvFiles, resolveSourceRoot };
+export { type AgentConfig, type AgentInfo, type AgentInit, BUILTIN_TOOL_NAMES, type BashFactory, type BashLike, type BuildContext, type BuildOptions, type BuildPlugin, type CallHandle, DEFAULT_DEV_PORT, type DevOptions, type FileStat, type FlueContext, type FlueEvent, type FlueEventCallback, type FlueFs, type FlueHarness, type FlueSession, type FlueSessions, type ModelConfig, type PromptModel, type PromptOptions, type PromptResponse, type PromptResultResponse, type PromptUsage, ResultUnavailableError, type Role, type SandboxFactory, type SessionData, type SessionEnv, type SessionOptions, type SessionStore, type ShellOptions, type ShellResult, type Skill, type SkillOptions, type TaskOptions, type ThinkingLevel, type ToolDef, type ToolParameters, build, createTools, dev, parseEnvFiles, resolveEnvFiles, resolveSourceRoot };

package/dist/index.mjs

@@ -422,9 +422,13 @@ import { Bash, InMemoryFs } from 'just-bash';
 import {
   createFlueContext,
   InMemorySessionStore,
+  InMemoryRunStore,
+  createDurableRunStore,
+  createRunSubscriberRegistry,
   bashFactoryToSessionEnv,
   resolveModel,
   handleAgentRequest,
+  handleRunRouteRequest,
   configureFlueRuntime,
   createDefaultFlueApp,
 } from '@flue/sdk/internal';
@@ -528,6 +532,10 @@ function resolveSandbox(sandbox) {
 
 // Fallback in-memory store (used if no DO storage is available).
 const memoryStore = new InMemorySessionStore();
+const memoryRunStore = new InMemoryRunStore();
+
+// Module-scoped per-isolate registry; run ids isolate buckets across DOs.
+const runSubscribers = createRunSubscriberRegistry();
 
 // Create a DO-backed session store from the Durable Object's SQL storage.
 function createDOStore(sql) {
@@ -554,7 +562,7 @@ function createDOStore(sql) {
   };
 }
 
-function createContextForRequest(id, payload, doInstance, req) {
+function createContextForRequest(id, runId, payload, doInstance, req) {
   // Use DO SQLite storage by default, fall back to in-memory
   const defaultStore = doInstance?.ctx?.storage?.sql
     ? createDOStore(doInstance.ctx.storage.sql)
@@ -562,6 +570,7 @@ function createContextForRequest(id, payload, doInstance, req) {
 
   return createFlueContext({
     id,
+    runId,
     payload,
     env: doInstance?.env ?? {},
     req,
@@ -575,6 +584,12 @@ function createContextForRequest(id, payload, doInstance, req) {
   });
 }
 
+function createRunStoreForRequest(doInstance) {
+  return doInstance?.ctx?.storage?.sql
+    ? createDurableRunStore(doInstance.ctx.storage.sql)
+    : memoryRunStore;
+}
+
 function runWithInstanceContext(doInstance, fn) {
   return runWithCloudflareContext(
     { env: doInstance.env, agentInstance: doInstance, storage: doInstance.ctx.storage },
@@ -612,28 +627,41 @@ async function handleFlueFiberRecovered(ctx, _doInstance, agentName) {
  */
 async function dispatchAgent(request, doInstance, agentName, handler) {
   const id = doInstance.name; // DO room name set by routeAgentRequest
+  const runRoute = parseRunRoute(request);
+  if (runRoute) {
+    return handleRunRouteRequest({
+      request,
+      agentName,
+      id,
+      runStore: createRunStoreForRequest(doInstance),
+      runSubscribers,
+      ...runRoute,
+    });
+  }
 
   return handleAgentRequest({
     request,
     agentName,
     id,
     handler,
-    createContext: (id_, payload, req) => createContextForRequest(id_, payload, doInstance, req),
-    startWebhook: (requestId, run) => {
+    runStore: createRunStoreForRequest(doInstance),
+    runSubscribers,
+    createContext: (id_, runId, payload, req) => createContextForRequest(id_, runId, payload, doInstance, req),
+    startWebhook: (runId, run) => {
       const wrapped = (fiber) => {
         fiber?.stash?.({
           version: 1,
           kind: 'webhook',
           agentName,
           id,
-          requestId,
+          runId,
           phase: 'running',
           startedAt: Date.now(),
         });
         return runWithInstanceContext(doInstance, run);
       };
       assertAgentsDurabilityApi(doInstance, 'runFiber');
-      return doInstance.runFiber('flue:webhook:' + requestId, wrapped);
+      return doInstance.runFiber('flue:webhook:' + runId, wrapped);
     },
     runHandler: (ctx, h) => runWithInstanceContext(doInstance, () => {
       assertAgentsDurabilityApi(doInstance, 'keepAliveWhile');
@@ -642,6 +670,21 @@ async function dispatchAgent(request, doInstance, agentName, handler) {
   });
 }
 
+// Positional parse so an instance id of "runs" is not treated as the marker.
+function parseRunRoute(request) {
+  const segments = new URL(request.url).pathname.split('/').filter(Boolean);
+  if (segments.length < 4) return null;
+  if (segments[0] !== 'agents') return null;
+  if (segments[3] !== 'runs') return null;
+  const runId = segments[4];
+  const child = segments[5];
+  if (!runId) return null;
+  if (!child) return { action: 'get', runId };
+  if (child === 'events') return { action: 'events', runId };
+  if (child === 'stream') return { action: 'stream', runId };
+  return null;
+}
+
 // ─── Per-Agent Durable Object Classes ──────────────────────────────────────
 
 ${agentClasses}
@@ -769,6 +812,8 @@ import { Bash, InMemoryFs } from 'just-bash';
 import {
   createFlueContext,
   InMemorySessionStore,
+  InMemoryRunStore,
+  createRunSubscriberRegistry,
   bashFactoryToSessionEnv,
   resolveModel,
   configureFlueRuntime,
@@ -827,10 +872,13 @@ async function createLocalEnv() {
 
 // Default persistence store for Node — in-memory, process lifetime.
 const defaultStore = new InMemorySessionStore();
+const runStore = new InMemoryRunStore();
+const runSubscribers = createRunSubscriberRegistry();
 
-function createContextForRequest(id, payload, req) {
+function createContextForRequest(id, runId, payload, req) {
   return createFlueContext({
     id,
+    runId,
     payload,
     env: process.env,
     req,
@@ -857,6 +905,8 @@ configureFlueRuntime({
   allowNonWebhook: isLocalMode,
   handlers,
   createContext: createContextForRequest,
+  runStore,
+  runSubscribers,
 });
 
 // ─── App composition ────────────────────────────────────────────────────────

package/dist/internal.d.mts

@@ -1,10 +1,47 @@
-import { A as SessionStore, D as SessionData, v as ModelConfig } from "./types-BAmV4f3Q.mjs";
+import { A as SessionStore, D as SessionData, f as FlueEvent, v as ModelConfig } from "./types-Cdcq_ET2.mjs";
 import { FlueContextConfig, FlueContextInternal, createFlueContext } from "./client.mjs";
-import { a as AgentHandler, c as RunHandlerFn, l as StartWebhookFn, n as configureFlueRuntime, o as CreateContextFn, r as createDefaultFlueApp, s as HandleAgentOptions, t as FlueRuntime, u as handleAgentRequest } from "./flue-app-CG8i4wNG.mjs";
+import { _ as RunStatus, a as AgentHandler, c as RunHandlerFn, d as RunSubscriberListener, f as RunSubscriberRegistry, g as RunRecord, h as EndRunInput, l as StartWebhookFn, m as CreateRunInput, n as configureFlueRuntime, o as CreateContextFn, p as createRunSubscriberRegistry, r as createDefaultFlueApp, s as HandleAgentOptions, t as FlueRuntime, u as handleAgentRequest, v as RunStore, y as RunStoreOptions } from "./flue-app-O4_iqLkn.mjs";
 import { bashFactoryToSessionEnv } from "./sandbox.mjs";
 import { Api, Model } from "@mariozechner/pi-ai";
 import { AgentMessage } from "@mariozechner/pi-agent-core";
 
+//#region src/cloudflare/run-store.d.ts
+interface SqlResult {
+  toArray(): SqlRow[];
+}
+type SqlRow = Record<string, unknown>;
+interface SqlStorage {
+  exec(query: string, ...bindings: unknown[]): SqlResult;
+}
+declare function createDurableRunStore(sql: SqlStorage, options?: RunStoreOptions): RunStore;
+//#endregion
+//#region src/node/run-store.d.ts
+declare class InMemoryRunStore implements RunStore {
+  private instances;
+  private maxCompletedRuns;
+  private maxEventBytes;
+  constructor(options?: RunStoreOptions);
+  createRun(input: CreateRunInput): Promise<void>;
+  endRun(input: EndRunInput): Promise<void>;
+  appendEvent(runId: string, event: FlueEvent): Promise<void>;
+  getEvents(runId: string, fromIndex?: number): Promise<FlueEvent[]>;
+  getRun(runId: string): Promise<RunRecord | null>;
+  private getInstance;
+  private pruneCompletedRuns;
+}
+//#endregion
+//#region src/runtime/handle-run-routes.d.ts
+interface HandleRunRouteOptions {
+  request: Request;
+  runStore?: RunStore;
+  runSubscribers?: RunSubscriberRegistry;
+  agentName: string;
+  id: string;
+  runId?: string;
+  action: 'get' | 'events' | 'stream';
+}
+declare function handleRunRouteRequest(opts: HandleRunRouteOptions): Promise<Response>;
+//#endregion
 //#region src/session.d.ts
 /** In-memory session store. Sessions persist for the lifetime of the process. */
 declare class InMemorySessionStore implements SessionStore {
@@ -21,4 +58,4 @@ declare class InMemorySessionStore implements SessionStore {
  */
 declare function resolveModel(model: ModelConfig | undefined): Model<Api> | undefined;
 //#endregion
-export { type AgentHandler, type CreateContextFn, type FlueContextConfig, type FlueContextInternal, type FlueRuntime, type HandleAgentOptions, InMemorySessionStore, type RunHandlerFn, type StartWebhookFn, bashFactoryToSessionEnv, configureFlueRuntime, createDefaultFlueApp, createFlueContext, handleAgentRequest, resolveModel };
+export { type AgentHandler, type CreateContextFn, type FlueContextConfig, type FlueContextInternal, type FlueRuntime, type HandleAgentOptions, type HandleRunRouteOptions, InMemoryRunStore, InMemorySessionStore, type RunHandlerFn, type RunRecord, type RunStatus, type RunStore, type RunSubscriberListener, type RunSubscriberRegistry, type StartWebhookFn, bashFactoryToSessionEnv, configureFlueRuntime, createDefaultFlueApp, createDurableRunStore, createFlueContext, createRunSubscriberRegistry, handleAgentRequest, handleRunRouteRequest, resolveModel };

package/dist/internal.mjs

@@ -1,12 +1,291 @@
 import "./result-K1IRhWKM.mjs";
-import { i as handleAgentRequest, n as createDefaultFlueApp, t as configureFlueRuntime } from "./flue-app-DeTOZjPs.mjs";
-import { r as getProviderConfiguration, s as resolveRegisteredModel } from "./providers-DeFRIwp0.mjs";
-import { t as InMemorySessionStore } from "./session-CFOByKnM.mjs";
+import { a as handleAgentRequest, i as handleRunRouteRequest, n as createDefaultFlueApp, t as configureFlueRuntime } from "./flue-app-SjL4I83Y.mjs";
+import { r as getProviderConfiguration, s as resolveRegisteredModel } from "./providers-BjEEoKLy.mjs";
+import { t as InMemorySessionStore } from "./session-CRFfAJDq.mjs";
 import { bashFactoryToSessionEnv } from "./sandbox.mjs";
-import "./mcp-DM6yv_Qc.mjs";
+import "./mcp-DwLSoSxp.mjs";
 import { createFlueContext } from "./client.mjs";
 import { getModel } from "@mariozechner/pi-ai";
 
+//#region src/runtime/run-store.ts
+const DEFAULT_MAX_COMPLETED_RUNS = 50;
+const DEFAULT_MAX_EVENT_BYTES = 256 * 1024;
+const TRUNCATABLE_FIELDS = [
+	"result",
+	"args",
+	"text",
+	"content"
+];
+const PREVIEW_CHARS = 1024;
+const ENCODER = new TextEncoder();
+function truncateEventForPersistence(event, maxBytes = DEFAULT_MAX_EVENT_BYTES) {
+	const candidate = cloneJson(event);
+	let serialized = JSON.stringify(candidate);
+	if (byteLength(serialized) <= maxBytes) return event;
+	const originalSerialized = serialized;
+	const originalSize = byteLength(originalSerialized);
+	const truncatedFields = /* @__PURE__ */ new Set();
+	while (byteLength(serialized) > maxBytes) {
+		let largestField;
+		let largestSize = 0;
+		for (const field of TRUNCATABLE_FIELDS) {
+			if (truncatedFields.has(field) || !(field in candidate)) continue;
+			const fieldSize = byteLength(JSON.stringify(candidate[field]));
+			if (fieldSize > largestSize) {
+				largestField = field;
+				largestSize = fieldSize;
+			}
+		}
+		if (!largestField) break;
+		candidate[largestField] = truncateValue(candidate[largestField], largestSize);
+		truncatedFields.add(largestField);
+		serialized = JSON.stringify(candidate);
+	}
+	if (byteLength(serialized) <= maxBytes) return candidate;
+	return {
+		...pickEventIdentity(candidate),
+		truncated: true,
+		originalSize,
+		preview: originalSerialized.slice(0, PREVIEW_CHARS)
+	};
+}
+function truncateValue(value, originalSize) {
+	return {
+		truncated: true,
+		originalSize,
+		preview: JSON.stringify(value).slice(0, PREVIEW_CHARS)
+	};
+}
+function pickEventIdentity(event) {
+	const identity = {};
+	for (const key of [
+		"type",
+		"runId",
+		"eventIndex",
+		"timestamp",
+		"session",
+		"parentSession",
+		"harness",
+		"taskId",
+		"toolCallId",
+		"operationId"
+	]) if (key in event) identity[key] = event[key];
+	return identity;
+}
+function cloneJson(value) {
+	return JSON.parse(JSON.stringify(value));
+}
+function byteLength(value) {
+	return ENCODER.encode(value).byteLength;
+}
+
+//#endregion
+//#region src/cloudflare/run-store.ts
+function createDurableRunStore(sql, options = {}) {
+	ensureRunTables(sql);
+	return new DurableRunStore(sql, options);
+}
+var DurableRunStore = class {
+	maxCompletedRuns;
+	maxEventBytes;
+	constructor(sql, options) {
+		this.sql = sql;
+		this.maxCompletedRuns = options.maxCompletedRuns ?? DEFAULT_MAX_COMPLETED_RUNS;
+		this.maxEventBytes = options.maxEventBytes ?? DEFAULT_MAX_EVENT_BYTES;
+	}
+	async createRun(input) {
+		this.sql.exec(`INSERT OR REPLACE INTO flue_runs
+			 (run_id, instance_id, agent_name, status, started_at, ended_at, is_error, duration_ms, result, error)
+			 VALUES (?, ?, ?, ?, ?, NULL, NULL, NULL, NULL, NULL)`, input.runId, input.instanceId, input.agentName, "active", input.startedAt);
+	}
+	async endRun(input) {
+		this.sql.exec(`UPDATE flue_runs
+			 SET status = ?, ended_at = ?, is_error = ?, duration_ms = ?, result = ?, error = ?
+			 WHERE run_id = ?`, input.isError ? "errored" : "completed", input.endedAt, input.isError ? 1 : 0, input.durationMs, JSON.stringify(input.result ?? null), JSON.stringify(input.error ?? null), input.runId);
+		this.pruneCompletedRuns();
+	}
+	async appendEvent(runId, event) {
+		const storedEvent = truncateEventForPersistence(event, this.maxEventBytes);
+		this.sql.exec(`INSERT OR REPLACE INTO flue_run_events
+			 (run_id, event_index, type, payload, timestamp)
+			 VALUES (?, ?, ?, ?, ?)`, runId, storedEvent.eventIndex ?? 0, storedEvent.type, JSON.stringify(storedEvent), storedEvent.timestamp ?? (/* @__PURE__ */ new Date()).toISOString());
+	}
+	async getEvents(runId, fromIndex) {
+		return this.sql.exec(fromIndex === void 0 ? "SELECT payload FROM flue_run_events WHERE run_id = ? ORDER BY event_index ASC" : "SELECT payload FROM flue_run_events WHERE run_id = ? AND event_index >= ? ORDER BY event_index ASC", ...fromIndex === void 0 ? [runId] : [runId, fromIndex]).toArray().flatMap((row) => typeof row.payload === "string" ? [JSON.parse(row.payload)] : []);
+	}
+	async getRun(runId) {
+		const row = this.sql.exec("SELECT * FROM flue_runs WHERE run_id = ?", runId).toArray()[0];
+		if (!row) return null;
+		return rowToRunRecord(row);
+	}
+	pruneCompletedRuns() {
+		const rows = this.sql.exec(`SELECT run_id FROM flue_runs
+				 WHERE status != 'active'
+				 ORDER BY started_at ASC`).toArray();
+		const deleteCount = rows.length - this.maxCompletedRuns;
+		if (deleteCount <= 0) return;
+		for (const row of rows.slice(0, deleteCount)) {
+			this.sql.exec("DELETE FROM flue_run_events WHERE run_id = ?", row.run_id);
+			this.sql.exec("DELETE FROM flue_runs WHERE run_id = ?", row.run_id);
+		}
+	}
+};
+function ensureRunTables(sql) {
+	sql.exec(`CREATE TABLE IF NOT EXISTS flue_runs (
+		 run_id TEXT PRIMARY KEY,
+		 instance_id TEXT NOT NULL,
+		 agent_name TEXT NOT NULL,
+		 status TEXT NOT NULL,
+		 started_at TEXT NOT NULL,
+		 ended_at TEXT,
+		 is_error INTEGER,
+		 duration_ms INTEGER,
+		 result TEXT,
+		 error TEXT
+		)`);
+	sql.exec(`CREATE TABLE IF NOT EXISTS flue_run_events (
+		 run_id TEXT NOT NULL,
+		 event_index INTEGER NOT NULL,
+		 type TEXT NOT NULL,
+		 payload TEXT NOT NULL,
+		 timestamp TEXT NOT NULL,
+		 PRIMARY KEY (run_id, event_index)
+		)`);
+	sql.exec("CREATE INDEX IF NOT EXISTS flue_runs_instance_started_idx ON flue_runs (instance_id, started_at DESC)");
+	sql.exec("CREATE INDEX IF NOT EXISTS flue_run_events_run_idx ON flue_run_events (run_id, event_index ASC)");
+}
+function rowToRunRecord(row) {
+	const result = typeof row.result === "string" ? JSON.parse(row.result) : void 0;
+	const error = typeof row.error === "string" ? JSON.parse(row.error) : void 0;
+	return {
+		runId: String(row.run_id),
+		instanceId: String(row.instance_id),
+		agentName: String(row.agent_name),
+		status: row.status,
+		startedAt: String(row.started_at),
+		endedAt: typeof row.ended_at === "string" ? row.ended_at : void 0,
+		isError: row.is_error === null || row.is_error === void 0 ? void 0 : Boolean(row.is_error),
+		durationMs: typeof row.duration_ms === "number" ? row.duration_ms : void 0,
+		result,
+		error
+	};
+}
+
+//#endregion
+//#region src/node/run-store.ts
+var InMemoryRunStore = class {
+	instances = /* @__PURE__ */ new Map();
+	maxCompletedRuns;
+	maxEventBytes;
+	constructor(options = {}) {
+		this.maxCompletedRuns = options.maxCompletedRuns ?? DEFAULT_MAX_COMPLETED_RUNS;
+		this.maxEventBytes = options.maxEventBytes ?? DEFAULT_MAX_EVENT_BYTES;
+	}
+	async createRun(input) {
+		const instance = this.getInstance(input.instanceId);
+		instance.runs.set(input.runId, {
+			runId: input.runId,
+			instanceId: input.instanceId,
+			agentName: input.agentName,
+			status: "active",
+			startedAt: input.startedAt
+		});
+		instance.events.set(input.runId, []);
+	}
+	async endRun(input) {
+		const existing = await this.getRun(input.runId);
+		if (!existing) return;
+		const instance = this.getInstance(existing.instanceId);
+		instance.runs.set(input.runId, {
+			...existing,
+			status: input.isError ? "errored" : "completed",
+			endedAt: input.endedAt,
+			isError: input.isError,
+			durationMs: input.durationMs,
+			result: input.result,
+			error: input.error
+		});
+		this.pruneCompletedRuns(instance);
+	}
+	async appendEvent(runId, event) {
+		const run = await this.getRun(runId);
+		if (!run) return;
+		const instance = this.getInstance(run.instanceId);
+		const events = instance.events.get(runId) ?? [];
+		events.push(truncateEventForPersistence(event, this.maxEventBytes));
+		instance.events.set(runId, events);
+	}
+	async getEvents(runId, fromIndex) {
+		const run = await this.getRun(runId);
+		if (!run) return [];
+		const events = this.getInstance(run.instanceId).events.get(runId) ?? [];
+		if (fromIndex === void 0) return [...events];
+		return events.filter((event) => typeof event.eventIndex === "number" && event.eventIndex >= fromIndex);
+	}
+	async getRun(runId) {
+		for (const instance of this.instances.values()) {
+			const run = instance.runs.get(runId);
+			if (run) return run;
+		}
+		return null;
+	}
+	getInstance(instanceId) {
+		let instance = this.instances.get(instanceId);
+		if (!instance) {
+			instance = {
+				runs: /* @__PURE__ */ new Map(),
+				events: /* @__PURE__ */ new Map()
+			};
+			this.instances.set(instanceId, instance);
+		}
+		return instance;
+	}
+	pruneCompletedRuns(instance) {
+		const completed = [...instance.runs.values()].filter((run) => run.status !== "active").sort((a, b) => a.startedAt.localeCompare(b.startedAt));
+		const deleteCount = completed.length - this.maxCompletedRuns;
+		if (deleteCount <= 0) return;
+		for (const run of completed.slice(0, deleteCount)) {
+			instance.runs.delete(run.runId);
+			instance.events.delete(run.runId);
+		}
+	}
+};
+
+//#endregion
+//#region src/runtime/run-subscribers.ts
+function createRunSubscriberRegistry() {
+	const listeners = /* @__PURE__ */ new Map();
+	return {
+		subscribe(runId, listener) {
+			let bucket = listeners.get(runId);
+			if (!bucket) {
+				bucket = /* @__PURE__ */ new Set();
+				listeners.set(runId, bucket);
+			}
+			bucket.add(listener);
+			return () => {
+				const current = listeners.get(runId);
+				if (!current) return;
+				current.delete(listener);
+				if (current.size === 0) listeners.delete(runId);
+			};
+		},
+		publish(runId, event) {
+			const bucket = listeners.get(runId);
+			if (!bucket || bucket.size === 0) return;
+			for (const listener of [...bucket]) try {
+				listener(event);
+			} catch (error) {
+				console.error("[flue:run-subscribers] listener threw:", error);
+			}
+		},
+		complete(runId) {
+			listeners.delete(runId);
+		}
+	};
+}
+
+//#endregion
 //#region src/internal.ts
 /**
 * Internal runtime helpers consumed by the generated server entry point.
@@ -54,4 +333,4 @@ function applyProviderSettings(model, providerSettings) {
 }
 
 //#endregion
-export { InMemorySessionStore, bashFactoryToSessionEnv, configureFlueRuntime, createDefaultFlueApp, createFlueContext, handleAgentRequest, resolveModel };
+export { InMemoryRunStore, InMemorySessionStore, bashFactoryToSessionEnv, configureFlueRuntime, createDefaultFlueApp, createDurableRunStore, createFlueContext, createRunSubscriberRegistry, handleAgentRequest, handleRunRouteRequest, resolveModel };

package/dist/{mcp-C3UBXVkR.d.mts → mcp-BfcWmA-A.d.mts}

@@ -1,4 +1,4 @@
-import { L as ToolDef } from "./types-BAmV4f3Q.mjs";
+import { L as ToolDef } from "./types-Cdcq_ET2.mjs";
 
 //#region src/mcp.d.ts
 type McpTransport = 'streamable-http' | 'sse';