@baishuyun/agents 0.0.1

package/src/form-builder/utils/process-confirm-tool-call.ts

@@ -0,0 +1,123 @@
+import {
+  convertToModelMessages,
+  type Tool,
+  type ToolCallOptions,
+  type ToolSet,
+  type UIMessageStreamWriter,
+  getToolName,
+  isToolUIPart,
+} from "ai";
+
+import type { FormBuildUIMessage } from "../types/index.js";
+import { APPROVAL } from "../consts/index.js";
+
+function isValidToolName<K extends PropertyKey, T extends object>(
+  key: K,
+  obj: T,
+): key is K & keyof T {
+  return key in obj;
+}
+
+export async function processFormBuildConfirmToolCalls<
+  Tools extends ToolSet,
+  ExecutableTools extends {
+    [Tool in keyof Tools as Tools[Tool] extends { execute: Function }
+      ? never
+      : Tool]: Tools[Tool];
+  },
+>(
+  {
+    writer,
+    messages,
+  }: {
+    tools: Tools; // used for type inference
+    writer: UIMessageStreamWriter;
+    messages: FormBuildUIMessage[]; // IMPORTANT: replace with your message type
+  },
+  executeFunctions: {
+    [K in keyof Tools & keyof ExecutableTools]?: (
+      args: ExecutableTools[K] extends Tool<infer P> ? P : never,
+      context: ToolCallOptions,
+    ) => Promise<any>;
+  },
+): Promise<FormBuildUIMessage[]> {
+  const lastMessage = messages[messages.length - 1];
+  const parts = lastMessage.parts;
+  if (!parts) return messages;
+
+  const processedParts = await Promise.all(
+    parts.map(async (part) => {
+      // Only process tool invocations parts
+      if (!isToolUIPart(part)) return part;
+
+      const toolName = getToolName(part);
+
+      // Only continue if we have an execute function for the tool (meaning it requires confirmation) and it's in a 'output-available' state
+      if (!(toolName in executeFunctions) || part.state !== "output-available")
+        return part;
+
+      let result;
+
+      if (part.output === APPROVAL.YES) {
+        // Get the tool and check if the tool has an execute function.
+        if (
+          !isValidToolName(toolName, executeFunctions) ||
+          part.state !== "output-available"
+        ) {
+          return part;
+        }
+
+        const toolInstance = executeFunctions[toolName] as Tool["execute"];
+        if (toolInstance) {
+          result = await toolInstance(part.input, {
+            messages: convertToModelMessages(messages),
+            toolCallId: part.toolCallId,
+          });
+        } else {
+          result = "Error: No execute function found on tool";
+        }
+      } else if (part.output === APPROVAL.NO) {
+        result = "已取消操作。";
+      } else {
+        // For any unhandled responses, return the original part.
+        return part;
+      }
+
+      // Forward updated tool result to the client.
+      writer.write({
+        type: "tool-output-available",
+        toolCallId: part.toolCallId,
+        output: result,
+      });
+
+      // Return updated toolInvocation with the actual result.
+      return {
+        ...part,
+        output: result,
+      };
+    }),
+  );
+
+  // Finally return the processed messages
+  return [...messages.slice(0, -1), { ...lastMessage, parts: processedParts }];
+}
+
+export function getToolsRequiringConfirmation<T extends ToolSet>(
+  tools: T,
+): string[] {
+  return (Object.keys(tools) as (keyof T)[]).filter((key) => {
+    const maybeTool = tools[key];
+    return typeof maybeTool.execute !== "function";
+  }) as string[];
+}
+
+export function getExecutableTools<T extends ToolSet>(tools: T): Set<string> {
+  const results = new Set<string>();
+  (Object.keys(tools) as (keyof T)[]).forEach((key) => {
+    const maybeTool = tools[key];
+    if (typeof maybeTool.execute === "function") {
+      results.add(key as string);
+    }
+  });
+  return results;
+}

package/src/form-designer/index.ts

