@xtalpi/agentic-lab-agent-sdk 0.0.17

package/LICENSE.md

@@ -0,0 +1,20 @@
+# MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,172 @@
+# @xtalpi/agentic-lab-agent-sdk
+
+用于构建 AI Agent 服务的 Node.js / NestJS 工具包，提供消息处理、SSE 流式响应、协议封装、Prompt 管理、Skill 加载、调用链追踪等开箱即用的能力。
+
+## 特性
+
+- **消息处理** — 解析聊天参数、加载 & 归一化历史消息
+- **SSE 流式响应** — 一行代码设置 SSE Headers，流式写入数据块
+- **协议层** — 统一的数据协议，内置 FileLink / ToolCall / Progress / SMILES / ECharts / Form 等富内容类型
+- **Prompt 管理** — 从文件系统加载 System Prompt
+- **Skill 管理** — 自动发现 `storage/skills` 目录下的技能
+- **文件工具** — 路径解析、JSON 读写、文件拷贝等常用文件操作
+- **Agent 模块** — 一步完成 Tracer 创建 + onChunk 包装，简化 Agent 运行时初始化
+- **中间件** — Tool Call 状态通知中间件，自动向流中写入工具调用进度
+
+## 安装
+
+```bash
+npm install @xtalpi/agentic-lab-agent-sdk
+# 或
+pnpm add @xtalpi/agentic-lab-agent-sdk
+```
+
+## 环境要求
+
+- Node.js >= 22.22.0
+- 可选 peer dependencies：`@langchain/core` >= 1.1.39, `langchain` >= 1.3.0（使用 agent / middleware 时需要）
+
+## 快速开始
+
+```ts
+import { curve, UIEnv } from '@xtalpi/agentic-lab-agent-sdk';
+
+// 设置 UI 环境（默认为 Curve）
+curve.setUIEnv(UIEnv.Common); // 所有协议输出自动降级为纯 Markdown
+
+const parsed = curve.message.parseChatParams({
+  message_id: 'msg-1',
+  context_link: 'ctx-1',
+  messages: [{ role: 'user', content: 'hello' }],
+});
+
+console.log(parsed.query); // "hello"
+```
+
+## 模块概览
+
+所有功能通过唯一的 `curve` 实例访问：
+
+```ts
+import { curve } from '@xtalpi/agentic-lab-agent-sdk';
+```
+
+### `curve.message`
+
+| 方法 | 说明 |
+| --- | --- |
+| `parseChatParams(params)` | 校验并解析聊天请求参数，自动提取 `query` |
+| `loadMessages(messages, options?)` | 加载 & 归一化历史消息，支持 `maxHistoryMessages` 限制 |
+
+### `curve.stream`
+
+| 方法 | 说明 |
+| --- | --- |
+| `setupSSEHeaders(res)` | 设置 Express Response 的 SSE 响应头 |
+| `writeChunk(res, chunk)` | 写入一个 SSE 数据块 |
+| `writeDone(res)` | 发送 `[DONE]` 并结束响应 |
+| `writeError(res, error)` | 写入错误信息 |
+
+### `curve.setUIEnv(env)` / `curve.getUIEnv()`
+
+切换 UI 环境，影响 `curve.protocol` 所有输出格式：
+
+| UIEnv | `output()` 返回 | `toXxxChunk()` 返回 |
+| --- | --- | --- |
+| `UIEnv.Curve` | `CurveChunk` 对象（含 data_type, metadata） | `` ```data JSON``` `` 协议格式 |
+| `UIEnv.Common` | 纯 `string`（Markdown 文本） | 可读的 Markdown 描述文本 |
+
+### `curve.protocol`
+
+| 方法 | 说明 |
+| --- | --- |
+| `output(chunk)` | 将 StreamChunk 或 string 转换为 CurveChunk（Curve 模式）或纯 string（Common 模式） |
+| `toFileLinkChunk(...)` | 生成文件链接协议块 |
+| `toToolCallChunk(...)` | 生成工具调用状态协议块 |
+| `toProgressChunk(...)` | 生成进度条协议块 |
+| `toSmilesChunk(...)` | 生成 SMILES 分子式协议块 |
+| `toEChartsChunk(options)` | 生成 ECharts 图表协议块 |
+| `toFormChunk(schema, action?, title?)` | 生成表单协议块 |
+
+### `curve.prompt`
+
+| 方法 | 说明 |
+| --- | --- |
+| `loadPrompt(filePath)` | 从指定路径加载 Prompt 文件 |
+| `systemPrompt()` | 加载 `storage/prompts/system.md` |
+
+### `curve.skill`
+
+| 方法 | 说明 |
+| --- | --- |
+| `getSkillDirs()` | 返回 `storage/skills` 下的技能目录路径 |
+
+### `curve.file`
+
+文件系统常用操作：`isExist`, `isFile`, `readJsonSync`, `writeJson`, `readFileString`, `resolvePath`, `copyFileSync`, `ensureDir` 等。
+
+### `curve.utils`
+
+通用工具方法：`uuidv4`, `delay`, `parseJsonSilent`, `paramsException`, `commonException` 等。
+
+### `curve.agent`
+
+Agent 模块，通过 `init()` 一步完成运行时初始化。
+
+| 方法 / 属性 | 说明 |
+| --- | --- |
+| `init(onChunk?, options?)` | 创建 tracer 并包装 onChunk，返回 `{ tracer, onChunk }` |
+| `loadTrace(traceId)` | 加载指定 traceId 的持久化追踪数据 |
+| `Tracer` | `AgentTracer` 类引用 |
+| `traceEventType` | `TraceEventType` 枚举 |
+
+```ts
+import { curve } from '@xtalpi/agentic-lab-agent-sdk';
+
+// 流式场景：一步创建 tracer + 包装 onChunk
+const { tracer, onChunk } = curve.agent.init(_onChunk, { query: 'user question' });
+
+// 非流式场景：只需 tracer
+const { tracer } = curve.agent.init(undefined, { query: 'user question' });
+
+// 加载历史追踪数据
+const traceData = await curve.agent.loadTrace(traceId);
+```
+
+追踪数据自动持久化到 `storage/cache/traces/` 目录。
+
+### `curve.middleware`
+
+中间件模块，提供 Agent 运行时中间件。
+
+| 方法 | 说明 |
+| --- | --- |
+| `createToolMiddleware(tools)` | 创建工具调用通知中间件，自动将 Tool Call 状态写入 SSE 流 |
+| `createErrorCatch()` | 创建错误捕获中间件，拦截工具错误并回传给 LLM |
+
+```ts
+import { curve } from '@xtalpi/agentic-lab-agent-sdk';
+
+const middleware = [
+  curve.middleware.createToolMiddleware(tools),
+  curve.middleware.createErrorCatch(),
+];
+```
+
+
+## 项目约定
+
+SDK 默认从 `process.cwd()` 下读取以下目录结构：
+
+```
+storage/
+  prompts/
+    system.md
+  skills/
+  cache/
+    traces/
+```
+
+## License
+
+[MIT](./LICENSE.md)

