@cuylabs/agent-core 0.7.0 → 0.9.0

package/dist/{builder-BRvqCcIk.d.ts → builder-BgZ_j4Vs.d.ts}

@@ -1,5 +1,6 @@
-import { P as PromptConfig, a as PromptBuildContext, M as MiddlewareRunner, b as PromptSection, c as ModelFamily } from './runner-DSKaEz3z.js';
-import { S as SkillRegistry } from './registry-BDLIHOQB.js';
+import { d as PromptConfig, P as PromptBuildContext, c as PromptSection, e as ModelFamily } from './types-DTSkxakL.js';
+import { S as SkillRegistry } from './registry-DwYqsQkX.js';
+import { M as MiddlewareRunner } from './runner-CI-XeR16.js';
 
 interface PromptSectionPreview {
     id: string;

package/dist/chunk-4QFNWPIF.js

@@ -0,0 +1,202 @@
+// src/inference/errors/classify.ts
+function isRetryableCategory(category) {
+  switch (category) {
+    case "rate_limit":
+    case "overloaded":
+    case "network":
+    case "timeout":
+      return true;
+    case "auth":
+    case "invalid_request":
+    case "context_overflow":
+    case "content_filter":
+    case "cancelled":
+    case "unknown":
+      return false;
+  }
+}
+function classifyFromStatusAndMessage(status, message) {
+  const lowerMessage = message.toLowerCase();
+  if (status) {
+    if (status === 429) return "rate_limit";
+    if (status === 401 || status === 403) return "auth";
+    if (status === 400) {
+      if (lowerMessage.includes("context") || lowerMessage.includes("token")) {
+        return "context_overflow";
+      }
+      return "invalid_request";
+    }
+    if (status === 503 || status === 502) return "overloaded";
+    if (status >= 500) return "network";
+  }
+  if (lowerMessage.includes("rate") && lowerMessage.includes("limit")) {
+    return "rate_limit";
+  }
+  if (lowerMessage.includes("overload") || lowerMessage.includes("capacity")) {
+    return "overloaded";
+  }
+  if (lowerMessage.includes("too_many_requests")) {
+    return "rate_limit";
+  }
+  if (lowerMessage.includes("unauthorized") || lowerMessage.includes("invalid api key")) {
+    return "auth";
+  }
+  if (lowerMessage.includes("context") && lowerMessage.includes("length")) {
+    return "context_overflow";
+  }
+  if (lowerMessage.includes("content") && lowerMessage.includes("filter")) {
+    return "content_filter";
+  }
+  if (lowerMessage.includes("timeout") || lowerMessage.includes("timed out")) {
+    return "timeout";
+  }
+  if (lowerMessage.includes("network") || lowerMessage.includes("econnrefused") || lowerMessage.includes("econnreset")) {
+    return "network";
+  }
+  return "unknown";
+}
+function parseRetryDelay(headers) {
+  const retryAfterMs = headers["retry-after-ms"];
+  if (retryAfterMs) {
+    const parsed = parseFloat(retryAfterMs);
+    if (!Number.isNaN(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+  const retryAfter = headers["retry-after"];
+  if (retryAfter) {
+    const seconds = parseFloat(retryAfter);
+    if (!Number.isNaN(seconds) && seconds > 0) {
+      return Math.ceil(seconds * 1e3);
+    }
+    const dateMs = Date.parse(retryAfter);
+    if (!Number.isNaN(dateMs)) {
+      const delayMs = dateMs - Date.now();
+      if (delayMs > 0) {
+        return Math.ceil(delayMs);
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/inference/errors/extract.ts
+function extractFromAISDKError(error) {
+  const result = {};
+  const anyError = error;
+  if (typeof anyError.status === "number") {
+    result.status = anyError.status;
+  } else if (typeof anyError.statusCode === "number") {
+    result.status = anyError.statusCode;
+  }
+  if (anyError.responseHeaders && typeof anyError.responseHeaders === "object") {
+    result.headers = anyError.responseHeaders;
+  } else if (anyError.headers && typeof anyError.headers === "object") {
+    result.headers = anyError.headers;
+  }
+  if (anyError.data && typeof anyError.data === "object") {
+    const data = anyError.data;
+    if (data.type === "error" && typeof data.error === "object") {
+      const innerError = data.error;
+      if (innerError.type === "too_many_requests") {
+        result.category = "rate_limit";
+      } else if (innerError.type === "overloaded") {
+        result.category = "overloaded";
+      }
+    }
+    if (typeof data.isRetryable === "boolean" && !data.isRetryable && !result.category) {
+      result.category = "invalid_request";
+    }
+  }
+  return result;
+}
+
+// src/inference/errors/llm-error.ts
+var LLMError = class _LLMError extends Error {
+  category;
+  status;
+  headers;
+  provider;
+  model;
+  isRetryable;
+  retryDelayMs;
+  constructor(options) {
+    super(options.message, { cause: options.cause });
+    this.name = "LLMError";
+    this.status = options.status;
+    this.headers = options.headers;
+    this.provider = options.provider;
+    this.model = options.model;
+    this.category = options.category ?? classifyFromStatusAndMessage(
+      options.status,
+      options.message
+    );
+    this.isRetryable = isRetryableCategory(this.category);
+    this.retryDelayMs = this.headers ? parseRetryDelay(this.headers) : void 0;
+  }
+  static from(error, context) {
+    if (error instanceof _LLMError) {
+      return error;
+    }
+    if (error instanceof Error) {
+      if (error.name === "AbortError" || error.message.includes("abort")) {
+        return new _LLMError({
+          message: error.message,
+          category: "cancelled",
+          cause: error,
+          ...context
+        });
+      }
+      return new _LLMError({
+        message: error.message,
+        cause: error,
+        ...extractFromAISDKError(error),
+        ...context
+      });
+    }
+    return new _LLMError({
+      message: String(error),
+      category: "unknown",
+      ...context
+    });
+  }
+  get description() {
+    const parts = [this.message];
+    if (this.provider) parts.unshift(`[${this.provider}]`);
+    if (this.status) parts.push(`(HTTP ${this.status})`);
+    if (this.isRetryable && this.retryDelayMs) {
+      parts.push(`retry in ${Math.ceil(this.retryDelayMs / 1e3)}s`);
+    }
+    return parts.join(" ");
+  }
+};
+
+// src/inference/errors/utils.ts
+function isRetryable(error) {
+  if (error instanceof LLMError) {
+    return error.isRetryable;
+  }
+  return LLMError.from(error).isRetryable;
+}
+function getRetryDelay(error) {
+  if (error instanceof LLMError) {
+    return error.isRetryable ? error.retryDelayMs : void 0;
+  }
+  const llmError = LLMError.from(error);
+  return llmError.isRetryable ? llmError.retryDelayMs : void 0;
+}
+function getErrorCategory(error) {
+  if (error instanceof LLMError) {
+    return error.category;
+  }
+  return LLMError.from(error).category;
+}
+
+export {
+  isRetryableCategory,
+  parseRetryDelay,
+  LLMError,
+  isRetryable,
+  getRetryDelay,
+  getErrorCategory
+};

package/dist/chunk-5ARZJWD2.js

@@ -0,0 +1,259 @@
+// src/safety/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/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/patterns.ts
+function matchApprovalPattern(pattern, value) {
+  if (pattern.length > 500) return false;
+  const p = pattern.toLowerCase();
+  const v = value.toLowerCase();
+  let pi = 0;
+  let vi = 0;
+  let starPi = -1;
+  let starVi = -1;
+  while (vi < v.length) {
+    if (pi < p.length && (p[pi] === "?" || p[pi] === v[vi])) {
+      pi++;
+      vi++;
+    } else if (pi < p.length && p[pi] === "*") {
+      starPi = pi;
+      starVi = vi;
+      pi++;
+    } else if (starPi !== -1) {
+      pi = starPi + 1;
+      starVi++;
+      vi = starVi;
+    } else {
+      return false;
+    }
+  }
+  while (pi < p.length && p[pi] === "*") {
+    pi++;
+  }
+  return pi === p.length;
+}
+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: {
+      const json = JSON.stringify(args);
+      const truncated = json.length > 50 ? `${json.slice(0, 50)}...` : json;
+      return `${tool}(${truncated})`;
+    }
+  }
+}
+
+// src/safety/handler.ts
+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;
+  let requestCounter = 0;
+  const initialRuleCount = config.rules?.length ?? 0;
+  const rules = [...config.rules ?? []];
+  const activeRequests = /* @__PURE__ */ new Set();
+  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 ac = new AbortController();
+    activeRequests.add(ac);
+    let timeoutId;
+    try {
+      const action = await Promise.race([
+        onRequest(requestData),
+        new Promise((_, reject) => {
+          timeoutId = setTimeout(() => {
+            reject(new ApprovalTimeoutError(tool, timeout));
+          }, timeout);
+          ac.signal.addEventListener("abort", () => {
+            clearTimeout(timeoutId);
+            reject(new Error("Cancelled"));
+          }, { once: true });
+        })
+      ]);
+      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;
+      }
+    } finally {
+      clearTimeout(timeoutId);
+      activeRequests.delete(ac);
+    }
+  }
+  function cancelAll(_reason) {
+    for (const ac of activeRequests) {
+      ac.abort();
+    }
+    activeRequests.clear();
+  }
+  function addRule(rule) {
+    rules.push(rule);
+  }
+  function getRules() {
+    return rules;
+  }
+  function clearSessionRules() {
+    rules.splice(initialRuleCount);
+  }
+  return {
+    request,
+    cancelAll,
+    addRule,
+    getRules,
+    clearSessionRules
+  };
+}
+
+export {
+  getToolRisk,
+  ApprovalDeniedError,
+  ApprovalTimeoutError,
+  createApprovalHandler
+};

package/dist/chunk-DXFBQMXP.js

@@ -0,0 +1,53 @@
+// 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);
+    }
+    const wrapped = (event) => {
+      handler(event);
+    };
+    set.add(wrapped);
+    return () => {
+      set.delete(wrapped);
+      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-EKR6PKXU.js

@@ -0,0 +1,180 @@
+// src/presets/builtins.ts
+var explore = {
+  name: "explore",
+  description: "Read-only exploration mode for understanding content",
+  allowTools: ["read*", "search*", "glob*", "grep*", "list*", "find*"],
+  denyTools: ["write*", "edit*", "delete*", "bash*", "exec*", "run*"],
+  systemPrompt: `{basePrompt}
+
+## EXPLORATION MODE
+
+You are in **exploration mode**. Your goal is to thoroughly understand the content.
+
+Guidelines:
+- **Always start with glob or grep to discover correct paths** \u2014 never assume directory structure
+- Use search and read tools extensively to build understanding
+- Map out structures, dependencies, and patterns
+- Look for conventions, common patterns, and documentation
+- DO NOT modify anything \u2014 only read and analyse
+- Summarise findings clearly with references to specific locations
+
+Error recovery:
+- If a tool returns an error (ENOENT, not found, etc.), try a different path or approach
+- Use glob with broader patterns to discover the correct location
+- Keep going until you have a thorough answer \u2014 do not give up after one failure
+- You have multiple steps available \u2014 use them all if needed`,
+  temperature: 0.3,
+  maxSteps: 30
+};
+var plan = {
+  name: "plan",
+  description: "Planning mode for analyzing tasks and creating detailed plans",
+  allowTools: ["read*", "search*", "glob*", "grep*", "list*", "find*"],
+  denyTools: ["write*", "edit*", "delete*", "bash*", "exec*", "run*"],
+  systemPrompt: `{basePrompt}
+
+## PLANNING MODE
+
+You are in **planning mode**. Your goal is to analyze and plan before implementation.
+
+Guidelines:
+- Analyse the task requirements thoroughly
+- Research existing patterns and conventions
+- Identify potential impacts and dependencies
+- Create a clear, step-by-step implementation plan
+- DO NOT implement anything \u2014 only plan and document
+- Output a numbered list of specific, actionable steps`,
+  temperature: 0.2,
+  maxSteps: 20
+};
+var review = {
+  name: "review",
+  description: "Thorough review and analysis mode",
+  allowTools: ["read*", "grep*", "search*", "glob*", "list*"],
+  denyTools: ["*"],
+  systemPrompt: `{basePrompt}
+
+## REVIEW MODE
+
+You are in **review mode**. Your goal is to perform a thorough analysis.
+
+Review checklist:
+- [ ] Logic errors and edge cases
+- [ ] Security vulnerabilities
+- [ ] Performance issues
+- [ ] Error handling and recovery
+- [ ] Clarity and maintainability
+- [ ] Coverage gaps
+
+Guidelines:
+- Be thorough and systematic
+- Cite specific locations and details
+- Explain WHY something is an issue
+- Suggest concrete fixes
+- Rate severity: Critical / High / Medium / Low`,
+  temperature: 0.1,
+  maxSteps: 25
+};
+var quick = {
+  name: "quick",
+  description: "Fast mode for simple questions and quick operations",
+  systemPrompt: `{basePrompt}
+
+## QUICK MODE
+
+You are in **quick mode**. Be fast and focused.
+
+Guidelines:
+- Answer directly without lengthy explanations
+- Use minimal tool calls (1-3 max)
+- If you can't answer quickly, say so
+- Prioritize speed over thoroughness`,
+  temperature: 0,
+  maxSteps: 5
+};
+var careful = {
+  name: "careful",
+  description: "Extra cautious mode for sensitive operations",
+  denyTools: ["bash*", "exec*", "run*", "delete*", "remove*"],
+  systemPrompt: `{basePrompt}
+
+## CAREFUL MODE
+
+You are in **careful mode**. Every action must be verified.
+
+Guidelines:
+- Double-check before any file modifications
+- Explain what you're about to do BEFORE doing it
+- Prefer smaller, incremental changes
+- Always verify changes after making them
+- If uncertain, ask for clarification rather than guessing`,
+  temperature: 0,
+  maxSteps: 50
+};
+var code = {
+  name: "code",
+  description: "Full-power implementation mode for writing and modifying code",
+  systemPrompt: `{basePrompt}
+
+## IMPLEMENTATION MODE
+
+You are a focused **implementation agent**. Your goal is to complete the assigned task fully and correctly.
+
+Guidelines:
+- Read existing code first to understand context and conventions before making changes
+- Follow the project's existing patterns, naming conventions, and style
+- Make minimal, targeted changes \u2014 do not refactor unrelated code
+- Verify your work: re-read modified files, run tests or lint if available
+- If the task requires multiple files, handle them systematically one at a time
+
+Error recovery:
+- If a command fails, read the error output carefully and fix the root cause
+- If a test fails, read the failure details and iterate until it passes
+- If you cannot find a file, use glob or grep to discover the correct path
+- Keep iterating until the task is DONE \u2014 do not stop at a partial solution
+- You have many steps available \u2014 use them all if needed`,
+  temperature: 0,
+  maxSteps: 50
+};
+var watch = {
+  name: "watch",
+  description: "Process monitoring mode for running and watching long commands",
+  allowTools: ["bash*", "exec*", "run*", "read*", "grep*", "glob*", "list*", "find*"],
+  denyTools: ["write*", "edit*", "delete*", "remove*"],
+  systemPrompt: `{basePrompt}
+
+## WATCH MODE
+
+You are a **process monitor**. Your goal is to execute a command, observe its output, and report the result.
+
+Guidelines:
+- Run the command as given \u2014 do not modify or "improve" it
+- Wait for completion and capture the full output
+- Parse the output for success/failure status, error counts, warnings
+- Report a clear summary: what ran, whether it passed, key details
+- If the process fails, include the relevant error output verbatim
+- Do NOT attempt to fix issues \u2014 only observe and report`,
+  temperature: 0,
+  maxSteps: 10,
+  reasoningLevel: "low"
+};
+var Presets = {
+  explore,
+  plan,
+  review,
+  quick,
+  careful,
+  code,
+  watch
+};
+
+export {
+  explore,
+  plan,
+  review,
+  quick,
+  careful,
+  code,
+  watch,
+  Presets
+};