@xtalpi/agentic-lab-agent-sdk 0.0.17

package/dist/index.js

@@ -0,0 +1,53 @@
+import { StreamModule } from "./stream/stream.js";
+import { ProtocolModule } from "./protocal/protocal.js";
+import { ContextModule } from "./context/context.js";
+import { MessageModule } from "./message/message.js";
+import { PromptModule } from "./prompt/prompt.js";
+import { SkillModule } from "./skill/skill.js";
+import { FileModule } from "./file/file.js";
+import { UtilsModule } from "./utils/utils.js";
+import { TraceEventType } from "./types/tracer/index.js";
+import { AgentModule } from "./agent/index.js";
+import { MiddlewareModule } from "./middleware/index.js";
+
+//#region src/index.ts
+let UIEnv = /* @__PURE__ */ function(UIEnv$1) {
+	UIEnv$1["Curve"] = "Curve";
+	UIEnv$1["Common"] = "Common";
+	return UIEnv$1;
+}({});
+var Curve = class {
+	stream;
+	protocol;
+	context;
+	message;
+	prompt;
+	skill;
+	file;
+	utils;
+	agent;
+	middleware;
+	_uiEnv = UIEnv.Curve;
+	constructor() {
+		this.stream = new StreamModule(this);
+		this.protocol = new ProtocolModule(this);
+		this.context = new ContextModule();
+		this.message = new MessageModule(this);
+		this.file = new FileModule();
+		this.prompt = new PromptModule(this);
+		this.skill = new SkillModule(this);
+		this.utils = new UtilsModule();
+		this.agent = new AgentModule();
+		this.middleware = new MiddlewareModule();
+	}
+	setUIEnv(env) {
+		this._uiEnv = env;
+	}
+	getUIEnv() {
+		return this._uiEnv;
+	}
+};
+const curve = new Curve();
+
+//#endregion
+export { Curve, TraceEventType, UIEnv, curve };

package/dist/message/message.d.ts

@@ -0,0 +1,12 @@
+import { ChatMessageItem, ChatParams, LoadMessagesOptions } from "../types/message/index.js";
+import { Curve } from "../index.js";
+
+//#region src/message/message.d.ts
+declare class MessageModule {
+  private readonly curve;
+  constructor(curve: Curve);
+  parseChatParams(params?: ChatParams): ChatParams;
+  loadMessages(messages: ChatMessageItem[], options?: LoadMessagesOptions): ChatMessageItem[];
+}
+//#endregion
+export { MessageModule };

package/dist/message/message.js

@@ -0,0 +1,35 @@
+import { normalizeContent } from "./normalize.js";
+import { ResponseMode } from "../types/message/enum.js";
+
+//#region src/message/message.ts
+var MessageModule = class {
+	constructor(curve) {
+		this.curve = curve;
+		this.curve = curve;
+	}
+	parseChatParams(params) {
+		if (!params?.context_link) this.curve.utils.paramsException("context_link");
+		if (!params?.message_id) this.curve.utils.paramsException("message_id");
+		if (!Array.isArray(params?.messages) || params.messages.length === 0) this.curve.utils.paramsException("messages");
+		const query = params?.messages?.filter?.((msg) => msg.role === "user")?.pop?.()?.content ?? "";
+		if (!query) this.curve.utils.commonException("Not found user input content");
+		return {
+			...params,
+			response_mode: params?.response_mode ?? ResponseMode.Streaming,
+			agent_params_global: params?.agent_params_global ?? {},
+			query
+		};
+	}
+	loadMessages(messages, options) {
+		const { maxHistoryMessages = 20, isNormalize = true } = options ?? {};
+		const normalizedMessages = messages.filter((message) => typeof message?.content === "string" && message.content).map((message) => ({
+			role: message.role === "agent" ? "assistant" : message.role,
+			content: isNormalize && ["assistant", "agent"].includes(message.role) ? normalizeContent(message.content) : message.content
+		})).filter((message) => message.content.trim().length > 0);
+		if ([...normalizedMessages].reverse()[0]?.role !== "user") throw new Error("Not found user query content");
+		return normalizedMessages.slice(Math.max(0, normalizedMessages.length - 1 - maxHistoryMessages * 2));
+	}
+};
+
+//#endregion
+export { MessageModule };

package/dist/message/normalize.d.ts

@@ -0,0 +1,4 @@
+//#region src/message/normalize.d.ts
+declare const normalizeContent: (content: string) => string;
+//#endregion
+export { normalizeContent };

