@cuylabs/agent-core 0.8.0 → 0.10.0

package/dist/chunk-BFM2YHNM.js

@@ -1,222 +0,0 @@
-// src/safety/approval/risk.ts
-var DEFAULT_TOOL_RISKS = {
-  read: "safe",
-  read_file: "safe",
-  grep: "safe",
-  glob: "safe",
-  list_dir: "safe",
-  plan: "safe",
-  invoke_agent: "safe",
-  wait_agent: "safe",
-  close_agent: "safe",
-  skill: "safe",
-  skill_resource: "safe",
-  write: "moderate",
-  write_file: "moderate",
-  edit: "moderate",
-  edit_file: "moderate",
-  create_file: "moderate",
-  bash: "dangerous",
-  shell: "dangerous",
-  delete_file: "dangerous",
-  remove: "dangerous"
-};
-function getToolRisk(tool, customRisks) {
-  if (customRisks?.[tool]) {
-    return customRisks[tool];
-  }
-  if (DEFAULT_TOOL_RISKS[tool]) {
-    return DEFAULT_TOOL_RISKS[tool];
-  }
-  return "moderate";
-}
-
-// src/safety/approval/errors.ts
-var ApprovalDeniedError = class extends Error {
-  constructor(tool, args, message) {
-    super(message || `Operation denied: ${tool}`);
-    this.tool = tool;
-    this.args = args;
-    this.name = "ApprovalDeniedError";
-  }
-};
-var ApprovalTimeoutError = class extends Error {
-  constructor(tool, timeoutMs) {
-    super(`Approval timeout after ${timeoutMs}ms for: ${tool}`);
-    this.tool = tool;
-    this.timeoutMs = timeoutMs;
-    this.name = "ApprovalTimeoutError";
-  }
-};
-
-// src/safety/approval/patterns.ts
-function matchApprovalPattern(pattern, value) {
-  const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
-  return new RegExp(`^${regex}$`, "i").test(value);
-}
-function extractApprovalPatterns(tool, args) {
-  if (!args || typeof args !== "object") {
-    return [tool];
-  }
-  const record = args;
-  if ("path" in record && typeof record.path === "string" || "filePath" in record && typeof record.filePath === "string") {
-    const path = record.path ?? record.filePath;
-    const dir = path.substring(0, path.lastIndexOf("/") + 1);
-    return [dir ? `${dir}*` : path];
-  }
-  if ("command" in record && typeof record.command === "string") {
-    const command = record.command.split(/\s+/)[0];
-    return [command];
-  }
-  if ("pattern" in record && typeof record.pattern === "string") {
-    return [record.pattern];
-  }
-  return [tool];
-}
-function describeApprovalOperation(tool, args) {
-  if (!args || typeof args !== "object") {
-    return `Execute ${tool}`;
-  }
-  const record = args;
-  switch (tool) {
-    case "read":
-    case "read_file":
-      return `Read file: ${record.path ?? record.filePath}`;
-    case "write":
-    case "write_file":
-    case "create_file":
-      return `Write file: ${record.path ?? record.filePath}`;
-    case "edit":
-    case "edit_file":
-      return `Edit file: ${record.path ?? record.filePath}`;
-    case "delete_file":
-    case "remove":
-      return `Delete: ${record.path}`;
-    case "bash":
-    case "shell": {
-      const command = String(record.command);
-      return `Run command: ${command.slice(0, 100)}${command.length > 100 ? "..." : ""}`;
-    }
-    case "grep":
-      return `Search for: ${record.pattern}`;
-    case "glob":
-      return `Find files: ${record.pattern}`;
-    default:
-      return `${tool}(${JSON.stringify(args).slice(0, 50)}...)`;
-  }
-}
-
-// src/safety/approval/handler.ts
-var requestCounter = 0;
-function findMatchingRule(rules, tool, patterns) {
-  for (let index = rules.length - 1; index >= 0; index--) {
-    const rule = rules[index];
-    const toolMatches = rule.tool === "*" || matchApprovalPattern(rule.tool, tool);
-    const patternMatches = patterns.some(
-      (pattern) => matchApprovalPattern(rule.pattern, pattern)
-    );
-    if (toolMatches && patternMatches) {
-      return rule;
-    }
-  }
-  return void 0;
-}
-function createApprovalHandler(config = {}) {
-  const {
-    defaultAction = "ask",
-    timeout = 5 * 60 * 1e3,
-    onRequest
-  } = config;
-  const rules = [...config.rules ?? []];
-  const pending = /* @__PURE__ */ new Map();
-  async function request(sessionId, tool, args, customRisks) {
-    const risk = getToolRisk(tool, customRisks);
-    const patterns = extractApprovalPatterns(tool, args);
-    const matchingRule = findMatchingRule(rules, tool, patterns);
-    if (matchingRule) {
-      if (matchingRule.action === "allow") {
-        return;
-      }
-      throw new ApprovalDeniedError(
-        tool,
-        args,
-        `Denied by rule: ${matchingRule.pattern}`
-      );
-    }
-    if (risk === "safe" && defaultAction !== "deny") {
-      return;
-    }
-    if (!onRequest) {
-      if (defaultAction === "allow") {
-        return;
-      }
-      if (defaultAction === "deny") {
-        throw new ApprovalDeniedError(tool, args);
-      }
-      throw new ApprovalDeniedError(tool, args, "No approval handler configured");
-    }
-    const id = `approval-${++requestCounter}-${Date.now()}`;
-    const requestData = {
-      id,
-      sessionId,
-      tool,
-      args,
-      description: describeApprovalOperation(tool, args),
-      risk,
-      patterns,
-      timestamp: Date.now()
-    };
-    const action = await Promise.race([
-      new Promise((resolve, reject) => {
-        pending.set(id, { resolve, reject });
-        onRequest(requestData).then(resolve).catch(reject).finally(() => pending.delete(id));
-      }),
-      new Promise((_, reject) => {
-        setTimeout(() => {
-          pending.delete(id);
-          reject(new ApprovalTimeoutError(tool, timeout));
-        }, timeout);
-      })
-    ]);
-    switch (action) {
-      case "allow":
-        return;
-      case "deny":
-        throw new ApprovalDeniedError(tool, args);
-      case "remember":
-        for (const pattern of patterns) {
-          rules.push({ pattern, tool, action: "allow" });
-        }
-        return;
-    }
-  }
-  function cancelAll(reason) {
-    for (const [id, { reject }] of pending) {
-      reject(new Error(reason ?? "Cancelled"));
-      pending.delete(id);
-    }
-  }
-  function addRule(rule) {
-    rules.push(rule);
-  }
-  function getRules() {
-    return rules;
-  }
-  function clearSessionRules() {
-    rules.length = config.rules?.length ?? 0;
-  }
-  return {
-    request,
-    cancelAll,
-    addRule,
-    getRules,
-    clearSessionRules
-  };
-}
-
-export {
-  getToolRisk,
-  ApprovalDeniedError,
-  ApprovalTimeoutError,
-  createApprovalHandler
-};

