@skein-js/agent-protocol 0.1.0

package/dist/index.js

@@ -0,0 +1,1382 @@
+// src/sse/sse.ts
+import { serializeWireJson } from "@skein-js/core";
+var SSE_HEADERS = {
+  "content-type": "text/event-stream",
+  "cache-control": "no-cache, no-transform",
+  connection: "keep-alive"
+};
+function encodeFrame(frame) {
+  return `id: ${frame.seq}
+event: ${frame.event}
+data: ${serializeWireJson(frame.data)}
+
+`;
+}
+function encodeTerminal(status) {
+  const event = status === "error" || status === "timeout" ? "error" : "end";
+  return `event: ${event}
+data: ${JSON.stringify({ status })}
+
+`;
+}
+async function* toSseEvents(frames, finalStatus) {
+  let sawErrorFrame = false;
+  for await (const frame of frames) {
+    if (frame.event === "error") sawErrorFrame = true;
+    yield encodeFrame(frame);
+  }
+  const status = await finalStatus();
+  const terminal = status ?? "success";
+  if ((terminal === "error" || terminal === "timeout") && sawErrorFrame) return;
+  yield encodeTerminal(terminal);
+}
+function parseAfterSeq(lastEventId) {
+  if (lastEventId === void 0) return 0;
+  const parsed = Number.parseInt(lastEventId, 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : 0;
+}
+
+// src/validation/parse.ts
+import { SkeinHttpError } from "@skein-js/core";
+function parse(schema, raw, subject = "request body") {
+  const result = schema.safeParse(raw);
+  if (!result.success) {
+    throw SkeinHttpError.badRequest(`Invalid ${subject}.`, { details: result.error.flatten() });
+  }
+  return result.data;
+}
+function requireParam(params, name) {
+  const value = params[name];
+  if (typeof value !== "string" || value.length === 0) {
+    throw SkeinHttpError.badRequest(`Missing path parameter "${name}".`);
+  }
+  return value;
+}
+
+// src/validation/schemas.ts
+import { z } from "zod";
+var commandSchema = z.object({
+  resume: z.unknown().optional(),
+  update: z.unknown().optional(),
+  goto: z.unknown().optional()
+}).passthrough();
+var streamModeSchema = z.union([z.string(), z.array(z.string())]);
+var configSchema = z.record(z.unknown());
+var multitaskStrategySchema = z.enum(["reject", "interrupt", "rollback", "enqueue"]);
+var interruptWhenSchema = z.union([z.array(z.string()), z.literal("*")]);
+var runCreateSchema = z.object({
+  assistant_id: z.string().min(1),
+  thread_id: z.string().min(1).optional(),
+  input: z.unknown().optional(),
+  command: commandSchema.optional(),
+  config: configSchema.optional(),
+  context: z.unknown().optional(),
+  stream_mode: streamModeSchema.optional(),
+  metadata: z.record(z.unknown()).optional(),
+  multitask_strategy: multitaskStrategySchema.optional(),
+  interrupt_before: interruptWhenSchema.optional(),
+  interrupt_after: interruptWhenSchema.optional()
+}).passthrough();
+var threadStreamSchema = z.object({
+  assistant_id: z.string().min(1),
+  input: z.unknown().optional(),
+  config: configSchema.optional(),
+  context: z.unknown().optional(),
+  stream_mode: streamModeSchema.optional(),
+  metadata: z.record(z.unknown()).optional()
+}).passthrough();
+var commandBodySchema = z.object({
+  assistant_id: z.string().min(1).optional(),
+  command: commandSchema.optional(),
+  resume: z.unknown().optional(),
+  stream_mode: streamModeSchema.optional(),
+  config: configSchema.optional(),
+  context: z.unknown().optional(),
+  metadata: z.record(z.unknown()).optional()
+}).passthrough();
+var threadCreateSchema = z.object({
+  thread_id: z.string().min(1).optional(),
+  metadata: z.record(z.unknown()).optional()
+}).passthrough();
+var threadPatchSchema = z.object({
+  metadata: z.record(z.unknown()).optional()
+}).passthrough();
+var assistantSearchSchema = z.object({
+  graph_id: z.string().optional(),
+  limit: z.number().int().positive().optional(),
+  offset: z.number().int().nonnegative().optional()
+}).passthrough();
+var storePutSchema = z.object({
+  namespace: z.array(z.string()).min(1),
+  key: z.string().min(1),
+  value: z.record(z.unknown())
+}).passthrough();
+var storeSearchSchema = z.object({
+  namespace_prefix: z.array(z.string()).optional(),
+  query: z.string().optional(),
+  limit: z.number().int().positive().optional(),
+  offset: z.number().int().nonnegative().optional()
+}).passthrough();
+var listNamespacesSchema = z.object({
+  prefix: z.array(z.string()).optional()
+}).passthrough();
+
+// src/create-handlers.ts
+var json = (body, status = 200) => ({ kind: "json", status, body });
+var empty = (status = 204) => ({ kind: "empty", status });
+function queryValue(value) {
+  return Array.isArray(value) ? value[0] : value;
+}
+function namespaceFromQuery(value) {
+  if (Array.isArray(value)) return value;
+  if (typeof value === "string" && value.length > 0) return value.split(".");
+  return [];
+}
+function positiveIntQuery(value) {
+  const raw = queryValue(value);
+  if (raw === void 0) return void 0;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : void 0;
+}
+function createProtocolHandlers(service) {
+  const sse = (runId, frames) => ({
+    kind: "sse",
+    status: 200,
+    events: toSseEvents(frames, () => service.runs.finalStatus(runId))
+  });
+  const afterSeqFrom = (req) => parseAfterSeq(req.headers["last-event-id"]);
+  return {
+    // --- assistants ---------------------------------------------------------------------------
+    getAssistant: async (req) => json(await service.assistants.get(requireParam(req.params, "assistant_id"))),
+    searchAssistants: async (req) => json(await service.assistants.search(parse(assistantSearchSchema, req.body ?? {}))),
+    getAssistantSchemas: async (req) => json(await service.assistants.schemas(requireParam(req.params, "assistant_id"))),
+    // --- threads ------------------------------------------------------------------------------
+    createThread: async (req) => json(await service.threads.create(parse(threadCreateSchema, req.body ?? {}))),
+    getThread: async (req) => json(await service.threads.get(requireParam(req.params, "thread_id"))),
+    listThreads: async () => json(await service.threads.list()),
+    patchThread: async (req) => json(
+      await service.threads.patch(
+        requireParam(req.params, "thread_id"),
+        parse(threadPatchSchema, req.body ?? {})
+      )
+    ),
+    deleteThread: async (req) => {
+      await service.threads.delete(requireParam(req.params, "thread_id"));
+      return empty();
+    },
+    getThreadHistory: async (req) => {
+      const limit = positiveIntQuery(req.query["limit"]);
+      const options = limit === void 0 ? void 0 : { limit };
+      return json(await service.threads.history(requireParam(req.params, "thread_id"), options));
+    },
+    getThreadState: async (req) => json(await service.threads.getState(requireParam(req.params, "thread_id"))),
+    // --- runs ---------------------------------------------------------------------------------
+    createWaitRun: async (req) => json(await service.runs.createWait(parse(runCreateSchema, req.body))),
+    createStreamRun: async (req) => {
+      const started = await service.runs.createStream(
+        parse(runCreateSchema, req.body)
+      );
+      return sse(started.runId, started.frames);
+    },
+    createBackgroundRun: async (req) => json(
+      await service.runs.createBackground(
+        requireParam(req.params, "thread_id"),
+        parse(runCreateSchema, req.body)
+      )
+    ),
+    getRun: async (req) => json(await service.runs.get(requireParam(req.params, "run_id"))),
+    listThreadRuns: async (req) => json(await service.runs.listByThread(requireParam(req.params, "thread_id"))),
+    joinRunStream: async (req) => {
+      const runId = requireParam(req.params, "run_id");
+      const frames = await service.runs.join(runId, afterSeqFrom(req));
+      return sse(runId, frames);
+    },
+    cancelRun: async (req) => json(await service.runs.cancel(requireParam(req.params, "run_id"))),
+    deleteRun: async (req) => {
+      await service.runs.delete(requireParam(req.params, "run_id"));
+      return empty();
+    },
+    // --- thread streaming / commands ----------------------------------------------------------
+    postThreadStream: async (req) => {
+      const started = await service.threadStream.stream(
+        requireParam(req.params, "thread_id"),
+        parse(threadStreamSchema, req.body)
+      );
+      return sse(started.runId, started.frames);
+    },
+    getThreadStream: async (req) => {
+      const started = await service.threadStream.joinStream(
+        requireParam(req.params, "thread_id"),
+        afterSeqFrom(req)
+      );
+      return sse(started.runId, started.frames);
+    },
+    postThreadCommands: async (req) => {
+      const started = await service.threadStream.command(
+        requireParam(req.params, "thread_id"),
+        parse(commandBodySchema, req.body ?? {})
+      );
+      return sse(started.runId, started.frames);
+    },
+    // --- store --------------------------------------------------------------------------------
+    putStoreItem: async (req) => {
+      const body = parse(storePutSchema, req.body);
+      return json(await service.store.put(body.namespace, body.key, body.value));
+    },
+    getStoreItem: async (req) => {
+      const namespace = namespaceFromQuery(req.query["namespace"]);
+      const key = queryValue(req.query["key"]) ?? "";
+      return json(await service.store.get(namespace, key));
+    },
+    deleteStoreItem: async (req) => {
+      const namespace = namespaceFromQuery(req.query["namespace"]);
+      const key = queryValue(req.query["key"]) ?? "";
+      await service.store.delete(namespace, key);
+      return empty();
+    },
+    searchStoreItems: async (req) => {
+      const body = parse(storeSearchSchema, req.body ?? {});
+      return json(
+        await service.store.search({
+          prefix: body.namespace_prefix,
+          query: body.query,
+          limit: body.limit,
+          offset: body.offset
+        })
+      );
+    },
+    listStoreNamespaces: async (req) => {
+      const body = parse(listNamespacesSchema, req.body ?? {});
+      return json(await service.store.listNamespaces(body.prefix));
+    }
+  };
+}
+
+// src/assistants/assistant-service.ts
+import { SkeinHttpError as SkeinHttpError2 } from "@skein-js/core";
+function createAssistantService(deps) {
+  const requireAssistant = async (assistantId) => {
+    const assistant = await deps.store.assistants.get(assistantId);
+    if (!assistant) throw SkeinHttpError2.notFound(`Assistant "${assistantId}" not found.`);
+    return assistant;
+  };
+  return {
+    async registerGraphAssistants() {
+      const registered = [];
+      for (const graphId of deps.graphs.ids) {
+        const existing = await deps.store.assistants.get(graphId);
+        registered.push(
+          existing ?? await deps.store.assistants.create({ graph_id: graphId, assistant_id: graphId })
+        );
+      }
+      return registered;
+    },
+    get: requireAssistant,
+    list: () => deps.store.assistants.list(),
+    async search(query) {
+      const all = await deps.store.assistants.list();
+      const filtered = query.graph_id ? all.filter((assistant) => assistant.graph_id === query.graph_id) : all;
+      const offset = query.offset ?? 0;
+      return filtered.slice(offset, query.limit === void 0 ? void 0 : offset + query.limit);
+    },
+    async schemas(assistantId) {
+      const assistant = await requireAssistant(assistantId);
+      return deps.graphs.schemas(assistant.graph_id);
+    }
+  };
+}
+
+// src/deps.ts
+var noopLogger = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+function resolveDeps(deps) {
+  return {
+    ...deps,
+    clock: deps.clock ?? (() => /* @__PURE__ */ new Date()),
+    logger: deps.logger ?? noopLogger
+  };
+}
+
+// src/runs/cancellation.ts
+var RunControlRegistry = class {
+  #entries = /* @__PURE__ */ new Map();
+  /** Start tracking a run and return its abort signal + reason box. */
+  register(runId) {
+    const controller = new AbortController();
+    const reason = { current: null };
+    const abort = (next) => {
+      if (reason.current === null) reason.current = next;
+      controller.abort();
+    };
+    this.#entries.set(runId, { controller, reason, abort });
+    return { signal: controller.signal, reason, abort };
+  }
+  /** Abort a tracked run with a reason. Returns false if the run isn't currently executing. */
+  abort(runId, reason) {
+    const entry = this.#entries.get(runId);
+    if (!entry) return false;
+    entry.abort(reason);
+    return true;
+  }
+  /** Stop tracking a run once it has settled. */
+  clear(runId) {
+    this.#entries.delete(runId);
+  }
+  /** Whether a run is currently being tracked (i.e. executing). */
+  isTracking(runId) {
+    return this.#entries.has(runId);
+  }
+};
+
+// src/runs/thread-locks.ts
+var ThreadLocks = class {
+  #tails = /* @__PURE__ */ new Map();
+  /** Run `task` after any in-flight task for `key` has settled, serializing access per key. */
+  async run(key, task) {
+    const previous = this.#tails.get(key) ?? Promise.resolve();
+    const result = previous.then(task, task);
+    const tail = result.then(
+      () => void 0,
+      () => void 0
+    );
+    this.#tails.set(key, tail);
+    try {
+      return await result;
+    } finally {
+      if (this.#tails.get(key) === tail) this.#tails.delete(key);
+    }
+  }
+};
+
+// src/context.ts
+function createContext(deps) {
+  return {
+    deps: resolveDeps(deps),
+    control: new RunControlRegistry(),
+    locks: new ThreadLocks()
+  };
+}
+
+// src/runs/run-service.ts
+import {
+  isTerminalRunStatus as isTerminalRunStatus3,
+  SkeinHttpError as SkeinHttpError5
+} from "@skein-js/core";
+
+// src/runs/run-engine.ts
+import {
+  isTerminalRunStatus as isTerminalRunStatus2,
+  SkeinHttpError as SkeinHttpError4
+} from "@skein-js/core";
+
+// src/normalize-error.ts
+import { isSkeinHttpError, SkeinHttpError as SkeinHttpError3 } from "@skein-js/core";
+function serializeError(error) {
+  if (error instanceof Error) {
+    return { name: error.name, message: error.message };
+  }
+  return { name: "Error", message: String(error) };
+}
+
+// src/sse/run-frame-stream.ts
+var STREAM_MODES = [
+  "values",
+  "updates",
+  "messages",
+  "messages-tuple",
+  "custom",
+  "events",
+  "debug"
+];
+function isStreamMode(value) {
+  return typeof value === "string" && STREAM_MODES.includes(value);
+}
+function chunkToFrameBody(chunk) {
+  if (Array.isArray(chunk) && chunk.length === 2 && isStreamMode(chunk[0])) {
+    return { event: chunk[0], data: chunk[1] };
+  }
+  return { event: "updates", data: chunk };
+}
+function toRunFrame(seq, body) {
+  return { seq, event: body.event, data: body.data };
+}
+
+// src/store/skein-base-store.ts
+import {
+  BaseStore
+} from "@langchain/langgraph";
+function toLangGraphItem(item) {
+  return {
+    namespace: item.namespace,
+    key: item.key,
+    value: item.value,
+    createdAt: new Date(item.createdAt),
+    updatedAt: new Date(item.updatedAt)
+  };
+}
+function toLangGraphSearchItem(item) {
+  const base = toLangGraphItem(item);
+  return item.score === void 0 ? base : { ...base, score: item.score };
+}
+function prefixFromListOperation(operation) {
+  const prefixCondition = operation.matchConditions?.find(
+    (condition) => condition.matchType === "prefix"
+  );
+  if (!prefixCondition) return void 0;
+  return prefixCondition.path.every((segment) => segment !== "*") ? prefixCondition.path : void 0;
+}
+var SkeinBaseStore = class extends BaseStore {
+  constructor(repo) {
+    super();
+    this.repo = repo;
+  }
+  repo;
+  async get(namespace, key) {
+    const item = await this.repo.get(namespace, key);
+    return item ? toLangGraphItem(item) : null;
+  }
+  async put(namespace, key, value) {
+    await this.repo.put(namespace, key, value);
+  }
+  async delete(namespace, key) {
+    await this.repo.delete(namespace, key);
+  }
+  async search(namespacePrefix, options) {
+    const query = { prefix: namespacePrefix, limit: options?.limit ?? 10 };
+    if (options?.query !== void 0) query.query = options.query;
+    if (options?.offset !== void 0) query.offset = options.offset;
+    const items = await this.repo.search(query);
+    return items.map(toLangGraphSearchItem);
+  }
+  async listNamespaces(options) {
+    const all = await this.repo.listNamespaces(options?.prefix);
+    const offset = options?.offset ?? 0;
+    const end = options?.limit === void 0 ? void 0 : offset + options.limit;
+    return all.slice(offset, end);
+  }
+  // BaseStore's only abstract method. The convenience methods above are overridden to hit the repo
+  // directly, so this dispatcher can safely call them without recursing back through `batch`.
+  async batch(operations) {
+    const results = await Promise.all(operations.map((operation) => this.runOperation(operation)));
+    return results;
+  }
+  runOperation(operation) {
+    if ("namespacePrefix" in operation) {
+      const search = operation;
+      return this.search(search.namespacePrefix, search);
+    }
+    if ("value" in operation) {
+      const put = operation;
+      return put.value === null ? this.delete(put.namespace, put.key) : this.put(put.namespace, put.key, put.value);
+    }
+    if ("key" in operation) {
+      const get = operation;
+      return this.get(get.namespace, get.key);
+    }
+    return this.listNamespaces({ prefix: prefixFromListOperation(operation) });
+  }
+};
+
+// src/runs/run-status.ts
+import { isTerminalRunStatus } from "@skein-js/core";
+function threadStatusForRun(status) {
+  switch (status) {
+    case "running":
+      return "busy";
+    case "interrupted":
+      return "interrupted";
+    case "error":
+    case "timeout":
+      return "error";
+    // pending (not yet started) and success both leave the thread idle.
+    case "pending":
+    case "success":
+      return "idle";
+    default:
+      return "idle";
+  }
+}
+
+// src/threads/thread-mirror.ts
+function isInterruptedSnapshot(snapshot) {
+  return snapshot.next.length > 0;
+}
+function collectInterrupts(snapshot) {
+  const byTask = {};
+  for (const task of snapshot.tasks) {
+    if (task.interrupts && task.interrupts.length > 0) {
+      byTask[task.id] = task.interrupts;
+    }
+  }
+  return byTask;
+}
+function runStatusForSnapshot(snapshot) {
+  return isInterruptedSnapshot(snapshot) ? "interrupted" : "success";
+}
+function snapshotToThreadUpdate(snapshot, runStatus) {
+  return {
+    values: snapshot.values,
+    interrupts: collectInterrupts(snapshot),
+    status: threadStatusForRun(runStatus)
+  };
+}
+function toCheckpoint(config) {
+  const configurable = config?.configurable;
+  if (!configurable) return null;
+  const threadId = configurable["thread_id"];
+  if (typeof threadId !== "string") return null;
+  return {
+    thread_id: threadId,
+    checkpoint_ns: configurable["checkpoint_ns"] ?? "",
+    checkpoint_id: configurable["checkpoint_id"],
+    checkpoint_map: configurable["checkpoint_map"]
+  };
+}
+function toThreadTask(task) {
+  return {
+    id: task.id,
+    name: task.name,
+    result: task.result,
+    error: task.error === void 0 ? null : String(task.error),
+    interrupts: task.interrupts ?? [],
+    checkpoint: null,
+    state: null
+  };
+}
+function snapshotToThreadState(snapshot) {
+  return {
+    values: snapshot.values,
+    next: [...snapshot.next],
+    checkpoint: toCheckpoint(snapshot.config) ?? {
+      thread_id: "",
+      checkpoint_ns: "",
+      checkpoint_id: void 0,
+      checkpoint_map: void 0
+    },
+    metadata: snapshot.metadata ?? {},
+    created_at: snapshot.createdAt ?? null,
+    parent_checkpoint: toCheckpoint(snapshot.parentConfig),
+    tasks: snapshot.tasks.map(toThreadTask)
+  };
+}
+
+// src/runs/run-input.ts
+import { Command } from "@langchain/langgraph";
+function toGraphMode(mode) {
+  if (mode === "messages-tuple") return "messages";
+  if (mode === "events") return "updates";
+  return mode;
+}
+function normalizeModes(mode) {
+  const requested = mode === void 0 ? [] : Array.isArray(mode) ? mode : [mode];
+  const mapped = requested.map(toGraphMode);
+  const deduped = [...new Set(mapped)];
+  return deduped.length > 0 ? deduped : ["values"];
+}
+function toGraphInput(kwargs) {
+  if (kwargs.command) {
+    return new Command(kwargs.command);
+  }
+  return kwargs.input ?? null;
+}
+var RESERVED_CONFIGURABLE_KEYS = /* @__PURE__ */ new Set([
+  "thread_id",
+  "run_id",
+  "checkpoint_id",
+  "checkpoint_ns",
+  "checkpoint_map",
+  "checkpoint"
+]);
+function sanitizeConfigurable(configurable) {
+  if (!configurable) return {};
+  const clean = {};
+  for (const [key, value] of Object.entries(configurable)) {
+    if (RESERVED_CONFIGURABLE_KEYS.has(key) || key.startsWith("__")) continue;
+    clean[key] = value;
+  }
+  return clean;
+}
+function toGraphCallOptions(kwargs, threadId, signal) {
+  const options = {
+    // Drop server-owned keys from the client's configurable, then force this thread's id.
+    configurable: { ...sanitizeConfigurable(kwargs.config?.configurable), thread_id: threadId },
+    streamMode: normalizeModes(kwargs.stream_mode),
+    signal
+  };
+  if (kwargs.context !== void 0) options.context = kwargs.context;
+  const recursionLimit = kwargs.config?.recursion_limit;
+  if (typeof recursionLimit === "number") options.recursionLimit = recursionLimit;
+  if (kwargs.interrupt_before !== void 0) options.interruptBefore = kwargs.interrupt_before;
+  if (kwargs.interrupt_after !== void 0) options.interruptAfter = kwargs.interrupt_after;
+  return options;
+}
+
+// src/runs/run-log.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function messageType(node) {
+  if (typeof node["type"] === "string") return node["type"];
+  const getType = node["_getType"];
+  if (typeof getType === "function") {
+    try {
+      const type = getType.call(node);
+      return typeof type === "string" ? type : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function extractToolActivity(data) {
+  const calls = [];
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (node, depth) => {
+    if (depth > 6 || !isRecord(node) || seen.has(node)) return;
+    seen.add(node);
+    const toolCalls = node["tool_calls"];
+    if (Array.isArray(toolCalls)) {
+      for (const call of toolCalls) {
+        if (isRecord(call) && typeof call["name"] === "string" && call["name"].length > 0) {
+          calls.push({ name: call["name"], id: typeof call["id"] === "string" ? call["id"] : void 0 });
+        }
+      }
+    }
+    if (messageType(node) === "tool") {
+      results.push({
+        name: typeof node["name"] === "string" ? node["name"] : "tool",
+        id: typeof node["tool_call_id"] === "string" ? node["tool_call_id"] : void 0
+      });
+    }
+    for (const value of Object.values(node)) {
+      if (Array.isArray(value)) {
+        for (const item of value) visit(item, depth + 1);
+      } else if (isRecord(value)) {
+        visit(value, depth + 1);
+      }
+    }
+  };
+  try {
+    visit(data, 0);
+  } catch {
+  }
+  return { calls, results };
+}
+function describeInterrupts(snapshot) {
+  const prompts = [];
+  try {
+    for (const task of snapshot.tasks ?? []) {
+      for (const interrupt of task.interrupts ?? []) {
+        const value = interrupt.value;
+        prompts.push(typeof value === "string" ? value : JSON.stringify(value));
+      }
+    }
+  } catch {
+  }
+  return prompts;
+}
+
+// src/runs/run-engine.ts
+async function resolveGraph(deps, graphId, kwargs) {
+  const resolved = await deps.graphs.load(graphId);
+  const graph = typeof resolved === "function" ? await resolved({ configurable: kwargs.config?.configurable }) : resolved;
+  graph.checkpointer = deps.checkpointer;
+  graph.store = new SkeinBaseStore(deps.store.store);
+  return graph;
+}
+async function finalizeRun(deps, runId, status) {
+  const fresh = await deps.store.runs.get(runId);
+  if (!fresh) return status;
+  if (isTerminalRunStatus2(fresh.status)) return fresh.status;
+  await deps.store.runs.setStatus(runId, status);
+  return status;
+}
+async function mirrorThread(deps, threadId, patch) {
+  const thread = await deps.store.threads.get(threadId);
+  if (!thread) return;
+  let effective = patch;
+  if (patch.status && patch.status !== "error" && patch.metadata === void 0 && thread.metadata != null && "error" in thread.metadata) {
+    const cleared = { ...thread.metadata };
+    delete cleared["error"];
+    effective = { ...patch, metadata: cleared };
+  }
+  await deps.store.threads.update(threadId, effective);
+}
+async function mirrorThreadStatus(deps, threadId, status) {
+  await mirrorThread(deps, threadId, { status });
+}
+async function mirrorThreadError(deps, threadId, message) {
+  const thread = await deps.store.threads.get(threadId);
+  if (!thread) return;
+  const metadata = { ...thread.metadata, error: message };
+  await deps.store.threads.update(threadId, { status: "error", metadata });
+}
+async function executeRun(deps, exec) {
+  const { run, kwargs, control } = exec;
+  const runId = run.run_id;
+  const threadId = run.thread_id;
+  let seq = 0;
+  const startedAt = deps.clock().getTime();
+  const loggedTools = /* @__PURE__ */ new Set();
+  const logToolActivity = (data) => {
+    const { calls, results } = extractToolActivity(data);
+    for (const call of calls) {
+      const key = `call:${call.id ?? call.name}`;
+      if (loggedTools.has(key)) continue;
+      loggedTools.add(key);
+      deps.logger.info(`run ${runId} \u2192 tool call: ${call.name}`);
+    }
+    for (const result of results) {
+      const key = `result:${result.id ?? result.name}`;
+      if (loggedTools.has(key)) continue;
+      loggedTools.add(key);
+      deps.logger.info(`run ${runId} \u2190 tool result: ${result.name}`);
+    }
+  };
+  const logFinished = (status) => {
+    if (!deps.logRunActivity) return;
+    deps.logger.info(
+      `run ${runId} ${status} in ${deps.clock().getTime() - startedAt}ms (${seq} frames)`
+    );
+  };
+  const timer = deps.runTimeoutMs !== void 0 ? setTimeout(() => control.abort("timeout"), deps.runTimeoutMs) : void 0;
+  try {
+    const current = await deps.store.runs.get(runId);
+    if (current && isTerminalRunStatus2(current.status)) {
+      return { status: current.status, values: {} };
+    }
+    await deps.store.runs.setStatus(runId, "running");
+    await mirrorThreadStatus(deps, threadId, "busy");
+    if (deps.logRunActivity) {
+      deps.logger.info(`run ${runId} started \xB7 assistant=${run.assistant_id} thread=${threadId}`);
+    }
+    const assistant = await deps.store.assistants.get(run.assistant_id);
+    if (!assistant) {
+      throw SkeinHttpError4.notFound(`Assistant "${run.assistant_id}" not found.`);
+    }
+    const graph = await resolveGraph(deps, assistant.graph_id, kwargs);
+    const input = toGraphInput(kwargs);
+    const options = toGraphCallOptions(kwargs, threadId, control.signal);
+    const stream = await graph.stream(input, options);
+    for await (const chunk of stream) {
+      seq += 1;
+      const body = chunkToFrameBody(chunk);
+      await deps.bus.publish(runId, toRunFrame(seq, body));
+      if (deps.logRunActivity) logToolActivity(body.data);
+    }
+    if (control.signal.aborted) {
+      const timedOut = control.reason.current === "timeout";
+      const finalStatus2 = await finalizeRun(deps, runId, timedOut ? "timeout" : "error");
+      if (finalStatus2 === "timeout") await mirrorThreadError(deps, threadId, "Run timed out.");
+      else if (finalStatus2 === "error") await mirrorThreadStatus(deps, threadId, "idle");
+      logFinished(finalStatus2);
+      return { status: finalStatus2, values: {} };
+    }
+    const snapshot = await graph.getState({ configurable: { thread_id: threadId } });
+    const computed = runStatusForSnapshot(snapshot);
+    const finalStatus = await finalizeRun(deps, runId, computed);
+    if (finalStatus === computed) {
+      await mirrorThread(deps, threadId, snapshotToThreadUpdate(snapshot, finalStatus));
+    } else {
+      await mirrorThreadStatus(deps, threadId, finalStatus === "error" ? "error" : "idle");
+    }
+    if (deps.logRunActivity && finalStatus === "interrupted") {
+      const prompts = describeInterrupts(snapshot);
+      deps.logger.info(
+        `run ${runId} interrupted${prompts.length ? ` \xB7 awaiting: ${prompts.join("; ")}` : ""}`
+      );
+    }
+    logFinished(finalStatus);
+    return { status: finalStatus, values: snapshot.values };
+  } catch (error) {
+    const reason = control.reason.current;
+    if (reason === "timeout") {
+      const finalStatus2 = await finalizeRun(deps, runId, "timeout");
+      if (finalStatus2 === "timeout") await mirrorThreadError(deps, threadId, "Run timed out.");
+      logFinished(finalStatus2);
+      return { status: finalStatus2, values: {} };
+    }
+    if (reason === "cancel" || control.signal.aborted) {
+      const finalStatus2 = await finalizeRun(deps, runId, "error");
+      if (finalStatus2 === "error") await mirrorThreadStatus(deps, threadId, "idle");
+      logFinished(finalStatus2);
+      return { status: finalStatus2, values: {} };
+    }
+    const serialized = serializeError(error);
+    seq += 1;
+    await deps.bus.publish(runId, { seq, event: "error", data: serialized });
+    const finalStatus = await finalizeRun(deps, runId, "error");
+    if (finalStatus === "error") await mirrorThreadError(deps, threadId, serialized.message);
+    if (deps.logRunActivity) deps.logger.error(`run ${runId} error: ${serialized.message}`);
+    logFinished(finalStatus);
+    return { status: finalStatus, values: {} };
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+    await deps.bus.close(runId);
+  }
+}
+
+// src/runs/run-service.ts
+function toKwargs(input) {
+  const kwargs = {};
+  if (input.input !== void 0) kwargs.input = input.input;
+  if (input.command !== void 0) kwargs.command = input.command;
+  if (input.config !== void 0) kwargs.config = input.config;
+  if (input.context !== void 0) kwargs.context = input.context;
+  if (input.stream_mode !== void 0) kwargs.stream_mode = input.stream_mode;
+  if (input.interrupt_before !== void 0) kwargs.interrupt_before = input.interrupt_before;
+  if (input.interrupt_after !== void 0) kwargs.interrupt_after = input.interrupt_after;
+  return kwargs;
+}
+function createRunService(ctx) {
+  const { deps, control, locks } = ctx;
+  const requireThread = async (threadId) => {
+    if (!await deps.store.threads.get(threadId)) {
+      throw SkeinHttpError5.notFound(`Thread "${threadId}" not found.`);
+    }
+  };
+  const requireAssistant = async (assistantId) => {
+    const assistant = await deps.store.assistants.get(assistantId);
+    if (!assistant) throw SkeinHttpError5.notFound(`Assistant "${assistantId}" not found.`);
+    return assistant.assistant_id;
+  };
+  const ensureThread = async (threadId) => {
+    if (threadId === void 0) return (await deps.store.threads.create()).thread_id;
+    const existing = await deps.store.threads.get(threadId);
+    return (existing ?? await deps.store.threads.create({ thread_id: threadId })).thread_id;
+  };
+  const createPendingRun = async (input, threadId, assistantId, kwargs) => {
+    return locks.run(threadId, async () => {
+      const strategy = input.multitask_strategy ?? "reject";
+      if (await deps.store.runs.hasActiveRun(threadId)) {
+        if (strategy !== "reject") {
+          deps.logger.warn(`multitask_strategy "${strategy}" treated as reject (MVP).`);
+        }
+        throw SkeinHttpError5.conflict(`Thread "${threadId}" already has an active run.`, {
+          code: "thread_busy"
+        });
+      }
+      return deps.store.runs.create({
+        thread_id: threadId,
+        assistant_id: assistantId,
+        status: "pending",
+        metadata: input.metadata,
+        multitask_strategy: strategy,
+        kwargs
+      });
+    });
+  };
+  const runInline = (run, kwargs) => {
+    const runControl = control.register(run.run_id);
+    const done = executeRun(deps, { run, kwargs, control: runControl }).finally(
+      () => control.clear(run.run_id)
+    );
+    return done;
+  };
+  return {
+    async createWait(input) {
+      const assistantId = await requireAssistant(input.assistant_id);
+      const threadId = await ensureThread(input.thread_id);
+      const kwargs = toKwargs(input);
+      const run = await createPendingRun(input, threadId, assistantId, kwargs);
+      const outcome = await runInline(run, kwargs);
+      return outcome.values;
+    },
+    async createStream(input) {
+      const assistantId = await requireAssistant(input.assistant_id);
+      const threadId = await ensureThread(input.thread_id);
+      const kwargs = toKwargs(input);
+      const run = await createPendingRun(input, threadId, assistantId, kwargs);
+      void runInline(run, kwargs).catch(
+        (error) => deps.logger.error("stream run failed", error)
+      );
+      return { runId: run.run_id, frames: deps.bus.subscribe(run.run_id, 0) };
+    },
+    async createBackground(threadId, input) {
+      const assistantId = await requireAssistant(input.assistant_id);
+      await requireThread(threadId);
+      const kwargs = toKwargs(input);
+      const run = await createPendingRun(
+        { ...input, thread_id: threadId },
+        threadId,
+        assistantId,
+        kwargs
+      );
+      await deps.queue.enqueue({ run_id: run.run_id, thread_id: threadId });
+      return run;
+    },
+    async get(runId) {
+      const run = await deps.store.runs.get(runId);
+      if (!run) throw SkeinHttpError5.notFound(`Run "${runId}" not found.`);
+      return run;
+    },
+    async listByThread(threadId) {
+      await requireThread(threadId);
+      return deps.store.runs.listByThread(threadId);
+    },
+    async cancel(runId) {
+      const run = await deps.store.runs.get(runId);
+      if (!run) throw SkeinHttpError5.notFound(`Run "${runId}" not found.`);
+      if (isTerminalRunStatus3(run.status)) return run;
+      if (run.status === "pending") {
+        await deps.store.runs.setStatus(runId, "error");
+        await deps.store.threads.update(run.thread_id, { status: "idle" });
+        await deps.bus.close(runId);
+        control.abort(runId, "cancel");
+      } else {
+        await deps.store.runs.setStatus(runId, "error");
+        await deps.store.threads.update(run.thread_id, { status: "idle" });
+        control.abort(runId, "cancel");
+      }
+      return await deps.store.runs.get(runId) ?? run;
+    },
+    async delete(runId) {
+      if (!await deps.store.runs.get(runId)) {
+        throw SkeinHttpError5.notFound(`Run "${runId}" not found.`);
+      }
+      control.abort(runId, "cancel");
+      await deps.store.runs.delete(runId);
+    },
+    async join(runId, afterSeq = 0) {
+      if (!await deps.store.runs.get(runId)) {
+        throw SkeinHttpError5.notFound(`Run "${runId}" not found.`);
+      }
+      return deps.bus.subscribe(runId, afterSeq);
+    },
+    async finalStatus(runId) {
+      const run = await deps.store.runs.get(runId);
+      return run?.status ?? null;
+    }
+  };
+}
+
+// src/store/store-service.ts
+import { SkeinHttpError as SkeinHttpError6 } from "@skein-js/core";
+function createStoreService(deps) {
+  return {
+    put: (namespace, key, value) => deps.store.store.put(namespace, key, value),
+    async get(namespace, key) {
+      const item = await deps.store.store.get(namespace, key);
+      if (!item) {
+        throw SkeinHttpError6.notFound(
+          `Store item "${key}" not found in namespace [${namespace.join(", ")}].`
+        );
+      }
+      return item;
+    },
+    delete: (namespace, key) => deps.store.store.delete(namespace, key),
+    search: (query) => deps.store.store.search(query),
+    listNamespaces: (prefix) => deps.store.store.listNamespaces(prefix)
+  };
+}
+
+// src/threads/thread-service.ts
+import {
+  isTerminalRunStatus as isTerminalRunStatus4,
+  SkeinHttpError as SkeinHttpError7
+} from "@skein-js/core";
+function emptyThreadState(threadId) {
+  return {
+    values: {},
+    next: [],
+    checkpoint: {
+      thread_id: threadId,
+      checkpoint_ns: "",
+      checkpoint_id: void 0,
+      checkpoint_map: void 0
+    },
+    metadata: {},
+    created_at: null,
+    parent_checkpoint: null,
+    tasks: []
+  };
+}
+function createThreadService(ctx) {
+  const { deps, control } = ctx;
+  const requireThread = async (threadId) => {
+    const thread = await deps.store.threads.get(threadId);
+    if (!thread) throw SkeinHttpError7.notFound(`Thread "${threadId}" not found.`);
+    return thread;
+  };
+  const readHistory = async (threadId, options) => {
+    await requireThread(threadId);
+    const runs = await deps.store.runs.listByThread(threadId);
+    const latest = [...runs].sort((a, b) => b.created_at.localeCompare(a.created_at))[0];
+    if (!latest) return [];
+    const assistant = await deps.store.assistants.get(latest.assistant_id);
+    if (!assistant) return [];
+    const resolved = await deps.graphs.load(assistant.graph_id);
+    let graph;
+    if (typeof resolved === "function") {
+      const kwargs = await deps.store.runs.getKwargs(latest.run_id);
+      graph = await resolved({ configurable: kwargs?.config?.configurable });
+    } else {
+      graph = resolved;
+    }
+    graph.checkpointer = deps.checkpointer;
+    const states = [];
+    const limit = options?.limit;
+    for await (const snapshot of graph.getStateHistory({
+      configurable: { thread_id: threadId }
+    })) {
+      states.push(snapshotToThreadState(snapshot));
+      if (limit !== void 0 && states.length >= limit) break;
+    }
+    return states;
+  };
+  return {
+    create: (input) => deps.store.threads.create(input),
+    get: requireThread,
+    list: () => deps.store.threads.list(),
+    async patch(threadId, patch) {
+      await requireThread(threadId);
+      return deps.store.threads.update(threadId, { metadata: patch.metadata });
+    },
+    async delete(threadId) {
+      await requireThread(threadId);
+      const runs = await deps.store.runs.listByThread(threadId);
+      for (const run of runs) {
+        if (!isTerminalRunStatus4(run.status)) {
+          control.abort(run.run_id, "cancel");
+          await deps.bus.close(run.run_id);
+        }
+      }
+      await deps.store.threads.delete(threadId);
+    },
+    history: readHistory,
+    async getState(threadId) {
+      const [current] = await readHistory(threadId, { limit: 1 });
+      return current ?? emptyThreadState(threadId);
+    }
+  };
+}
+
+// src/threads/thread-stream-service.ts
+import {
+  isTerminalRunStatus as isTerminalRunStatus5,
+  SkeinHttpError as SkeinHttpError8
+} from "@skein-js/core";
+function createThreadStreamService(ctx, runs) {
+  const { deps } = ctx;
+  const requireThread = async (threadId) => {
+    const thread = await deps.store.threads.get(threadId);
+    if (!thread) throw SkeinHttpError8.notFound(`Thread "${threadId}" not found.`);
+    return thread;
+  };
+  const latestRunAssistant = async (threadId) => {
+    const threadRuns = await deps.store.runs.listByThread(threadId);
+    const latest = [...threadRuns].sort((a, b) => b.created_at.localeCompare(a.created_at))[0];
+    return latest?.assistant_id;
+  };
+  return {
+    async stream(threadId, input) {
+      await requireThread(threadId);
+      return runs.createStream({ ...input, thread_id: threadId });
+    },
+    async joinStream(threadId, afterSeq) {
+      await requireThread(threadId);
+      const threadRuns = await deps.store.runs.listByThread(threadId);
+      const sorted = [...threadRuns].sort((a, b) => b.created_at.localeCompare(a.created_at));
+      const target = sorted.find((run) => !isTerminalRunStatus5(run.status)) ?? sorted[0];
+      if (!target) throw SkeinHttpError8.notFound(`Thread "${threadId}" has no runs to stream.`);
+      return { runId: target.run_id, frames: await runs.join(target.run_id, afterSeq) };
+    },
+    async command(threadId, input) {
+      const thread = await requireThread(threadId);
+      if (thread.status !== "interrupted") {
+        throw SkeinHttpError8.conflict(`Thread "${threadId}" is not interrupted.`, {
+          code: "thread_not_interrupted"
+        });
+      }
+      const command = input.command ?? (input.resume !== void 0 ? { resume: input.resume } : void 0);
+      if (!command) {
+        throw SkeinHttpError8.badRequest("A command must provide `command` or `resume`.");
+      }
+      const assistantId = input.assistant_id ?? await latestRunAssistant(threadId);
+      if (!assistantId) {
+        throw SkeinHttpError8.badRequest(
+          "Cannot resume: no assistant_id and no prior run on the thread."
+        );
+      }
+      const runInput = {
+        thread_id: threadId,
+        assistant_id: assistantId,
+        command,
+        stream_mode: input.stream_mode,
+        config: input.config,
+        context: input.context,
+        metadata: input.metadata
+      };
+      return runs.createStream(runInput);
+    }
+  };
+}
+
+// src/service.ts
+function buildProtocolService(ctx) {
+  const runs = createRunService(ctx);
+  return {
+    assistants: createAssistantService(ctx.deps),
+    threads: createThreadService(ctx),
+    threadStream: createThreadStreamService(ctx, runs),
+    runs,
+    store: createStoreService(ctx.deps)
+  };
+}
+function createProtocolService(deps) {
+  return buildProtocolService(createContext(deps));
+}
+
+// src/auth/auth-scoped-store.ts
+import {
+  SkeinHttpError as SkeinHttpError9
+} from "@skein-js/core";
+function stampFromFilters(metadata, filters) {
+  const stamped = { ...metadata ?? {} };
+  for (const [key, value] of Object.entries(filters)) {
+    if (typeof value === "string") {
+      stamped[key] = value;
+    } else if (typeof value.$eq === "string") {
+      stamped[key] = value.$eq;
+    } else if (value.$contains !== void 0) {
+      const required = Array.isArray(value.$contains) ? value.$contains : [value.$contains];
+      const current = Array.isArray(stamped[key]) ? stamped[key] : [];
+      stamped[key] = [.../* @__PURE__ */ new Set([...current, ...required])];
+    }
+  }
+  return stamped;
+}
+function createAuthScopedStore(inner, engine, filters, resource) {
+  if (!filters) return inner;
+  const matches = (metadata) => engine.matchesFilters(metadata ?? void 0, filters);
+  const stamp = (metadata) => stampFromFilters(metadata ?? void 0, filters);
+  if (resource === "threads") {
+    const threads = {
+      list: async () => (await inner.threads.list()).filter((thread) => matches(thread.metadata)),
+      get: async (threadId) => {
+        const thread = await inner.threads.get(threadId);
+        return thread && matches(thread.metadata) ? thread : null;
+      },
+      create: async (input) => {
+        if (input?.thread_id !== void 0) {
+          const existing = await inner.threads.get(input.thread_id);
+          if (existing && !matches(existing.metadata)) {
+            throw SkeinHttpError9.notFound(`Thread "${input.thread_id}" not found.`);
+          }
+        }
+        return inner.threads.create({ ...input, metadata: stamp(input?.metadata) });
+      },
+      update: async (threadId, patch) => {
+        const thread = await inner.threads.get(threadId);
+        if (!thread || !matches(thread.metadata)) {
+          throw SkeinHttpError9.notFound(`Thread "${threadId}" not found.`);
+        }
+        const next = patch.metadata !== void 0 ? { ...patch, metadata: stamp(patch.metadata) } : patch;
+        return inner.threads.update(threadId, next);
+      },
+      delete: async (threadId) => {
+        const thread = await inner.threads.get(threadId);
+        if (!thread || !matches(thread.metadata)) {
+          throw SkeinHttpError9.notFound(`Thread "${threadId}" not found.`);
+        }
+        return inner.threads.delete(threadId);
+      }
+    };
+    const runs = {
+      ...inner.runs,
+      get: async (runId) => {
+        const run = await inner.runs.get(runId);
+        return run && matches(run.metadata) ? run : null;
+      },
+      listByThread: async (threadId) => (await inner.runs.listByThread(threadId)).filter((run) => matches(run.metadata)),
+      create: (input) => inner.runs.create({ ...input, metadata: stamp(input.metadata) }),
+      setStatus: async (runId, status) => {
+        const run = await inner.runs.get(runId);
+        if (!run || !matches(run.metadata)) {
+          throw SkeinHttpError9.notFound(`Run "${runId}" not found.`);
+        }
+        return inner.runs.setStatus(runId, status);
+      },
+      delete: async (runId) => {
+        const run = await inner.runs.get(runId);
+        if (!run || !matches(run.metadata)) {
+          throw SkeinHttpError9.notFound(`Run "${runId}" not found.`);
+        }
+        return inner.runs.delete(runId);
+      }
+    };
+    return { ...inner, threads, runs };
+  }
+  return inner;
+}
+
+// src/auth/route-authz.ts
+var ROUTE_AUTHZ = {
+  // assistants
+  getAssistant: { resource: "assistants", action: "read" },
+  getAssistantSchemas: { resource: "assistants", action: "read" },
+  searchAssistants: { resource: "assistants", action: "search" },
+  // threads
+  createThread: { resource: "threads", action: "create" },
+  getThread: { resource: "threads", action: "read" },
+  getThreadState: { resource: "threads", action: "read" },
+  getThreadHistory: { resource: "threads", action: "read" },
+  listThreads: { resource: "threads", action: "search" },
+  patchThread: { resource: "threads", action: "update" },
+  deleteThread: { resource: "threads", action: "delete" },
+  // runs (authorized through the owning thread)
+  createWaitRun: { resource: "threads", action: "create_run" },
+  createStreamRun: { resource: "threads", action: "create_run" },
+  createBackgroundRun: { resource: "threads", action: "create_run" },
+  getRun: { resource: "threads", action: "read" },
+  listThreadRuns: { resource: "threads", action: "read" },
+  joinRunStream: { resource: "threads", action: "read" },
+  cancelRun: { resource: "threads", action: "update" },
+  deleteRun: { resource: "threads", action: "delete" },
+  // thread streaming / commands
+  postThreadStream: { resource: "threads", action: "create_run" },
+  getThreadStream: { resource: "threads", action: "read" },
+  postThreadCommands: { resource: "threads", action: "create_run" },
+  // store
+  putStoreItem: { resource: "store", action: "put" },
+  getStoreItem: { resource: "store", action: "get" },
+  deleteStoreItem: { resource: "store", action: "delete" },
+  searchStoreItems: { resource: "store", action: "search" },
+  listStoreNamespaces: { resource: "store", action: "list_namespaces" }
+};
+function authValue(req) {
+  const body = typeof req.body === "object" && req.body !== null ? req.body : {};
+  return { ...req.query, ...req.params, ...body };
+}
+var FRAMING_HEADERS = /* @__PURE__ */ new Set(["content-length", "transfer-encoding", "connection"]);
+function synthesizeRequest(req) {
+  const headers = new Headers();
+  for (const [name, value] of Object.entries(req.headers)) {
+    if (value !== void 0 && !FRAMING_HEADERS.has(name.toLowerCase())) headers.set(name, value);
+  }
+  const method = req.method.toUpperCase();
+  const carriesBody = method !== "GET" && method !== "HEAD" && req.body !== void 0;
+  return new Request(req.url, {
+    method,
+    headers,
+    body: carriesBody ? JSON.stringify(req.body) : void 0
+  });
+}
+
+// src/auth/authorizing-handlers.ts
+var STUDIO_USER = {
+  identity: "langgraph-studio-user",
+  display_name: "langgraph-studio-user",
+  is_authenticated: true,
+  permissions: []
+};
+function createAuthorizingHandlers(context, engine) {
+  const baseHandlers = createProtocolHandlers(buildProtocolService(context));
+  const names = Object.keys(baseHandlers);
+  const resolveAuthContext = async (req) => {
+    if (!engine.studioAuthDisabled && req.headers["x-auth-scheme"] === "langsmith") {
+      return { user: STUDIO_USER, scopes: [] };
+    }
+    return engine.authenticate(synthesizeRequest(req));
+  };
+  const wrapped = {};
+  for (const name of names) {
+    const route = ROUTE_AUTHZ[name];
+    wrapped[name] = async (req) => {
+      const authContext = await resolveAuthContext(req);
+      const { filters } = await engine.authorize({
+        resource: route.resource,
+        action: route.action,
+        value: authValue(req),
+        context: authContext
+      });
+      if (!filters) return baseHandlers[name](req);
+      const scopedStore = createAuthScopedStore(context.deps.store, engine, filters, route.resource);
+      const scopedContext = {
+        ...context,
+        deps: { ...context.deps, store: scopedStore }
+      };
+      return createProtocolHandlers(buildProtocolService(scopedContext))[name](req);
+    };
+  }
+  return wrapped;
+}
+
+// src/runs/run-worker.ts
+import { isTerminalRunStatus as isTerminalRunStatus6 } from "@skein-js/core";
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function createRunWorker(ctx, options = {}) {
+  const { deps, control } = ctx;
+  const maxConcurrency = options.maxConcurrency ?? 1;
+  const shutdownGraceMs = options.shutdownGraceMs ?? 5e3;
+  const inFlight = /* @__PURE__ */ new Set();
+  const process = async (queued) => {
+    const run = await deps.store.runs.get(queued.run_id);
+    if (!run || isTerminalRunStatus6(run.status)) return;
+    const kwargs = await deps.store.runs.getKwargs(queued.run_id) ?? {};
+    const runControl = control.register(queued.run_id);
+    inFlight.add(queued.run_id);
+    try {
+      await executeRun(deps, { run, kwargs, control: runControl });
+    } finally {
+      control.clear(queued.run_id);
+      inFlight.delete(queued.run_id);
+    }
+  };
+  let consumer;
+  return {
+    start() {
+      if (consumer) return;
+      consumer = deps.queue.consume(process, { concurrency: maxConcurrency });
+    },
+    async stop() {
+      if (!consumer) return;
+      const active = consumer;
+      consumer = void 0;
+      let drained = false;
+      const graceful = active.close().then(() => {
+        drained = true;
+      });
+      await Promise.race([graceful, sleep(shutdownGraceMs)]);
+      if (!drained) {
+        for (const runId of inFlight) control.abort(runId, "cancel");
+        await graceful;
+      }
+    }
+  };
+}
+
+// src/runtime.ts
+function createProtocolRuntime(deps, options = {}) {
+  const context = createContext(deps);
+  const service = buildProtocolService(context);
+  const handlers = deps.auth ? createAuthorizingHandlers(context, deps.auth) : createProtocolHandlers(service);
+  return {
+    service,
+    handlers,
+    worker: createRunWorker(context, options.worker)
+  };
+}
+export {
+  SSE_HEADERS,
+  SkeinBaseStore,
+  buildProtocolService,
+  createContext,
+  createProtocolHandlers,
+  createProtocolRuntime,
+  createProtocolService,
+  createRunWorker,
+  encodeFrame,
+  encodeTerminal,
+  parseAfterSeq,
+  toSseEvents
+};