package/dist/message/normalize.js

@@ -0,0 +1,11 @@
+//#region src/message/normalize.ts
+const TOOL_CALL_BLOCK_RE = /```data\s+?\{[\s\S]*?"data_type"\s*:\s*"tool_call"[\s\S]*?```/g;
+const TOOL_USE_JSON_RE = /\{\s*"type"\s*:\s*"tool_use"[^}]*\}/g;
+const COLLAPSE_BLANK_RE = /\n{3,}/g;
+const normalizeContent = (content) => {
+	if (!(content && typeof content === "string")) return content;
+	return content.replaceAll(TOOL_CALL_BLOCK_RE, "").replaceAll(TOOL_USE_JSON_RE, "").replaceAll(COLLAPSE_BLANK_RE, "\n\n").trim();
+};
+
+//#endregion
+export { normalizeContent };

package/dist/middleware/createToolErrorCatchMiddleware.d.ts

@@ -0,0 +1,7 @@
+import * as langchain2 from "langchain";
+import * as _langchain_core_tools5 from "@langchain/core/tools";
+
+//#region src/middleware/createToolErrorCatchMiddleware.d.ts
+declare const createToolErrorCatchMiddleware: () => langchain2.AgentMiddleware<undefined, undefined, unknown, readonly (_langchain_core_tools5.ClientTool | _langchain_core_tools5.ServerTool)[]>;
+//#endregion
+export { createToolErrorCatchMiddleware };

package/dist/middleware/createToolErrorCatchMiddleware.js

@@ -0,0 +1,45 @@
+import { ToolMessage, createMiddleware } from "langchain";
+
+//#region src/middleware/createToolErrorCatchMiddleware.ts
+const stringifyDetails = (details) => {
+	if (details === void 0 || details === null) return "";
+	if (typeof details === "string") return details;
+	try {
+		return JSON.stringify(details, null, 2);
+	} catch {
+		return String(details);
+	}
+};
+const isToolAbortError = (error) => error instanceof Error && error.name === "ToolAbortError";
+const buildAbortSummary = (toolName, error) => {
+	const resolvedToolName = toolName || "unknown_tool";
+	const detailsText = stringifyDetails(error.details);
+	return [
+		`Tool ${resolvedToolName} validation or business check failed: ${error.message}`,
+		detailsText ? `Details: ${detailsText}` : "",
+		"This is a terminal failure for the current task. Please inform the user directly and stop calling tools."
+	].filter(Boolean).join("\n");
+};
+const buildToolMessageContent = (toolName, error) => {
+	if (isToolAbortError(error)) return buildAbortSummary(toolName, error);
+	return `Tool ${toolName || "unknown_tool"} error: ${error instanceof Error ? error.message : String(error)}`;
+};
+const createToolErrorCatchMiddleware = () => createMiddleware({
+	name: "ToolErrorCatchMiddleware",
+	wrapToolCall: async (request, handler) => {
+		try {
+			return await handler(request);
+		} catch (error) {
+			const toolName = request.toolCall?.name ?? "";
+			return new ToolMessage({
+				content: buildToolMessageContent(toolName, error),
+				tool_call_id: request.toolCall?.id ?? "",
+				name: toolName,
+				status: "error"
+			});
+		}
+	}
+});
+
+//#endregion
+export { createToolErrorCatchMiddleware };

package/dist/middleware/createToolMiddleware.d.ts

@@ -0,0 +1,8 @@
+import * as langchain0 from "langchain";
+import * as _langchain_core_tools0 from "@langchain/core/tools";
+import { StructuredTool } from "@langchain/core/tools";
+
+//#region src/middleware/createToolMiddleware.d.ts
+declare const createToolMiddleware: (tools: StructuredTool[]) => langchain0.AgentMiddleware<undefined, undefined, unknown, readonly (_langchain_core_tools0.ClientTool | _langchain_core_tools0.ServerTool)[]>;
+//#endregion
+export { createToolMiddleware };

package/dist/middleware/createToolMiddleware.js

