@elizaos/agent 2.0.0-beta.1 → 2.0.11-beta.5

package/runtime/tool-call-cache/cache.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Tool-call cache.
+ *
+ * Two-tier: in-memory LRU + on-disk persistent. Entries are keyed by
+ * `sha256(toolName + ':' + canonicalJson(args))` and tagged with the tool
+ * implementation version. A version bump on the descriptor invalidates all
+ * prior entries for that tool without an explicit purge. Side-effect tools
+ * opt out via `cacheable: false` and short-circuit straight to the
+ * underlying executor.
+ *
+ * The disk tier runs every output through a privacy redactor before
+ * serialisation. Tool inputs/outputs may contain user PII (search queries,
+ * fetched HTML, file contents) and the cross-session disk reuse is what
+ * forces this — a process-only cache could rely on the surrounding
+ * trajectory filter, but a shared on-disk store cannot.
+ */
+import type { CacheableToolDescriptor, PrivacyRedactor, ToolArgs, ToolCacheEntry, ToolOutput } from "./types.ts";
+export interface ToolCallCacheOptions {
+    /** Root directory for the on-disk tier. Defaults to `<stateDir>/tool-cache`. */
+    diskRoot?: string;
+    /** Maximum entries in the in-memory tier. Default 1000. */
+    memoryCapacity?: number;
+    /** Privacy redactor applied to outputs before disk write. Required. */
+    redact: PrivacyRedactor;
+    /** Clock injection for tests. */
+    now?: () => number;
+}
+export declare class ToolCallCache {
+    private readonly memory;
+    private readonly disk;
+    private readonly now;
+    constructor(options: ToolCallCacheOptions);
+    /**
+     * Look up a cache entry for (toolName, args). Returns undefined on miss,
+     * on TTL expiry, or on tool-version mismatch. A disk hit promotes the
+     * entry into the in-memory tier.
+     */
+    get(descriptor: CacheableToolDescriptor, args: ToolArgs): ToolCacheEntry | undefined;
+    /**
+     * Record a fresh tool result. Returns immediately when the descriptor is not cacheable.
+     * Both tiers are written synchronously; the disk tier runs through the
+     * privacy redactor inside DiskStore.write.
+     */
+    set(descriptor: CacheableToolDescriptor, args: ToolArgs, output: ToolOutput): void;
+    /**
+     * Drop entries from the cache. With no arguments this purges everything.
+     * With a tool name it purges every in-memory entry whose toolName matches,
+     * and removes the disk-tier file for each matching key. Disk entries
+     * written from a previous process that never made it into this LRU are
+     * not enumerable (we deliberately do not maintain a disk index) — for a
+     * full per-tool disk purge, bump the tool's `version` in its descriptor,
+     * which forces every prior entry to miss on lookup.
+     */
+    invalidate(toolName?: string, argHash?: string): void;
+    /**
+     * Run a tool through the cache. On hit, returns the cached output without
+     * invoking `execute`. On miss, runs `execute`, persists the result, and
+     * returns it. Side-effect tools (`cacheable: false`) always run.
+     */
+    run(descriptor: CacheableToolDescriptor, args: ToolArgs, execute: () => Promise<ToolOutput>): Promise<ToolOutput>;
+}
+//# sourceMappingURL=cache.d.ts.map

package/runtime/tool-call-cache/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../src/runtime/tool-call-cache/cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAQH,OAAO,KAAK,EACV,uBAAuB,EACvB,eAAe,EACf,QAAQ,EACR,cAAc,EACd,UAAU,EACX,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,oBAAoB;IACnC,gFAAgF;IAChF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2DAA2D;IAC3D,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,uEAAuE;IACvE,MAAM,EAAE,eAAe,CAAC;IACxB,iCAAiC;IACjC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA8B;IACrD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAY;IACjC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;gBAEvB,OAAO,EAAE,oBAAoB;IAOzC;;;;OAIG;IACH,GAAG,CACD,UAAU,EAAE,uBAAuB,EACnC,IAAI,EAAE,QAAQ,GACb,cAAc,GAAG,SAAS;IAsB7B;;;;OAIG;IACH,GAAG,CACD,UAAU,EAAE,uBAAuB,EACnC,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,UAAU,GACjB,IAAI;IAgBP;;;;;;;;OAQG;IACH,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAqBrD;;;;OAIG;IACG,GAAG,CACP,UAAU,EAAE,uBAAuB,EACnC,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,MAAM,OAAO,CAAC,UAAU,CAAC,GACjC,OAAO,CAAC,UAAU,CAAC;CAOvB"}

