@cuylabs/agent-core 0.7.0 → 0.8.0

package/dist/{chunk-CDTV2UYU.js → chunk-YSLSEQ6B.js}

@@ -1,3 +1,11 @@
+import {
+  createApprovalHandler
+} from "./chunk-BFM2YHNM.js";
+import {
+  getModelId,
+  getProviderId
+} from "./chunk-DWYX7ASF.js";
+
 // src/middleware/runner.ts
 function isBlockedModelCall(value) {
   return "block" in value && value.block === true;
@@ -249,221 +257,6 @@ var MiddlewareRunner = class {
   }
 };
 
-// src/safety/approval/risk.ts
-var DEFAULT_TOOL_RISKS = {
-  read: "safe",
-  read_file: "safe",
-  grep: "safe",
-  glob: "safe",
-  list_dir: "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
-  };
-}
-
 // src/middleware/approval.ts
 function approvalMiddleware(config = {}) {
   const handler = createApprovalHandler(config);
@@ -753,28 +546,48 @@ async function createAndRegisterProvider(spanProcessor, serviceName) {
 }
 
 // src/middleware/prompt-cache/cache.ts
+function detectCacheProvider(input) {
+  const provider = getProviderId(input.model);
+  if (provider) {
+    const p = provider.toLowerCase();
+    if (p === "anthropic") return "anthropic";
+    if (p === "openai") return "openai";
+    if (p === "google") return "google";
+  }
+  const modelId = getModelId(input.model);
+  if (/claude/i.test(modelId)) return "anthropic";
+  return "unknown";
+}
 var MAX_ANTHROPIC_BREAKPOINTS = 4;
-var DEFAULT_TTL = "5m";
-var DEFAULT_MESSAGE_BREAKPOINTS = 1;
-function isAnthropicModel(model) {
-  if (typeof model === "object" && model !== null) {
-    if ("provider" in model && typeof model.provider === "string") {
-      if (model.provider.toLowerCase().startsWith("anthropic")) return true;
-    }
-    if ("modelId" in model && typeof model.modelId === "string") {
-      if (/claude/i.test(model.modelId)) return true;
+function applyAnthropicCache(input, ttl, maxMsgBreakpoints) {
+  const hasSystem = input.system.some((s) => s.length > 0);
+  if (hasSystem) {
+    input.systemMessages = buildAnthropicSystemMessages(input.system, ttl);
+  }
+  if (maxMsgBreakpoints > 0) {
+    const breakpointIndices = findMessageBreakpointIndices(
+      input.messages,
+      maxMsgBreakpoints
+    );
+    const cacheControl = buildAnthropicCacheControl(ttl);
+    for (const idx of breakpointIndices) {
+      const msg = input.messages[idx];
+      msg.providerOptions = {
+        ...msg.providerOptions,
+        ...cacheControl
+      };
     }
   }
-  return false;
+  return input;
 }
-function buildCacheControl(ttl) {
+function buildAnthropicCacheControl(ttl) {
   return {
     anthropic: {
       cacheControl: { type: "ephemeral", ttl }
     }
   };
 }
-function buildCachedSystemMessages(system, ttl) {
+function buildAnthropicSystemMessages(system, ttl) {
   const filtered = system.filter(Boolean);
   if (filtered.length === 0) return [];
   return filtered.map((content, i) => {
@@ -784,7 +597,7 @@ function buildCachedSystemMessages(system, ttl) {
       content
     };
     if (isLast) {
-      msg.providerOptions = buildCacheControl(ttl);
+      msg.providerOptions = buildAnthropicCacheControl(ttl);
     }
     return msg;
   });
@@ -800,37 +613,28 @@ function findMessageBreakpointIndices(messages, count) {
   }
   return indices;
 }
+var DEFAULT_TTL = "5m";
+var DEFAULT_MESSAGE_BREAKPOINTS = 1;
 function promptCacheMiddleware(config) {
   const ttl = config?.ttl ?? DEFAULT_TTL;
   const maxMsgBreakpoints = Math.min(
     config?.messageBreakpoints ?? DEFAULT_MESSAGE_BREAKPOINTS,
     MAX_ANTHROPIC_BREAKPOINTS - 1
-    // Reserve 1 for system
   );
   return {
     name: "prompt-cache",
     model: {
       async input(input, _ctx) {
-        if (!isAnthropicModel(input.model)) return;
-        const hasSystem = input.system.some((s) => s.length > 0);
-        if (hasSystem) {
-          input.systemMessages = buildCachedSystemMessages(input.system, ttl);
-        }
-        if (maxMsgBreakpoints > 0) {
-          const breakpointIndices = findMessageBreakpointIndices(
-            input.messages,
-            maxMsgBreakpoints
-          );
-          const cacheControl = buildCacheControl(ttl);
-          for (const idx of breakpointIndices) {
-            const msg = input.messages[idx];
-            msg.providerOptions = {
-              ...msg.providerOptions,
-              ...cacheControl
-            };
-          }
+        const provider = detectCacheProvider(input);
+        switch (provider) {
+          case "anthropic":
+            return applyAnthropicCache(input, ttl, maxMsgBreakpoints);
+          // OpenAI caches prefixes automatically — no client action needed.
+          // case "openai":
+          //   return applyOpenAICache(input);
+          default:
+            return;
         }
-        return input;
       }
     }
   };
@@ -840,10 +644,6 @@ export {
   MiddlewareRunner,
   otelMiddleware,
   createTelemetryConfig,
-  getToolRisk,
-  ApprovalDeniedError,
-  ApprovalTimeoutError,
-  createApprovalHandler,
   approvalMiddleware,
   promptCacheMiddleware
 };

package/dist/context/index.js

@@ -10,7 +10,7 @@ import {
   pruneContext,
   pruneToolResults,
   shouldPruneContext
-} from "../chunk-BNSHUWCV.js";
+} from "../chunk-WWYYNWEW.js";
 export {
   ContextManager,
   DEFAULT_CONTEXT_LIMITS,

package/dist/errors/index.d.ts

@@ -0,0 +1,11 @@
+import { E as ErrorCategory, R as ResponseHeaders } from '../llm-error-D93FNNLY.js';
+export { L as LLMError, a as LLMErrorOptions } from '../llm-error-D93FNNLY.js';
+
+declare function isRetryableCategory(category: ErrorCategory): boolean;
+declare function parseRetryDelay(headers: ResponseHeaders): number | undefined;
+
+declare function isRetryable(error: unknown): boolean;
+declare function getRetryDelay(error: unknown): number | undefined;
+declare function getErrorCategory(error: unknown): ErrorCategory;
+
+export { ErrorCategory, ResponseHeaders, getErrorCategory, getRetryDelay, isRetryable, isRetryableCategory, parseRetryDelay };

package/dist/errors/index.js

@@ -0,0 +1,16 @@
+import {
+  LLMError,
+  getErrorCategory,
+  getRetryDelay,
+  isRetryable,
+  isRetryableCategory,
+  parseRetryDelay
+} from "../chunk-RZITT45F.js";
+export {
+  LLMError,
+  getErrorCategory,
+  getRetryDelay,
+  isRetryable,
+  isRetryableCategory,
+  parseRetryDelay
+};

package/dist/events-CE72w8W4.d.ts

@@ -0,0 +1,149 @@
+import * as ai from 'ai';
+import { T as TokenUsage, M as Message } from './messages-BYWGn8TY.js';
+
+/** Agent status for UI display */
+type AgentStatus = "idle" | "processing" | "thinking" | "reasoning" | "calling-tool" | "waiting-approval" | "error";
+/** Approval request for UI */
+interface ApprovalEvent {
+    id: string;
+    tool: string;
+    args: unknown;
+    description: string;
+    risk: "safe" | "moderate" | "dangerous";
+}
+/** Neutral turn-commit boundaries for runtime/durability integrations */
+type AgentTurnBoundaryKind = "input-commit-start" | "input-commit-finish" | "intervention-commit-start" | "intervention-commit-finish" | "step-commit-start" | "step-commit-finish" | "output-commit-start" | "output-commit-finish";
+/**
+ * Events emitted during agent execution
+ *
+ * These events are designed for UI consumption:
+ * - status: Overall agent state for status indicators
+ * - approval-request: User confirmation needed
+ * - progress: Step counts for progress bars
+ */
+type AgentEvent = {
+    type: "status";
+    status: AgentStatus;
+} | {
+    type: "approval-request";
+    request: ApprovalEvent;
+} | {
+    type: "approval-resolved";
+    id: string;
+    action: "allow" | "deny" | "remember";
+} | {
+    type: "step-start";
+    step: number;
+    maxSteps: number;
+} | {
+    type: "step-finish";
+    step: number;
+    usage?: TokenUsage;
+    finishReason?: string;
+} | {
+    type: "turn-boundary";
+    boundary: AgentTurnBoundaryKind;
+    step?: number;
+    messageRole?: Message["role"];
+    pendingToolCallCount?: number;
+} | {
+    type: "message";
+    message: Message;
+} | {
+    type: "text-start";
+} | {
+    type: "text-delta";
+    text: string;
+} | {
+    type: "text-end";
+} | {
+    type: "reasoning-start";
+    id: string;
+} | {
+    type: "reasoning-delta";
+    id: string;
+    text: string;
+} | {
+    type: "reasoning-end";
+    id: string;
+} | {
+    type: "tool-start";
+    toolName: string;
+    toolCallId: string;
+    input: unknown;
+} | {
+    type: "tool-result";
+    toolName: string;
+    toolCallId: string;
+    result: unknown;
+} | {
+    type: "tool-error";
+    toolName: string;
+    toolCallId: string;
+    error: string;
+} | {
+    type: "computer-call";
+    callId: string;
+    action: unknown;
+    pendingSafetyChecks?: unknown[];
+} | {
+    type: "computer-result";
+    callId: string;
+    result: unknown;
+} | {
+    type: "intervention-applied";
+    id: string;
+    message: string;
+} | {
+    type: "doom-loop";
+    toolName: string;
+    repeatCount: number;
+} | {
+    type: "context-overflow";
+    inputTokens: number;
+    limit: number;
+} | {
+    type: "turn-summary";
+    turnId: string;
+    files: Array<{
+        path: string;
+        type: "created" | "modified" | "deleted" | "unchanged";
+        additions: number;
+        deletions: number;
+    }>;
+    additions: number;
+    deletions: number;
+} | {
+    type: "retry";
+    attempt: number;
+    delayMs: number;
+    error: Error;
+} | {
+    type: "error";
+    error: Error;
+} | {
+    type: "complete";
+    usage?: TokenUsage;
+    output?: string;
+};
+/**
+ * Step-processing result - what happens after reducing one streamed step
+ */
+type StepProcessingResult = "continue" | "stop" | "compact";
+/**
+ * @deprecated Use `StepProcessingResult`.
+ */
+type ProcessorResult = StepProcessingResult;
+/**
+ * Stream input for model inference
+ */
+interface StreamInput {
+    sessionID: string;
+    model: ai.LanguageModel;
+    system: string[];
+    messages: ai.ModelMessage[];
+    abort: AbortSignal;
+    tools: Record<string, unknown>;
+}
+
+export type { AgentEvent as A, ProcessorResult as P, StepProcessingResult as S, AgentStatus as a, AgentTurnBoundaryKind as b, ApprovalEvent as c, StreamInput as d };

package/dist/{index-C33hlD6H.d.ts → index-CWSchSql.d.ts}

@@ -1,15 +1,18 @@
 import { LanguageModel } from 'ai';
-import { R as ReasoningLevel } from './types-CQaXbRsS.js';
-import { T as Tool } from './tool-Db1Ue-1U.js';
-import { h as AgentMiddleware, d as StreamProvider, P as PromptConfig, A as AgentEvent, M as MiddlewareRunner } from './runner-DSKaEz3z.js';
+import { P as Preset } from './types-BnpEOYV-.js';
+import { T as Tool } from './tool-BHbyUAy3.js';
+import { A as AgentMiddleware, d as StreamProvider, P as PromptConfig, M as MiddlewareRunner } from './runner-e2YRcUoX.js';
 import { S as SessionManager, f as SessionContext, i as SessionInfo } from './session-manager-B_CWGTsl.js';
 import { T as ToolHost } from './types-CHiPh8U2.js';
 import { T as TokenUsage, M as Message } from './messages-BYWGn8TY.js';
+import { A as AgentEvent } from './events-CE72w8W4.js';
+import { R as ReasoningLevel } from './types-CQaXbRsS.js';
 import { a as MCPManager } from './types-VQgymC1N.js';
+import { A as AgentSignal } from './types-YuWV4ag7.js';
 import { U as UndoResult, T as TurnChangeTracker } from './tracker-DClqYqTj.js';
-import { P as PromptBuilder } from './builder-BRvqCcIk.js';
-import { P as PendingIntervention, g as InterventionController } from './types-FRpzzg_9.js';
-import { s as DoomLoopHandler, o as AgentTurnStepRuntimeConfig } from './types-CqDZTh4d.js';
+import { P as PromptBuilder } from './builder-UpOWQMW3.js';
+import { P as PendingIntervention, g as InterventionController } from './types-KKDrdU9Y.js';
+import { s as DoomLoopHandler, o as AgentTurnStepRuntimeConfig } from './types-QKHHQLLq.js';
 
 /**
  * Tools whose outputs should never be pruned automatically.
@@ -156,51 +159,17 @@ interface AgentConfig {
      * Simplest way to enable tracing.
      */
     tracing?: TracingConfig;
-}
-
-/**
- * Agent preset - a reusable configuration profile.
- */
-interface Preset {
-    /** Unique identifier for this preset */
-    name: string;
-    /** Human-readable description */
-    description: string;
-    /**
-     * Tool allow patterns (glob-like).
-     * If provided, only tools matching these patterns are candidates.
-     */
-    allowTools?: string[];
-    /**
-     * Tool deny patterns (glob-like).
-     * Deny patterns apply only after allow matching, so explicit allows win.
-     */
-    denyTools?: string[];
     /**
-     * Override system prompt.
-     * Use `{basePrompt}` to include the parent's system prompt.
+     * Event signal for multi-consumer dispatch.
+     *
+     * Every event yielded by `chat()` is also emitted here, enabling
+     * passive observers (SSE routes, TUI renderers, plugins) to
+     * subscribe without consuming the primary generator.
+     *
+     * Defaults to an in-process `LocalSignal`.  A distributed runtime
+     * can supply its own implementation to bridge events externally.
      */
-    systemPrompt?: string;
-    /** Override temperature (0-1). */
-    temperature?: number;
-    /** Override max steps. */
-    maxSteps?: number;
-    /** Override reasoning level. */
-    reasoningLevel?: ReasoningLevel;
-    /** Override model. */
-    model?: LanguageModel;
-}
-/**
- * Result of applying a preset - ready for `fork()`.
- */
-interface AppliedPreset {
-    name: string;
-    systemPrompt?: string;
-    tools?: Tool.AnyInfo[];
-    temperature?: number;
-    maxSteps?: number;
-    reasoningLevel?: ReasoningLevel;
-    model?: LanguageModel;
+    signal?: AgentSignal;
 }
 
 interface AgentForkOptions {
@@ -275,6 +244,8 @@ declare class Agent {
     private mcpManager?;
     /** Whether MCP has been connected (lazy init) */
     private mcpConnected;
+    /** Whether skill tools have been resolved (lazy init) */
+    private skillToolsResolved;
     /** Cached MCP tools (refreshed on connect) */
     private mcpToolsCache?;
     /** Prompt pipeline builder (when using layered prompt mode) */
@@ -289,7 +260,17 @@ declare class Agent {
     private telemetrySettings?;
     /** Tracing shutdown function (from `tracing` config auto-setup) */
     private tracingShutdown?;
+    /** Multi-consumer event dispatch */
+    private readonly _signal;
     constructor(config: AgentConstructionOptions);
+    /**
+     * Event signal — subscribe to events without consuming the generator.
+     *
+     * Every event yielded by `chat()` is also dispatched here, allowing
+     * multiple passive observers (SSE routes, TUI, plugins) to listen
+     * concurrently.
+     */
+    get signal(): AgentSignal;
     /** Agent name (identity for spans, Dapr workflows, etc.) */
     get name(): string;
     /** Working directory for file operations */
@@ -315,6 +296,11 @@ declare class Agent {
      * Check if current model supports reasoning
      */
     supportsReasoning(): boolean;
+    /**
+     * Ensure skill tools are registered when `prompt.skills` is configured.
+     * Lazy initialization — resolves the registry and adds tools on first use.
+     */
+    private ensureSkillTools;
     /**
      * Ensure MCP is connected and return tools
      * Lazy initialization - only connects on first use
@@ -1069,4 +1055,4 @@ declare class SubAgentTracker {
  */
 declare function createSubAgentTools(parent: Agent, config: SubAgentToolConfig): Tool.AnyInfo[];
 
-export { type AppliedPreset as A, type CompactionConfig as C, DEFAULT_MAX_CONCURRENT as D, type Preset as P, type SubAgentCompletedResult as S, type TracingConfig as T, type AgentConfig as a, Agent as b, type AgentProfile as c, DEFAULT_MAX_SPAWN_DEPTH as d, DEFAULT_SESSION_TITLE_PREFIX as e, PRUNE_PROTECTED_TOOLS as f, type SubAgentHandle as g, type SubAgentStatus as h, type SubAgentToolConfig as i, SubAgentTracker as j, type SubAgentUsage as k, createAgent as l, createSubAgentTools as m };
+export { type AgentConfig as A, type CompactionConfig as C, DEFAULT_MAX_CONCURRENT as D, PRUNE_PROTECTED_TOOLS as P, type SubAgentCompletedResult as S, type TracingConfig as T, Agent as a, type AgentProfile as b, DEFAULT_MAX_SPAWN_DEPTH as c, DEFAULT_SESSION_TITLE_PREFIX as d, type SubAgentHandle as e, type SubAgentStatus as f, type SubAgentToolConfig as g, SubAgentTracker as h, type SubAgentUsage as i, createAgent as j, createSubAgentTools as k };