package/dist/agent/index.d.ts

@@ -0,0 +1,21 @@
+import { TraceData, TraceEventType } from "../types/tracer/index.js";
+import { AgentTracer } from "./tracer.js";
+
+//#region src/agent/index.d.ts
+interface AgentInitResult {
+  tracer: AgentTracer;
+  onChunk: (chunk: any) => void;
+}
+declare class AgentModule {
+  readonly Tracer: typeof AgentTracer;
+  readonly traceEventType: typeof TraceEventType;
+  private storagePath?;
+  init(onChunk?: (chunk: any) => void, options?: {
+    query?: string;
+    noPrint?: boolean;
+    storagePath?: string;
+  }): AgentInitResult;
+  loadTrace(traceId: string): Promise<TraceData | null>;
+}
+//#endregion
+export { AgentInitResult, AgentModule };

package/dist/agent/index.js

@@ -0,0 +1,30 @@
+import { TraceEventType } from "../types/tracer/index.js";
+import { AgentTracer } from "./tracer.js";
+
+//#region src/agent/index.ts
+var AgentModule = class {
+	Tracer = AgentTracer;
+	traceEventType = TraceEventType;
+	storagePath;
+	init(onChunk, options) {
+		if (options?.storagePath) this.storagePath = options.storagePath;
+		const tracer = new AgentTracer(options);
+		const wrappedOnChunk = (chunk) => {
+			if (chunk && typeof chunk === "object") chunk.metadata = {
+				...chunk.metadata || {},
+				traceId: tracer.traceId
+			};
+			onChunk?.(chunk);
+		};
+		return {
+			tracer,
+			onChunk: wrappedOnChunk
+		};
+	}
+	async loadTrace(traceId) {
+		return AgentTracer.loadTrace(traceId, this.storagePath);
+	}
+};
+
+//#endregion
+export { AgentModule };