@@ -0,0 +1,32 @@
+import { curve } from "../index.js";
+import { createMiddleware } from "langchain";
+
+//#region src/middleware/createToolMiddleware.ts
+const toToolId = (name) => `tool_${name}`;
+const toGroupId = (name) => `group_${name}`;
+const createToolMiddleware = (tools) => {
+	const toolNames = new Set(tools.map((t) => t.name));
+	return createMiddleware({
+		name: "ToolCallNotifyMiddleware",
+		wrapToolCall: async (request, handler) => {
+			const toolName = request.toolCall?.name ?? "";
+			if (!toolNames.has(toolName)) return handler(request);
+			const writer = request.runtime?.writer;
+			if (!writer) return handler(request);
+			const toolId = toToolId(toolName);
+			const groupId = toGroupId(toolName);
+			writer(curve.protocol.output({ content: [curve.protocol.toToolCallChunk(toolId, toolName, "running", groupId)] }));
+			try {
+				const result = await handler(request);
+				writer(curve.protocol.output({ content: [curve.protocol.toToolCallChunk(toolId, toolName, "finished", groupId)] }));
+				return result;
+			} catch (error) {
+				writer(curve.protocol.output({ content: [curve.protocol.toToolCallChunk(toolId, toolName, "failed", groupId)] }));
+				throw error;
+			}
+		}
+	});
+};
+
+//#endregion
+export { createToolMiddleware };

package/dist/middleware/index.d.ts

@@ -0,0 +1,11 @@
+import * as langchain0 from "langchain";
+import * as _langchain_core_tools1 from "@langchain/core/tools";
+import { StructuredTool } from "@langchain/core/tools";
+
+//#region src/middleware/index.d.ts
+declare class MiddlewareModule {
+  createToolMiddleware: (tools: StructuredTool[]) => langchain0.AgentMiddleware<undefined, undefined, unknown, readonly (_langchain_core_tools1.ClientTool | _langchain_core_tools1.ServerTool)[]>;
+  createToolErrorCatchMiddleware: () => langchain0.AgentMiddleware<undefined, undefined, unknown, readonly (_langchain_core_tools1.ClientTool | _langchain_core_tools1.ServerTool)[]>;
+}
+//#endregion
+export { MiddlewareModule };

package/dist/middleware/index.js

@@ -0,0 +1,11 @@
+import { createToolMiddleware } from "./createToolMiddleware.js";
+import { createToolErrorCatchMiddleware } from "./createToolErrorCatchMiddleware.js";
+
+//#region src/middleware/index.ts
+var MiddlewareModule = class {
+	createToolMiddleware = (tools) => createToolMiddleware(tools);
+	createToolErrorCatchMiddleware = () => createToolErrorCatchMiddleware();
+};
+
+//#endregion
+export { MiddlewareModule };

package/dist/prompt/prompt.d.ts

@@ -0,0 +1,11 @@
+import { Curve } from "../index.js";
+
+//#region src/prompt/prompt.d.ts
+declare class PromptModule {
+  private readonly curve;
+  constructor(curve: Curve);
+  loadPrompt(filePath: string): Promise<string>;
+  systemPrompt(): Promise<string>;
+}
+//#endregion
+export { PromptModule };

package/dist/prompt/prompt.js

@@ -0,0 +1,19 @@
+//#region src/prompt/prompt.ts
+var PromptModule = class {
+	constructor(curve) {
+		this.curve = curve;
+		this.curve = curve;
+	}
+	async loadPrompt(filePath) {
+		if (!this.curve.file.isExist(filePath)) throw new Error(`Not found ${filePath}`);
+		return await this.curve.file.readFileString(this.curve.file.resolvePath(filePath));
+	}
+	async systemPrompt() {
+		const storageDir = this.curve.file.resolvePath(process.cwd(), "storage");
+		const filePath = this.curve.file.resolvePath(storageDir, "prompts/system.md");
+		return this.loadPrompt(filePath);
+	}
+};
+
+//#endregion
+export { PromptModule };

package/dist/protocal/protocal.d.ts

@@ -0,0 +1,22 @@
+import { Action, Schema } from "../types/protocal/content/form.js";
+import { ViewType } from "../types/protocal/content/fileLink.js";
+import { CurveChunk, CurveInnerChunk } from "../types/protocal/index.js";
+import { StreamChunk } from "../types/stream/index.js";
+import { Curve } from "../index.js";
+
+//#region src/protocal/protocal.d.ts
+declare class ProtocolModule {
+  private readonly curve;
+  constructor(curve: Curve);
+  output(chunk: StreamChunk): CurveChunk | string;
+  formatInnerChunk(chunk: CurveInnerChunk): string;
+  private innerChunkToMarkdown;
+  toFileLinkChunk(filePath: string, view?: ViewType, label?: string, table?: string): string;
+  toToolCallChunk(toolId: string, title?: string, status?: string, groupId?: string): string;
+  toProgressChunk(id: string, value: number, text?: string, type?: string, position?: string): string;
+  toSmilesChunk(smiles: string, uiType?: string, uiSize?: string): string;
+  toEChartsChunk(options?: Record<string, any>): string;
+  toFormChunk(schema?: Schema, action?: Action, title?: string): string;
+}
+//#endregion
+export { ProtocolModule };