package/runtime/tool-call-cache/cache.js

@@ -0,0 +1,123 @@
+/**
+ * Tool-call cache.
+ *
+ * Two-tier: in-memory LRU + on-disk persistent. Entries are keyed by
+ * `sha256(toolName + ':' + canonicalJson(args))` and tagged with the tool
+ * implementation version. A version bump on the descriptor invalidates all
+ * prior entries for that tool without an explicit purge. Side-effect tools
+ * opt out via `cacheable: false` and short-circuit straight to the
+ * underlying executor.
+ *
+ * The disk tier runs every output through a privacy redactor before
+ * serialisation. Tool inputs/outputs may contain user PII (search queries,
+ * fetched HTML, file contents) and the cross-session disk reuse is what
+ * forces this — a process-only cache could rely on the surrounding
+ * trajectory filter, but a shared on-disk store cannot.
+ */
+import path from "node:path";
+import { resolveStateDir } from "../../config/paths.js";
+import { DiskStore } from "./disk-store.js";
+import { buildCacheKey } from "./key.js";
+import { Lru } from "./lru.js";
+export class ToolCallCache {
+    memory;
+    disk;
+    now;
+    constructor(options) {
+        const root = options.diskRoot ?? path.join(resolveStateDir(), "tool-cache");
+        this.memory = new Lru(options.memoryCapacity ?? 1000);
+        this.disk = new DiskStore(root, options.redact);
+        this.now = options.now ?? Date.now;
+    }
+    /**
+     * Look up a cache entry for (toolName, args). Returns undefined on miss,
+     * on TTL expiry, or on tool-version mismatch. A disk hit promotes the
+     * entry into the in-memory tier.
+     */
+    get(descriptor, args) {
+        if (!descriptor.cacheable)
+            return undefined;
+        const key = buildCacheKey(descriptor.name, args);
+        const fromMemory = this.memory.get(key);
+        const candidate = fromMemory ?? this.disk.read(key);
+        if (!candidate)
+            return undefined;
+        if (candidate.toolVersion !== descriptor.version) {
+            this.memory.delete(key);
+            this.disk.delete(key);
+            return undefined;
+        }
+        if (candidate.expiresAt <= this.now()) {
+            this.memory.delete(key);
+            this.disk.delete(key);
+            return undefined;
+        }
+        if (!fromMemory)
+            this.memory.set(key, candidate);
+        return candidate;
+    }
+    /**
+     * Record a fresh tool result. Returns immediately when the descriptor is not cacheable.
+     * Both tiers are written synchronously; the disk tier runs through the
+     * privacy redactor inside DiskStore.write.
+     */
+    set(descriptor, args, output) {
+        if (!descriptor.cacheable)
+            return;
+        const key = buildCacheKey(descriptor.name, args);
+        const cachedAt = this.now();
+        const entry = {
+            key,
+            toolName: descriptor.name,
+            toolVersion: descriptor.version,
+            cachedAt,
+            expiresAt: cachedAt + descriptor.ttlMs,
+            output,
+        };
+        this.memory.set(key, entry);
+        this.disk.write(entry);
+    }
+    /**
+     * Drop entries from the cache. With no arguments this purges everything.
+     * With a tool name it purges every in-memory entry whose toolName matches,
+     * and removes the disk-tier file for each matching key. Disk entries
+     * written from a previous process that never made it into this LRU are
+     * not enumerable (we deliberately do not maintain a disk index) — for a
+     * full per-tool disk purge, bump the tool's `version` in its descriptor,
+     * which forces every prior entry to miss on lookup.
+     */
+    invalidate(toolName, argHash) {
+        if (!toolName) {
+            this.memory.clear();
+            this.disk.clear();
+            return;
+        }
+        if (argHash) {
+            this.memory.delete(argHash);
+            this.disk.delete(argHash);
+            return;
+        }
+        const toDelete = [];
+        for (const [key, entry] of this.memory.entries()) {
+            if (entry.toolName === toolName)
+                toDelete.push(key);
+        }
+        for (const key of toDelete) {
+            this.memory.delete(key);
+            this.disk.delete(key);
+        }
+    }
+    /**
+     * Run a tool through the cache. On hit, returns the cached output without
+     * invoking `execute`. On miss, runs `execute`, persists the result, and
+     * returns it. Side-effect tools (`cacheable: false`) always run.
+     */
+    async run(descriptor, args, execute) {
+        const hit = this.get(descriptor, args);
+        if (hit)
+            return hit.output;
+        const output = await execute();
+        this.set(descriptor, args, output);
+        return output;
+    }
+}