@@ -0,0 +1,61 @@
+import { type InferUITools } from 'ai';
+import { designPrompt } from './prompts.js';
+import { ds } from '../form-builder/model/ds.js';
+import { confirmToCreateForm } from '../form-builder/tools/index.js';
+import { EnhancedAgent } from '../utils/index.js';
+
+const tools = {
+  confirmToCreateForm,
+};
+
+export type DesignTools = InferUITools<typeof tools>;
+
+export type DesignConfirmPayload = {
+  formName: string;
+};
+
+export const DesignWithConfirmAgent = new EnhancedAgent<DesignConfirmPayload, {}>(
+  {
+    system: designPrompt,
+    model: ds,
+  },
+  {
+    type: 'data-confirm',
+    data: {
+      type: 'tool-confirmToCreateForm',
+      payload: {
+        formName: '',
+      },
+    },
+  },
+  {},
+  (_, body) => {
+    return {
+      formName: body.name,
+    };
+  }
+);
+
+export const createDisigner = () => {
+  return new EnhancedAgent<{ formName: string }, {}>(
+    {
+      system: designPrompt,
+      model: ds,
+    },
+    {
+      type: 'data-confirm',
+      data: {
+        type: 'tool-confirmToCreateForm',
+        payload: {
+          formName: '',
+        },
+      },
+    },
+    {},
+    (_, body) => {
+      return {
+        formName: body.name,
+      };
+    }
+  );
+};

package/src/form-designer/prompts.ts

@@ -0,0 +1,50 @@
+export const designPrompt = `
+你是表单字段设计专家，根据设计说明理解业务需求，首先对表单进行介绍，从业务角度输出简要的字段设计说明。
+
+格式：
+- 关联字段 label 命名无需加“关联”二字，直接像设计普通字段一样命名
+- 关联字段创建无需特定分区和说明，像设计普通字段一样设计
+- 统一使用中文
+
+注意：
+- 必须设计一个关联字段，即使在关联表中，也尝试继续生成关联字段（优先使用记录类字段）
+- 如果设计的是关联表，设计流水号字段，用来被其他表单关联
+- 字段数量控制在 10 个以内
+- 涉及到合同、记录相关等信息时，使用关联字段，组织架构相关信息，无需关联
+- 无需设计真实的表单，只需输出字段设计说明
+- 直接根据用户输入推断需求
+- 字段类型尽量使用多样化字段，避免单一字段类型
+
+输出示例：
+
+创建一张“用户信息”表，用于系统中管理和维护所有用户的基本资料和账户状态，支持用户身份识别、权限管理及后续业务流程的对接。该表是用户相关业务的核心表单，广泛应用于认证授权、客户管理、营销活动、服务交付等环节。
+
+**字段列举：**
+- 用户编号（唯一标识，主键）
+- 用户姓名（真实姓名）
+- 用户昵称（系统显示名）
+- 账户类型（如普通用户、管理员、VIP客户等）
+- 手机号码（用于登录和联系）
+- 电子邮箱（用于通知与找回密码）
+- 性别
+- 出生日期
+- 所在地区（省市区）
+- 详细地址
+- 注册渠道（如官网、App、第三方授权）
+- 用户状态（激活、冻结、注销等）
+- 最近登录时间
+- 登录次数
+- 关联账户（如公司/组织、合作伙伴）
+- 用户等级（积分等级或会员等级）
+- 备注说明
+
+**关联说明：**
+- 关联订单表（用户可关联多个订单）
+- 关联权限角色表（实现权限管理）
+- 关联营销活动参与记录表（用户参与的营销活动）
+- 关联客服工单表（用户反馈与支持）
+
+**设计说明：**
+该表结构设计兼顾用户身份信息的完整性与业务拓展需求，注重数据的规范化和关联性。字段覆盖用户基本身份信息及账户状态，有助于实现精准营销及服务管理。可根据实际业务需求扩展用户画像字段（如兴趣爱好、行为标签），或增加多账户、多设备管理等功能。与其他业务实体的关联设计方便后续业务流程的整合和数据分析。
+
+`;