package/dist/protocal/protocal.js

@@ -0,0 +1,118 @@
+import { DataType } from "../types/protocal/enum.js";
+import { ToolCallStatus } from "../types/protocal/content/toolCall.js";
+import { ProgressType } from "../types/protocal/content/progress.js";
+import { ViewType } from "../types/protocal/content/fileLink.js";
+import { SmilesContentSize, SmilesContentType } from "../types/protocal/content/smiles.js";
+import { ActionType } from "../types/protocal/content/form.js";
+import { UIEnv } from "../index.js";
+
+//#region src/protocal/protocal.ts
+var ProtocolModule = class {
+	constructor(curve) {
+		this.curve = curve;
+		this.curve = curve;
+	}
+	output(chunk) {
+		let content = "";
+		if (chunk.content && typeof chunk.content === "string") content = chunk.content;
+		else if (Array.isArray(chunk.content)) content = chunk.content.join("");
+		if (this.curve.getUIEnv() === UIEnv.Common) return content;
+		return {
+			data_type: chunk.data_type ?? DataType.Markdown,
+			metadata: chunk.metadata ?? {},
+			content
+		};
+	}
+	formatInnerChunk(chunk) {
+		if (this.curve.getUIEnv() === UIEnv.Common) return this.innerChunkToMarkdown(chunk);
+		return `\n\`\`\`data ${JSON.stringify(chunk)}\`\`\`\n`;
+	}
+	innerChunkToMarkdown(chunk) {
+		const c = chunk.content;
+		switch (chunk.data_type) {
+			case DataType.FileLink: return `Generated file **${c.label || "file"}**, link: **${c.link}**`;
+			case DataType.ToolCall: return `Calling tool **${c.title || c.tool_id}**, status: **${c.status}**`;
+			case DataType.Progress: return `Current progress: **${c.value}%**${c.text ? ` (${c.text})` : ""}`;
+			case DataType.Smiles: return `Molecular structure (SMILES): \`${c.value}\``;
+			case DataType.ECharts: return `Chart data:\n${JSON.stringify(c, null, 2)}`;
+			case DataType.Form: return `Form: **${c.title || "Untitled"}**\n${JSON.stringify(c.schema, null, 2)}`;
+			default: return typeof c === "string" ? c : JSON.stringify(c, null, 2);
+		}
+	}
+	toFileLinkChunk(filePath, view, label, table) {
+		if (!filePath) throw new Error("[File link] file path is required");
+		const chunk = {
+			data_type: DataType.FileLink,
+			content: {
+				label: label ?? this.curve.file.getFilename(filePath),
+				link: filePath,
+				view: view ?? ViewType.Link
+			}
+		};
+		if (table) chunk.content.table = table;
+		return this.formatInnerChunk(chunk);
+	}
+	toToolCallChunk(toolId, title, status, groupId) {
+		if (!toolId) throw new Error("[Tool call] toolId is required");
+		const chunk = {
+			data_type: DataType.ToolCall,
+			content: {
+				tool_id: toolId,
+				title: title ?? toolId,
+				group_id: groupId ?? toolId,
+				status: status ?? ToolCallStatus.Created
+			}
+		};
+		return this.formatInnerChunk(chunk);
+	}
+	toProgressChunk(id, value, text, type, position) {
+		if (!(value >= 0 && value <= 100)) throw new Error("[Progress] value must be between 0 and 100");
+		if (!id) throw new Error("[Progress] id is required");
+		const chunk = {
+			data_type: DataType.Progress,
+			content: {
+				id,
+				value,
+				type: type ?? ProgressType.Linear
+			}
+		};
+		if (text) chunk.content.text = text;
+		if (position) chunk.content.position = position;
+		return this.formatInnerChunk(chunk);
+	}
+	toSmilesChunk(smiles, uiType, uiSize) {
+		if (!smiles) throw new Error("[Smiles] smiles is required");
+		const chunk = {
+			data_type: DataType.Smiles,
+			content: {
+				value: smiles,
+				ui_type: uiType ?? SmilesContentType.Image,
+				ui_size: uiSize ?? SmilesContentSize.Normal
+			}
+		};
+		return this.formatInnerChunk(chunk);
+	}
+	toEChartsChunk(options) {
+		if (!options) throw new Error("[ECharts] options is required");
+		const chunk = {
+			data_type: DataType.ECharts,
+			content: options
+		};
+		return this.formatInnerChunk(chunk);
+	}
+	toFormChunk(schema, action, title) {
+		if (!(schema && typeof schema === "object")) throw new Error("[Form] schema is required");
+		const chunk = {
+			data_type: DataType.Form,
+			content: {
+				action: action ?? ActionType.Chat,
+				title: title ?? "",
+				schema
+			}
+		};
+		return this.formatInnerChunk(chunk);
+	}
+};
+
+//#endregion
+export { ProtocolModule };

