@skein-js/server-kit 0.11.2 → 0.12.0

package/dist/dev.js

@@ -0,0 +1,303 @@
+import {
+  hydrateCheckpointer,
+  snapshotCheckpointer
+} from "./chunk-JUBBCC7R.js";
+
+// src/langgraph-import.ts
+import { readFile } from "fs/promises";
+import path from "path";
+import {
+  MemorySaver
+} from "@langchain/langgraph";
+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 langgraphAssistantVersionSchema = z.object({
+  assistant_id: z.string(),
+  version: z.number(),
+  graph_id: z.string(),
+  name: z.string().optional(),
+  description: z.string().nullish(),
+  config: jsonObject.optional(),
+  context: z.unknown().optional(),
+  metadata: jsonObject.optional(),
+  created_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(),
+  assistant_versions: z.array(langgraphAssistantVersionSchema).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 toAssistantVersion(row, now) {
+  return {
+    assistant_id: row.assistant_id,
+    version: row.version,
+    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 ?? {},
+    created_at: toIso(row.created_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,
+    webhook
+  } = kwargs;
+  return {
+    input,
+    command,
+    config,
+    context,
+    stream_mode,
+    interrupt_before,
+    interrupt_after,
+    ...typeof webhook === "string" ? { webhook } : {}
+  };
+}
+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)
+    ]),
+    assistantVersions: (ops?.assistant_versions ?? []).map((row) => [
+      JSON.stringify([row.assistant_id, row.version]),
+      toAssistantVersion(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 MemorySaver();
+    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 MemorySaver();
+  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);
+}
+export {
+  describeSnapshot,
+  loadSnapshotIntoStore,
+  readLanggraphDevState
+};

package/dist/in-memory-runtime-32UYJRVJ.js

@@ -0,0 +1,9 @@
+import {
+  loadInMemoryRuntime,
+  loadReloadableInMemoryRuntime
+} from "./chunk-QOHYARHD.js";
+import "./chunk-JUBBCC7R.js";
+export {
+  loadInMemoryRuntime,
+  loadReloadableInMemoryRuntime
+};