package/dist/agent/tracer.d.ts

@@ -0,0 +1,37 @@
+import { TraceData } from "../types/tracer/index.js";
+import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
+import { LLMResult } from "@langchain/core/outputs";
+import { BaseMessage } from "@langchain/core/messages";
+
+//#region src/agent/tracer.d.ts
+declare class AgentTracer extends BaseCallbackHandler {
+  name: string;
+  readonly traceId: string;
+  private traceData;
+  private tracesDir;
+  private pendingLLM;
+  private pendingTool;
+  private noPrint;
+  private storagePath?;
+  constructor(options?: {
+    query?: string;
+    noPrint?: boolean;
+    storagePath?: string;
+  });
+  private addEvent;
+  private persist;
+  private safeStringify;
+  private truncate;
+  handleChainError(err: any): Promise<void>;
+  handleLLMStart(_llm: any, _prompts: string[], runId: string): Promise<void>;
+  handleChatModelStart(_llm: any, messages: BaseMessage[][], runId: string): Promise<void>;
+  handleLLMEnd(output: LLMResult, runId: string): Promise<void>;
+  handleLLMError(err: any, runId: string): Promise<void>;
+  handleToolStart(tool: any, input: string, runId: string, _parentRunId?: string, _tags?: string[], _metadata?: Record<string, unknown>, runName?: string): Promise<void>;
+  handleToolEnd(output: any, runId: string): Promise<void>;
+  handleToolError(err: any, runId: string): Promise<void>;
+  getTraceData(): TraceData;
+  static loadTrace(traceId: string, storagePath?: string): Promise<TraceData | null>;
+}
+//#endregion
+export { AgentTracer };

package/dist/agent/tracer.js