package/dist/skill/skill.d.ts

@@ -0,0 +1,14 @@
+import { Curve } from "../index.js";
+
+//#region src/skill/skill.d.ts
+declare class SkillModule {
+  private readonly curve;
+  constructor(curve: Curve);
+  /**
+   * 获取 skills 目录路径列表（相对于 FilesystemBackend 的 rootDir）
+   * deepagents SkillsMiddleware 要求使用相对路径
+   */
+  getSkillDirs(): string[];
+}
+//#endregion
+export { SkillModule };

package/dist/skill/skill.js

@@ -0,0 +1,18 @@
+//#region src/skill/skill.ts
+var SkillModule = class {
+	constructor(curve) {
+		this.curve = curve;
+		this.curve = curve;
+	}
+	/**
+	* 获取 skills 目录路径列表（相对于 FilesystemBackend 的 rootDir）
+	* deepagents SkillsMiddleware 要求使用相对路径
+	*/
+	getSkillDirs() {
+		const skillsDir = this.curve.file.resolvePath(process.cwd(), "storage", "skills");
+		return this.curve.file.isExist(skillsDir) ? ["storage/skills"] : [];
+	}
+};
+
+//#endregion
+export { SkillModule };

package/dist/stream/stream.d.ts

@@ -0,0 +1,15 @@
+import { Curve } from "../index.js";
+import { Response } from "express";
+
+//#region src/stream/stream.d.ts
+declare class StreamModule {
+  private readonly curve;
+  constructor(curve: Curve);
+  private flush;
+  setupSSEHeaders(res: Response): void;
+  writeChunk(res: Response, chunk: Record<string, any> | string): void;
+  writeDone(res: Response): void;
+  writeError(res: Response, error: any): void;
+}
+//#endregion
+export { StreamModule };

package/dist/stream/stream.js

@@ -0,0 +1,38 @@
+import { getMessageFromError } from "../utils/error.js";
+
+//#region src/stream/stream.ts
+var StreamModule = class {
+	constructor(curve) {
+		this.curve = curve;
+		this.curve = curve;
+	}
+	flush(res) {
+		if (typeof res.flush === "function") res.flush();
+	}
+	setupSSEHeaders(res) {
+		res.setHeader("Content-Type", "text/event-stream");
+		res.setHeader("Cache-Control", "no-cache");
+		res.setHeader("Connection", "keep-alive");
+		res.setHeader("X-Accel-Buffering", "no");
+		res.flushHeaders();
+	}
+	writeChunk(res, chunk) {
+		let content = "";
+		if (typeof chunk === "string") content = chunk;
+		else content = JSON.stringify(chunk);
+		res.write(`data: ${content}\n\n`);
+		this.flush(res);
+	}
+	writeDone(res) {
+		res.write(`data: [DONE]\n\n`);
+		res.end();
+	}
+	writeError(res, error) {
+		const errorMessage = getMessageFromError(error);
+		res.write(`data: [ERROR] ${errorMessage}\n\n`);
+		this.flush(res);
+	}
+};
+
+//#endregion
+export { StreamModule };

package/dist/types/message/enum.d.ts

@@ -0,0 +1,7 @@
+//#region src/types/message/enum.d.ts
+declare enum ResponseMode {
+  Normal = "normal",
+  Streaming = "streaming",
+}
+//#endregion
+export { ResponseMode };

package/dist/types/message/enum.js

