@cuylabs/agent-core 0.6.0 → 0.8.0

package/dist/{chunk-O2ZCFQL6.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);
@@ -752,13 +545,105 @@ async function createAndRegisterProvider(spanProcessor, serviceName) {
   return provider;
 }
 
+// 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;
+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 input;
+}
+function buildAnthropicCacheControl(ttl) {
+  return {
+    anthropic: {
+      cacheControl: { type: "ephemeral", ttl }
+    }
+  };
+}
+function buildAnthropicSystemMessages(system, ttl) {
+  const filtered = system.filter(Boolean);
+  if (filtered.length === 0) return [];
+  return filtered.map((content, i) => {
+    const isLast = i === filtered.length - 1;
+    const msg = {
+      role: "system",
+      content
+    };
+    if (isLast) {
+      msg.providerOptions = buildAnthropicCacheControl(ttl);
+    }
+    return msg;
+  });
+}
+function findMessageBreakpointIndices(messages, count) {
+  if (count <= 0 || messages.length < 2) return [];
+  const indices = [];
+  for (let i = messages.length - 2; i >= 0 && indices.length < count; i--) {
+    const msg = messages[i];
+    if (msg.role === "user" || msg.role === "assistant") {
+      indices.push(i);
+    }
+  }
+  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
+  );
+  return {
+    name: "prompt-cache",
+    model: {
+      async input(input, _ctx) {
+        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;
+        }
+      }
+    }
+  };
+}
+
 export {
   MiddlewareRunner,
   otelMiddleware,
   createTelemetryConfig,
-  getToolRisk,
-  ApprovalDeniedError,
-  ApprovalTimeoutError,
-  createApprovalHandler,
-  approvalMiddleware
+  approvalMiddleware,
+  promptCacheMiddleware
 };

package/dist/context/index.js

@@ -10,7 +10,7 @@ import {
   pruneContext,
   pruneToolResults,
   shouldPruneContext
-} from "../chunk-QAQADS4X.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/host/index.d.ts

@@ -0,0 +1,45 @@
+import { T as ToolHost } from '../types-CHiPh8U2.js';
+export { D as DirEntry, E as ExecOptions, a as ExecResult, F as FileStat } from '../types-CHiPh8U2.js';
+
+/**
+ * LocalHost — executes tools on the local machine.
+ *
+ * Default ToolHost implementation. Uses Node's `child_process.spawn`
+ * for commands and `node:fs/promises` for file operations.
+ */
+
+/**
+ * Create a ToolHost that runs everything on the local machine.
+ *
+ * @param defaultCwd  Working directory for commands when none is specified.
+ *                    Defaults to `process.cwd()`.
+ */
+declare function localHost(defaultCwd?: string): ToolHost;
+
+/**
+ * Configuration for creating a Docker-backed `ToolHost`.
+ */
+interface DockerHostOptions {
+    /**
+     * The container to connect to. Either:
+     * - A string container name or ID
+     * - A Dockerode `Container`-like object
+     */
+    container: string | {
+        id: string;
+        modem?: unknown;
+    };
+    /** User to run commands as inside the container. */
+    user?: string;
+    /** Default working directory inside the container. */
+    workdir?: string;
+    /**
+     * Dockerode constructor options.
+     * Only used when `container` is a string.
+     */
+    dockerOptions?: Record<string, unknown>;
+}
+
+declare function dockerHost(options: DockerHostOptions): Promise<ToolHost>;
+
+export { type DockerHostOptions, ToolHost, dockerHost, localHost };

package/dist/host/index.js

@@ -0,0 +1,8 @@
+import {
+  dockerHost,
+  localHost
+} from "../chunk-VNQBHPCT.js";
+export {
+  dockerHost,
+  localHost
+};