@@ -0,0 +1,217 @@
+import { FileModule } from "../file/file.js";
+import { TraceEventType } from "../types/tracer/index.js";
+import fse from "fs-extra";
+import { v4 } from "uuid";
+import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
+
+//#region src/agent/tracer.ts
+const file = new FileModule();
+function getTracesDir(storagePath) {
+	const base = storagePath || file.resolvePath(process.cwd(), "storage");
+	return file.resolvePath(base, "cache", "traces");
+}
+var AgentTracer = class extends BaseCallbackHandler {
+	name = "AgentTracer";
+	traceId;
+	traceData;
+	tracesDir;
+	pendingLLM = /* @__PURE__ */ new Map();
+	pendingTool = /* @__PURE__ */ new Map();
+	noPrint;
+	storagePath;
+	constructor(options) {
+		super();
+		this.traceId = v4();
+		this.storagePath = options?.storagePath;
+		this.tracesDir = getTracesDir(this.storagePath);
+		this.noPrint = options?.noPrint ?? false;
+		this.traceData = {
+			traceId: this.traceId,
+			query: options?.query,
+			startTime: Date.now(),
+			events: [],
+			totalTokens: {
+				promptTokens: 0,
+				completionTokens: 0,
+				totalTokens: 0
+			},
+			llmCalls: 0,
+			toolCalls: 0
+		};
+		fse.ensureDirSync(this.tracesDir);
+	}
+	addEvent(event) {
+		this.traceData.events.push(event);
+		this.persist();
+	}
+	persist() {
+		try {
+			if (!fse.existsSync(this.tracesDir)) fse.ensureDirSync(this.tracesDir);
+			this.traceData.endTime = Date.now();
+			const filePath = file.resolvePath(this.tracesDir, `${this.traceId}.json`);
+			fse.writeJsonSync(filePath, this.traceData, { spaces: 2 });
+		} catch (err) {
+			console.error(`[AgentTracer] persist failed: ${err.message}`);
+		}
+	}
+	safeStringify(value) {
+		try {
+			return typeof value === "string" ? value : JSON.stringify(value);
+		} catch {
+			return String(value);
+		}
+	}
+	truncate(text, maxLen = 300) {
+		return text.length > maxLen ? text.slice(0, maxLen) + "..." : text;
+	}
+	async handleChainError(err) {
+		!this.noPrint && console.log(`[Tracer] ❌ Chain Error: ${this.truncate(err.message)}\n`);
+		this.addEvent({
+			type: TraceEventType.ChainError,
+			timestamp: Date.now(),
+			runId: "",
+			data: { error: err.message }
+		});
+	}
+	async handleLLMStart(_llm, _prompts, runId) {
+		this.pendingLLM.set(runId, { startTime: Date.now() });
+		const inputPreview = _prompts?.[0] ? this.truncate(this.safeStringify(_prompts[0])) : "";
+		!this.noPrint && console.log(`[Tracer] 🚀 LLM Start (handleLLMStart)\n  input: ${inputPreview}\n`);
+	}
+	async handleChatModelStart(_llm, messages, runId) {
+		this.pendingLLM.set(runId, { startTime: Date.now() });
+		this.traceData.llmCalls++;
+		const last = messages?.[0]?.[messages[0].length - 1];
+		const inputStr = this.safeStringify(last);
+		!this.noPrint && console.log(`[Tracer] 🚀 LLM *${this.traceData.llmCalls} Start\n  input: ${this.truncate(inputStr)}\n`);
+		this.addEvent({
+			type: TraceEventType.LlmStart,
+			timestamp: Date.now(),
+			runId,
+			data: {
+				llmIndex: this.traceData.llmCalls,
+				input: inputStr
+			}
+		});
+	}
+	async handleLLMEnd(output, runId) {
+		const pending = this.pendingLLM.get(runId);
+		if (!pending) return;
+		this.pendingLLM.delete(runId);
+		const duration = Date.now() - pending.startTime;
+		const usage = output?.llmOutput?.tokenUsage || {};
+		const gen = output?.generations?.[0]?.[0];
+		const msg = gen?.message ?? gen;
+		const promptTokens = usage.promptTokens || 0;
+		const completionTokens = usage.completionTokens || 0;
+		this.traceData.totalTokens.promptTokens += promptTokens;
+		this.traceData.totalTokens.completionTokens += completionTokens;
+		this.traceData.totalTokens.totalTokens += promptTokens + completionTokens;
+		const outputStr = this.safeStringify(msg);
+		const durationSec = (duration / 1e3).toFixed(2);
+		!this.noPrint && console.log(`[Tracer] ✅ LLM *${this.traceData.llmCalls} End\n  duration: ${durationSec}s (${duration}ms)\n  tokens: ${promptTokens}+${completionTokens}=${promptTokens + completionTokens}\n  output: ${this.truncate(outputStr)}\n`);
+		this.addEvent({
+			type: TraceEventType.LlmEnd,
+			timestamp: Date.now(),
+			runId,
+			duration,
+			data: {
+				llmIndex: this.traceData.llmCalls,
+				tokenUsage: {
+					promptTokens,
+					completionTokens
+				},
+				output: outputStr
+			}
+		});
+	}
+	async handleLLMError(err, runId) {
+		const p = this.pendingLLM.get(runId);
+		if (!p) return;
+		this.pendingLLM.delete(runId);
+		const duration = Date.now() - p.startTime;
+		const durationSec = (duration / 1e3).toFixed(2);
+		!this.noPrint && console.log(`[Tracer] ❌ LLM *${this.traceData.llmCalls} Error\n  duration: ${durationSec}s (${duration}ms)\n  error: ${this.truncate(err.message)}\n`);
+		this.addEvent({
+			type: TraceEventType.LlmError,
+			timestamp: Date.now(),
+			runId,
+			duration,
+			data: { error: err.message }
+		});
+	}
+	async handleToolStart(tool, input, runId, _parentRunId, _tags, _metadata, runName) {
+		const toolName = runName || tool?.name || tool?.id?.[tool.id?.length - 1] || "unknown";
+		this.pendingTool.set(runId, {
+			startTime: Date.now(),
+			toolName
+		});
+		this.traceData.toolCalls++;
+		!this.noPrint && console.log(`[Tracer][${toolName}] 🔧 Tool Start\n  input: ${this.truncate(this.safeStringify(input))}\n`);
+		this.addEvent({
+			type: TraceEventType.ToolStart,
+			timestamp: Date.now(),
+			runId,
+			data: {
+				toolName,
+				input: this.safeStringify(input)
+			}
+		});
+	}
+	async handleToolEnd(output, runId) {
+		const t = this.pendingTool.get(runId);
+		if (!t) return;
+		this.pendingTool.delete(runId);
+		const duration = Date.now() - t.startTime;
+		const durationSec = (duration / 1e3).toFixed(2);
+		!this.noPrint && console.log(`[Tracer][${t.toolName}] ✅ Tool End\n  duration: ${durationSec}s (${duration}ms)\n  output: ${this.truncate(this.safeStringify(output))}\n`);
+		this.addEvent({
+			type: TraceEventType.ToolEnd,
+			timestamp: Date.now(),
+			runId,
+			duration,
+			data: {
+				toolName: t.toolName,
+				output: this.safeStringify(output)
+			}
+		});
+	}
+	async handleToolError(err, runId) {
+		const t = this.pendingTool.get(runId);
+		if (!t) return;
+		this.pendingTool.delete(runId);
+		const duration = Date.now() - t.startTime;
+		const durationSec = (duration / 1e3).toFixed(2);
+		!this.noPrint && console.log(`[Tracer][${t.toolName}] ❌ Tool Error\n  duration: ${durationSec}s (${duration}ms)\n  error: ${this.truncate(err.message)}\n`);
+		this.addEvent({
+			type: TraceEventType.ToolError,
+			timestamp: Date.now(),
+			runId,
+			duration,
+			data: {
+				toolName: t.toolName,
+				error: err.message
+			}
+		});
+	}
+	getTraceData() {
+		return { ...this.traceData };
+	}
+	static async loadTrace(traceId, storagePath) {
+		try {
+			const tracesDir = getTracesDir(storagePath);
+			if (!fse.existsSync(tracesDir)) {
+				fse.ensureDirSync(tracesDir);
+				return null;
+			}
+			const filePath = file.resolvePath(tracesDir, `${traceId}.json`);
+			if (!file.isExist(filePath)) return null;
+			return file.readJsonSync(filePath, true);
+		} catch {
+			return null;
+		}
+	}
+};
+
+//#endregion
+export { AgentTracer };