@@ -0,0 +1,9 @@
+//#region src/types/message/enum.ts
+let ResponseMode = /* @__PURE__ */ function(ResponseMode$1) {
+	ResponseMode$1["Normal"] = "normal";
+	ResponseMode$1["Streaming"] = "streaming";
+	return ResponseMode$1;
+}({});
+
+//#endregion
+export { ResponseMode };

package/dist/types/message/index.d.ts

@@ -0,0 +1,20 @@
+//#region src/types/message/index.d.ts
+interface ChatMessageItem {
+  role: string;
+  content: string;
+}
+interface ChatParams {
+  message_id?: string;
+  context_link?: string;
+  messages?: ChatMessageItem[];
+  agent_params_global?: Record<string, any>;
+  response_mode?: string;
+  query?: string;
+  [propName: string]: any;
+}
+interface LoadMessagesOptions {
+  maxHistoryMessages?: number;
+  isNormalize?: boolean;
+}
+//#endregion
+export { ChatMessageItem, ChatParams, LoadMessagesOptions };

package/dist/types/message/index.js

@@ -0,0 +1 @@
+export {  };

package/dist/types/protocal/content/echarts.d.ts

@@ -0,0 +1,7 @@
+//#region src/types/protocal/content/echarts.d.ts
+interface EChartsContent {
+  title?: string;
+  [propName: string]: any;
+}
+//#endregion
+export { EChartsContent };

package/dist/types/protocal/content/echarts.js

@@ -0,0 +1 @@
+export {  };

package/dist/types/protocal/content/fileLink.d.ts

@@ -0,0 +1,14 @@
+//#region src/types/protocal/content/fileLink.d.ts
+declare enum ViewType {
+  Inner = "inner",
+  // 内嵌在视图中
+  Link = "link",
+}
+interface FileLinkContent {
+  label: string;
+  link: string;
+  view: ViewType;
+  table?: string;
+}
+//#endregion
+export { FileLinkContent, ViewType };

package/dist/types/protocal/content/fileLink.js

@@ -0,0 +1,9 @@
+//#region src/types/protocal/content/fileLink.ts
+let ViewType = /* @__PURE__ */ function(ViewType$1) {
+	ViewType$1["Inner"] = "inner";
+	ViewType$1["Link"] = "link";
+	return ViewType$1;
+}({});
+
+//#endregion
+export { ViewType };

package/dist/types/protocal/content/form.d.ts

@@ -0,0 +1,49 @@
+//#region src/types/protocal/content/form.d.ts
+type FieldType = 'String' | 'Number' | 'Boolean' | 'JSON' | 'Select' | 'Checkbox' | 'Time' | 'Text' | 'HTML' | 'Structure' | 'Attachment';
+type ConditionOperator = 'eq' | 'ne' | 'gt' | 'lt' | 'gte' | 'lte' | 'in' | 'notIn' | 'regexp' | 'nregexp';
+interface CommonOption {
+  label: string;
+  value: string | number | boolean;
+}
+interface FieldCondition {
+  field: string;
+  operator?: ConditionOperator;
+  value: any;
+}
+interface SchemaFiled {
+  field: string;
+  type: FieldType;
+  label?: string;
+  value?: any;
+  filePath?: string;
+  required?: boolean;
+  placeholder?: string;
+  options?: CommonOption[];
+  booleanOptions?: [string, string];
+  regex?: string;
+  regexErrorMessage?: string;
+  condition?: FieldCondition;
+  disabled?: boolean;
+  hint?: string;
+  order?: number;
+  multiple?: boolean;
+}
+interface Schema {
+  fields: SchemaFiled[];
+}
+declare enum ActionType {
+  Chat = "chat",
+  Request = "request",
+  OpenForm = "open-form",
+}
+interface Action {
+  type: ActionType;
+  value: string | FormContent;
+}
+interface FormContent {
+  schema: Schema;
+  action?: Action;
+  [propName: string]: any;
+}
+//#endregion
+export { Action, ActionType, CommonOption, ConditionOperator, FieldCondition, FieldType, FormContent, Schema, SchemaFiled };

package/dist/types/protocal/content/form.js

@@ -0,0 +1,10 @@
+//#region src/types/protocal/content/form.ts
+let ActionType = /* @__PURE__ */ function(ActionType$1) {
+	ActionType$1["Chat"] = "chat";
+	ActionType$1["Request"] = "request";
+	ActionType$1["OpenForm"] = "open-form";
+	return ActionType$1;
+}({});
+
+//#endregion
+export { ActionType };