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

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

@@ -1,18 +1,15 @@
+import {
+  getDatabase
+} from "./roy-agent-core-qxybm159.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-0sgn3de4.js";
 import {
   __toCommonJS
-} from "./chunk-wbkh7wat.js";
+} from "./roy-agent-core-fs0mn2jk.js";
 
-// src/env/workflow/storage/workflow-repo.ts
+// packages/core/src/env/workflow/storage/workflow-repo.ts
 import { randomUUID } from "crypto";
 function rowToWorkflow(row) {
   const metadata = JSON.parse(row.metadata);
@@ -199,7 +196,5 @@ class WorkflowRepository {
     return rows.map(rowToWorkflow);
   }
 }
-export {
-  rowToWorkflow,
-  WorkflowRepository
-};
+
+export { rowToWorkflow, WorkflowRepository };

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

@@ -0,0 +1,303 @@
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-yn761yve.js";
+
+// packages/core/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/@ai-setting/roy-agent-core-w75rafhy.js

@@ -0,0 +1,202 @@
+// packages/core/src/env/hook/hook-manager.ts
+class HookManager {
+  _hooks = new Map;
+  componentName;
+  componentVersion;
+  defaultPriority;
+  constructor(options = {}) {
+    this.componentName = options.componentName ?? "unknown";
+    this.componentVersion = options.componentVersion ?? "0.0.0";
+    this.defaultPriority = options.defaultPriority ?? 0;
+  }
+  register(hookPoint, hook) {
+    const hooks = this.getOrCreateHooks(hookPoint);
+    hooks.push(hook);
+  }
+  registerMany(hookPoint, hooks) {
+    const hookList = this.getOrCreateHooks(hookPoint);
+    hookList.push(...hooks);
+  }
+  unregister(hookPoint, name) {
+    const hooks = this._hooks.get(hookPoint);
+    if (!hooks)
+      return false;
+    const index = hooks.findIndex((h) => h.name === name);
+    if (index === -1)
+      return false;
+    hooks.splice(index, 1);
+    return true;
+  }
+  unregisterAll(hookPoint) {
+    this._hooks.delete(hookPoint);
+  }
+  async execute(hookPoint, data, metadata = {}) {
+    const hooks = this._hooks.get(hookPoint);
+    if (!hooks || hooks.length === 0)
+      return;
+    const sortedHooks = this.sortHooks(hooks);
+    const ctx = this.createContext(hookPoint, data, metadata, "before");
+    for (const hook of sortedHooks) {
+      await this.safeExecute(hook, ctx);
+    }
+  }
+  async executeAndCollect(hookPoint, data, metadata = {}) {
+    const hooks = this._hooks.get(hookPoint);
+    if (!hooks || hooks.length === 0)
+      return [];
+    const sortedHooks = this.sortHooks(hooks);
+    const ctx = this.createContext(hookPoint, data, metadata, "before");
+    const results = [];
+    for (const hook of sortedHooks) {
+      const result = await this.safeExecuteAndReturn(hook, ctx);
+      if (result !== undefined) {
+        results.push(result);
+      }
+    }
+    return results;
+  }
+  count(hookPoint) {
+    return this._hooks.get(hookPoint)?.length ?? 0;
+  }
+  clear() {
+    this._hooks.clear();
+  }
+  getHookPoints() {
+    return Array.from(this._hooks.keys());
+  }
+  hasHooks(hookPoint) {
+    return this.count(hookPoint) > 0;
+  }
+  setComponentInfo(name, version) {
+    this.componentName = name;
+    this.componentVersion = version;
+  }
+  get hooks() {
+    return this._hooks;
+  }
+  async executeWithIntervention(hookPoint, data, metadata = {}) {
+    const hooks = this._hooks.get(hookPoint);
+    if (!hooks || hooks.length === 0) {
+      return { stopped: false, results: [] };
+    }
+    const sortedHooks = this.sortHooks(hooks);
+    const ctx = this.createContext(hookPoint, data, metadata, "before");
+    const results = [];
+    let stopped = false;
+    let action;
+    for (const hook of sortedHooks) {
+      if (stopped)
+        break;
+      const result = await this.safeExecuteAndReturn(hook, ctx);
+      results.push(result);
+      if (result && typeof result === "object" && "stopped" in result) {
+        const hookResult = result;
+        if (hookResult.stopped) {
+          stopped = true;
+          action = hookResult.action;
+        }
+      }
+    }
+    return { stopped, action, results };
+  }
+  getOrCreateHooks(hookPoint) {
+    let hooks = this._hooks.get(hookPoint);
+    if (!hooks) {
+      hooks = [];
+      this._hooks.set(hookPoint, hooks);
+    }
+    return hooks;
+  }
+  sortHooks(hooks) {
+    return [...hooks].sort((a, b) => {
+      const priorityA = a.priority ?? this.defaultPriority;
+      const priorityB = b.priority ?? this.defaultPriority;
+      return priorityA - priorityB;
+    });
+  }
+  createContext(hookPoint, data, metadata, phase) {
+    return {
+      component: {
+        name: this.componentName,
+        version: this.componentVersion
+      },
+      data,
+      metadata,
+      phase,
+      hookPoint
+    };
+  }
+  async safeExecute(hook, ctx) {
+    try {
+      await hook.execute(ctx);
+    } catch (error) {
+      console.error(`Hook "${hook.name}" failed:`, error);
+    }
+  }
+  async safeExecuteAndReturn(hook, ctx) {
+    try {
+      return await hook.execute(ctx);
+    } catch (error) {
+      console.error(`Hook "${hook.name}" failed:`, error);
+      return;
+    }
+  }
+}
+
+// packages/core/src/env/hook/global-hook-manager.ts
+var globalHookManager = new HookManager;
+var AgentHookPoints = {
+  BEFORE_START: "agent:before.start",
+  BEFORE_LLM: "agent:before.llm",
+  AFTER_LLM: "agent:after.llm",
+  BEFORE_TOOL: "agent:before.tool",
+  AFTER_TOOL: "agent:after.tool",
+  ON_ITERATION: "agent:on.iteration",
+  ON_THRESHOLD: "agent:on.threshold",
+  AFTER_COMPLETE: "agent:after.complete",
+  ON_ERROR: "agent:on.error"
+};
+var LLMHookPoints = {
+  BEFORE_INVOKE: "llm:before.invoke",
+  AFTER_INVOKE: "llm:after.invoke",
+  ON_STREAM: "llm:on.stream"
+};
+var ToolHookPoints = {
+  BEFORE_EXECUTE: "tool:before.execute",
+  AFTER_EXECUTE: "tool:after.execute",
+  BEFORE_REGISTER: "tool:before.register",
+  AFTER_REGISTER: "tool:after.register",
+  ON_ERROR: "tool:on.error"
+};
+var hookPointAliases = {
+  "before.tool": "tool:before.execute",
+  "after.tool": "tool:after.execute",
+  "llm.before-invoke": "llm:before.invoke",
+  "llm.after-invoke": "llm:after.invoke",
+  "llm.stream": "llm:on.stream"
+};
+function setupAliasHooks() {
+  const originalRegister = globalHookManager.register.bind(globalHookManager);
+  globalHookManager.register = function(hookPoint, hook) {
+    originalRegister(hookPoint, hook);
+    const alias = hookPointAliases[hookPoint];
+    if (alias) {
+      originalRegister(alias, hook);
+    }
+  };
+}
+setupAliasHooks();
+async function executeAgentHook(hookPoint, data, metadata = {}) {
+  await globalHookManager.execute(hookPoint, data, metadata);
+}
+async function executeAgentHookWithIntervention(hookPoint, data, metadata = {}) {
+  return globalHookManager.executeWithIntervention(hookPoint, data, metadata);
+}
+async function executeLLMHook(hookPoint, data, metadata = {}) {
+  await globalHookManager.execute(hookPoint, data, metadata);
+}
+async function executeToolHook(hookPoint, data, metadata = {}) {
+  await globalHookManager.execute(hookPoint, data, metadata);
+}
+
+export { HookManager, globalHookManager, AgentHookPoints, LLMHookPoints, ToolHookPoints, executeAgentHook, executeAgentHookWithIntervention, executeLLMHook, executeToolHook };