package/dist/chunk-DWYX7ASF.js

@@ -1,26 +0,0 @@
-// src/models/identifiers.ts
-function getModelId(model) {
-  if (typeof model === "string") return model;
-  if (typeof model === "object" && model !== null && "modelId" in model) {
-    return String(model.modelId);
-  }
-  return String(model);
-}
-function getProviderId(model) {
-  if (typeof model === "string") {
-    if (model.includes("/")) {
-      return model.split("/")[0];
-    }
-    return void 0;
-  }
-  if (typeof model === "object" && model !== null && "provider" in model) {
-    const provider = String(model.provider);
-    return provider.split(".")[0];
-  }
-  return void 0;
-}
-
-export {
-  getModelId,
-  getProviderId
-};

package/dist/chunk-KUVSERLJ.js

@@ -1,50 +0,0 @@
-// src/signal/local.ts
-var LocalSignal = class {
-  /** type → Set<handler> for typed subscriptions */
-  typed = /* @__PURE__ */ new Map();
-  /** handlers that receive every event */
-  wildcard = /* @__PURE__ */ new Set();
-  on(type, handler) {
-    let set = this.typed.get(type);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      this.typed.set(type, set);
-    }
-    set.add(handler);
-    return () => {
-      set.delete(handler);
-      if (set.size === 0) this.typed.delete(type);
-    };
-  }
-  onAny(handler) {
-    this.wildcard.add(handler);
-    return () => {
-      this.wildcard.delete(handler);
-    };
-  }
-  emit(event) {
-    const set = this.typed.get(event.type);
-    if (set) {
-      for (const fn of set) {
-        try {
-          fn(event);
-        } catch {
-        }
-      }
-    }
-    for (const fn of this.wildcard) {
-      try {
-        fn(event);
-      } catch {
-      }
-    }
-  }
-  clear() {
-    this.typed.clear();
-    this.wildcard.clear();
-  }
-};
-
-export {
-  LocalSignal
-};

