agent-scene-toolkit 0.1.0

package/README.md

@@ -0,0 +1,135 @@
+# agent-scene-toolkit
+
+Lightweight Agent orchestration library built on LangChain, with unified SSE streaming.
+
+> **3 分钟上手**：定义 Profile → 定义 ToolKit → 创建 Agent → 对话。
+
+## ✨ Features
+
+- **ToolKit**（静态能力包）：按领域分组的工具集 + 使用策略 Prompt
+- **Profile**（角色身份）：只需定义 name + systemPrompt + model
+- **Scene**（运行时上下文）：注入动态业务状态 + 工具集过滤
+- **单/多 Agent 自动切换**：配置 `supervisor` 即启用多 Agent 协作
+- **标准化 SSE 事件流**：`text` / `tool_start` / `tool_end` / `handoff` / `agent` / `error` / `done`
+- **Express 一行集成**：`app.post('/chat', agent.handleRequest())`
+
+## 📦 Install
+
+```bash
+npm install agent-scene-toolkit @langchain/core @langchain/langgraph @langchain/openai langchain express
+```
+
+## 🚀 Quick Start
+
+```typescript
+import { createAgent, defineProfile, defineToolKit, defineScene } from 'agent-scene-toolkit'
+
+// 1. 定义能力包
+const canvasToolKit = defineToolKit({
+  name: 'canvas',
+  tools: [bindElementTool],
+  prompt: '画面调整时优先使用 canvas 工具...',
+})
+
+// 2. 定义角色
+const director = defineProfile({
+  name: '导演',
+  systemPrompt: '你是一位视频导演...',
+  model: 'gpt-4o',
+})
+
+// 3. 定义场景
+const timelineScene = defineScene({
+  name: 'timeline-editing',
+  toolkits: ['canvas'],
+  prompt: (ctx) => `视频时长: ${ctx.duration}秒`,
+})
+
+// 4. 创建 Agent
+const agent = createAgent({
+  toolkits: [canvasToolKit],
+  agents: [director],
+  scene: timelineScene,
+  llm: { baseURL: 'https://api.openai.com/v1', apiKey: 'sk-xxx' },
+})
+
+// 5. 发起对话
+for await (const event of agent.chat({ message: '你好', threadId: 'thread-001' })) {
+  console.log(event)
+}
+```
+
+## 🤝 Multi-Agent
+
+配置 `supervisor` 后自动启用 Supervisor 策略：
+
+```typescript
+const agent = createAgent({
+  toolkits: [canvasToolKit, aiToolKit],
+  agents: [director, screenwriter],
+  supervisor: '导演', // ← 指定 Supervisor
+  llm: { baseURL: 'https://api.openai.com/v1', apiKey: 'sk-xxx' },
+})
+```
+
+## 🌐 Express Integration
+
+```typescript
+import express from 'express'
+
+const app = express()
+app.use(express.json())
+app.post('/chat', agent.handleRequest())
+```
+
+## 📡 SSE Event Protocol
+
+| Event | Trigger | Payload |
+|-------|---------|---------|
+| `text` | LLM outputs text token | `{ content: string }` |
+| `tool_start` | Tool call begins | `{ toolName: string, input: Record<string, any> }` |
+| `tool_end` | Tool call ends | `{ toolName: string, output: any }` |
+| `handoff` | Agent switch (multi-agent) | `{ from: string, to: string }` |
+| `agent` | Current answering agent | `{ name: string }` |
+| `error` | Execution error | `{ message: string }` |
+| `done` | Stream ends | `{}` |
+
+## ⚙️ Full Configuration
+
+```typescript
+const agent = createAgent({
+  toolkits: [canvasToolKit, aiToolKit],   // Global toolkit pool
+  agents: [director],                      // Agent profiles
+  supervisor: '导演',                      // Optional: enables multi-agent
+  scene: timelineScene,                    // Optional: runtime context + tool filtering
+  checkpointer: new MemorySaver(),         // Optional: memory persistence
+  maxMessages: 50,                         // Optional: sliding window size
+  callbacks: [langfuseHandler],            // Optional: LangChain callbacks (e.g. LangFuse)
+  llm: {                                  // Optional: OpenAI-compatible gateway
+    baseURL: 'https://api.openai.com/v1',
+    apiKey: 'sk-xxx',
+  },
+})
+```
+
+## 📖 API Documentation
+
+```bash
+npm run docs
+```
+
+Generates TypeDoc documentation from TSDoc comments.
+
+## 🛠️ Development
+
+```bash
+npm run build      # Build ESM + CJS + .d.ts
+npm run dev        # Watch mode
+npm run typecheck  # Type check
+npm run playground # Launch debug playground
+```
+
+## 📄 License
+
+MIT © [Lootoe](https://github.com/Lootoe)
+

package/dist/index.cjs

@@ -0,0 +1,570 @@
+'use strict';
+
+var langgraph = require('@langchain/langgraph');
+var openai = require('@langchain/openai');
+var langchain = require('langchain');
+var messages = require('@langchain/core/messages');
+var prebuilt = require('@langchain/langgraph/prebuilt');
+var langgraphSupervisor = require('@langchain/langgraph-supervisor');
+
+// src/profile.ts
+function defineProfile(input) {
+  if (!input.name) throw new Error("Profile name is required");
+  if (!input.systemPrompt) throw new Error("Profile systemPrompt is required");
+  if (!input.model) throw new Error("Profile model is required");
+  return Object.freeze({ ...input });
+}
+
+// src/toolkit.ts
+function defineToolKit(input) {
+  if (!input.name) throw new Error("ToolKit name is required");
+  if (!input.tools?.length) throw new Error("ToolKit tools must not be empty");
+  if (!input.prompt) throw new Error("ToolKit prompt is required");
+  return Object.freeze({ ...input });
+}
+
+// src/scene.ts
+function defineScene(input) {
+  if (!input.name) throw new Error("Scene name is required");
+  if (!input.toolkits?.length) throw new Error("Scene toolkits must not be empty");
+  if (typeof input.prompt !== "function") throw new Error("Scene prompt must be a function");
+  return Object.freeze({ ...input });
+}
+
+// src/prompt.ts
+var BASE_PROMPT = `You are an autonomous AI agent. You can reason, plan, and take actions using the tools available to you.
+
+## Core Behavior
+- When given a task, break it down into steps, then execute each step using the appropriate tools.
+- After each tool call, observe the result and decide the next action. Continue until the task is fully completed.
+- If no tools are needed, respond directly with your knowledge.
+- Never fabricate uncertain information. If you cannot complete a task, explain why honestly.
+
+## Rules
+- Respond in the same language as the user.
+- Follow tool parameter schemas strictly \u2014 do not invent or omit required fields.
+- When multiple tools are available, choose the most relevant one for the current step.`;
+function buildPromptChain(params) {
+  const layers = [
+    // ① Base — 库内置固定指令
+    BASE_PROMPT,
+    // ② Profile — 角色身份提示词
+    params.profile.systemPrompt,
+    // ③ ToolKit — 当前场景激活的能力包提示词
+    ...params.toolkitPrompts
+  ];
+  if (params.scene) {
+    try {
+      const scenePrompt = params.scene.prompt(params.sceneContext ?? {});
+      layers.push(scenePrompt);
+    } catch (error) {
+      console.error("[buildPromptChain] Scene.prompt() error:", error);
+      layers.push(`[Scene context unavailable due to error: ${error instanceof Error ? error.message : String(error)}]`);
+    }
+  }
+  return layers.filter(Boolean).join("\n\n");
+}
+async function buildSingleGraph(params) {
+  const hasCallbacks = params.callbacks.length > 0;
+  const callbacksOrUndefined = hasCallbacks ? params.callbacks : void 0;
+  let llm;
+  try {
+    llm = new openai.ChatOpenAI({
+      model: params.model,
+      apiKey: params.llm?.apiKey,
+      configuration: params.llm?.baseURL ? { baseURL: params.llm.baseURL } : void 0,
+      // LLM 层透传 callbacks — 追踪 LLM 调用本身
+      callbacks: callbacksOrUndefined
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error("[buildSingleGraph] LLM initialization failed:", message);
+    throw new Error(`Failed to initialize LLM: ${message}`);
+  }
+  console.log("[buildSingleGraph] systemPrompt:", JSON.stringify(params.systemPrompt));
+  console.log("[buildSingleGraph] model:", params.model);
+  console.log("[buildSingleGraph] tools:", params.tools.map((t) => t.name));
+  console.log("[buildSingleGraph] threadId:", params.threadId);
+  console.log("[buildSingleGraph] maxMessages:", params.maxMessages);
+  let graph;
+  try {
+    graph = langchain.createAgent({
+      model: llm,
+      tools: params.tools,
+      checkpointer: params.checkpointer,
+      systemPrompt: params.systemPrompt,
+      // 滑动窗口中间件 — beforeModel 阶段裁剪消息，Checkpointer 仍全量存储
+      middleware: [
+        langchain.createMiddleware({
+          name: "sliding-window",
+          beforeModel: (state) => {
+            try {
+              const max = params.maxMessages;
+              if (!state.messages || state.messages.length <= max) return void 0;
+              return { messages: state.messages.slice(-max) };
+            } catch (error) {
+              console.error("[buildSingleGraph] sliding-window middleware error:", error);
+              return void 0;
+            }
+          }
+        })
+      ]
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error("[buildSingleGraph] Graph creation failed:", message);
+    throw new Error(`Failed to create agent graph: ${message}`);
+  }
+  try {
+    return graph.stream(
+      { messages: [new messages.HumanMessage(params.message)] },
+      {
+        configurable: { thread_id: params.threadId },
+        recursionLimit: 25,
+        streamMode: ["messages", "updates"],
+        // graph 层透传 callbacks — 追踪完整执行链路（工具调用、节点跳转等）
+        callbacks: callbacksOrUndefined
+      }
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error("[buildSingleGraph] Stream initialization failed:", message);
+    throw new Error(`Failed to start agent stream: ${message}`);
+  }
+}
+async function buildSupervisorGraph(params) {
+  const hasCallbacks = params.callbacks.length > 0;
+  const callbacksOrUndefined = hasCallbacks ? params.callbacks : void 0;
+  const workerProfiles = params.agents.filter((profile) => profile.name !== params.supervisorName);
+  const workers = [];
+  const failedWorkers = [];
+  for (const profile of workerProfiles) {
+    try {
+      const workerLLM = new openai.ChatOpenAI({
+        model: profile.model,
+        apiKey: params.llm?.apiKey,
+        configuration: params.llm?.baseURL ? { baseURL: params.llm.baseURL } : void 0,
+        callbacks: callbacksOrUndefined
+      });
+      const workerPrompt = params.workerPrompts.get(profile.name) ?? profile.systemPrompt;
+      const worker = prebuilt.createReactAgent({
+        llm: workerLLM,
+        tools: params.tools,
+        name: profile.name,
+        prompt: workerPrompt
+      });
+      workers.push(worker);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`[buildSupervisorGraph] Failed to create worker "${profile.name}":`, message);
+      failedWorkers.push(profile.name);
+    }
+  }
+  if (workers.length === 0) {
+    throw new Error(
+      `Failed to create any workers. All ${workerProfiles.length} workers failed: ${failedWorkers.join(", ")}`
+    );
+  }
+  if (failedWorkers.length > 0) {
+    console.warn(
+      `[buildSupervisorGraph] ${failedWorkers.length} worker(s) failed to initialize: ${failedWorkers.join(", ")}`
+    );
+  }
+  const supervisorProfile = params.agents.find((p) => p.name === params.supervisorName);
+  let supervisorLLM;
+  try {
+    supervisorLLM = new openai.ChatOpenAI({
+      model: supervisorProfile.model,
+      apiKey: params.llm?.apiKey,
+      configuration: params.llm?.baseURL ? { baseURL: params.llm.baseURL } : void 0,
+      callbacks: callbacksOrUndefined
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error("[buildSupervisorGraph] Supervisor LLM initialization failed:", message);
+    throw new Error(`Failed to initialize Supervisor LLM: ${message}`);
+  }
+  console.log("[buildSupervisorGraph] supervisor:", params.supervisorName);
+  console.log("[buildSupervisorGraph] workers:", workers.map((_, i) => workerProfiles[i]?.name));
+  console.log("[buildSupervisorGraph] tools:", params.tools.map((t) => t.name));
+  console.log("[buildSupervisorGraph] threadId:", params.threadId);
+  let workflow;
+  try {
+    workflow = langgraphSupervisor.createSupervisor({
+      agents: workers,
+      llm: supervisorLLM,
+      prompt: params.supervisorPrompt,
+      // 保留完整消息历史，让前端能追踪 handoff 过程
+      outputMode: "full_history",
+      // 滑动窗口 — 只裁剪发给 LLM 的消息，Checkpointer 仍全量存储
+      // 与 single.ts 的 createMiddleware.beforeModel 策略一致
+      preModelHook: (state) => {
+        try {
+          const max = params.maxMessages;
+          if (!state.messages || state.messages.length <= max) {
+            return { llmInputMessages: state.messages || [] };
+          }
+          return { llmInputMessages: state.messages.slice(-max) };
+        } catch (error) {
+          console.error("[buildSupervisorGraph] sliding-window preModelHook error:", error);
+          return { llmInputMessages: state.messages || [] };
+        }
+      }
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error("[buildSupervisorGraph] Supervisor workflow creation failed:", message);
+    throw new Error(`Failed to create supervisor workflow: ${message}`);
+  }
+  let graph;
+  try {
+    graph = workflow.compile({
+      checkpointer: params.checkpointer
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error("[buildSupervisorGraph] Graph compilation failed:", message);
+    throw new Error(`Failed to compile supervisor graph: ${message}`);
+  }
+  try {
+    return graph.stream(
+      { messages: [new messages.HumanMessage(params.message)] },
+      {
+        configurable: { thread_id: params.threadId },
+        recursionLimit: 50,
+        // 多 Agent 需要更高的递归限制
+        streamMode: ["messages", "updates"],
+        callbacks: callbacksOrUndefined
+      }
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error("[buildSupervisorGraph] Stream initialization failed:", message);
+    throw new Error(`Failed to start supervisor stream: ${message}`);
+  }
+}
+async function* transformStream(stream, onToolEnd) {
+  let currentAgentName = null;
+  for await (const chunk of stream) {
+    let events;
+    let detectedAgent;
+    try {
+      const result = parseStreamChunk(chunk, currentAgentName);
+      events = result.events;
+      detectedAgent = result.detectedAgent;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("[transformStream] Failed to parse chunk:", message, chunk);
+      continue;
+    }
+    if (detectedAgent && detectedAgent !== currentAgentName) {
+      if (currentAgentName) {
+        yield { type: "handoff", from: currentAgentName, to: detectedAgent };
+      }
+      yield { type: "agent", name: detectedAgent };
+      currentAgentName = detectedAgent;
+    }
+    for (const event of events) {
+      yield event;
+      if (event.type === "tool_end" && onToolEnd) {
+        try {
+          onToolEnd(event.toolName, event.output);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          console.error(`[transformStream] Scene.onToolEnd("${event.toolName}") error:`, message);
+        }
+      }
+    }
+  }
+}
+function parseStreamChunk(chunk, currentAgentName) {
+  const events = [];
+  let detectedAgent = null;
+  if (!Array.isArray(chunk) || chunk.length !== 2) return { events, detectedAgent };
+  const [mode, data] = chunk;
+  if (mode === "messages") {
+    const [message, metadata] = data;
+    if (metadata?.langgraph_node && typeof metadata.langgraph_node === "string") {
+      const nodeName = metadata.langgraph_node;
+      if (nodeName !== "tools" && !nodeName.startsWith("__")) {
+        detectedAgent = nodeName;
+      }
+    }
+    if (messages.isAIMessageChunk(message)) {
+      const aiChunk = message;
+      if (aiChunk.tool_call_chunks && aiChunk.tool_call_chunks.length > 0) {
+        for (const toolChunk of aiChunk.tool_call_chunks) {
+          if (toolChunk.name) {
+            events.push({
+              type: "tool_start",
+              toolName: toolChunk.name,
+              input: {}
+            });
+          }
+        }
+      }
+      const content = typeof aiChunk.content === "string" ? aiChunk.content : "";
+      if (content) {
+        events.push({ type: "text", content });
+      }
+    }
+  }
+  if (mode === "updates") {
+    if (data && typeof data === "object") {
+      const nodeData = data;
+      for (const [nodeName, nodeOutput] of Object.entries(nodeData)) {
+        if (nodeOutput?.messages) {
+          const toolMessages = nodeOutput.messages;
+          for (const msg of toolMessages) {
+            if (msg instanceof messages.ToolMessage) {
+              events.push({
+                type: "tool_end",
+                toolName: msg.name ?? "unknown",
+                output: safeParseJSON(
+                  typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+                )
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  return { events, detectedAgent };
+}
+function safeParseJSON(str) {
+  try {
+    return JSON.parse(str);
+  } catch {
+    return str;
+  }
+}
+function formatSSE(event) {
+  return `data: ${JSON.stringify(event)}
+
+`;
+}
+
+// src/middleware.ts
+function writeSSEHeaders(res) {
+  res.status(200);
+  res.setHeader("Content-Type", "text/event-stream; charset=utf-8");
+  res.setHeader("Cache-Control", "no-cache, no-transform");
+  res.setHeader("Connection", "keep-alive");
+  res.setHeader("X-Accel-Buffering", "no");
+  res.flushHeaders?.();
+}
+function parseChatOptions(req) {
+  const body = req.body ?? {};
+  return {
+    message: typeof body.message === "string" ? body.message : "",
+    threadId: typeof body.threadId === "string" ? body.threadId : "",
+    sceneContext: body.sceneContext
+  };
+}
+function createExpressHandler(agent) {
+  return async (req, res) => {
+    try {
+      writeSSEHeaders(res);
+    } catch (error) {
+      console.error("[createExpressHandler] Failed to write SSE headers:", error);
+      if (!res.headersSent) {
+        res.status(500).json({ error: "Failed to initialize SSE stream" });
+      }
+      return;
+    }
+    const safeWrite = (event) => {
+      try {
+        return res.write(formatSSE(event));
+      } catch (error) {
+        console.error("[createExpressHandler] Failed to write SSE event:", error);
+        return false;
+      }
+    };
+    try {
+      const chatOptions = parseChatOptions(req);
+      for await (const event of agent.chat(chatOptions)) {
+        const success = safeWrite(event);
+        if (!success && event.type !== "done") {
+          console.warn("[createExpressHandler] Client disconnected, stopping stream");
+          break;
+        }
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("[createExpressHandler] Stream error:", message);
+      safeWrite({ type: "error", message });
+      safeWrite({ type: "done" });
+    } finally {
+      try {
+        res.end();
+      } catch (error) {
+        console.error("[createExpressHandler] Failed to end response:", error);
+      }
+    }
+  };
+}
+
+// src/agent.ts
+var Agent = class {
+  /** @internal */
+  options;
+  constructor(options) {
+    this.options = {
+      maxMessages: 50,
+      callbacks: [],
+      checkpointer: new langgraph.MemorySaver(),
+      ...options
+    };
+    this.validate();
+  }
+  /**
+   * 发起对话，返回标准化 SSE 事件的异步生成器。
+   *
+   * 完整流程：
+   * 1. ToolKit 过滤（Scene.toolkits 决定）
+   * 2. Prompt 4 层拼接（Base → Profile → ToolKit → Scene）
+   * 3. 构建 LangGraph 图 + stream
+   * 4. 转换流事件 → 标准化 SSEEvent
+   *
+   * 任何异常均以 `error` + `done` 事件正常结束流，不崩溃。
+   *
+   * @param chatOptions - 对话参数
+   * @yields 标准化 SSE 事件序列
+   */
+  async *chat(chatOptions) {
+    try {
+      if (!chatOptions.message) {
+        yield { type: "error", message: "message is required" };
+        yield { type: "done" };
+        return;
+      }
+      if (!chatOptions.threadId) {
+        yield { type: "error", message: "threadId is required" };
+        yield { type: "done" };
+        return;
+      }
+      const scene = this.options.scene;
+      const activeToolkits = scene ? this.options.toolkits.filter((tk) => scene.toolkits.includes(tk.name)) : this.options.toolkits;
+      const tools = activeToolkits.flatMap((tk) => tk.tools);
+      const toolkitPrompts = activeToolkits.map((tk) => tk.prompt);
+      const isMultiAgent = this.options.agents.length > 1 && !!this.options.supervisor;
+      let stream;
+      if (isMultiAgent) {
+        const supervisorProfile = this.options.agents.find(
+          (a) => a.name === this.options.supervisor
+        );
+        const supervisorPrompt = buildPromptChain({
+          profile: supervisorProfile,
+          toolkitPrompts,
+          scene,
+          sceneContext: chatOptions.sceneContext
+        });
+        const workerPrompts = /* @__PURE__ */ new Map();
+        for (const profile of this.options.agents) {
+          if (profile.name !== this.options.supervisor) {
+            workerPrompts.set(
+              profile.name,
+              buildPromptChain({
+                profile,
+                toolkitPrompts,
+                scene,
+                sceneContext: chatOptions.sceneContext
+              })
+            );
+          }
+        }
+        stream = await buildSupervisorGraph({
+          supervisorPrompt,
+          agents: this.options.agents,
+          supervisorName: this.options.supervisor,
+          tools,
+          workerPrompts,
+          message: chatOptions.message,
+          threadId: chatOptions.threadId,
+          checkpointer: this.options.checkpointer,
+          maxMessages: this.options.maxMessages,
+          callbacks: this.options.callbacks,
+          llm: this.options.llm
+        });
+      } else {
+        const profile = this.options.agents[0];
+        const systemPrompt = buildPromptChain({
+          profile,
+          toolkitPrompts,
+          scene,
+          sceneContext: chatOptions.sceneContext
+        });
+        stream = await buildSingleGraph({
+          systemPrompt,
+          tools,
+          model: profile.model,
+          message: chatOptions.message,
+          threadId: chatOptions.threadId,
+          checkpointer: this.options.checkpointer,
+          maxMessages: this.options.maxMessages,
+          callbacks: this.options.callbacks,
+          llm: this.options.llm
+        });
+      }
+      yield* transformStream(stream, scene?.onToolEnd);
+      yield { type: "done" };
+    } catch (err) {
+      const message = err instanceof Error ? `${err.message}${err.cause ? ` | cause: ${err.cause}` : ""}${err.stack ? `
+${err.stack}` : ""}` : String(err);
+      console.error("[agent.chat] error:", message);
+      yield { type: "error", message };
+      yield { type: "done" };
+    }
+  }
+  /**
+   * 返回 Express RequestHandler，直接用于路由挂载。
+   *
+   * @example
+   * ```ts
+   * app.post('/chat', agent.handleRequest())
+   * ```
+   */
+  handleRequest() {
+    return createExpressHandler(this);
+  }
+  /**
+   * 参数校验 — 在构造时执行，快速失败。
+   */
+  validate() {
+    if (!this.options.agents.length) {
+      throw new Error("At least one agent is required");
+    }
+    if (this.options.supervisor) {
+      const found = this.options.agents.find((a) => a.name === this.options.supervisor);
+      if (!found) {
+        throw new Error(`Supervisor "${this.options.supervisor}" not found in agents`);
+      }
+    }
+    if (this.options.scene) {
+      const registeredNames = new Set(this.options.toolkits.map((tk) => tk.name));
+      for (const name of this.options.scene.toolkits) {
+        if (!registeredNames.has(name)) {
+          throw new Error(`Scene references toolkit "${name}" which is not registered`);
+        }
+      }
+    }
+  }
+};
+function createAgent2(options) {
+  return new Agent(options);
+}
+
+exports.Agent = Agent;
+exports.buildPromptChain = buildPromptChain;
+exports.buildSingleGraph = buildSingleGraph;
+exports.buildSupervisorGraph = buildSupervisorGraph;
+exports.createAgent = createAgent2;
+exports.createExpressHandler = createExpressHandler;
+exports.defineProfile = defineProfile;
+exports.defineScene = defineScene;
+exports.defineToolKit = defineToolKit;
+exports.formatSSE = formatSSE;
+exports.transformStream = transformStream;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map