@kiwa-test/agent 0.2.0

package/README.md

@@ -0,0 +1,133 @@
+# @kiwa-test/agent
+
+Agent orchestration mock harness for kiwa — LangGraph 型 state machine + OpenAI Assistants v2 の 1 統一 API。
+
+LangGraph は agent graph の DSL、 OpenAI Assistants v2 は stateful conversation + run status polling model。 本 package は kiwa test で real LangGraph runtime / real OpenAI API を叩かずに agent orchestration chain を組み立てるための in-process implementation を提供する。
+
+- `StateGraph` — LangGraph 型 API (`addNode` + `addEdge` + `compile` → `invoke` / `stream`)
+- `StateMachine` — 低水準 state graph 実行 engine、 `StateGraph` の backing store
+- `AssistantsClient` — Assistants v2 mock (`createAssistant` + `createThread` + `addMessage` + `createRun` + `poll` + `submitToolOutputs`)
+- deterministic id 発行 (`idSeed` 指定で snapshot test 可)、 6 compile validation + max steps guard で runaway loop 遮断
+
+## Usage — LangGraph 型 state machine
+
+```ts
+import { END, START, StateGraph } from '@kiwa-test/agent';
+
+interface ChatState {
+  messages: string[];
+  intent: string | null;
+  reply: string | null;
+}
+
+const graph = new StateGraph<ChatState>()
+  .addNode('classify', (s) => ({
+    intent: s.messages[0]?.startsWith('/help') ? 'help' : 'chat',
+  }))
+  .addNode('answer', (s) => ({
+    reply: s.intent === 'help' ? 'help: A, B, C' : `chat: ${s.messages[0]}`,
+  }))
+  .addEdge(START, 'classify')
+  .addEdge('classify', 'answer')
+  .addEdge('answer', END);
+
+const compiled = graph.compile();
+const final = await compiled.invoke({ messages: ['/help me'], intent: null, reply: null });
+// final.intent === 'help'
+// final.reply === 'help: A, B, C'
+
+// stream で中間 state を順次観測
+for await (const step of compiled.stream({ messages: ['hi'], intent: null, reply: null })) {
+  console.log(step.node, step.patch);
+}
+```
+
+## Usage — OpenAI Assistants v2
+
+```ts
+import { AssistantsClient, toolCall } from '@kiwa-test/agent';
+
+const client = new AssistantsClient({ idSeed: 'demo' });
+
+const assistant = client.createAssistant({
+  name: 'weather-agent',
+  instructions: 'answer weather with the weather tool',
+  handler: async (ctx) => {
+    if (ctx.toolOutputs === undefined) {
+      return {
+        kind: 'tool_calls',
+        toolCalls: [toolCall({ id: 'c1', name: 'weather', arguments: { city: 'tokyo' } })],
+      };
+    }
+    return { kind: 'message', content: `weather: ${ctx.toolOutputs[0]?.output}` };
+  },
+});
+
+const thread = client.createThread({ messages: [{ role: 'user', content: 'weather in tokyo?' }] });
+const run = client.createRun({ threadId: thread.id, assistantId: assistant.id });
+
+const step1 = await client.poll(run.id);
+// step1.status === 'requires_action'
+// step1.requiredAction.toolCalls === [ { id: 'c1', function: { name: 'weather', arguments: '{"city":"tokyo"}' }, ... } ]
+
+client.submitToolOutputs(run.id, {
+  toolOutputs: [{ toolCallId: 'c1', output: 'sunny 22C' }],
+});
+
+const step2 = await client.poll(run.id);
+// step2.status === 'completed'
+// thread.messages.at(-1) === { role: 'assistant', content: 'weather: sunny 22C' }
+```
+
+## LangGraph → real 対応表
+
+| real LangGraph API | kiwa mock 対応 |
+|---|---|
+| `new StateGraph(channels)` | `new StateGraph<TState>()` (v0.1 は shallow merge) |
+| `graph.addNode(name, fn)` | `graph.addNode(name, handler)` |
+| `graph.addEdge(from, to)` | `graph.addEdge(from, to)` (unconditional) |
+| `graph.setEntryPoint(name)` | `graph.addEdge(START, name)` に統一 |
+| `graph.setFinishPoint(name)` | `graph.addEdge(name, END)` に統一 |
+| `graph.compile()` | `graph.compile()` → `CompiledGraph` |
+| `compiled.invoke(state)` | `compiled.invoke(state)` |
+| `compiled.stream(state)` | `compiled.stream(state)` async generator |
+
+## Assistants v2 → real 対応表
+
+| real Assistants v2 API | kiwa mock 対応 |
+|---|---|
+| `openai.beta.assistants.create` | `client.createAssistant({ name, instructions, handler })` |
+| `openai.beta.threads.create` | `client.createThread({ messages? })` |
+| `openai.beta.threads.messages.create` | `client.addMessage(threadId, { role, content })` |
+| `openai.beta.threads.runs.create` | `client.createRun({ threadId, assistantId })` |
+| `openai.beta.threads.runs.retrieve` | `client.poll(runId)` |
+| `openai.beta.threads.runs.submitToolOutputs` | `client.submitToolOutputs(runId, { toolOutputs })` |
+| `openai.beta.threads.runs.cancel` | `client.cancel(runId)` |
+
+## Run status transition
+
+1. `createRun()` → status = **queued**
+2. 1 回目の `poll()` → handler を呼び、 結果に応じて
+   - `{ kind: 'message' }` → **completed** + assistant message を thread に append
+   - `{ kind: 'tool_calls' }` → **requires_action** + pending tool_calls を保持
+   - handler が throw → **failed** + lastError = { code: 'handler_error', message }
+3. **requires_action** 中に `submitToolOutputs()` → **queued** に戻し、 次 `poll()` で handler 再呼出 (context.toolOutputs で結果参照可能)
+4. `cancel()` → queued / requires_action / in_progress を **failed** に倒す (lastError.code = 'cancelled')
+
+## Compile validation (6 項目、 fail-fast)
+
+1. START edge が最低 1 本存在する
+2. START edge の to が存在する node (or END)
+3. 全 edge の to が存在する node (or END)
+4. 全 edge の from が存在する node (or START)
+5. 全 node に out-edge が最低 1 本存在する
+6. START edge は 1 本のみ
+
+## 未対応 (v0.2 以降)
+
+- LangGraph — `addConditionalEdges` / `channels` reducer / `interrupt` / `checkpointer`
+- Assistants v2 — vector store / `file_search` / `code_interpreter` / streaming (SSE)
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,536 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AssistantsClient: () => AssistantsClient,
+  CompiledGraph: () => CompiledGraph,
+  DEFAULT_MAX_STEPS: () => DEFAULT_MAX_STEPS,
+  END: () => END,
+  GraphCompileError: () => GraphCompileError,
+  MaxStepsExceededError: () => MaxStepsExceededError,
+  START: () => START,
+  StateGraph: () => StateGraph,
+  StateMachine: () => StateMachine,
+  toolCall: () => toolCall
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var END = "__end__";
+var START = "__start__";
+
+// src/state-machine.ts
+var DEFAULT_MAX_STEPS = 100;
+var GraphCompileError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GraphCompileError";
+  }
+};
+var MaxStepsExceededError = class extends Error {
+  steps;
+  constructor(steps) {
+    super(`state machine exceeded max steps: ${steps}`);
+    this.name = "MaxStepsExceededError";
+    this.steps = steps;
+  }
+};
+var StateMachine = class {
+  nodes = /* @__PURE__ */ new Map();
+  edges = [];
+  compiled = false;
+  /** node を登録。 同名 node は上書きする。 */
+  addNode(name, handler) {
+    if (!name || name.trim() === "") {
+      throw new GraphCompileError("node name must be a non-empty string");
+    }
+    if (name === START || name === END) {
+      throw new GraphCompileError(`node name "${name}" is reserved`);
+    }
+    this.nodes.set(name, handler);
+    this.compiled = false;
+    return this;
+  }
+  /** edge を追加。 from / to は node 名 or START / END sentinel。 */
+  addEdge(from, to) {
+    if (!from || !to) {
+      throw new GraphCompileError("edge from/to must be non-empty strings");
+    }
+    this.edges.push({ from, to });
+    this.compiled = false;
+    return this;
+  }
+  /** node 数 (test / debug 用)。 */
+  get nodeCount() {
+    return this.nodes.size;
+  }
+  /** edge 数 (test / debug 用)。 */
+  get edgeCount() {
+    return this.edges.length;
+  }
+  /** compile 済かどうか (test / debug 用)。 */
+  get isCompiled() {
+    return this.compiled;
+  }
+  /**
+   * validate + compile — validate 6 項目を fail-fast で確認、 pass なら
+   * `compiled = true` を立てて invoke / stream 可能状態にする。
+   */
+  compile() {
+    const startEdges = this.edges.filter((e) => e.from === START);
+    if (startEdges.length === 0) {
+      throw new GraphCompileError(
+        'graph has no START edge \u2014 addEdge(START, "first_node") is required'
+      );
+    }
+    if (startEdges.length > 1) {
+      throw new GraphCompileError(
+        `graph has ${startEdges.length} START edges \u2014 v0.1 supports only 1 entry`
+      );
+    }
+    const startTo = startEdges[0].to;
+    if (startTo !== END && !this.nodes.has(startTo)) {
+      throw new GraphCompileError(`START edge targets unknown node: ${startTo}`);
+    }
+    const nodesWithOutEdge = /* @__PURE__ */ new Set();
+    for (const edge of this.edges) {
+      if (edge.from !== START && !this.nodes.has(edge.from)) {
+        throw new GraphCompileError(`edge.from references unknown node: ${edge.from}`);
+      }
+      if (edge.to !== END && !this.nodes.has(edge.to)) {
+        throw new GraphCompileError(`edge.to references unknown node: ${edge.to}`);
+      }
+      if (edge.from !== START) {
+        nodesWithOutEdge.add(edge.from);
+      }
+    }
+    for (const nodeName of this.nodes.keys()) {
+      if (!nodesWithOutEdge.has(nodeName)) {
+        throw new GraphCompileError(
+          `node "${nodeName}" has no outgoing edge \u2014 every node must connect to at least END`
+        );
+      }
+    }
+    this.compiled = true;
+    return this;
+  }
+  /**
+   * invoke — 初期 state から実行、 END に到達した final state を返す。 compile
+   * 未実施なら throw。
+   */
+  async invoke(initialState, options = {}) {
+    let last = initialState;
+    for await (const step of this.stream(initialState, options)) {
+      last = step.state;
+    }
+    return last;
+  }
+  /**
+   * stream — 各 node 実行後の {node, patch, state} を順次 yield。 END に到達した
+   * 時点で generator は終了する。
+   */
+  async *stream(initialState, options = {}) {
+    if (!this.compiled) {
+      throw new GraphCompileError("state machine not compiled \u2014 call compile() before invoke/stream");
+    }
+    const maxSteps = options.maxSteps ?? DEFAULT_MAX_STEPS;
+    let currentState = { ...initialState };
+    let currentNode = this.startNode();
+    let stepCount = 0;
+    while (currentNode !== END) {
+      stepCount += 1;
+      if (stepCount > maxSteps) {
+        throw new MaxStepsExceededError(stepCount);
+      }
+      const handler = this.nodes.get(currentNode);
+      if (!handler) {
+        throw new GraphCompileError(`runtime: node not found: ${currentNode}`);
+      }
+      const patch = await handler(currentState);
+      currentState = { ...currentState, ...patch };
+      yield { node: currentNode, patch, state: currentState };
+      const next = this.nextNode(currentNode);
+      if (next === void 0) {
+        throw new GraphCompileError(`runtime: no outgoing edge from node: ${currentNode}`);
+      }
+      currentNode = next;
+    }
+  }
+  startNode() {
+    const startEdge = this.edges.find((e) => e.from === START);
+    return startEdge.to;
+  }
+  nextNode(from) {
+    const edge = this.edges.find((e) => e.from === from);
+    return edge?.to;
+  }
+};
+
+// src/langgraph.ts
+var StateGraph = class {
+  machine = new StateMachine();
+  /** node を追加。 handler は現 state から partial state を返す (同期 / 非同期両対応)。 */
+  addNode(name, handler) {
+    this.machine.addNode(name, handler);
+    return this;
+  }
+  /**
+   * edge を追加。 `from` は node 名 or `START`、 `to` は node 名 or `END`。
+   * v0.1 は unconditional edge のみ (conditional_edges は v0.2)。
+   */
+  addEdge(from, to) {
+    this.machine.addEdge(from, to);
+    return this;
+  }
+  /** compile + validate、 CompiledGraph を返す。 */
+  compile() {
+    this.machine.compile();
+    return new CompiledGraph(this.machine);
+  }
+  /** node 数 (test / debug 用)。 */
+  get nodeCount() {
+    return this.machine.nodeCount;
+  }
+  /** edge 数 (test / debug 用)。 */
+  get edgeCount() {
+    return this.machine.edgeCount;
+  }
+};
+var CompiledGraph = class {
+  constructor(machine) {
+    this.machine = machine;
+  }
+  machine;
+  /**
+   * invoke — 初期 state から実行し END 到達時の final state を返す。 中間 step
+   * を捨てて final だけ欲しい場合の shortcut。
+   */
+  async invoke(initialState, options) {
+    return this.machine.invoke(initialState, options);
+  }
+  /**
+   * stream — 各 node 実行後の GraphStep (node 名 + patch + merge 後 state) を
+   * 順次 yield。 END 到達時点で generator 終了。 real LangGraph の `stream()`
+   * (default mode = "values") に整合。
+   */
+  async *stream(initialState, options) {
+    for await (const step of this.machine.stream(initialState, options)) {
+      yield step;
+    }
+  }
+};
+
+// src/openai-assistants.ts
+var AssistantsClient = class {
+  assistants = /* @__PURE__ */ new Map();
+  threads = /* @__PURE__ */ new Map();
+  runs = /* @__PURE__ */ new Map();
+  handlers = /* @__PURE__ */ new Map();
+  nextId = 1;
+  idSeed;
+  constructor(config = {}) {
+    this.idSeed = config.idSeed ?? "kiwa";
+  }
+  // ---- Assistant CRUD ------------------------------------------------
+  /**
+   * Assistant resource を発行。 real API と同じく id + name + instructions を持つ。
+   * handler は必須ではないが、 createRun() までに registerHandler() で紐付け必要。
+   */
+  createAssistant(params) {
+    const id = this.mintId("asst");
+    const assistant = {
+      id,
+      name: params.name,
+      instructions: params.instructions,
+      createdAt: Date.now()
+    };
+    this.assistants.set(id, assistant);
+    if (params.handler) {
+      this.handlers.set(id, params.handler);
+    }
+    return assistant;
+  }
+  /**
+   * assistant に handler を後付け登録。 test で「先に assistant を作って後で handler
+   * を差し替える」 シナリオ (behavior injection) 用。
+   */
+  registerHandler(assistantId, handler) {
+    if (!this.assistants.has(assistantId)) {
+      throw new Error(`unknown assistant id: ${assistantId}`);
+    }
+    this.handlers.set(assistantId, handler);
+  }
+  /** assistant 参照 (test / debug 用)。 */
+  getAssistant(id) {
+    return this.assistants.get(id);
+  }
+  // ---- Thread CRUD ---------------------------------------------------
+  /**
+   * Thread resource を発行。 初期 messages を渡すと user message として append される
+   * (real API と同じ挙動)。
+   */
+  createThread(params = {}) {
+    const id = this.mintId("thread");
+    const thread = {
+      id,
+      createdAt: Date.now(),
+      messages: []
+    };
+    this.threads.set(id, thread);
+    if (params.messages) {
+      for (const m of params.messages) {
+        this.addMessage(id, { role: m.role, content: m.content });
+      }
+    }
+    return thread;
+  }
+  /**
+   * Thread に message を append。 real API と同じく role は user / assistant、
+   * v0.1 は tool role 未対応 (Assistants v2 の tool message は submitToolOutputs
+   * 経路に統一)。
+   */
+  addMessage(threadId, params) {
+    const thread = this.threads.get(threadId);
+    if (!thread) {
+      throw new Error(`unknown thread id: ${threadId}`);
+    }
+    const message = {
+      id: this.mintId("msg"),
+      role: params.role,
+      content: params.content,
+      createdAt: Date.now()
+    };
+    thread.messages.push(message);
+    return message;
+  }
+  /** thread 参照 (test / debug 用、 messages は readonly view として返す)。 */
+  getThread(id) {
+    return this.threads.get(id);
+  }
+  // ---- Run lifecycle -------------------------------------------------
+  /**
+   * Run 発行 — thread + assistant を紐付けた Run resource (queued) を返す。 実際の
+   * assistant 実行は `poll(runId)` を呼び出した時に走る (real API の polling model と
+   * 同構造、 real でも create 直後は queued で 1 tick 後に進行する)。
+   */
+  createRun(params) {
+    if (!this.threads.has(params.threadId)) {
+      throw new Error(`unknown thread id: ${params.threadId}`);
+    }
+    if (!this.assistants.has(params.assistantId)) {
+      throw new Error(`unknown assistant id: ${params.assistantId}`);
+    }
+    if (!this.handlers.has(params.assistantId)) {
+      throw new Error(
+        `assistant ${params.assistantId} has no handler registered \u2014 call registerHandler() first`
+      );
+    }
+    const id = this.mintId("run");
+    const run = {
+      id,
+      threadId: params.threadId,
+      assistantId: params.assistantId,
+      status: "queued",
+      createdAt: Date.now()
+    };
+    this.runs.set(id, run);
+    return run;
+  }
+  /**
+   * poll — Run の 1 tick を進める。 real API polling は同じ retrieveRun で status
+   * を確認する model、 mock は「poll 呼出 = 1 tick 進行」 と扱う。 呼出後の Run
+   * (copy) を返す。 呼出前 status に応じて next status が deterministic に決まる。
+   *
+   * 1. queued → poll 1 回目で handler 呼出、 result に応じて completed / requires_action / failed
+   * 2. in_progress → poll 呼出でも遷移しない (v0.1 は 1 tick = 1 handler 呼出 model、
+   *    in_progress は queued → completed の間の transient state として使用しない)、
+   *    そのまま返す。 実質 queued と completed / requires_action / failed の 3 状態が
+   *    caller に見える。
+   * 3. requires_action → poll でも遷移しない (submitToolOutputs 待ち)
+   * 4. completed / failed → 変化なし、 そのまま返す
+   */
+  async poll(runId) {
+    const run = this.runs.get(runId);
+    if (!run) {
+      throw new Error(`unknown run id: ${runId}`);
+    }
+    if (run.status !== "queued") {
+      return { ...run };
+    }
+    return this.executeRun(run);
+  }
+  /**
+   * pollUntilFinal — completed / failed / requires_action に到達するまで poll を
+   * 繰り返す utility。 requires_action は「final ではない」 が「client 側 action 待ち」
+   * なので、 これも終端扱いで返す (client 側で submitToolOutputs → 再度 pollUntilFinal
+   * を呼ぶ想定)。 real API では intervalMs で backoff するが、 mock は同期実行のため
+   * poll = 1 tick 進行 model で maxAttempts のみ意味を持つ。
+   */
+  async pollUntilFinal(runId, options = {}) {
+    const maxAttempts = options.maxAttempts ?? 20;
+    let attempts = 0;
+    let run = await this.poll(runId);
+    while (run.status === "queued" || run.status === "in_progress") {
+      attempts += 1;
+      if (attempts > maxAttempts) {
+        throw new Error(`pollUntilFinal exceeded ${maxAttempts} attempts for run ${runId}`);
+      }
+      run = await this.poll(runId);
+    }
+    return run;
+  }
+  /**
+   * submitToolOutputs — requires_action 中の Run に tool 実行結果を差し込む。 status
+   * を queued に戻し、 次 poll で handler が再度呼び出される (context.toolOutputs
+   * で結果参照可能)。 real API と同じ semantic。
+   */
+  submitToolOutputs(runId, params) {
+    const run = this.runs.get(runId);
+    if (!run) {
+      throw new Error(`unknown run id: ${runId}`);
+    }
+    if (run.status !== "requires_action") {
+      throw new Error(
+        `run ${runId} is not requires_action (current: ${run.status}), cannot submit tool outputs`
+      );
+    }
+    const { requiredAction: _dropped, ...rest } = run;
+    void _dropped;
+    const updated = {
+      ...rest,
+      status: "queued"
+    };
+    this.runs.set(runId, updated);
+    this.pendingToolOutputs.set(runId, params.toolOutputs);
+    return { ...updated };
+  }
+  /**
+   * cancel — queued / in_progress の Run を強制終了させる。 status は failed に倒す
+   * (real API は cancelled status を持つが v0.1 は failed に統合、 lastError.code =
+   * 'cancelled' で識別可能)。
+   */
+  cancel(runId) {
+    const run = this.runs.get(runId);
+    if (!run) {
+      throw new Error(`unknown run id: ${runId}`);
+    }
+    if (run.status === "completed" || run.status === "failed") {
+      return { ...run };
+    }
+    const { requiredAction: _dropped, ...rest } = run;
+    void _dropped;
+    const updated = {
+      ...rest,
+      status: "failed",
+      failedAt: Date.now(),
+      lastError: { code: "cancelled", message: "run cancelled by client" }
+    };
+    this.runs.set(runId, updated);
+    return { ...updated };
+  }
+  /** run 参照 (test / debug 用)。 */
+  getRun(id) {
+    const run = this.runs.get(id);
+    return run ? { ...run } : void 0;
+  }
+  // ---- internal helpers ----------------------------------------------
+  pendingToolOutputs = /* @__PURE__ */ new Map();
+  async executeRun(run) {
+    const thread = this.threads.get(run.threadId);
+    const handler = this.handlers.get(run.assistantId);
+    if (!thread || !handler) {
+      throw new Error(`run ${run.id} references missing thread or handler`);
+    }
+    const toolOutputs = this.pendingToolOutputs.get(run.id);
+    let result;
+    try {
+      const ctx = toolOutputs !== void 0 ? {
+        thread: [...thread.messages],
+        runId: run.id,
+        assistantId: run.assistantId,
+        toolOutputs
+      } : {
+        thread: [...thread.messages],
+        runId: run.id,
+        assistantId: run.assistantId
+      };
+      result = await handler(ctx);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const updated2 = {
+        ...run,
+        status: "failed",
+        failedAt: Date.now(),
+        lastError: { code: "handler_error", message }
+      };
+      this.runs.set(run.id, updated2);
+      this.pendingToolOutputs.delete(run.id);
+      return { ...updated2 };
+    }
+    this.pendingToolOutputs.delete(run.id);
+    if (result.kind === "message") {
+      this.addMessage(run.threadId, { role: "assistant", content: result.content });
+      const updated2 = {
+        ...run,
+        status: "completed",
+        completedAt: Date.now()
+      };
+      this.runs.set(run.id, updated2);
+      return { ...updated2 };
+    }
+    const updated = {
+      ...run,
+      status: "requires_action",
+      requiredAction: { type: "submit_tool_outputs", toolCalls: result.toolCalls }
+    };
+    this.runs.set(run.id, updated);
+    return { ...updated };
+  }
+  mintId(kind) {
+    const id = `${this.idSeed}_${kind}_${this.nextId}`;
+    this.nextId += 1;
+    return id;
+  }
+};
+function toolCall(params) {
+  return {
+    id: params.id,
+    type: "function",
+    function: {
+      name: params.name,
+      arguments: JSON.stringify(params.arguments)
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AssistantsClient,
+  CompiledGraph,
+  DEFAULT_MAX_STEPS,
+  END,
+  GraphCompileError,
+  MaxStepsExceededError,
+  START,
+  StateGraph,
+  StateMachine,
+  toolCall
+});
+//# sourceMappingURL=index.cjs.map