package/dist/chunk-N7P4PN3O.js

@@ -1,84 +0,0 @@
-// src/scope/store.ts
-import { AsyncLocalStorage } from "async_hooks";
-import { randomUUID } from "crypto";
-var scopeStore = new AsyncLocalStorage();
-function cloneAttributes(attributes) {
-  return { ...attributes };
-}
-function cloneScope(scope) {
-  return {
-    ...scope,
-    attributes: cloneAttributes(scope.attributes)
-  };
-}
-function getStoredScope() {
-  return scopeStore.getStore();
-}
-function buildScope(options, current) {
-  const parent = options.parent === void 0 ? current : options.parent ?? void 0;
-  const id = options.id ?? randomUUID();
-  return {
-    id,
-    rootId: parent?.rootId ?? id,
-    kind: options.kind,
-    name: options.name,
-    parentId: parent?.id,
-    depth: (parent?.depth ?? -1) + 1,
-    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    sessionId: options.sessionId ?? parent?.sessionId,
-    taskId: options.taskId ?? parent?.taskId,
-    step: options.step ?? parent?.step,
-    attributes: cloneAttributes(options.attributes ?? {})
-  };
-}
-function runWithScope(scope, fn) {
-  return Promise.resolve(scopeStore.run(scope, fn));
-}
-
-// src/scope/run.ts
-function currentScope() {
-  const scope = getStoredScope();
-  return scope ? cloneScope(scope) : void 0;
-}
-function snapshotScope(scope = getStoredScope()) {
-  return scope ? cloneScope(scope) : void 0;
-}
-function createScope(options) {
-  return buildScope(options, getStoredScope());
-}
-function withinScope(options, fn) {
-  return runWithScope(buildScope(options, getStoredScope()), fn);
-}
-function restoreScope(snapshot, fn) {
-  if (!snapshot) {
-    return Promise.resolve(fn());
-  }
-  return runWithScope(cloneScope(snapshot), fn);
-}
-async function* streamWithinScope(options, iterable) {
-  const scope = buildScope(options, getStoredScope());
-  const iterator = await runWithScope(scope, () => iterable[Symbol.asyncIterator]());
-  try {
-    while (true) {
-      const next = await runWithScope(scope, () => iterator.next());
-      if (next.done) {
-        return next.value;
-      }
-      yield next.value;
-    }
-  } finally {
-    const returnFn = iterator.return?.bind(iterator);
-    if (returnFn) {
-      await runWithScope(scope, () => returnFn(void 0));
-    }
-  }
-}
-
-export {
-  currentScope,
-  snapshotScope,
-  createScope,
-  withinScope,
-  restoreScope,
-  streamWithinScope
-};

package/dist/chunk-SDSBEQXG.js