package/dist/context/context.d.ts

@@ -0,0 +1,6 @@
+//#region src/context/context.d.ts
+declare class ContextModule {
+  test(): void;
+}
+//#endregion
+export { ContextModule };

package/dist/context/context.js

@@ -0,0 +1,9 @@
+//#region src/context/context.ts
+var ContextModule = class {
+	test() {
+		console.log("context test");
+	}
+};
+
+//#endregion
+export { ContextModule };

package/dist/file/file.d.ts

@@ -0,0 +1,25 @@
+//#region src/file/file.d.ts
+declare class FileModule {
+  isExist(filePath: string): boolean;
+  isFile(filePath: string): boolean;
+  isWritable(filePath: string): boolean;
+  readJsonSync(filePath: string, silent?: boolean): any;
+  writeJson(filePath: string, data: any, spaces?: number): Promise<void>;
+  readFileString(filePath: string): Promise<string>;
+  readFileStringSync(filePath: string): string;
+  readFileBufferSync(filePath: string): Buffer;
+  resolvePath(...args: any[]): string;
+  joinPath(...args: string[]): string;
+  getFilename(filePath: string, ext?: string): string;
+  dirname(filePath: string): string;
+  extname(filePath: string): string;
+  isAbsolute(filePath: string): boolean;
+  mkdirSync(dir: string): void;
+  copy(src: string, dst: string): Promise<void>;
+  ensureDir(dir: string): Promise<void>;
+  writeFile(filePath: string, data: Buffer | string): Promise<void>;
+  readFileBuffer(filePath: string): Promise<Buffer>;
+  remove(filePath: string): Promise<void>;
+}
+//#endregion
+export { FileModule };

package/dist/file/file.js

