@skein-js/express 0.4.0 → 0.6.3

package/dist/index.d.ts

@@ -1,45 +1,13 @@
-import { ProtocolRuntime, Logger, ProtocolDeps, ProtocolHandlers, ProtocolRequest, ProtocolResponse } from '@skein-js/agent-protocol';
-import { ModuleImporter } from '@skein-js/config';
-import { CorsOptions } from 'cors';
+import { ProtocolRuntime, Logger, ProtocolHandlers, ProtocolRequest, ProtocolResponse } from '@skein-js/agent-protocol';
+export { skeinRoutes } from '@skein-js/agent-protocol';
+import { SkeinRuntimeOptions } from '@skein-js/server-kit';
+export { DevStateCounts, DevStateSnapshot, InMemoryRuntimeConfig, LanggraphCorsConfig, ReloadableInMemoryRuntime, corsFromHttpConfig, describeSnapshot, loadInMemoryRuntime, loadReloadableInMemoryRuntime, loadSnapshotIntoStore, readLanggraphDevState, toCorsOptions } from '@skein-js/server-kit';
 import { Router, Express, Request, Response } from 'express';
 import { Server } from 'node:http';
-import { MemoryStoreSnapshot } from '@skein-js/storage-memory';
-import { BaseCheckpointSaver } from '@langchain/langgraph';
-import { SkeinStore } from '@skein-js/core';
+import { CorsOptions } from 'cors';
 
-interface SkeinRouterCommonOptions {
-    logger?: Logger;
-    /**
-     * Cross-origin access for browser clients (Agent Chat UI, React `useStream`). When omitted, CORS
-     * is driven by the config's `http.cors` block (LangGraph-compatible) and is otherwise **off** — we
-     * do not default to LangGraph's permissive `origin: "*"`. Set this to override: `CorsOptions` to
-     * restrict origins for `skein up`, `true` for permissive dev (reflect the request origin), or
-     * `false` to force it off. An explicit value wins over `http.cors`.
-     */
-    cors?: boolean | CorsOptions;
-    /**
-     * Eager-load every declared graph at boot instead of lazily on first request. `skein dev` sets
-     * this so (a) graph import errors surface at startup and (b) the graph source files enter the
-     * running process's module graph — which is what arms `tsx watch`'s hot reload (it only watches
-     * files that have actually been imported). Load failures are logged, not thrown, so one bad
-     * graph never takes the server down or breaks the watch loop.
-     */
-    warm?: boolean;
-}
 /** Either point at a `langgraph.json` (in-memory runtime) or inject a ready `ProtocolDeps`. */
