@cuylabs/agent-core 0.5.0 → 0.7.0

package/dist/chunk-VNQBHPCT.js

@@ -0,0 +1,398 @@
+// src/host/local.ts
+import { spawn } from "child_process";
+import fs from "fs/promises";
+import { existsSync } from "fs";
+import path from "path";
+import process from "process";
+function getShell() {
+  if (process.platform === "win32") {
+    return { shell: "cmd.exe", args: ["/c"] };
+  }
+  const userShell = process.env.SHELL ?? "/bin/bash";
+  return { shell: userShell, args: ["-c"] };
+}
+async function killProcessTree(pid) {
+  try {
+    if (process.platform !== "win32") {
+      process.kill(-pid, "SIGKILL");
+    } else {
+      const { exec: execCb } = await import("child_process");
+      execCb(`taskkill /pid ${pid} /t /f`, () => {
+      });
+    }
+  } catch {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  }
+}
+function localHost(defaultCwd) {
+  const cwd = defaultCwd ?? process.cwd();
+  return {
+    name: "local",
+    // --------------------------------------------------------------------------
+    // File system
+    // --------------------------------------------------------------------------
+    async readFile(filePath) {
+      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+      return fs.readFile(abs, "utf-8");
+    },
+    async readBytes(filePath, offset, length) {
+      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+      const fh = await fs.open(abs, "r");
+      try {
+        const buf = Buffer.alloc(length);
+        await fh.read(buf, 0, length, offset);
+        return buf;
+      } finally {
+        await fh.close();
+      }
+    },
+    async writeFile(filePath, content) {
+      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+      await fs.mkdir(path.dirname(abs), { recursive: true });
+      await fs.writeFile(abs, content, "utf-8");
+    },
+    async exists(filePath) {
+      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+      return existsSync(abs);
+    },
+    async stat(filePath) {
+      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+      const s = await fs.stat(abs);
+      return {
+        size: s.size,
+        mtime: s.mtime,
+        isDirectory: s.isDirectory(),
+        isFile: s.isFile()
+      };
+    },
+    async readdir(dirPath) {
+      const abs = path.isAbsolute(dirPath) ? dirPath : path.resolve(cwd, dirPath);
+      const entries = await fs.readdir(abs, { withFileTypes: true });
+      return entries.map((e) => ({
+        name: e.name,
+        isDirectory: e.isDirectory(),
+        isFile: e.isFile()
+      }));
+    },
+    async mkdir(dirPath) {
+      const abs = path.isAbsolute(dirPath) ? dirPath : path.resolve(cwd, dirPath);
+      await fs.mkdir(abs, { recursive: true });
+    },
+    // --------------------------------------------------------------------------
+    // Process execution
+    // --------------------------------------------------------------------------
+    exec(command, options) {
+      const { shell, args } = getShell();
+      const execCwd = options?.cwd ?? cwd;
+      const env = {
+        ...process.env,
+        ...options?.env,
+        // Disable pagers — tools collect output, not interactive
+        PAGER: "cat",
+        GIT_PAGER: "cat"
+      };
+      return new Promise((resolve, reject) => {
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        let settled = false;
+        const child = spawn(shell, [...args, command], {
+          cwd: execCwd,
+          detached: process.platform !== "win32",
+          env,
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        child.stdout?.on("data", (data) => {
+          stdout += data.toString();
+          options?.onStdout?.(data);
+        });
+        child.stderr?.on("data", (data) => {
+          stderr += data.toString();
+          options?.onStderr?.(data);
+        });
+        let timer;
+        if (options?.timeout && options.timeout > 0) {
+          timer = setTimeout(() => {
+            timedOut = true;
+            if (child.pid) killProcessTree(child.pid);
+          }, options.timeout);
+        }
+        const onAbort = () => {
+          if (child.pid) killProcessTree(child.pid);
+        };
+        options?.signal?.addEventListener("abort", onAbort, { once: true });
+        child.on("close", (code) => {
+          if (settled) return;
+          settled = true;
+          if (timer) clearTimeout(timer);
+          options?.signal?.removeEventListener("abort", onAbort);
+          resolve({ stdout, stderr, exitCode: code, timedOut });
+        });
+        child.on("error", (err) => {
+          if (settled) return;
+          settled = true;
+          if (timer) clearTimeout(timer);
+          options?.signal?.removeEventListener("abort", onAbort);
+          reject(err);
+        });
+      });
+    }
+  };
+}
+
+// src/host/docker/exec.ts
+async function loadDockerode() {
+  try {
+    const module = await import("dockerode");
+    return module.default ?? module;
+  } catch {
+    throw new Error(
+      "dockerHost requires the 'dockerode' package. Install it with: npm install dockerode"
+    );
+  }
+}
+async function resolveDockerRuntime(options) {
+  const Dockerode = await loadDockerode();
+  if (typeof options.container === "string") {
+    const docker = new Dockerode(options.dockerOptions);
+    const container2 = docker.getContainer(options.container);
+    return {
+      docker,
+      container: container2,
+      label: options.container
+    };
+  }
+  const container = options.container;
+  return {
+    docker: { modem: container.modem },
+    container,
+    label: container.id?.slice(0, 12) ?? "unknown"
+  };
+}
+async function containerExec(runtime, command, options = {}) {
+  const envEntries = options.env ? Object.entries(options.env).filter((entry) => entry[1] !== void 0).map(([key, value]) => `${key}=${value}`) : void 0;
+  const exec = await runtime.container.exec({
+    Cmd: ["sh", "-c", command],
+    ...options.user ? { User: options.user } : {},
+    ...options.workdir ? { WorkingDir: options.workdir } : {},
+    ...envEntries && envEntries.length > 0 ? { Env: envEntries } : {},
+    AttachStdout: true,
+    AttachStderr: true
+  });
+  const stream = await exec.start({});
+  let timedOut = false;
+  let aborted = false;
+  return await new Promise((resolve, reject) => {
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    runtime.docker.modem.demuxStream(
+      stream,
+      {
+        write: (chunk) => {
+          stdoutChunks.push(chunk);
+          options.onStdout?.(chunk);
+          return true;
+        },
+        end: function() {
+          return this;
+        }
+      },
+      {
+        write: (chunk) => {
+          stderrChunks.push(chunk);
+          options.onStderr?.(chunk);
+          return true;
+        },
+        end: function() {
+          return this;
+        }
+      }
+    );
+    let timer;
+    if (options.timeout && options.timeout > 0) {
+      timer = setTimeout(() => {
+        timedOut = true;
+        stream.destroy?.();
+      }, options.timeout);
+    }
+    const onAbort = () => {
+      aborted = true;
+      stream.destroy?.();
+    };
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    stream.on("end", async () => {
+      if (timer) {
+        clearTimeout(timer);
+      }
+      options.signal?.removeEventListener("abort", onAbort);
+      try {
+        const info = await exec.inspect();
+        resolve({
+          stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
+          stderr: Buffer.concat(stderrChunks).toString("utf-8"),
+          exitCode: timedOut || aborted ? null : info.ExitCode ?? 0,
+          timedOut
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+    stream.on("error", (error) => {
+      if (timer) {
+        clearTimeout(timer);
+      }
+      options.signal?.removeEventListener("abort", onAbort);
+      if (timedOut || aborted) {
+        resolve({
+          stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
+          stderr: Buffer.concat(stderrChunks).toString("utf-8"),
+          exitCode: null,
+          timedOut
+        });
+        return;
+      }
+      reject(error);
+    });
+  });
+}
+async function runDockerCommand(options) {
+  const { runtime, command, defaultUser, defaultWorkdir, execOptions } = options;
+  return await containerExec(runtime, command, {
+    user: defaultUser,
+    workdir: execOptions?.workdir ?? execOptions?.cwd ?? defaultWorkdir,
+    env: execOptions?.env,
+    timeout: execOptions?.timeout,
+    signal: execOptions?.signal,
+    onStdout: execOptions?.onStdout,
+    onStderr: execOptions?.onStderr
+  });
+}
+
+// src/host/docker/shell.ts
+function sq(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function resolveDockerPath(path2, defaultWorkdir) {
+  if (path2.startsWith("/")) {
+    return path2;
+  }
+  const base = defaultWorkdir.endsWith("/") ? defaultWorkdir : `${defaultWorkdir}/`;
+  return `${base}${path2}`;
+}
+
+// src/host/docker/host.ts
+async function dockerHost(options) {
+  const runtime = await resolveDockerRuntime(options);
+  const defaultUser = options.user;
+  const defaultWorkdir = options.workdir ?? "/";
+  async function run(command, execOptions) {
+    return await runDockerCommand({
+      runtime,
+      command,
+      defaultUser,
+      defaultWorkdir,
+      execOptions
+    });
+  }
+  return {
+    name: `docker:${runtime.label}`,
+    async readFile(filePath) {
+      const absPath = resolveDockerPath(filePath, defaultWorkdir);
+      const result = await run(`cat ${sq(absPath)}`);
+      if (result.exitCode !== 0) {
+        throw new Error(`readFile failed (${absPath}): ${result.stderr.trim()}`);
+      }
+      return result.stdout;
+    },
+    async readBytes(filePath, offset, length) {
+      const absPath = resolveDockerPath(filePath, defaultWorkdir);
+      const result = await run(
+        `dd if=${sq(absPath)} bs=1 skip=${offset} count=${length} 2>/dev/null`
+      );
+      if (result.exitCode !== 0) {
+        throw new Error(
+          `readBytes failed (${absPath}): ${result.stderr.trim()}`
+        );
+      }
+      return Buffer.from(result.stdout, "binary");
+    },
+    async writeFile(filePath, content) {
+      const absPath = resolveDockerPath(filePath, defaultWorkdir);
+      const dir = absPath.substring(0, absPath.lastIndexOf("/")) || "/";
+      await run(`mkdir -p ${sq(dir)}`);
+      const encoded = Buffer.from(content, "utf-8").toString("base64");
+      const result = await run(`echo ${sq(encoded)} | base64 -d > ${sq(absPath)}`);
+      if (result.exitCode !== 0) {
+        throw new Error(
+          `writeFile failed (${absPath}): ${result.stderr.trim()}`
+        );
+      }
+    },
+    async exists(filePath) {
+      const absPath = resolveDockerPath(filePath, defaultWorkdir);
+      const result = await run(`test -e ${sq(absPath)}`);
+      return result.exitCode === 0;
+    },
+    async stat(filePath) {
+      const absPath = resolveDockerPath(filePath, defaultWorkdir);
+      const result = await run(
+        `stat -c '%s %Y %F' ${sq(absPath)} 2>/dev/null || stat -f '%z %m %HT' ${sq(absPath)}`
+      );
+      if (result.exitCode !== 0) {
+        throw new Error(`stat failed (${absPath}): ${result.stderr.trim()}`);
+      }
+      const parts = result.stdout.trim().split(/\s+/);
+      if (parts.length < 3) {
+        throw new Error(
+          `stat: unexpected output format for ${absPath}: ${result.stdout}`
+        );
+      }
+      const size = parseInt(parts[0], 10);
+      const mtimeSec = parseInt(parts[1], 10);
+      const typeStr = parts.slice(2).join(" ").toLowerCase();
+      return {
+        size,
+        mtime: new Date(mtimeSec * 1e3),
+        isDirectory: typeStr.includes("directory"),
+        isFile: typeStr.includes("regular") || typeStr.includes("file")
+      };
+    },
+    async readdir(dirPath) {
+      const absPath = resolveDockerPath(dirPath, defaultWorkdir);
+      const result = await run(
+        `find ${sq(absPath)} -maxdepth 1 -mindepth 1 -printf '%f\\t%y\\n' 2>/dev/null || for f in ${sq(absPath)}/*; do [ -e "$f" ] || continue; n=$(basename "$f"); if [ -d "$f" ]; then printf '%s\\td\\n' "$n"; else printf '%s\\tf\\n' "$n"; fi; done`
+      );
+      if (result.exitCode !== 0) {
+        throw new Error(
+          `readdir failed (${absPath}): ${result.stderr.trim()}`
+        );
+      }
+      return result.stdout.trim().split("\n").filter(Boolean).map((line) => {
+        const [name, type] = line.split("	");
+        return {
+          name,
+          isDirectory: type === "d",
+          isFile: type === "f"
+        };
+      });
+    },
+    async mkdir(dirPath) {
+      const absPath = resolveDockerPath(dirPath, defaultWorkdir);
+      const result = await run(`mkdir -p ${sq(absPath)}`);
+      if (result.exitCode !== 0) {
+        throw new Error(`mkdir failed (${absPath}): ${result.stderr.trim()}`);
+      }
+    },
+    async exec(command, execOptions) {
+      return await run(command, execOptions);
+    }
+  };
+}
+
+export {
+  localHost,
+  dockerHost
+};

package/dist/{chunk-X635CM2F.js → chunk-ZPMACVZK.js}

@@ -3,7 +3,7 @@ import {
   extractProvider,
   getDefaultResolver,
   likelySupportsReasoning
-} from "./chunk-QWFMX226.js";
+} from "./chunk-QGOGIP7T.js";
 
 // src/reasoning/types.ts
 var STANDARD_LEVELS = ["off", "low", "medium", "high"];

package/dist/context/index.js

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

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
+};

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

@@ -1,15 +1,20 @@
 import { LanguageModel } from 'ai';
 import { R as ReasoningLevel } from './types-CQaXbRsS.js';
-import { T as Tool } from './tool-pFAnJc5Y.js';
-import { f as AgentMiddleware, P as PromptConfig, A as AgentEvent, M as MiddlewareRunner } from './runner-C7aMP_x3.js';
-import { g as SessionManager, c as SessionContext, f as SessionInfo } from './session-manager-Uawm2Le7.js';
-import { d as ToolHost } from './tool-DYp6-cC3.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 { 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 MCPManager } from './types-VQgymC1N.js';
 import { U as UndoResult, T as TurnChangeTracker } from './tracker-DClqYqTj.js';
-import { P as PromptBuilder } from './builder-RcTZuYnO.js';
-import { x as DoomLoopHandler, Z as StreamProvider, J as PendingIntervention, I as InterventionController, q as AgentTurnStepRuntimeConfig } from './types-MM1JoX5T.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';
 
+/**
+ * Tools whose outputs should never be pruned automatically.
+ */
+declare const PRUNE_PROTECTED_TOOLS: readonly ["skill"];
 /**
  * Configuration for automatic context compaction.
  */
@@ -1064,4 +1069,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, Agent as a, type AgentConfig as b, type AgentProfile as c, DEFAULT_MAX_SPAWN_DEPTH as d, DEFAULT_SESSION_TITLE_PREFIX as e, type SubAgentHandle as f, type SubAgentStatus as g, type SubAgentToolConfig as h, SubAgentTracker as i, type SubAgentUsage as j, createAgent as k, createSubAgentTools as l };
+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 };

package/dist/{index-tmhaADz5.d.ts → index-CfBGYrpd.d.ts}

@@ -1,4 +1,4 @@
-import { f as AgentMiddleware } from './runner-C7aMP_x3.js';
+import { h as AgentMiddleware } from './runner-DSKaEz3z.js';
 import { TelemetrySettings } from 'ai';
 
 /**
@@ -195,4 +195,123 @@ declare function otelMiddleware(config?: OtelMiddlewareConfig): AgentMiddleware;
 
 declare function createTelemetryConfig(config: TelemetryConfig): TelemetryConfigResult;
 
-export { type ApprovalConfig as A, type OtelMiddlewareConfig as O, type RiskLevel as R, type TelemetryConfig as T, type ApprovalRule as a, type ApprovalAction as b, type ApprovalMiddlewareConfig as c, type ApprovalRequest as d, type TelemetryConfigResult as e, approvalMiddleware as f, createTelemetryConfig as g, otelMiddleware as o };
+/**
+ * Prompt Cache Middleware — Type definitions.
+ *
+ * Defines the configuration for provider-specific prompt caching.
+ * Currently supports Anthropic's `cache_control` with ephemeral breakpoints.
+ */
+/**
+ * Supported cache TTL values for Anthropic prompt caching.
+ *
+ * - `"5m"` — 5-minute cache (default, ~90% input cost reduction)
+ * - `"1h"` — 1-hour cache (higher write cost, but longer retention)
+ */
+type CacheTTL = "5m" | "1h";
+/**
+ * Configuration for the prompt cache middleware.
+ *
+ * @example
+ * ```typescript
+ * // Default — auto-detect Anthropic, 5-minute TTL
+ * promptCacheMiddleware()
+ *
+ * // Custom TTL
+ * promptCacheMiddleware({ ttl: "1h" })
+ *
+ * // Custom breakpoint strategy
+ * promptCacheMiddleware({
+ *   messageBreakpoints: 2,   // cache system + 2 message boundaries
+ * })
+ * ```
+ */
+interface PromptCacheConfig {
+    /**
+     * Cache TTL. Defaults to `"5m"` (Anthropic's default).
+     *
+     * - `"5m"` — 5 minutes. 1.25× write, 0.1× read.
+     * - `"1h"` — 1 hour. Higher write cost, longer retention.
+     */
+    ttl?: CacheTTL;
+    /**
+     * Number of cache breakpoints to place on conversation messages.
+     *
+     * Anthropic allows up to 4 breakpoints total. The system prompt always
+     * gets one. This controls how many additional breakpoints are placed
+     * on conversation messages (counting from the end of stable content).
+     *
+     * Defaults to `1` (system + 1 message boundary = 2 breakpoints).
+     *
+     * Set to `0` to only cache the system prompt.
+     */
+    messageBreakpoints?: number;
+}
+
+/**
+ * Prompt Cache Middleware — Anthropic prompt caching via `model.input`.
+ *
+ * Reduces input token costs by marking stable content (system prompt,
+ * older conversation messages) with Anthropic `cache_control` breakpoints.
+ *
+ * How it works:
+ *
+ * 1. The middleware runs before each `streamText()` call via `model.input`
+ * 2. It detects if the model is Anthropic (via provider string or model ID)
+ * 3. For Anthropic models, it sets `cache_control: { type: "ephemeral" }`
+ *    on the system prompt and on stable conversation messages
+ * 4. The AI SDK's Anthropic provider translates these into API-level
+ *    `cache_control` fields that Anthropic uses for prefix caching
+ *
+ * Cost impact:
+ * - First call per cache region: 1.25× write cost (25% premium)
+ * - Subsequent calls hitting cache: 0.1× read cost (90% savings)
+ * - Cache TTL: 5 minutes (default) or 1 hour
+ * - Net savings on multi-turn conversations: ~75%
+ *
+ * Anthropic limits: max 4 cache breakpoints per request.
+ * This middleware uses 1 for system + up to `messageBreakpoints` for messages.
+ *
+ * @example
+ * ```typescript
+ * import { promptCacheMiddleware } from "@cuylabs/agent-core/middleware";
+ *
+ * const agent = createAgent({
+ *   model: anthropic("claude-sonnet-4-20250514"),
+ *   middleware: [promptCacheMiddleware()],
+ * });
+ * ```
+ */
+
+/**
+ * Create a prompt cache middleware for Anthropic models.
+ *
+ * Automatically detects Anthropic models and adds `cache_control`
+ * breakpoints to the system prompt and stable conversation messages.
+ * Non-Anthropic models are passed through unchanged.
+ *
+ * @param config - Optional configuration (TTL, breakpoint count)
+ * @returns An `AgentMiddleware` that enables Anthropic prompt caching
+ *
+ * @example
+ * ```typescript
+ * import { anthropic } from "@ai-sdk/anthropic";
+ * import { createAgent } from "@cuylabs/agent-core";
+ * import { promptCacheMiddleware } from "@cuylabs/agent-core/middleware";
+ *
+ * const agent = createAgent({
+ *   model: anthropic("claude-sonnet-4-20250514"),
+ *   middleware: [promptCacheMiddleware()],
+ * });
+ *
+ * // With custom config
+ * const agent2 = createAgent({
+ *   model: anthropic("claude-sonnet-4-20250514"),
+ *   middleware: [
+ *     promptCacheMiddleware({ ttl: "1h", messageBreakpoints: 2 }),
+ *   ],
+ * });
+ * ```
+ */
+declare function promptCacheMiddleware(config?: PromptCacheConfig): AgentMiddleware;
+
+export { type ApprovalConfig as A, type CacheTTL as C, type OtelMiddlewareConfig as O, type PromptCacheConfig as P, type RiskLevel as R, type TelemetryConfig as T, type ApprovalRule as a, type ApprovalAction as b, type ApprovalMiddlewareConfig as c, type ApprovalRequest as d, type TelemetryConfigResult as e, approvalMiddleware as f, createTelemetryConfig as g, otelMiddleware as o, promptCacheMiddleware as p };