@@ -0,0 +1,95 @@
+import * as fs from "fs";
+import * as path from "path";
+import fse from "fs-extra";
+
+//#region src/file/file.ts
+var FileModule = class {
+	isExist(filePath) {
+		return fs.existsSync(path.resolve(filePath));
+	}
+	isFile(filePath) {
+		if (!this.isExist(filePath)) return false;
+		return fs.statSync(filePath).isFile();
+	}
+	isWritable(filePath) {
+		try {
+			fs.accessSync(path.resolve(filePath), fs.constants.R_OK | fs.constants.W_OK);
+			return true;
+		} catch (error) {
+			return false;
+		}
+	}
+	readJsonSync(filePath, silent = false) {
+		try {
+			if (silent && !this.isFile(path.resolve(filePath))) {
+				console.warn(`Not found ${filePath}`);
+				return null;
+			}
+			const jsonObj = fse.readJsonSync(path.resolve(filePath));
+			if (!jsonObj) throw new Error("Invalid JSON.");
+			return jsonObj;
+		} catch (err) {
+			if (silent) {
+				console.error(err);
+				return null;
+			} else throw err;
+		}
+	}
+	async writeJson(filePath, data, spaces = 2) {
+		await fse.writeJson(path.resolve(filePath), data, { spaces });
+	}
+	readFileString(filePath) {
+		return new Promise((resolve, reject) => {
+			const cb = (err, data) => {
+				if (err) reject(err);
+				else resolve(data);
+			};
+			fs.readFile(path.resolve(filePath), "utf8", cb);
+		});
+	}
+	readFileStringSync(filePath) {
+		return fs.readFileSync(path.resolve(filePath), "utf-8");
+	}
+	readFileBufferSync(filePath) {
+		return fs.readFileSync(path.resolve(filePath));
+	}
+	resolvePath(...args) {
+		return path.resolve(...args);
+	}
+	joinPath(...args) {
+		return path.join(...args);
+	}
+	getFilename(filePath, ext) {
+		return ext ? path.basename(filePath, ext) : path.basename(filePath);
+	}
+	dirname(filePath) {
+		return path.dirname(filePath);
+	}
+	extname(filePath) {
+		return path.extname(filePath);
+	}
+	isAbsolute(filePath) {
+		return path.isAbsolute(filePath);
+	}
+	mkdirSync(dir) {
+		fs.mkdirSync(path.resolve(dir), { recursive: true });
+	}
+	async copy(src, dst) {
+		await fse.copy(src, dst);
+	}
+	async ensureDir(dir) {
+		await fse.ensureDir(dir);
+	}
+	async writeFile(filePath, data) {
+		await fs.promises.writeFile(path.resolve(filePath), data);
+	}
+	async readFileBuffer(filePath) {
+		return fs.promises.readFile(path.resolve(filePath));
+	}
+	async remove(filePath) {
+		await fse.remove(filePath);
+	}
+};
+
+//#endregion
+export { FileModule };

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+import { TraceData, TraceEvent, TraceEventType } from "./types/tracer/index.js";
+import { AgentModule } from "./agent/index.js";
+import { ContextModule } from "./context/context.js";
+import { FileModule } from "./file/file.js";
+import { StreamModule } from "./stream/stream.js";
+import { ProtocolModule } from "./protocal/protocal.js";
+import { MessageModule } from "./message/message.js";
+import { PromptModule } from "./prompt/prompt.js";
+import { SkillModule } from "./skill/skill.js";
+import { UtilsModule } from "./utils/utils.js";
+import { MiddlewareModule } from "./middleware/index.js";
+
+//#region src/index.d.ts
+declare enum UIEnv {
+  Curve = "Curve",
+  Common = "Common",
+}
+declare class Curve {
+  readonly stream: StreamModule;
+  readonly protocol: ProtocolModule;
+  readonly context: ContextModule;
+  readonly message: MessageModule;
+  readonly prompt: PromptModule;
+  readonly skill: SkillModule;
+  readonly file: FileModule;
+  readonly utils: UtilsModule;
+  readonly agent: AgentModule;
+  readonly middleware: MiddlewareModule;
+  private _uiEnv;
+  constructor();
+  setUIEnv(env: UIEnv): void;
+  getUIEnv(): UIEnv;
+}
+declare const curve: Curve;
+//#endregion
+export { Curve, type TraceData, type TraceEvent, TraceEventType, UIEnv, curve };