package/runtime/tool-call-cache/disk-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disk-store.d.ts","sourceRoot":"","sources":["../../../src/runtime/tool-call-cache/disk-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAWH,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAElE,qBAAa,SAAS;IAElB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,eAAe;IAG1C,OAAO,CAAC,OAAO;IAIf,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;IAS7C,KAAK,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI;IAYlC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAKzB,KAAK,IAAI,IAAI;CAKd"}

package/runtime/tool-call-cache/index.d.ts

@@ -0,0 +1,7 @@
+export type { ToolCallCacheOptions } from "./cache.ts";
+export { ToolCallCache } from "./cache.ts";
+export { buildCacheKey, canonicalizeJson } from "./key.ts";
+export { defaultPrivacyRedactor } from "./redact.ts";
+export { CACHEABLE_TOOL_REGISTRY, isCacheable, resolveToolDescriptor, } from "./registry.ts";
+export type { CacheableToolDescriptor, PrivacyRedactor, ToolArgs, ToolCacheEntry, ToolOutput, } from "./types.ts";
+//# sourceMappingURL=index.d.ts.map

package/runtime/tool-call-cache/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/tool-call-cache/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC3D,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EACL,uBAAuB,EACvB,WAAW,EACX,qBAAqB,GACtB,MAAM,eAAe,CAAC;AACvB,YAAY,EACV,uBAAuB,EACvB,eAAe,EACf,QAAQ,EACR,cAAc,EACd,UAAU,GACX,MAAM,YAAY,CAAC"}

package/runtime/tool-call-cache/index.js

@@ -0,0 +1,4 @@
+export { ToolCallCache } from "./cache.js";
+export { buildCacheKey, canonicalizeJson } from "./key.js";
+export { defaultPrivacyRedactor } from "./redact.js";
+export { CACHEABLE_TOOL_REGISTRY, isCacheable, resolveToolDescriptor, } from "./registry.js";

package/runtime/tool-call-cache/key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"key.d.ts","sourceRoot":"","sources":["../../../src/runtime/tool-call-cache/key.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAcvD;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,MAAM,CAOtE"}

package/runtime/tool-call-cache/key.js