package/src/utils/index.ts

@@ -0,0 +1,104 @@
+import {
+  Experimental_Agent as Agent,
+  type Experimental_AgentSettings as AgentSettings,
+  type ToolSet,
+  type UIDataTypes,
+} from 'ai';
+
+import { type ConfirmDataPart, type ConfirmMsg, type ValueOf } from '@baishuyun/types';
+
+type DataUIMessageChunk<DATA_TYPES extends UIDataTypes> = ValueOf<{
+  [NAME in keyof DATA_TYPES & string]: {
+    type: `data-${NAME}`;
+    id?: string;
+    data: DATA_TYPES[NAME];
+    transient?: boolean;
+  };
+}>;
+
+import { convertToModelMessages, createUIMessageStream, createUIMessageStreamResponse } from 'ai';
+
+export class EnhancedAgent<
+  ConfirmPayload,
+  TOOLS extends ToolSet,
+  OUTPUT = never,
+  OUTPUT_PARTIAL = never,
+> {
+  private agent: Agent<TOOLS, OUTPUT, OUTPUT_PARTIAL>;
+
+  private confirmInfo?: DataUIMessageChunk<ConfirmDataPart<ConfirmPayload>>;
+
+  private context: any = {};
+
+  private buildPayload: (ctx: any, body: any) => ConfirmPayload;
+
+  public static create<
+    ConfirmPayload,
+    TOOLS extends ToolSet,
+    OUTPUT = never,
+    OUTPUT_PARTIAL = never,
+  >(
+    agentSettings: AgentSettings<TOOLS, OUTPUT, OUTPUT_PARTIAL>,
+    confirmInfo?: DataUIMessageChunk<ConfirmDataPart<ConfirmPayload>>,
+    ctx: any = {},
+    buildPayload: (ctx: any, body: any) => ConfirmPayload = () => ({}) as ConfirmPayload
+  ) {
+    return new EnhancedAgent<ConfirmPayload, TOOLS, OUTPUT, OUTPUT_PARTIAL>(
+      agentSettings,
+      confirmInfo,
+      ctx,
+      buildPayload
+    );
+  }
+
+  public constructor(
+    agentSettings: AgentSettings<TOOLS, OUTPUT, OUTPUT_PARTIAL>,
+    confirmInfo?: DataUIMessageChunk<ConfirmDataPart<ConfirmPayload>>,
+    ctx: any = {},
+    buildPayload: (ctx: any, body: any) => ConfirmPayload = () => ({}) as ConfirmPayload
+  ) {
+    if (ctx) {
+      this.context = {
+        ...this.context,
+        ...ctx,
+      };
+    }
+
+    this.agent = new Agent({
+      ...agentSettings,
+      experimental_context: this.context,
+    });
+
+    this.buildPayload = buildPayload;
+
+    this.confirmInfo = confirmInfo;
+  }
+
+  public getCtx() {
+    return this.context;
+  }
+
+  public getResp(originalMessages: any, body: any) {
+    const stream = createUIMessageStream<ConfirmMsg<ConfirmPayload>>({
+      originalMessages,
+      execute: async ({ writer }) => {
+        const result = this.agent.stream({
+          messages: convertToModelMessages(originalMessages),
+        });
+
+        // 将结果写入流
+        writer.merge(result.toUIMessageStream({ originalMessages }));
+
+        for await (const _ of result.fullStream) {
+        }
+
+        if (this.confirmInfo) {
+          this.confirmInfo.data.payload = this.buildPayload(this.context, body);
+          writer.write(this.confirmInfo);
+        }
+      },
+    });
+
+    return createUIMessageStreamResponse({ stream });
+  }
+}

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "@baishuyun/typescript-config/ts-node.json",
+  "compilerOptions": {
+    "outDir": "./dist"
+  },
+  "references": [{ "path": "../types/tsconfig.json" }]
+}