@ai-setting/roy-agent-core 1.5.15-test → 1.5.17-beta.1

package/dist/shared/@ai-setting/roy-agent-core-1akcqxj9.js

@@ -0,0 +1,349 @@
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-44hnfb02.js";
+
+// src/env/mcp/tool/adapter.ts
+init_logger();
+import { z } from "zod";
+var logger = createLogger("mcp-adapter");
+function validateRequiredParams(inputSchema, args) {
+  if (!inputSchema) {
+    return { valid: true, missing: [] };
+  }
+  const schema = inputSchema;
+  const required = schema.required ?? [];
+  if (required.length === 0) {
+    return { valid: true, missing: [] };
+  }
+  const missing = [];
+  for (const param of required) {
+    const value = args[param];
+    if (value === undefined || value === null) {
+      missing.push(param);
+    }
+  }
+  if (missing.length > 0) {
+    return {
+      valid: false,
+      missing,
+      error: `Missing required parameter${missing.length > 1 ? "s" : ""}: ${missing.join(", ")}`
+    };
+  }
+  return { valid: true, missing: [] };
+}
+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) => {
+      const toolArgs = args ?? {};
+      const validation = validateRequiredParams(mcpTool.inputSchema, toolArgs);
+      if (!validation.valid) {
+        logger.warn(`[McpAdapter] Tool call skipped: ${toolName}`, {
+          reason: "missing_required_params",
+          missing: validation.missing
+        });
+        return {
+          success: false,
+          output: "",
+          error: validation.error
+        };
+      }
+      try {
+        const result = await mcpClient.callTool({
+          name: mcpTool.name,
+          arguments: toolArgs
+        });
+        return convertMcpCallResult(result);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorCode = error?.code;
+        logger.error(`[McpAdapter] Tool call failed: ${toolName}`, {
+          error: errorMessage,
+          errorCode,
+          receivedArgs: toolArgs
+        });
+        let userMessage = errorMessage;
+        if (errorCode === -32602) {
+          userMessage = `Invalid parameters for tool "${mcpTool.name}": ${errorMessage}`;
+        }
+        return {
+          success: false,
+          output: "",
+          error: userMessage
+        };
+      }
+    },
+    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/@ai-setting/roy-agent-core-1ce3fqrk.js

@@ -0,0 +1,117 @@
+import {
+  __esm
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/workflow/decorators/decorator-node.ts
+class DecoratorNode {
+  type = "decorator";
+  id;
+  methodName;
+  instance;
+  dependsOn;
+  timeout;
+  retryConfig;
+  constructor(definition) {
+    const config = definition.config;
+    this.id = definition.id;
+    this.methodName = config._methodName;
+    this.instance = config._instance;
+    this.dependsOn = definition.depends_on || [];
+    this.timeout = definition.timeout;
+    this.retryConfig = definition.retry;
+  }
+  async execute(context) {
+    const startTime = Date.now();
+    const method = this.instance[this.methodName];
+    if (typeof method !== "function") {
+      return {
+        success: false,
+        error: `Method '${this.methodName}' is not a function`,
+        duration: Date.now() - startTime
+      };
+    }
+    const input = this.prepareInput(context);
+    const result = await this.executeWithRetry(input, context.abort);
+    return {
+      success: !result.error,
+      output: result.output,
+      error: result.error,
+      duration: Date.now() - startTime,
+      metadata: {
+        methodName: this.methodName
+      }
+    };
+  }
+  prepareInput(context) {
+    const nodeOutputs = context.nodeOutputs;
+    if (this.dependsOn.length === 0) {
+      return context.input || {};
+    }
+    const input = {};
+    for (const depId of this.dependsOn) {
+      const depOutput = nodeOutputs instanceof Map ? nodeOutputs.get(depId) : nodeOutputs?.[depId];
+      if (depOutput && typeof depOutput === "object") {
+        if ("output" in depOutput) {
+          input[depId] = depOutput.output;
+        } else {
+          input[depId] = depOutput;
+        }
+      }
+    }
+    return input;
+  }
+  async executeWithRetry(input, abort) {
+    const maxAttempts = this.retryConfig?.max_attempts ?? 1;
+    const backoff = this.retryConfig?.backoff ?? "exponential";
+    const initialDelay = this.retryConfig?.initial_delay ?? 1000;
+    let lastError;
+    for (let attempt = 1;attempt <= maxAttempts; attempt++) {
+      if (abort?.aborted) {
+        return { error: "Execution aborted" };
+      }
+      try {
+        const output = await this.executeWithTimeout(input, abort);
+        return { output };
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (attempt < maxAttempts) {
+          const delay = this.calculateBackoff(backoff, initialDelay, attempt - 1);
+          await this.sleep(delay, abort);
+        }
+      }
+    }
+    return { error: lastError?.message || "Unknown error" };
+  }
+  async executeWithTimeout(input, abort) {
+    if (!this.timeout) {
+      return this.instance[this.methodName](input);
+    }
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`Execution timeout after ${this.timeout}ms`));
+      }, this.timeout);
+    });
+    return Promise.race([
+      this.instance[this.methodName](input),
+      timeoutPromise
+    ]);
+  }
+  calculateBackoff(backoff, initialDelay, attempt) {
+    if (backoff === "exponential") {
+      return initialDelay * Math.pow(2, attempt);
+    }
+    return initialDelay;
+  }
+  sleep(ms, abort) {
+    return new Promise((resolve) => {
+      const timeout = setTimeout(resolve, ms);
+      abort?.addEventListener("abort", () => {
+        clearTimeout(timeout);
+        resolve();
+      });
+    });
+  }
+}
+var init_decorator_node = () => {};
+
+export { DecoratorNode, init_decorator_node };

package/dist/shared/@ai-setting/roy-agent-core-2dhd60aw.js

@@ -0,0 +1,11 @@
+// src/env/hook/types.ts
+function createHook(meta, fn) {
+  return {
+    ...meta,
+    execute: fn
+  };
+}
+function createPriorityHook(name, fn, priority) {
+  return createHook({ name, priority }, fn);
+}
+export { createHook, createPriorityHook };