@ai-setting/roy-agent-core 1.5.13-test → 1.5.15-test

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

@@ -1,349 +0,0 @@
-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

@@ -1,117 +0,0 @@
-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

@@ -1,11 +0,0 @@
-// 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 };