@ai-setting/roy-agent-core 1.4.13 → 1.4.15

package/dist/shared/@ai-setting/roy-agent-core-6a72jfdy.js

@@ -0,0 +1,303 @@
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-j3wc4465.js";
+
+// src/env/mcp/tool/adapter.ts
+init_logger();
+import { z } from "zod";
+var logger = createLogger("mcp-adapter");
+function adaptMcpTool(mcpTool, mcpClient, serverName) {
+  const toolName = `mcp_${serverName}_${mcpTool.name}`;
+  const description = `MCP tool [${serverName}/${mcpTool.name}]: ${mcpTool.description ?? ""}`;
+  const paramsSchema = convertInputSchemaToZod(mcpTool.inputSchema);
+  return {
+    name: toolName,
+    description,
+    parameters: paramsSchema,
+    execute: async (args, _ctx) => {
+      try {
+        const result = await mcpClient.callTool({
+          name: mcpTool.name,
+          arguments: args ?? {}
+        });
+        return convertMcpCallResult(result);
+      } catch (error) {
+        logger.error(`[McpAdapter] Tool call failed: ${toolName}`, {
+          error: error instanceof Error ? error.message : String(error)
+        });
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+    },
+    metadata: {
+      category: "mcp",
+      tags: ["mcp", serverName],
+      mcpTool: {
+        originalName: mcpTool.name,
+        originalDescription: mcpTool.description || "",
+        inputSchema: mcpTool.inputSchema
+      }
+    }
+  };
+}
+function convertInputSchemaToZod(inputSchema) {
+  if (!inputSchema) {
+    return z.unknown();
+  }
+  const schema = inputSchema;
+  const properties = schema.properties ?? {};
+  const required = schema.required ?? [];
+  if (schema.anyOf || schema.oneOf) {
+    const unions = schema.anyOf || schema.oneOf || [];
+    const zodUnions = unions.map((s) => jsonSchemaToZod(s, false)).filter((t) => t);
+    if (zodUnions.length > 0) {
+      return z.union(zodUnions);
+    }
+  }
+  if (schema.allOf) {
+    const schemas = [];
+    for (const subSchema of schema.allOf) {
+      const sub = jsonSchemaToZod(subSchema, false);
+      schemas.push(sub);
+    }
+    if (schemas.length === 1) {
+      return schemas[0];
+    }
+    let combined = schemas[0];
+    for (let i = 1;i < schemas.length; i++) {
+      combined = z.intersection(combined, schemas[i]);
+    }
+    return combined;
+  }
+  const zodFields = {};
+  const fieldDescriptions = {};
+  for (const [key, prop] of Object.entries(properties)) {
+    const isRequired = required.includes(key);
+    const fieldResult = jsonSchemaToZod(prop, !isRequired);
+    const propSchema = prop;
+    if (propSchema.description) {
+      fieldDescriptions[key] = propSchema.description;
+    }
+    if (!isRequired) {
+      zodFields[key] = fieldResult.optional();
+    } else {
+      zodFields[key] = fieldResult;
+    }
+  }
+  if (Object.keys(zodFields).length === 0) {
+    return schema.description ? z.unknown().describe(schema.description) : z.unknown();
+  }
+  const result = z.object(zodFields);
+  if (schema.description) {
+    return result.describe(schema.description);
+  }
+  return result;
+}
+function jsonSchemaToZod(prop, isOptional) {
+  const description = prop.description;
+  let baseType;
+  if (prop.nullable === true) {
+    const innerType = jsonSchemaToZod({ ...prop, nullable: undefined }, isOptional);
+    baseType = z.union([innerType, z.null()]);
+    if (description) {
+      return baseType.describe(description);
+    }
+    return baseType;
+  }
+  if (prop.anyOf || prop.oneOf) {
+    const unions = prop.anyOf || prop.oneOf || [];
+    const zodUnions = unions.map((s) => jsonSchemaToZod(s, false)).filter((t) => t);
+    if (zodUnions.length > 0) {
+      baseType = z.union(zodUnions);
+      if (description) {
+        return baseType.describe(description);
+      }
+      return baseType;
+    }
+  }
+  if (prop.allOf) {
+    const schemas = [];
+    for (const subSchema of prop.allOf) {
+      const sub = jsonSchemaToZod(subSchema, false);
+      schemas.push(sub);
+    }
+    if (schemas.length === 1) {
+      baseType = schemas[0];
+    } else {
+      baseType = z.intersection(schemas[0], schemas[1]);
+      for (let i = 2;i < schemas.length; i++) {
+        baseType = z.intersection(baseType, schemas[i]);
+      }
+    }
+    if (description) {
+      return baseType.describe(description);
+    }
+    return baseType;
+  }
+  const types = prop.types || (prop.type ? [prop.type] : []);
+  if (types.length > 1) {
+    const zodTypes = types.map((t) => getZodTypeForBasicType(t, prop)).filter((t) => t);
+    if (zodTypes.length > 0) {
+      baseType = z.union(zodTypes);
+      if (description) {
+        return baseType.describe(description);
+      }
+      return baseType;
+    }
+  }
+  const type = types[0];
+  if (!type) {
+    if (prop.enum) {
+      return handleEnum(prop, description);
+    }
+    baseType = z.unknown();
+    if (description) {
+      return baseType.describe(description);
+    }
+    return baseType;
+  }
+  baseType = getZodTypeForBasicType(type, prop);
+  if (description) {
+    const schemaDescription = baseType._def?.description;
+    if (schemaDescription) {
+      return baseType.describe(`${schemaDescription}. ${description}`);
+    }
+    return baseType.describe(description);
+  }
+  return baseType;
+}
+function getZodTypeForBasicType(type, prop) {
+  switch (type) {
+    case "string": {
+      if (prop.enum && prop.enum.length > 0 && prop.enum.every((v) => typeof v === "string")) {
+        return handleEnum(prop, prop.description);
+      }
+      let schema = z.string();
+      if (typeof prop.minLength === "number") {
+        schema = schema.min(prop.minLength);
+      }
+      if (typeof prop.maxLength === "number") {
+        schema = schema.max(prop.maxLength);
+      }
+      if (prop.pattern) {
+        try {
+          schema = schema.regex(new RegExp(prop.pattern));
+        } catch {}
+      }
+      if (prop.format) {
+        schema = schema.describe(`Format: ${prop.format}`);
+      }
+      if (prop.default !== undefined) {
+        schema = schema.default(prop.default);
+      }
+      return schema;
+    }
+    case "number":
+    case "integer": {
+      let schema = type === "integer" ? z.number().int() : z.number();
+      if (typeof prop.minimum === "number") {
+        schema = schema.min(prop.minimum);
+      }
+      if (typeof prop.maximum === "number") {
+        schema = schema.max(prop.maximum);
+      }
+      if (prop.default !== undefined) {
+        schema = schema.default(prop.default);
+      }
+      return schema;
+    }
+    case "boolean": {
+      let schema = z.boolean();
+      if (prop.default !== undefined) {
+        schema = schema.default(prop.default);
+      }
+      return schema;
+    }
+    case "array": {
+      let itemSchema = z.unknown();
+      if (prop.items) {
+        itemSchema = jsonSchemaToZod(prop.items, false);
+      }
+      let schema = z.array(itemSchema);
+      if (prop.additionalProperties && typeof prop.additionalProperties !== "boolean") {
+        const additionalItems = jsonSchemaToZod(prop.additionalProperties, false);
+        schema = z.array(z.union([itemSchema, additionalItems]));
+      }
+      return schema;
+    }
+    case "object": {
+      if (prop.properties) {
+        const fields = {};
+        const required = prop.required ?? [];
+        for (const [key, value] of Object.entries(prop.properties)) {
+          const isRequired = required.includes(key);
+          fields[key] = isRequired ? jsonSchemaToZod(value, false) : jsonSchemaToZod(value, true).optional();
+        }
+        return z.object(fields);
+      }
+      if (prop.additionalProperties) {
+        if (typeof prop.additionalProperties === "boolean") {
+          return z.record(z.string(), z.unknown());
+        }
+        return z.record(z.string(), jsonSchemaToZod(prop.additionalProperties, false));
+      }
+      return z.record(z.string(), z.unknown());
+    }
+    case "null":
+      return z.null();
+    case "null | string":
+    case "string | null":
+      return z.union([z.string(), z.null()]);
+    case "null | number":
+    case "number | null":
+      return z.union([z.number(), z.null()]);
+    default:
+      if (prop.enum) {
+        return handleEnum(prop);
+      }
+      return z.unknown();
+  }
+}
+function handleEnum(prop, existingDescription) {
+  if (!prop.enum || prop.enum.length === 0) {
+    return z.unknown();
+  }
+  const stringValues = prop.enum.filter((v) => typeof v === "string");
+  if (stringValues.length === 0) {
+    return z.any();
+  }
+  let schema;
+  if (stringValues.length === 1) {
+    schema = z.literal(stringValues[0]);
+  } else {
+    schema = z.enum([stringValues[0], ...stringValues.slice(1)]);
+  }
+  const valuesList = stringValues.map((v) => `"${v}"`).join(", ");
+  const valuesDescription = `Valid values: ${valuesList}`;
+  if (existingDescription) {
+    return schema.describe(`${existingDescription}. ${valuesDescription}`);
+  }
+  return schema.describe(valuesDescription);
+}
+function convertMcpCallResult(result) {
+  const content = result.content;
+  const textContent = content?.filter((c) => c.type === "text")?.map((c) => c.text)?.join("") ?? "";
+  return {
+    success: !result.isError,
+    output: textContent,
+    error: result.isError ? textContent : undefined
+  };
+}
+function createMcpToolsDescription(tools) {
+  if (tools.length === 0) {
+    return "  No MCP tools currently available.";
+  }
+  return tools.map((t) => `  - ${t.name}: ${t.description}`).join(`
+`);
+}
+
+export { adaptMcpTool, convertInputSchemaToZod, createMcpToolsDescription };

package/dist/shared/{chunk-1aakcfp1.js → @ai-setting/roy-agent-core-7f303ffd.js}

@@ -3,9 +3,9 @@ import {
   getTracerProvider,
   init_tracer_provider,
   resetTracerProvider
-} from "./chunk-q9j99fsm.js";
-import"./chunk-1qwabsm0.js";
-import"./chunk-wbkh7wat.js";
+} from "./roy-agent-core-fv32jaa8.js";
+import"./roy-agent-core-bncgx3gb.js";
+import"./roy-agent-core-fs0mn2jk.js";
 init_tracer_provider();
 
 export {

package/dist/shared/@ai-setting/roy-agent-core-7fgf85wc.js

@@ -0,0 +1,284 @@
+import {
+  init_decorator_node
+} from "./roy-agent-core-1ce3fqrk.js";
+
+// src/env/workflow/decorators/workflow.ts
+import"reflect-metadata";
+
+// src/env/workflow/metadata/keys.ts
+var WORKFLOW_METADATA_KEY = Symbol("workflow:metadata");
+var NODE_METADATA_KEY = Symbol("workflow:node");
+var EDGE_METADATA_KEY = Symbol("workflow:edges");
+
+// src/env/workflow/decorators/workflow.ts
+function Workflow(options) {
+  return function(target) {
+    const metadata = {
+      name: options.name,
+      version: options.version || "1.0",
+      description: options.description,
+      entry: options.entry,
+      config: options.config,
+      tags: options.tags || [],
+      author: options.author
+    };
+    Reflect.defineMetadata(WORKFLOW_METADATA_KEY, metadata, target);
+    return target;
+  };
+}
+function getWorkflowMetadata(target) {
+  return Reflect.getMetadata(WORKFLOW_METADATA_KEY, target);
+}
+// src/env/workflow/decorators/node-as.ts
+import"reflect-metadata";
+function NodeAs(options = {}) {
+  return function(target, propertyKey, descriptor) {
+    const methodName = String(propertyKey);
+    const nodeMetadata = {
+      nodeId: options.nodeId || methodName,
+      nodeType: options.nodeType || "tool",
+      name: options.name,
+      dependsOn: normalizeDependsOn(options.dependsOn),
+      condition: options.condition,
+      retry: options.retry,
+      timeout: options.timeout,
+      config: options.config || {},
+      methodName,
+      method: descriptor.value
+    };
+    const existingNodes = Reflect.getMetadata(NODE_METADATA_KEY, target) || [];
+    const existingIndex = existingNodes.findIndex((n) => n.methodName === methodName);
+    if (existingIndex >= 0) {
+      existingNodes[existingIndex] = nodeMetadata;
+    } else {
+      existingNodes.push(nodeMetadata);
+    }
+    Reflect.defineMetadata(NODE_METADATA_KEY, existingNodes, target);
+    return descriptor;
+  };
+}
+function normalizeDependsOn(dependsOn) {
+  if (!dependsOn) {
+    return [];
+  }
+  return Array.isArray(dependsOn) ? dependsOn : [dependsOn];
+}
+function getNodeMetadatas(target) {
+  return Reflect.getMetadata(NODE_METADATA_KEY, target) || [];
+}
+// src/env/workflow/decorators/edge.ts
+import"reflect-metadata";
+function Edge(from, to) {
+  return function(target, propertyKey, descriptor) {
+    const edge = { from, to };
+    const existingEdges = Reflect.getMetadata(EDGE_METADATA_KEY, target) || [];
+    existingEdges.push(edge);
+    Reflect.defineMetadata(EDGE_METADATA_KEY, existingEdges, target);
+    return descriptor;
+  };
+}
+function WorkflowEdges(edges) {
+  return function(target) {
+    const edgeMetadatas = edges.map((edge) => ({
+      from: edge.from,
+      to: edge.to,
+      condition: edge.condition
+    }));
+    Reflect.defineMetadata(EDGE_METADATA_KEY, edgeMetadatas, target);
+    return target;
+  };
+}
+function getEdgeMetadatas(target) {
+  return Reflect.getMetadata(EDGE_METADATA_KEY, target) || [];
+}
+
+// src/env/workflow/decorators/index.ts
+init_decorator_node();
+
+// src/env/workflow/extractor/workflow-converter.ts
+import"reflect-metadata";
+class WorkflowConverter {
+  static extractWorkflowMetadata(targetClass) {
+    return getWorkflowMetadata(targetClass);
+  }
+  static extractNodeMetadatas(targetClass) {
+    return getNodeMetadatas(targetClass.prototype);
+  }
+  static extractEdgeMetadatas(targetClass) {
+    return getEdgeMetadatas(targetClass);
+  }
+  static fromClass(targetClass, instance) {
+    const workflowMeta = this.extractWorkflowMetadata(targetClass);
+    if (!workflowMeta) {
+      throw new Error("Class must be decorated with @Workflow");
+    }
+    const nodeMetadatas = this.extractNodeMetadatas(targetClass);
+    if (nodeMetadatas.length === 0) {
+      throw new Error("At least one method must be decorated with @NodeAs");
+    }
+    const edgeMetadatas = this.extractEdgeMetadatas(targetClass);
+    const nodeMap = this.buildNodeMap(nodeMetadatas, edgeMetadatas);
+    const nodes = Array.from(nodeMap.values()).map((meta) => ({
+      id: meta.nodeId,
+      type: meta.nodeType,
+      name: meta.name,
+      config: {
+        ...meta.config,
+        _methodName: meta.methodName,
+        _instance: instance
+      },
+      depends_on: meta.dependsOn,
+      condition: meta.condition,
+      retry: meta.retry,
+      timeout: meta.timeout
+    }));
+    const entry = workflowMeta.entry || nodeMetadatas[0]?.nodeId || "unknown";
+    return {
+      name: workflowMeta.name,
+      version: workflowMeta.version || "1.0",
+      description: workflowMeta.description,
+      config: workflowMeta.config || {},
+      nodes,
+      entry,
+      outputs: [],
+      metadata: {
+        tags: workflowMeta.tags || [],
+        author: workflowMeta.author
+      }
+    };
+  }
+  static buildNodeMap(nodeMetadatas, edgeMetadatas) {
+    const nodeMap = new Map;
+    for (const nodeMeta of nodeMetadatas) {
+      nodeMap.set(nodeMeta.nodeId, { ...nodeMeta });
+    }
+    for (const edge of edgeMetadatas) {
+      const targetNode = nodeMap.get(edge.to);
+      if (targetNode) {
+        if (!targetNode.dependsOn.includes(edge.from)) {
+          targetNode.dependsOn = [...targetNode.dependsOn, edge.from];
+        }
+        if (edge.condition) {
+          if (targetNode.condition) {
+            targetNode.condition = `(${targetNode.condition}) AND (${edge.condition})`;
+          } else {
+            targetNode.condition = edge.condition;
+          }
+        }
+      }
+    }
+    return nodeMap;
+  }
+  static validateWorkflowClass(targetClass) {
+    const errors = [];
+    const warnings = [];
+    const workflowMeta = this.extractWorkflowMetadata(targetClass);
+    if (!workflowMeta) {
+      errors.push("Class must be decorated with @Workflow");
+      return { valid: false, errors, warnings };
+    }
+    const nodeMetadatas = this.extractNodeMetadatas(targetClass);
+    if (nodeMetadatas.length === 0) {
+      errors.push("At least one method must be decorated with @NodeAs");
+      return { valid: false, errors, warnings };
+    }
+    const entry = workflowMeta.entry;
+    if (entry) {
+      const entries = Array.isArray(entry) ? entry : [entry];
+      for (const e of entries) {
+        if (!nodeMetadatas.find((n) => n.nodeId === e)) {
+          errors.push(`Entry node '${e}' not found`);
+        }
+      }
+    }
+    for (const node of nodeMetadatas) {
+      for (const dep of node.dependsOn) {
+        if (!nodeMetadatas.find((n) => n.nodeId === dep)) {
+          errors.push(`Node '${node.nodeId}' depends on non-existent node '${dep}'`);
+        }
+      }
+    }
+    if (this.hasCycle(nodeMetadatas)) {
+      errors.push("Workflow contains a cycle");
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  static hasCycle(nodeMetadatas) {
+    const visited = new Set;
+    const recStack = new Set;
+    const adjList = new Map;
+    for (const node of nodeMetadatas) {
+      adjList.set(node.nodeId, []);
+    }
+    for (const node of nodeMetadatas) {
+      for (const dep of node.dependsOn) {
+        const deps = adjList.get(dep);
+        if (deps) {
+          deps.push(node.nodeId);
+        }
+      }
+    }
+    const dfs = (nodeId) => {
+      visited.add(nodeId);
+      recStack.add(nodeId);
+      const neighbors = adjList.get(nodeId) || [];
+      for (const neighbor of neighbors) {
+        if (!visited.has(neighbor)) {
+          if (dfs(neighbor)) {
+            return true;
+          }
+        } else if (recStack.has(neighbor)) {
+          return true;
+        }
+      }
+      recStack.delete(nodeId);
+      return false;
+    };
+    for (const node of nodeMetadatas) {
+      if (!visited.has(node.nodeId)) {
+        if (dfs(node.nodeId)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  static async executeNode(nodeDef, context) {
+    const instance = nodeDef.config._instance;
+    const methodName = nodeDef.config._methodName;
+    if (!instance || !methodName) {
+      return { output: undefined, error: new Error("Missing method information") };
+    }
+    const method = instance[methodName];
+    if (typeof method !== "function") {
+      return { output: undefined, error: new Error(`Method ${methodName} is not a function`) };
+    }
+    const deps = nodeDef.depends_on || [];
+    let input = context.input;
+    if (deps.length > 0) {
+      input = {};
+      for (const depId of deps) {
+        input[depId] = context.previousOutputs.get(depId);
+      }
+    }
+    try {
+      const result = await method.call(instance, input);
+      return { output: result };
+    } catch (error) {
+      return {
+        output: undefined,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+    }
+  }
+}
+// src/env/workflow/utils/create-workflow.ts
+function createWorkflowFromClass(targetClass, options) {
+  const instance = options?.instance ?? new targetClass(...options?.constructorArgs ?? []);
+  return WorkflowConverter.fromClass(targetClass, instance);
+}
+export { Workflow, getWorkflowMetadata, NodeAs, getNodeMetadatas, Edge, WorkflowEdges, getEdgeMetadatas, WorkflowConverter, createWorkflowFromClass };

package/dist/shared/{chunk-t1rh6jtm.js → @ai-setting/roy-agent-core-7n436rb4.js}

@@ -1,16 +1,13 @@
+import {
+  getDatabase
+} from "./roy-agent-core-37e4tep3.js";
 import {
   exports_search_query_parser,
   init_search_query_parser
-} from "./chunk-ze20rksg.js";
-import {
-  getDatabase
-} from "./chunk-1pf5mfgd.js";
-import"./chunk-a9qmy3sc.js";
-import"./chunk-q9j99fsm.js";
-import"./chunk-1qwabsm0.js";
+} from "./roy-agent-core-rvxg1wps.js";
 import {
   __toCommonJS
-} from "./chunk-wbkh7wat.js";
+} from "./roy-agent-core-fs0mn2jk.js";
 
 // src/env/workflow/storage/workflow-repo.ts
 import { randomUUID } from "crypto";
@@ -199,7 +196,5 @@ class WorkflowRepository {
     return rows.map(rowToWorkflow);
   }
 }
-export {
-  rowToWorkflow,
-  WorkflowRepository
-};
+
+export { rowToWorkflow, WorkflowRepository };