@@ -1,157 +0,0 @@
-// src/tool/registry.ts
-var ToolRegistry = class {
-  tools = /* @__PURE__ */ new Map();
-  groups = /* @__PURE__ */ new Map();
-  // --------------------------------------------------------------------------
-  // Tool registration
-  // --------------------------------------------------------------------------
-  /**
-   * Register a tool. Throws if a tool with the same ID is already registered.
-   * Use `set()` for upsert semantics.
-   */
-  register(tool) {
-    if (this.tools.has(tool.id)) {
-      throw new Error(`Tool '${tool.id}' is already registered`);
-    }
-    this.tools.set(tool.id, tool);
-  }
-  /** Register multiple tools (throws on duplicates). */
-  registerAll(tools) {
-    for (const tool of tools) {
-      this.register(tool);
-    }
-  }
-  /** Register or replace a tool (upsert). */
-  set(tool) {
-    this.tools.set(tool.id, tool);
-  }
-  /** Unregister a tool by ID. Returns `true` if it existed. */
-  unregister(id) {
-    return this.tools.delete(id);
-  }
-  /** Get a tool by ID. */
-  get(id) {
-    return this.tools.get(id);
-  }
-  /** Check if a tool is registered. */
-  has(id) {
-    return this.tools.has(id);
-  }
-  /** Get all tool IDs. */
-  ids() {
-    return Array.from(this.tools.keys());
-  }
-  /** Get all tools. */
-  all() {
-    return Array.from(this.tools.values());
-  }
-  /** Clear all tools and groups. */
-  clear() {
-    this.tools.clear();
-    this.groups.clear();
-  }
-  /** Number of registered tools. */
-  get size() {
-    return this.tools.size;
-  }
-  // --------------------------------------------------------------------------
-  // Group management
-  // --------------------------------------------------------------------------
-  /**
-   * Register a named group of tool IDs.
-   * The group name can be used in `resolve()` specs.
-   * Tool IDs don't need to be registered yet — resolution is lazy.
-   */
-  registerGroup(name, toolIds) {
-    this.groups.set(name, toolIds);
-  }
-  /** Get tools in a group (only returns registered tools). */
-  getGroup(name) {
-    const ids = this.groups.get(name);
-    if (!ids) return void 0;
-    return ids.map((id) => this.tools.get(id)).filter((t) => t !== void 0);
-  }
-  /** Check if a group is registered. */
-  hasGroup(name) {
-    return this.groups.has(name);
-  }
-  /** List all group names. */
-  listGroups() {
-    return Array.from(this.groups.keys());
-  }
-  // --------------------------------------------------------------------------
-  // Resolution
-  // --------------------------------------------------------------------------
-  /**
-   * Resolve a `ToolSpec` to an array of tools.
-   *
-   * Supports group names, individual tool IDs, comma-separated strings,
-   * exclusions with `-` prefix, booleans, and pass-through arrays.
-   *
-   * @example
-   * ```typescript
-   * registry.resolve("read-only");          // group name
-   * registry.resolve("read,grep,glob");     // comma-separated IDs
-   * registry.resolve("all,-bash");          // all except bash
-   * registry.resolve(["read", "grep"]);     // array of IDs
-   * registry.resolve(true);                 // all registered tools
-   * registry.resolve(false);                // empty array
-   * ```
-   */
-  resolve(spec) {
-    if (spec === true) return this.all();
-    if (spec === false) return [];
-    if (Array.isArray(spec) && spec.length > 0 && typeof spec[0] !== "string") {
-      return spec;
-    }
-    const tokens = Array.isArray(spec) ? spec : spec.split(",").map((s) => s.trim()).filter(Boolean);
-    const includes = [];
-    const excludes = [];
-    for (const token of tokens) {
-      if (token.startsWith("-")) {
-        excludes.push(token.slice(1));
-      } else {
-        includes.push(token);
-      }
-    }
-    const result = /* @__PURE__ */ new Map();
-    if (includes.length === 0 && excludes.length > 0) {
-      for (const [id, tool] of this.tools) {
-        result.set(id, tool);
-      }
-    } else {
-      for (const token of includes) {
-        if (token === "all") {
-          for (const [id, tool] of this.tools) {
-            result.set(id, tool);
-          }
-        } else if (this.groups.has(token)) {
-          const ids = this.groups.get(token);
-          for (const id of ids) {
-            const tool = this.tools.get(id);
-            if (tool) result.set(id, tool);
-          }
-        } else if (this.tools.has(token)) {
-          result.set(token, this.tools.get(token));
-        }
-      }
-    }
-    for (const id of excludes) {
-      if (this.groups.has(id)) {
-        const ids = this.groups.get(id);
-        for (const gid of ids) {
-          result.delete(gid);
-        }
-      } else {
-        result.delete(id);
-      }
-    }
-    return Array.from(result.values());
-  }
-};
-var defaultRegistry = new ToolRegistry();
-
-export {
-  ToolRegistry,
-  defaultRegistry
-};