@@ -0,0 +1,31 @@
+/**
+ * Stable cache-key derivation.
+ *
+ * Args are JSON-stringified with sorted object keys so semantically-equal
+ * argument shapes (e.g. `{a:1,b:2}` and `{b:2,a:1}`) collide on the same
+ * key. The final key is `sha256(toolName + ':' + canonicalJson)`.
+ */
+import { createHash } from "node:crypto";
+export function canonicalizeJson(value) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((v) => canonicalizeJson(v)).join(",")}]`;
+    }
+    const obj = value;
+    const keys = Object.keys(obj).sort();
+    const parts = [];
+    for (const key of keys) {
+        parts.push(`${JSON.stringify(key)}:${canonicalizeJson(obj[key])}`);
+    }
+    return `{${parts.join(",")}}`;
+}
+export function buildCacheKey(toolName, args) {
+    const canonical = canonicalizeJson(args);
+    const hash = createHash("sha256");
+    hash.update(toolName);
+    hash.update(":");
+    hash.update(canonical);
+    return hash.digest("hex");
+}

package/runtime/tool-call-cache/lru.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lru.d.ts","sourceRoot":"","sources":["../../../src/runtime/tool-call-cache/lru.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,qBAAa,GAAG,CAAC,CAAC,EAAE,CAAC;IAGP,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAFrC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAmB;gBAEV,QAAQ,EAAE,MAAM;IAM7C,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAQ1B,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAU3B,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAIvB,KAAK,IAAI,IAAI;IAIb,IAAI,IAAI,MAAM;IAId,OAAO,IAAI,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAGpC"}

package/runtime/tool-call-cache/redact.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Default privacy redactor for the tool-call cache.
+ *
+ * The full trajectory privacy filter operates on a richer trajectory shape
+ * (steps, llmCalls, metadata) and exists in `plugins/plugin-training`. Pulling
+ * that dependency into app-core would invert the layer order, so we keep a
+ * focused redactor here that mirrors the credential + geo passes from that
+ * filter and is applied to every disk write.
+ *
+ * The redactor walks the value tree and replaces:
+ *   - common API key shapes (`sk-…`, `Bearer …`, `ghp_…`, `AKIA…`)
+ *   - environment-variable values whose key name looks like a secret
+ *   - geographic coordinates (matching the Location-plugin patterns)
+ */
+import type { PrivacyRedactor } from "./types.ts";
+export declare const defaultPrivacyRedactor: PrivacyRedactor;
+//# sourceMappingURL=redact.d.ts.map

package/runtime/tool-call-cache/redact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redact.d.ts","sourceRoot":"","sources":["../../../src/runtime/tool-call-cache/redact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAgElD,eAAO,MAAM,sBAAsB,EAAE,eAGpC,CAAC"}

package/runtime/tool-call-cache/redact.js

@@ -0,0 +1,77 @@
+/**
+ * Default privacy redactor for the tool-call cache.
+ *
+ * The full trajectory privacy filter operates on a richer trajectory shape
+ * (steps, llmCalls, metadata) and exists in `plugins/plugin-training`. Pulling
+ * that dependency into app-core would invert the layer order, so we keep a
+ * focused redactor here that mirrors the credential + geo passes from that
+ * filter and is applied to every disk write.
+ *
+ * The redactor walks the value tree and replaces:
+ *   - common API key shapes (`sk-…`, `Bearer …`, `ghp_…`, `AKIA…`)
+ *   - environment-variable values whose key name looks like a secret
+ *   - geographic coordinates (matching the Location-plugin patterns)
+ */
+const CREDENTIAL_PATTERNS = [
+    { label: "openai-key", pattern: /\bsk-[A-Za-z0-9_-]{16,}\b/g },
+    { label: "anthropic-key", pattern: /\bsk-ant-[A-Za-z0-9_-]{16,}\b/g },
+    { label: "bearer", pattern: /\bBearer\s+[A-Za-z0-9._-]{16,}\b/g },
+    { label: "github-token", pattern: /\bghp_[A-Za-z0-9]{20,}\b/g },
+    { label: "aws-access-key", pattern: /\bAKIA[0-9A-Z]{16}\b/g },
+];
+const GEO_PATTERNS = [
+    /"coords"\s*:\s*\{\s*"latitude"\s*:\s*-?\d+(?:\.\d+)?\s*,\s*"longitude"\s*:\s*-?\d+(?:\.\d+)?(?:\s*,\s*"[A-Za-z_][A-Za-z0-9_]*"\s*:\s*[^,}]+)*\s*\}/g,
+    /"latitude"\s*:\s*-?\d+(?:\.\d+)?\s*,\s*"longitude"\s*:\s*-?\d+(?:\.\d+)?/g,
+    /\b(?:current\s+location|location|coords|coordinates)\s*[:=]\s*-?\d+(?:\.\d+)?\s*,\s*-?\d+(?:\.\d+)?/gi,
+    /\b(?:lat|latitude)\s*[:=]\s*-?\d+(?:\.\d+)?\s*[,;]\s*(?:lng|lon|long|longitude)\s*[:=]\s*-?\d+(?:\.\d+)?/gi,
+    /\b-?\d{1,3}\.\d{2,}\s*,\s*-?\d{1,3}\.\d{2,}\b/g,
+];
+const SECRET_NAME = /KEY|TOKEN|SECRET|PASSWORD|API|CREDENTIAL/i;
+function snapshotEnvCredentials() {
+    const out = [];
+    for (const [key, value] of Object.entries(process.env)) {
+        if (!SECRET_NAME.test(key))
+            continue;
+        if (typeof value !== "string" || value.length < 8)
+            continue;
+        out.push(value);
+    }
+    return out;
+}
+function redactString(input, envValues) {
+    let out = input;
+    for (const pattern of GEO_PATTERNS) {
+        out = out.replace(pattern, "[REDACTED_GEO]");
+    }
+    for (const { label, pattern } of CREDENTIAL_PATTERNS) {
+        out = out.replace(pattern, `<REDACTED:${label}>`);
+    }
+    for (const credValue of envValues) {
+        if (!credValue)
+            continue;
+        const escaped = credValue.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        out = out.replace(new RegExp(escaped, "g"), "<REDACTED:env-secret>");
+    }
+    return out;
+}
+function walk(value, envValues) {
+    if (typeof value === "string") {
+        return redactString(value, envValues);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => walk(item, envValues));
+    }
+    if (value && typeof value === "object") {
+        const obj = value;
+        const out = {};
+        for (const key of Object.keys(obj)) {
+            out[key] = walk(obj[key], envValues);
+        }
+        return out;
+    }
+    return value;
+}
+export const defaultPrivacyRedactor = (value) => {
+    const envValues = snapshotEnvCredentials();
+    return walk(value, envValues);
+};

package/runtime/tool-call-cache/registry.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Cacheable-tool whitelist.
+ *
+ * The cache is opt-in. A tool only participates if it is registered here
+ * with `cacheable: true`. The default for any tool not in the registry is
+ * `cacheable: false` so side-effect tools (send_email, post_message,
+ * write_file, run_code, …) are guaranteed never to short-circuit through
+ * the cache unless they are explicitly registered.
+ *
+ * TTLs default to 24h. Tools with shorter freshness needs (file reads
+ * against a working tree) get short TTLs; tools whose results are stable
+ * across days (search results, immutable web archives) get longer ones.
+ */
+import type { CacheableToolDescriptor } from "./types.ts";
+export declare const CACHEABLE_TOOL_REGISTRY: Record<string, CacheableToolDescriptor>;
+export declare function resolveToolDescriptor(name: string, overrides?: Partial<Pick<CacheableToolDescriptor, "ttlMs" | "version">>): CacheableToolDescriptor;
+export declare function isCacheable(name: string): boolean;
+//# sourceMappingURL=registry.d.ts.map

package/runtime/tool-call-cache/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/runtime/tool-call-cache/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAK1D,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAgCzE,CAAC;AAEJ,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,SAAS,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,uBAAuB,EAAE,OAAO,GAAG,SAAS,CAAC,CAAC,GACtE,uBAAuB,CAezB;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEjD"}

package/runtime/tool-call-cache/registry.js

@@ -0,0 +1,66 @@
+/**
+ * Cacheable-tool whitelist.
+ *
+ * The cache is opt-in. A tool only participates if it is registered here
+ * with `cacheable: true`. The default for any tool not in the registry is
+ * `cacheable: false` so side-effect tools (send_email, post_message,
+ * write_file, run_code, …) are guaranteed never to short-circuit through
+ * the cache unless they are explicitly registered.
+ *
+ * TTLs default to 24h. Tools with shorter freshness needs (file reads
+ * against a working tree) get short TTLs; tools whose results are stable
+ * across days (search results, immutable web archives) get longer ones.
+ */
+const HOUR_MS = 60 * 60 * 1000;
+const DAY_MS = 24 * HOUR_MS;
+export const CACHEABLE_TOOL_REGISTRY = {
+    web_search: {
+        name: "web_search",
+        version: "1",
+        ttlMs: 6 * HOUR_MS,
+        cacheable: true,
+    },
+    web_fetch: {
+        name: "web_fetch",
+        version: "1",
+        ttlMs: DAY_MS,
+        cacheable: true,
+    },
+    file_read: {
+        name: "file_read",
+        version: "1",
+        ttlMs: 5 * 60 * 1000,
+        cacheable: true,
+    },
+    rag_search: {
+        name: "rag_search",
+        version: "1",
+        ttlMs: HOUR_MS,
+        cacheable: true,
+    },
+    knowledge_lookup: {
+        name: "knowledge_lookup",
+        version: "1",
+        ttlMs: HOUR_MS,
+        cacheable: true,
+    },
+};
+export function resolveToolDescriptor(name, overrides) {
+    const base = CACHEABLE_TOOL_REGISTRY[name];
+    if (!base) {
+        return {
+            name,
+            version: "1",
+            ttlMs: 0,
+            cacheable: false,
+        };
+    }
+    return {
+        ...base,
+        ttlMs: overrides?.ttlMs ?? base.ttlMs,
+        version: overrides?.version ?? base.version,
+    };
+}
+export function isCacheable(name) {
+    return CACHEABLE_TOOL_REGISTRY[name]?.cacheable === true;
+}

package/runtime/tool-call-cache/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/runtime/tool-call-cache/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE/C;;;GAGG;AACH,MAAM,MAAM,UAAU,GAClB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,UAAU,EAAE,GACZ;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;CAAE,CAAC;AAElC,MAAM,WAAW,cAAc;IAC7B,yDAAyD;IACzD,GAAG,EAAE,MAAM,CAAC;IACZ,0EAA0E;IAC1E,QAAQ,EAAE,MAAM,CAAC;IACjB,mEAAmE;IACnE,WAAW,EAAE,MAAM,CAAC;IACpB,yCAAyC;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,0DAA0D;IAC1D,SAAS,EAAE,MAAM,CAAC;IAClB,0BAA0B;IAC1B,MAAM,EAAE,UAAU,CAAC;CACpB;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,2EAA2E;IAC3E,OAAO,EAAE,MAAM,CAAC;IAChB,0BAA0B;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC"}

package/runtime/tool-call-cache-wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-call-cache-wrapper.d.ts","sourceRoot":"","sources":["../../src/runtime/tool-call-cache-wrapper.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EACV,MAAM,EAIP,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,uBAAuB,EAKvB,aAAa,EAEd,MAAM,4BAA4B,CAAC;AAEpC,UAAU,eAAe;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;CAC3C;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,CAC3C,GAAG,EAAE,eAAe,GAAG,SAAS,GAC/B,aAAa,GAAG,IAAI,CAOtB;AAyBD;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,aAAa,EACpB,GAAG,EAAE,eAAe,GAAG,SAAS,GAC/B,MAAM,CAwBR;AAED,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EAAE,EACjB,KAAK,EAAE,aAAa,EACpB,GAAG,EAAE,eAAe,GAAG,SAAS,GAC/B,MAAM,EAAE,CAEV;AAED,OAAO,EAAE,uBAAuB,EAAE,CAAC"}

package/runtime/trajectory-export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trajectory-export.d.ts","sourceRoot":"","sources":["../../src/runtime/trajectory-export.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EACV,UAAU,EACV,uBAAuB,EACvB,sBAAsB,EACtB,kBAAkB,EAInB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EASL,KAAK,mBAAmB,EAKzB,MAAM,2BAA2B,CAAC;AAEnC,MAAM,MAAM,8BAA8B,GAAG,uBAAuB,CAAC;AA8ErE,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,OAAO,EACZ,OAAO,EAAE,MAAM,GACd,kBAAkB,GAAG,IAAI,CA2D3B;AAED,wBAAgB,iCAAiC,CAC/C,SAAS,EAAE,mBAAmB,EAC9B,OAAO,EAAE,MAAM,GACd,UAAU,CA0BZ;AAED,wBAAgB,2BAA2B,CAAC,MAAM,EAAE;IAClD,OAAO,EAAE,MAAM,CAAC;IAChB,qBAAqB,EAAE,mBAAmB,EAAE,CAAC;IAC7C,OAAO,EAAE,8BAA8B,CAAC;CACzC,GAAG,sBAAsB,CAMzB;AAED,OAAO,EACL,sBAAsB,EACtB,qCAAqC,EACrC,iCAAiC,EACjC,mBAAmB,EACnB,0BAA0B,EAC1B,sBAAsB,EACtB,wBAAwB,GACzB,MAAM,2BAA2B,CAAC"}

package/runtime/trajectory-export.js

@@ -0,0 +1,132 @@
+/**
+ * Trajectory export — export and archive operations.
+ *
+ * Re-exports archive helpers and hosts the shared canonical list/detail/export
+ * shaping used by the agent runtime trajectory logger implementations.
+ */
+import { serializeTrajectoryExport } from "@elizaos/core";
+import { enrichTrajectoryLlmCall, normalizePersistedTrajectoryTiming, normalizePersistedUpdatedAt, normalizeStatus, normalizeTrajectoryMetadata, parseMetadata, toNumber, toOptionalNumber, toText, } from "./trajectory-internals.js";
+function toCreatedAt(timestamp) {
+    return new Date(timestamp ?? Date.now()).toISOString();
+}
+function toPublicTrajectoryLlmCall(call, trajectoryId, stepId) {
+    return enrichTrajectoryLlmCall({
+        ...call,
+        callId: toText(call.callId, `${stepId}-call`),
+        stepId,
+        trajectoryId,
+        timestamp: toNumber(call.timestamp, Date.now()),
+        model: toText(call.model, "unknown"),
+        systemPrompt: toText(call.systemPrompt, ""),
+        userPrompt: toText(call.userPrompt, ""),
+        response: toText(call.response, ""),
+        temperature: toNumber(call.temperature, 0),
+        maxTokens: toNumber(call.maxTokens, 0),
+        purpose: toText(call.purpose, "action"),
+        actionType: toText(call.actionType, "runtime.useModel"),
+        latencyMs: toNumber(call.latencyMs, 0),
+        ...(call.createdAt
+            ? { createdAt: toText(call.createdAt, toCreatedAt(call.timestamp)) }
+            : { createdAt: toCreatedAt(call.timestamp) }),
+    });
+}
+function toPublicTrajectoryProviderAccess(access, trajectoryId, stepId) {
+    return {
+        ...access,
+        providerId: toText(access.providerId, `${stepId}-provider`),
+        stepId,
+        trajectoryId,
+        providerName: toText(access.providerName, "unknown"),
+        purpose: toText(access.purpose, "provider"),
+        data: access.data && typeof access.data === "object" ? access.data : {},
+        timestamp: toNumber(access.timestamp, Date.now()),
+        ...(access.createdAt
+            ? { createdAt: toText(access.createdAt, toCreatedAt(access.timestamp)) }
+            : { createdAt: toCreatedAt(access.timestamp) }),
+    };
+}
+function toPublicTrajectoryStep(step, trajectoryId) {
+    return {
+        ...step,
+        stepId: toText(step.stepId, trajectoryId),
+        timestamp: toNumber(step.timestamp, Date.now()),
+        llmCalls: step.llmCalls.map((call) => toPublicTrajectoryLlmCall(call, trajectoryId, toText(step.stepId, trajectoryId))),
+        providerAccesses: step.providerAccesses.map((access) => toPublicTrajectoryProviderAccess(access, trajectoryId, toText(step.stepId, trajectoryId))),
+    };
+}
+export function trajectoryRowToListItem(row, agentId) {
+    if (!row || typeof row !== "object" || Array.isArray(row))
+        return null;
+    const record = row;
+    const normalizedMetadata = normalizeTrajectoryMetadata(parseMetadata(record.metadata), {
+        scenarioId: record.scenario_id,
+        batchId: record.batch_id,
+    });
+    const status = normalizeStatus(record.status, "completed");
+    const startTime = toNumber(record.start_time, Date.now());
+    const timing = normalizePersistedTrajectoryTiming({
+        status,
+        startTime,
+        endTime: toOptionalNumber(record.end_time) ?? null,
+        durationMs: toOptionalNumber(record.duration_ms) ?? null,
+        createdAt: record.created_at,
+        updatedAt: record.updated_at,
+    });
+    return {
+        id: toText(record.id ?? record.trajectory_id, ""),
+        agentId: toText(record.agent_id, agentId),
+        source: toText(record.source, "runtime"),
+        status,
+        startTime,
+        endTime: timing.endTime,
+        durationMs: timing.durationMs,
+        stepCount: toNumber(record.step_count, 0),
+        llmCallCount: toNumber(record.llm_call_count, 0),
+        providerAccessCount: toNumber(record.provider_access_count, 0),
+        totalPromptTokens: toNumber(record.total_prompt_tokens, 0),
+        totalCompletionTokens: toNumber(record.total_completion_tokens, 0),
+        totalCacheReadInputTokens: toNumber(record.total_cache_read_input_tokens, 0),
+        totalCacheCreationInputTokens: toNumber(record.total_cache_creation_input_tokens, 0),
+        scenarioId: normalizedMetadata.scenarioId,
+        batchId: normalizedMetadata.batchId,
+        createdAt: toText(record.created_at, new Date(toNumber(record.start_time, Date.now())).toISOString()),
+        updatedAt: normalizePersistedUpdatedAt({
+            startTime,
+            endTime: timing.endTime,
+            createdAt: record.created_at,
+            updatedAt: record.updated_at,
+        }),
+        metadata: normalizedMetadata.metadata,
+    };
+}
+export function persistedTrajectoryToDetailRecord(persisted, agentId) {
+    const timing = normalizePersistedTrajectoryTiming({
+        status: persisted.status,
+        startTime: persisted.startTime,
+        endTime: persisted.endTime,
+        createdAt: persisted.createdAt,
+        updatedAt: persisted.updatedAt,
+    });
+    const endTime = timing.endTime ?? undefined;
+    return {
+        trajectoryId: persisted.id,
+        agentId,
+        source: persisted.source,
+        status: persisted.status,
+        startTime: persisted.startTime,
+        ...(endTime !== undefined ? { endTime } : {}),
+        ...(timing.durationMs !== null ? { durationMs: timing.durationMs } : {}),
+        ...(persisted.scenarioId ? { scenarioId: persisted.scenarioId } : {}),
+        ...(persisted.batchId ? { batchId: persisted.batchId } : {}),
+        steps: persisted.steps.map((step) => toPublicTrajectoryStep(step, persisted.id)),
+        metrics: { finalStatus: persisted.status },
+        metadata: persisted.metadata,
+        stepsJson: JSON.stringify(persisted.steps),
+    };
+}
+export function exportPersistedTrajectories(params) {
+    const { agentId, persistedTrajectories, options } = params;
+    const trajectories = persistedTrajectories.map((trajectory) => persistedTrajectoryToDetailRecord(trajectory, agentId));
+    return serializeTrajectoryExport(trajectories, options);
+}
+export { ensureArchiveDirectory, resolvePreferredTrajectoryArchiveRoot, resolveTrajectoryArchiveDirectory, stringifyArchiveRow, TRAJECTORY_ARCHIVE_DIRNAME, toArchiveSafeTimestamp, writeCompressedJsonlRows, } from "./trajectory-internals.js";