-type SkeinRouterOptions = SkeinRouterCommonOptions & ({
-    config: string;
-    /**
-     * How graph modules are imported for the in-memory runtime. Defaults to a native
-     * dynamic `import()`; `skein dev` injects a vite-backed importer for TypeScript graphs.
-     */
-    importModule?: ModuleImporter;
-    deps?: never;
-} | {
-    deps: ProtocolDeps;
-    config?: never;
-    importModule?: never;
-});
+type SkeinRouterOptions = SkeinRuntimeOptions;
 interface SkeinRouter {
     /** Mount on an Express app: `app.use(router)`. */
     router: Router;
@@ -65,21 +33,6 @@ interface SkeinExpressServer {
 /** Build an Express server hosting the Agent Protocol, ready to `listen`. */
 declare function createExpressServer(options: SkeinRouterOptions): Promise<SkeinExpressServer>;
 
-type HttpMethod = "get" | "post" | "put" | "patch" | "delete";
-interface RouteBinding {
-    method: HttpMethod;
-    path: string;
-    handler: keyof ProtocolHandlers;
-    /**
-     * Fold the path `thread_id` into the request body before dispatch. The SDK addresses a
-     * thread-scoped run by its path (`POST /threads/{id}/runs/stream`) while carrying only
-     * `assistant_id` in the body, but the stateless run handlers read `thread_id` from the body — so a
-     * thread-scoped mount must copy it across, or the run would target a stray new thread.
-     */
-    foldThreadIdIntoBody?: boolean;
-}
-/** The route table, ordered most-specific-first within each method so literals win over params. */
-declare const skeinRoutes: readonly RouteBinding[];
 interface HandlerRouterOptions {
     /** Structured logger for unexpected (non-`SkeinHttpError`) faults. */
     logger?: Logger;
@@ -106,89 +59,4 @@ declare function sendProtocolResponse(response: ProtocolResponse, res: Response)
 /** Serialize a caught error onto `res`, using the protocol status when the error carries one. */
 declare function sendErrorResponse(error: unknown, res: Response, logger?: Logger): void;
 
-/** The checkpoint tuple `[checkpoint, metadata, parentId?]` with the blobs base64-encoded. */
-type SerializedCheckpointTuple = [string, string, string | undefined];
-/** `MemorySaver.storage` (thread → namespace → checkpointId → tuple) with blobs base64-encoded. */
-type SerializedCheckpointStorage = Record<string, Record<string, Record<string, SerializedCheckpointTuple>>>;
-/** `MemorySaver.writes` (key → taskId+idx → `[taskId, channel, blob]`) with the blob base64-encoded. */
-type SerializedCheckpointWrites = Record<string, Record<string, [string, string, string]>>;
-interface CheckpointerSnapshot {
-    storage: SerializedCheckpointStorage;
-    writes: SerializedCheckpointWrites;
-}
-/** A JSON-serializable snapshot of the whole in-memory dev runtime. */
-interface DevStateSnapshot {
-    version: 1;
-    store: MemoryStoreSnapshot;
-    checkpoints: CheckpointerSnapshot;
-}
-
-interface InMemoryRuntimeConfig {
-    /** In-memory `ProtocolDeps` (store, queue, bus, checkpointer) around the config's graphs. */
-    deps: ProtocolDeps;
-    /** CORS mapped from the config's `http.cors`, or `undefined` when none is declared. */
-    cors?: CorsOptions;
-}
-/** Load `langgraph.json`, wiring fresh in-memory drivers and reading its `http.cors` for the adapter. */
-declare function loadInMemoryRuntime(configPath: string, importModule?: ModuleImporter): Promise<InMemoryRuntimeConfig>;
-interface ReloadableInMemoryRuntime extends InMemoryRuntimeConfig {
-    /**
-     * Re-read the config and swap in freshly imported graphs, keeping the same drivers. Because the
-     * run engine calls `graphs.load()` per run (it never caches the compiled graph itself), the next
-     * run picks up the new code while every thread, run, checkpoint, and store item survives. This is
-     * what lets `skein dev` hot-reload graph source without dropping in-memory state.
-     */
-    reloadGraphs(): Promise<void>;
-    /** A JSON-serializable snapshot of all dev state (protocol store + checkpoints). */
-    snapshotState(): DevStateSnapshot;
-    /** Restore dev state from a {@link snapshotState} — call before the server starts serving. */
-    hydrateState(snapshot: DevStateSnapshot): void;
-}
-/**
- * Like {@link loadInMemoryRuntime}, but the returned `deps.graphs` delegates to a swappable config
- * registry so graphs can be reloaded in place, and it can snapshot/restore its dev state. `skein
- * dev` pairs this with vite's watcher (clear vite's cache, then `reloadGraphs()` — no server
- * restart, no lost state) and with on-disk JSON persistence across restarts.
- */
-declare function loadReloadableInMemoryRuntime(configPath: string, importModule?: ModuleImporter): Promise<ReloadableInMemoryRuntime>;
-
-/**
- * Read a LangGraph `.langgraph_api/` directory and reconstruct skein's `DevStateSnapshot`.
- * Returns `null` when the directory holds none of the expected files (nothing to import).
- */
-declare function readLanggraphDevState(langgraphApiDir: string): Promise<DevStateSnapshot | null>;
-/** Row/checkpoint counts in a snapshot, for CLI + log summaries. */
-interface DevStateCounts {
-    assistants: number;
-    threads: number;
-    runs: number;
-    items: number;
-    /** Threads that carry graph checkpoint history. */
-    checkpointedThreads: number;
-}
-declare function describeSnapshot(snapshot: DevStateSnapshot): DevStateCounts;
-/**
- * Load a `DevStateSnapshot` into a live store + checkpointer — the sink for importing into a real
- * skein deployment (e.g. Postgres). Resource rows go through the driver's `restore` (ids +
- * timestamps preserved, `ON CONFLICT DO NOTHING` so re-runs are safe); checkpoints — graph state +
- * full history — are copied via the public checkpointer API. Throws if the store can't bulk-restore
- * (both first-party drivers can); a custom driver must implement `restore` to be an import target.
- */
-declare function loadSnapshotIntoStore(snapshot: DevStateSnapshot, store: SkeinStore, checkpointer: BaseCheckpointSaver): Promise<void>;
-
-/** The `http.cors` block of a langgraph.json — LangGraph's field names (snake_case). */
-interface LanggraphCorsConfig {
-    allow_origins?: string[];
-    allow_origin_regex?: string;
-    allow_methods?: string[];
-    allow_headers?: string[];
-    allow_credentials?: boolean;
-    expose_headers?: string[];
-    max_age?: number;
-}
-/** Translate a LangGraph `http.cors` config into `cors` middleware options. */
-declare function toCorsOptions(config: LanggraphCorsConfig): CorsOptions;
-/** Read `http.cors` from a langgraph.json `http` block, mapped to `CorsOptions`, or `undefined`. */
-declare function corsFromHttpConfig(http: unknown): CorsOptions | undefined;
-
-export { type DevStateCounts, type DevStateSnapshot, type HandlerRouterOptions, type InMemoryRuntimeConfig, type LanggraphCorsConfig, type ReloadableInMemoryRuntime, type SkeinExpressServer, type SkeinRouter, type SkeinRouterOptions, corsFromHttpConfig, createExpressServer, createHandlerRouter, describeSnapshot, loadInMemoryRuntime, loadReloadableInMemoryRuntime, loadSnapshotIntoStore, readLanggraphDevState, sendErrorResponse, sendProtocolResponse, skeinRouter, skeinRoutes, toCorsOptions, toProtocolRequest };
+export { type HandlerRouterOptions, type SkeinExpressServer, type SkeinRouter, type SkeinRouterOptions, createExpressServer, createHandlerRouter, sendErrorResponse, sendProtocolResponse, skeinRouter, toProtocolRequest };

package/dist/index.js

@@ -1,158 +1,11 @@
 // src/skein-router.ts
-import {
-  createProtocolRuntime
-} from "@skein-js/agent-protocol";
-
-// src/in-memory-runtime.ts
-import { MemorySaver } from "@langchain/langgraph";
-import { loadAuthEngine, loadConfig } from "@skein-js/config";
-import { MemoryRunEventBus, MemoryRunQueue, MemorySkeinStore } from "@skein-js/storage-memory";
-
-// src/cors-config.ts
-var ALWAYS_EXPOSED_HEADERS = ["content-location", "x-pagination-total"];
-function toCorsOptions(config) {
-  const options = {};
-  const allowAll = config.allow_origins?.includes("*") ?? false;
-  if (config.allow_origin_regex !== void 0) {
-    const pattern = new RegExp(`^(?:${config.allow_origin_regex})$`);
-    const listed = allowAll ? void 0 : new Set(config.allow_origins);
-    options.origin = (origin, callback) => callback(
-      null,
-      origin !== void 0 && (allowAll || pattern.test(origin) || (listed?.has(origin) ?? false))
-    );
-  } else if (config.allow_origins !== void 0) {
-    options.origin = allowAll ? "*" : config.allow_origins;
-  }
-  if (config.allow_methods !== void 0) options.methods = config.allow_methods;
-  if (config.allow_headers !== void 0) options.allowedHeaders = config.allow_headers;
-  if (config.allow_credentials !== void 0) options.credentials = config.allow_credentials;
-  if (config.max_age !== void 0) options.maxAge = config.max_age;
-  const exposed = /* @__PURE__ */ new Set([...ALWAYS_EXPOSED_HEADERS, ...config.expose_headers ?? []]);
-  options.exposedHeaders = [...exposed];
-  return options;
-}
-function corsFromHttpConfig(http) {
-  if (typeof http !== "object" || http === null) return void 0;
-  const cors2 = http.cors;
-  if (typeof cors2 !== "object" || cors2 === null) return void 0;
-  return toCorsOptions(cors2);
-}
-
-// src/dev-persistence.ts
-var toBase64 = (bytes) => Buffer.from(bytes).toString("base64");
-var fromBase64 = (text) => new Uint8Array(Buffer.from(text, "base64"));
-var mapValues = (record, fn) => Object.fromEntries(Object.entries(record).map(([key, value]) => [key, fn(value)]));
-function snapshotCheckpointer(saver) {
-  return {
-    storage: mapValues(
-      saver.storage,
-      (namespaces) => mapValues(
-        namespaces,
-        (checkpoints) => mapValues(checkpoints, ([checkpoint, metadata, parentId]) => [
-          toBase64(checkpoint),
-          toBase64(metadata),
-          parentId
-        ])
-      )
-    ),
-    writes: mapValues(
-      saver.writes,
-      (taskWrites) => mapValues(taskWrites, ([taskId, channel, blob]) => [
-        taskId,
-        channel,
-        toBase64(blob)
-      ])
-    )
-  };
-}
-function hydrateCheckpointer(saver, snapshot) {
-  saver.storage = mapValues(
-    snapshot.storage,
-    (namespaces) => mapValues(
-      namespaces,
-      (checkpoints) => mapValues(
-        checkpoints,
-        ([checkpoint, metadata, parentId]) => [
-          fromBase64(checkpoint),
-          fromBase64(metadata),
-          parentId
-        ]
-      )
-    )
-  );
-  saver.writes = mapValues(
-    snapshot.writes,
-    (taskWrites) => mapValues(taskWrites, ([taskId, channel, blob]) => [
-      taskId,
-      channel,
-      fromBase64(blob)
-    ])
-  );
-}
-
-// src/in-memory-runtime.ts
-function toGraphResolver(graphs) {
-  return {
-    ids: graphs.ids,
-    load: (graphId) => graphs.load(graphId),
-    schemas: async (graphId) => await graphs.schemas(graphId)
-  };
-}
-function buildInMemoryDeps(graphs) {
-  return {
-    store: new MemorySkeinStore(),
-    graphs,
-    queue: new MemoryRunQueue(),
-    bus: new MemoryRunEventBus(),
-    checkpointer: new MemorySaver()
-  };
-}
-async function loadInMemoryRuntime(configPath, importModule) {
-  const { graphs, config, configDir } = await loadConfig({ configPath, importModule });
-  const deps = buildInMemoryDeps(toGraphResolver(graphs));
-  deps.auth = await loadAuthEngine(config.auth, { configDir, importModule });
-  return {
-    deps,
-    cors: corsFromHttpConfig(config.http)
-  };
-}
-async function loadReloadableInMemoryRuntime(configPath, importModule) {
-  const first = await loadConfig({ configPath, importModule });
-  let current = first.graphs;
-  const graphs = {
-    ids: first.graphs.ids,
-    load: (graphId) => current.load(graphId),
-    schemas: async (graphId) => await current.schemas(graphId)
-  };
-  const store = new MemorySkeinStore();
-  const checkpointer = new MemorySaver();
-  const deps = {
-    store,
-    graphs,
-    queue: new MemoryRunQueue(),
-    bus: new MemoryRunEventBus(),
-    checkpointer,
-    auth: await loadAuthEngine(first.config.auth, { configDir: first.configDir, importModule })
-  };
-  return {
-    deps,
-    cors: corsFromHttpConfig(first.config.http),
-    reloadGraphs: async () => {
-      current = (await loadConfig({ configPath, importModule })).graphs;
-    },
-    snapshotState: () => ({
-      version: 1,
-      store: store.snapshot(),
-      checkpoints: snapshotCheckpointer(checkpointer)
-    }),
-    hydrateState: (snapshot) => {
-      store.hydrate(snapshot.store);
-      hydrateCheckpointer(checkpointer, snapshot.checkpoints);
-    }
-  };
-}
+import { resolveProtocolRuntime } from "@skein-js/server-kit";
 
 // src/routes.ts
+import {
+  foldThreadId,
+  skeinRoutes
+} from "@skein-js/agent-protocol";
 import cors from "cors";
 import express from "express";
 
@@ -245,59 +98,7 @@ function toProtocolRequest(req) {
 }
 
 // src/routes.ts
-var skeinRoutes = [
-  // assistants
-  { method: "get", path: "/assistants/:assistant_id/schemas", handler: "getAssistantSchemas" },
-  { method: "get", path: "/assistants/:assistant_id", handler: "getAssistant" },
-  { method: "post", path: "/assistants/search", handler: "searchAssistants" },
-  // threads
-  { method: "post", path: "/threads/search", handler: "listThreads" },
-  { method: "post", path: "/threads", handler: "createThread" },
-  { method: "post", path: "/threads/:thread_id/copy", handler: "copyThread" },
-  { method: "get", path: "/threads/:thread_id", handler: "getThread" },
-  { method: "patch", path: "/threads/:thread_id", handler: "patchThread" },
-  { method: "delete", path: "/threads/:thread_id", handler: "deleteThread" },
-  { method: "get", path: "/threads/:thread_id/state", handler: "getThreadState" },
-  { method: "post", path: "/threads/:thread_id/history", handler: "getThreadHistory" },
-  // runs — the stateless handlers are reused on the thread-scoped path with the id folded in
-  { method: "post", path: "/runs/wait", handler: "createWaitRun" },
-  { method: "post", path: "/runs/stream", handler: "createStreamRun" },
-  {
-    method: "post",
-    path: "/threads/:thread_id/runs/wait",
-    handler: "createWaitRun",
-    foldThreadIdIntoBody: true
-  },
-  {
-    method: "post",
-    path: "/threads/:thread_id/runs/stream",
-    handler: "createStreamRun",
-    foldThreadIdIntoBody: true
-  },
-  { method: "post", path: "/threads/:thread_id/runs", handler: "createBackgroundRun" },
-  { method: "get", path: "/threads/:thread_id/runs", handler: "listThreadRuns" },
-  { method: "post", path: "/threads/:thread_id/runs/:run_id/cancel", handler: "cancelRun" },
-  { method: "get", path: "/threads/:thread_id/runs/:run_id/stream", handler: "joinRunStream" },
-  { method: "get", path: "/threads/:thread_id/runs/:run_id", handler: "getRun" },
-  { method: "delete", path: "/threads/:thread_id/runs/:run_id", handler: "deleteRun" },
-  { method: "get", path: "/runs/:run_id/stream", handler: "joinRunStream" },
-  // thread streaming / commands
-  { method: "post", path: "/threads/:thread_id/stream", handler: "postThreadStream" },
-  { method: "get", path: "/threads/:thread_id/stream", handler: "getThreadStream" },
-  { method: "post", path: "/threads/:thread_id/commands", handler: "postThreadCommands" },
-  // store
-  { method: "put", path: "/store/items", handler: "putStoreItem" },
-  { method: "get", path: "/store/items", handler: "getStoreItem" },
-  { method: "delete", path: "/store/items", handler: "deleteStoreItem" },
-  { method: "post", path: "/store/items/search", handler: "searchStoreItems" },
-  { method: "post", path: "/store/namespaces", handler: "listStoreNamespaces" }
-];
-function foldThreadId(request) {
-  const threadId = request.params["thread_id"];
-  if (threadId === void 0) return request;
-  const base = typeof request.body === "object" && request.body !== null && !Array.isArray(request.body) ? request.body : {};
-  return { ...request, body: { ...base, thread_id: threadId } };
-}
+import { skeinRoutes as skeinRoutes2 } from "@skein-js/agent-protocol";
 function createHandlerRouter(handlers, options = {}) {
   const router = express.Router();
   if (options.cors) router.use(cors(options.cors === true ? { origin: true } : options.cors));
@@ -321,31 +122,11 @@ function createHandlerRouter(handlers, options = {}) {
 
 // src/skein-router.ts
 async function skeinRouter(options) {
-  let deps;
-  let corsFromConfig;
-  if (options.deps) {
-    deps = options.deps;
-  } else {
-    const loaded = await loadInMemoryRuntime(options.config, options.importModule);
-    deps = loaded.deps;
-    corsFromConfig = loaded.cors;
-  }
-  const runtime = createProtocolRuntime(deps);
-  await runtime.service.assistants.registerGraphAssistants();
-  if (options.warm) {
-    await Promise.all(
-      deps.graphs.ids.map(
-        (graphId) => deps.graphs.load(graphId).catch((error) => {
-          options.logger?.warn(`Failed to warm graph "${graphId}".`, error);
-        })
-      )
-    );
-  }
-  runtime.worker.start();
+  const { runtime, cors: cors2 } = await resolveProtocolRuntime(options);
   const router = createHandlerRouter(runtime.handlers, {
     logger: options.logger,
     // Explicit option wins; otherwise fall back to the config's `http.cors`, else off.
-    cors: options.cors ?? corsFromConfig ?? false
+    cors: options.cors ?? cors2 ?? false
   });
   return { router, runtime };
 }
@@ -399,252 +180,16 @@ async function createExpressServer(options) {
   };
 }
 
-// src/langgraph-import.ts
-import { readFile } from "fs/promises";
-import path from "path";
-import {
-  MemorySaver as MemorySaver2
-} from "@langchain/langgraph";
+// src/index.ts
 import {
-  isTerminalRunStatus
-} from "@skein-js/core";
-import { SuperJSON } from "superjson";
-import { z } from "zod";
-var OPS_FILE = ".langgraphjs_ops.json";
-var STORE_FILE = ".langgraphjs_api.store.json";
-var CHECKPOINTER_FILE = ".langgraphjs_api.checkpointer.json";
-var langgraphSuperjson = new SuperJSON();
-langgraphSuperjson.registerCustom(
-  {
-    isApplicable: (value) => value instanceof Uint8Array,
-    serialize: (value) => Buffer.from(value).toString("base64"),
-    deserialize: (value) => new Uint8Array(Buffer.from(value, "base64"))
-  },
-  "Uint8Array"
-);
-var timestamp = z.union([z.date(), z.string()]).optional();
-var jsonObject = z.record(z.unknown());
-var langgraphAssistantSchema = z.object({
-  assistant_id: z.string(),
-  graph_id: z.string(),
-  name: z.string().optional(),
-  description: z.string().nullish(),
-  config: jsonObject.optional(),
-  context: z.unknown().optional(),
-  metadata: jsonObject.optional(),
-  version: z.number().optional(),
-  created_at: timestamp,
-  updated_at: timestamp
-}).passthrough();
-var langgraphThreadSchema = z.object({
-  thread_id: z.string(),
-  status: z.string().optional(),
-  metadata: jsonObject.optional(),
-  values: jsonObject.optional(),
-  interrupts: jsonObject.optional(),
-  created_at: timestamp,
-  updated_at: timestamp
-}).passthrough();
-var langgraphRunSchema = z.object({
-  run_id: z.string(),
-  thread_id: z.string(),
-  assistant_id: z.string(),
-  status: z.string().optional(),
-  metadata: jsonObject.optional(),
-  multitask_strategy: z.string().nullish(),
-  kwargs: jsonObject.optional(),
-  created_at: timestamp,
-  updated_at: timestamp
-}).passthrough();
-var langgraphOpsSchema = z.object({
-  assistants: z.record(langgraphAssistantSchema).optional(),
-  threads: z.record(langgraphThreadSchema).optional(),
-  runs: z.record(langgraphRunSchema).optional()
-}).passthrough();
-var langgraphStoreItemSchema = z.object({
-  namespace: z.array(z.string()),
-  key: z.string(),
-  value: jsonObject,
-  createdAt: timestamp,
-  updatedAt: timestamp
-}).passthrough();
-var langgraphStoreFileSchema = z.object({ data: z.map(z.string(), z.map(z.string(), langgraphStoreItemSchema)).optional() }).passthrough();
-var langgraphCheckpointerSchema = z.object({ storage: jsonObject, writes: jsonObject }).passthrough();
-async function readSuperjsonFile(filepath) {
-  let text;
-  try {
-    text = await readFile(filepath, "utf8");
-  } catch {
-    return null;
-  }
-  try {
-    return langgraphSuperjson.parse(text) ?? null;
-  } catch (error) {
-    throw new Error(
-      `Could not parse LangGraph state file "${filepath}": ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}
-function validateShape(schema, value, label) {
-  const result = schema.safeParse(value);
-  if (!result.success) {
-    const detail = result.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
-    throw new Error(`Invalid LangGraph ${label}: ${detail}`);
-  }
-  return result.data;
-}
-function toIso(value, fallback) {
-  if (value instanceof Date) return value.toISOString();
-  if (typeof value === "string") return value;
-  return fallback;
-}
-function toAssistant(row, now) {
-  return {
-    assistant_id: row.assistant_id,
-    graph_id: row.graph_id,
-    name: row.name ?? row.graph_id,
-    description: row.description ?? void 0,
-    config: row.config ?? {},
-    context: row.context ?? {},
-    metadata: row.metadata ?? {},
-    version: row.version ?? 1,
-    created_at: toIso(row.created_at, now),
-    updated_at: toIso(row.updated_at, now)
-  };
-}
-function toThread(row, now) {
-  const createdAt = toIso(row.created_at, now);
-  const updatedAt = toIso(row.updated_at, createdAt);
-  return {
-    thread_id: row.thread_id,
-    status: row.status ?? "idle",
-    metadata: row.metadata ?? {},
-    values: row.values ?? {},
-    interrupts: row.interrupts ?? {},
-    created_at: createdAt,
-    updated_at: updatedAt,
-    state_updated_at: updatedAt
-  };
-}
-function toRun(row, now) {
-  const createdAt = toIso(row.created_at, now);
-  const status = row.status ?? "success";
-  return {
-    run_id: row.run_id,
-    thread_id: row.thread_id,
-    assistant_id: row.assistant_id,
-    status: isTerminalRunStatus(status) ? status : "error",
-    metadata: row.metadata ?? {},
-    multitask_strategy: row.multitask_strategy ?? null,
-    created_at: createdAt,
-    updated_at: toIso(row.updated_at, createdAt)
-  };
-}
-function toRunKwargs(kwargs) {
-  if (!kwargs) return {};
-  const { input, command, config, context, stream_mode, interrupt_before, interrupt_after } = kwargs;
-  return { input, command, config, context, stream_mode, interrupt_before, interrupt_after };
-}
-async function readLanggraphDevState(langgraphApiDir) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const [opsRaw, storeRaw, checkpointerRaw] = await Promise.all([
-    readSuperjsonFile(path.join(langgraphApiDir, OPS_FILE)),
-    readSuperjsonFile(path.join(langgraphApiDir, STORE_FILE)),
-    readSuperjsonFile(path.join(langgraphApiDir, CHECKPOINTER_FILE))
-  ]);
-  if (!opsRaw && !storeRaw && !checkpointerRaw) return null;
-  const ops = opsRaw ? validateShape(langgraphOpsSchema, opsRaw, OPS_FILE) : null;
-  const storeFile = storeRaw ? validateShape(langgraphStoreFileSchema, storeRaw, STORE_FILE) : null;
-  const checkpointerFile = checkpointerRaw ? validateShape(langgraphCheckpointerSchema, checkpointerRaw, CHECKPOINTER_FILE) : null;
-  const runEntries = Object.entries(ops?.runs ?? {});
-  const items = [];
-  if (storeFile?.data) {
-    for (const namespaceItems of storeFile.data.values()) {
-      for (const stored of namespaceItems.values()) {
-        const item = {
-          namespace: stored.namespace,
-          key: stored.key,
-          value: stored.value,
-          createdAt: toIso(stored.createdAt, now),
-          updatedAt: toIso(stored.updatedAt, now)
-        };
-        items.push([JSON.stringify([stored.namespace, stored.key]), item]);
-      }
-    }
-  }
-  const store = {
-    assistants: Object.entries(ops?.assistants ?? {}).map(([id, row]) => [
-      id,
-      toAssistant(row, now)
-    ]),
-    threads: Object.entries(ops?.threads ?? {}).map(([id, row]) => [id, toThread(row, now)]),
-    runs: runEntries.map(([id, row]) => [id, toRun(row, now)]),
-    runKwargs: runEntries.map(([id, row]) => [id, toRunKwargs(row.kwargs)]),
-    items
-  };
-  let checkpoints = { storage: {}, writes: {} };
-  if (checkpointerFile) {
-    const saver = new MemorySaver2();
-    saver.storage = checkpointerFile.storage;
-    saver.writes = checkpointerFile.writes;
-    checkpoints = snapshotCheckpointer(saver);
-  }
-  return { version: 1, store, checkpoints };
-}
-function describeSnapshot(snapshot) {
-  return {
-    assistants: snapshot.store.assistants.length,
-    threads: snapshot.store.threads.length,
-    runs: snapshot.store.runs.length,
-    items: snapshot.store.items.length,
-    checkpointedThreads: Object.keys(snapshot.checkpoints.storage).length
-  };
-}
-function supportsRestore(store) {
-  return typeof store.restore === "function";
-}
-async function copyCheckpoints(snapshot, target) {
-  const source = new MemorySaver2();
-  hydrateCheckpointer(source, snapshot);
-  const tuples = [];
-  for await (const tuple of source.list({})) tuples.push(tuple);
-  tuples.reverse();
-  for (const tuple of tuples) {
-    const configurable = tuple.config.configurable ?? {};
-    const putConfig = {
-      configurable: {
-        thread_id: configurable.thread_id,
-        checkpoint_ns: configurable.checkpoint_ns ?? "",
-        // `put` reads `checkpoint_id` as the PARENT pointer; the child's own id is `checkpoint.id`.
-        checkpoint_id: tuple.parentConfig?.configurable?.checkpoint_id
-      }
-    };
-    const stored = await target.put(
-      putConfig,
-      tuple.checkpoint,
-      tuple.metadata ?? {},
-      tuple.checkpoint.channel_versions ?? {}
-    );
-    const writesByTask = /* @__PURE__ */ new Map();
-    for (const [taskId, channel, value] of tuple.pendingWrites ?? []) {
-      const writes = writesByTask.get(taskId) ?? [];
-      writes.push([channel, value]);
-      writesByTask.set(taskId, writes);
-    }
-    for (const [taskId, writes] of writesByTask) {
-      await target.putWrites(stored, writes, taskId);
-    }
-  }
-}
-async function loadSnapshotIntoStore(snapshot, store, checkpointer) {
-  if (!supportsRestore(store)) {
-    throw new Error(
-      "Target store does not support bulk import (no restore() method). Use the in-memory or Postgres driver, or implement restore() on your SkeinStore."
-    );
-  }
-  await store.restore(snapshot.store);
-  await copyCheckpoints(snapshot.checkpoints, checkpointer);
-}
+  loadInMemoryRuntime,
+  loadReloadableInMemoryRuntime,
+  readLanggraphDevState,
+  loadSnapshotIntoStore,
+  describeSnapshot,
+  corsFromHttpConfig,
+  toCorsOptions
+} from "@skein-js/server-kit";
 export {
   corsFromHttpConfig,
   createExpressServer,
@@ -657,7 +202,7 @@ export {
   sendErrorResponse,
   sendProtocolResponse,
   skeinRouter,
-  skeinRoutes,
+  skeinRoutes2 as skeinRoutes,
   toCorsOptions,
   toProtocolRequest
 };

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@skein-js/express",
-  "version": "0.4.0",
+  "version": "0.6.3",
   "description": "Express adapter for skein-js — mount the Agent Protocol on an Express Router.",
   "license": "Apache-2.0",
   "author": "Maina Wycliffe <wmmaina7@gmail.com>",
-  "homepage": "https://github.com/mainawycliffe/skein-js/tree/main/packages/server-express#readme",
+  "homepage": "https://github.com/skein-js/skein-js/tree/main/packages/server-express#readme",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/mainawycliffe/skein-js.git",
+    "url": "git+https://github.com/skein-js/skein-js.git",
     "directory": "packages/server-express"
   },
   "bugs": {
-    "url": "https://github.com/mainawycliffe/skein-js/issues"
+    "url": "https://github.com/skein-js/skein-js/issues"
   },
   "keywords": [
     "typescript",
@@ -41,12 +41,10 @@
   },
   "dependencies": {
     "cors": "^2.8.5",
-    "superjson": "^2.2.6",
-    "zod": "^3.25.76",
-    "@skein-js/agent-protocol": "0.4.0",
-    "@skein-js/config": "0.4.0",
-    "@skein-js/storage-memory": "0.4.0",
-    "@skein-js/core": "0.4.0"
+    "@skein-js/agent-protocol": "0.6.3",
+    "@skein-js/config": "0.6.3",
+    "@skein-js/server-kit": "0.6.3",
+    "@skein-js/core": "0.6.3"
   },
   "peerDependencies": {
     "@langchain/langgraph": "^1.4.0",
@@ -57,7 +55,8 @@
     "@langchain/langgraph": "^1.4.0",
     "@types/cors": "^2.8.17",
     "@types/express": "^5.0.0",
-    "express": "^5.2.1"
+    "express": "^5.2.1",
+    "@skein-js/storage-memory": "0.6.3"
   },
   "publishConfig": {
     "access": "public"