comisai 1.0.4

package/node_modules/@comis/shared/dist/suppress-error.test.js

@@ -0,0 +1,50 @@
+import { describe, it, expect, vi } from "vitest";
+import { suppressError } from "./suppress-error.js";
+describe("suppressError()", () => {
+    it("does not throw when promise rejects", () => {
+        expect(() => {
+            suppressError(Promise.reject(new Error("test")), "cleanup");
+        }).not.toThrow();
+    });
+    it("logs the error reason at debug level when no logger provided", async () => {
+        const debugSpy = vi.spyOn(console, "debug").mockImplementation(() => { });
+        suppressError(Promise.reject(new Error("test error")), "cleanup task");
+        // Wait for the microtask queue to flush
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(debugSpy).toHaveBeenCalledWith("Suppressed error (cleanup task): test error");
+        expect(debugSpy).toHaveBeenCalledTimes(1);
+        debugSpy.mockRestore();
+    });
+    it("uses custom logger when provided", async () => {
+        const debugSpy = vi.spyOn(console, "debug").mockImplementation(() => { });
+        const customLogger = vi.fn();
+        suppressError(Promise.reject(new Error("custom error")), "custom task", customLogger);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(customLogger).toHaveBeenCalledTimes(1);
+        expect(customLogger).toHaveBeenCalledWith("Suppressed error (custom task): custom error");
+        // console.debug should NOT be called when custom logger is provided
+        expect(debugSpy).not.toHaveBeenCalled();
+        debugSpy.mockRestore();
+    });
+    it("passes formatted error message string to custom logger", async () => {
+        const customLogger = vi.fn();
+        suppressError(Promise.reject(new Error("something broke")), "retry cleanup", customLogger);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(customLogger).toHaveBeenCalledWith("Suppressed error (retry cleanup): something broke");
+    });
+    it("handles non-Error rejection with custom logger", async () => {
+        const customLogger = vi.fn();
+        suppressError(Promise.reject("plain string rejection"), "string reject", customLogger);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(customLogger).toHaveBeenCalledWith("Suppressed error (string reject): plain string rejection");
+    });
+    it("does not cause unhandled rejection", async () => {
+        const unhandledHandler = vi.fn();
+        process.on("unhandledRejection", unhandledHandler);
+        suppressError(Promise.reject(new Error("should be caught")), "test");
+        // Wait enough for unhandledRejection to fire if it were going to
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        expect(unhandledHandler).not.toHaveBeenCalled();
+        process.removeListener("unhandledRejection", unhandledHandler);
+    });
+});

package/node_modules/@comis/shared/dist/timeout.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Shared timeout primitive for racing promises against wall-clock deadlines.
+ *
+ * Used across the monorepo wherever a promise needs a hard timeout
+ * (MCP tool calls, LLM prompt calls, health checks).
+ *
+ * @module
+ */
+/**
+ * Error thrown when a promise exceeds its wall-clock timeout.
+ *
+ * Extends `Error` so existing `catch (e: Error)` handlers work unchanged.
+ * The `timeoutMs` property preserves the configured limit for diagnostics.
+ */
+export declare class TimeoutError extends Error {
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number, label?: string);
+}
+/**
+ * Race a promise against a wall-clock timeout.
+ *
+ * - Resolves with the promise value if it settles before the deadline.
+ * - Rejects with `TimeoutError` if the deadline fires first.
+ * - Cleans up the timer on success and suppresses unhandled rejections
+ *   from the original promise when the timeout wins.
+ *
+ * @param promise - The promise to race.
+ * @param ms - Timeout in milliseconds.
+ * @param label - Optional label for the TimeoutError message.
+ */
+export declare function withTimeout<T>(promise: Promise<T>, ms: number, label?: string): Promise<T>;

package/node_modules/@comis/shared/dist/timeout.js

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Shared timeout primitive for racing promises against wall-clock deadlines.
+ *
+ * Used across the monorepo wherever a promise needs a hard timeout
+ * (MCP tool calls, LLM prompt calls, health checks).
+ *
+ * @module
+ */
+/**
+ * Error thrown when a promise exceeds its wall-clock timeout.
+ *
+ * Extends `Error` so existing `catch (e: Error)` handlers work unchanged.
+ * The `timeoutMs` property preserves the configured limit for diagnostics.
+ */
+export class TimeoutError extends Error {
+    timeoutMs;
+    constructor(timeoutMs, label) {
+        const message = label
+            ? `${label} timed out after ${timeoutMs}ms`
+            : `Operation timed out after ${timeoutMs}ms`;
+        super(message);
+        this.name = "TimeoutError";
+        this.timeoutMs = timeoutMs;
+    }
+}
+/**
+ * Race a promise against a wall-clock timeout.
+ *
+ * - Resolves with the promise value if it settles before the deadline.
+ * - Rejects with `TimeoutError` if the deadline fires first.
+ * - Cleans up the timer on success and suppresses unhandled rejections
+ *   from the original promise when the timeout wins.
+ *
+ * @param promise - The promise to race.
+ * @param ms - Timeout in milliseconds.
+ * @param label - Optional label for the TimeoutError message.
+ */
+export function withTimeout(promise, ms, label) {
+    let timer;
+    const timeoutPromise = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new TimeoutError(ms, label)), ms);
+    });
+    return Promise.race([promise, timeoutPromise]).finally(() => {
+        clearTimeout(timer);
+        // Suppress unhandled rejection when the original promise rejects after timeout wins
+        // eslint-disable-next-line no-restricted-syntax -- intentional fire-and-forget
+        promise.catch(() => { });
+    });
+}

package/node_modules/@comis/shared/dist/timeout.test.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/@comis/shared/dist/timeout.test.js

@@ -0,0 +1,75 @@
+import { describe, it, expect, vi } from "vitest";
+import { withTimeout, TimeoutError } from "./timeout.js";
+describe("TimeoutError", () => {
+    it("has name set to 'TimeoutError'", () => {
+        const error = new TimeoutError(5000);
+        expect(error.name).toBe("TimeoutError");
+    });
+    it("is instanceof Error", () => {
+        const error = new TimeoutError(5000);
+        expect(error).toBeInstanceOf(Error);
+    });
+    it("has correct timeoutMs property", () => {
+        const error = new TimeoutError(3000);
+        expect(error.timeoutMs).toBe(3000);
+    });
+    it("formats message with label", () => {
+        const error = new TimeoutError(5000, "MCP connect");
+        expect(error.message).toBe("MCP connect timed out after 5000ms");
+    });
+    it("formats message without label", () => {
+        const error = new TimeoutError(5000);
+        expect(error.message).toBe("Operation timed out after 5000ms");
+    });
+});
+describe("withTimeout", () => {
+    it("resolves when promise completes before timeout", async () => {
+        const result = await withTimeout(Promise.resolve(42), 1000);
+        expect(result).toBe(42);
+    });
+    it("rejects with TimeoutError when timeout fires first", async () => {
+        const neverResolves = new Promise(() => { });
+        await expect(withTimeout(neverResolves, 10, "test op")).rejects.toThrow(TimeoutError);
+    });
+    it("TimeoutError has correct timeoutMs on rejection", async () => {
+        const neverResolves = new Promise(() => { });
+        try {
+            await withTimeout(neverResolves, 25, "test op");
+            throw new Error("Should not reach here");
+        }
+        catch (e) {
+            expect(e).toBeInstanceOf(TimeoutError);
+            expect(e.timeoutMs).toBe(25);
+        }
+    });
+    it("timer is cleaned up on success", async () => {
+        vi.useFakeTimers();
+        try {
+            const promise = Promise.resolve("ok");
+            await withTimeout(promise, 60_000);
+            // After resolution, advancing time should not cause issues
+            // (timer was cleared, no pending timers)
+            expect(vi.getTimerCount()).toBe(0);
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+    it("propagates original error when promise rejects before timeout", async () => {
+        const originalError = new Error("original failure");
+        const failing = Promise.reject(originalError);
+        await expect(withTimeout(failing, 5000)).rejects.toThrow("original failure");
+        await expect(withTimeout(Promise.reject(originalError), 5000)).rejects.not.toBeInstanceOf(TimeoutError);
+    });
+    it("no unhandled rejection when original promise rejects after timeout", async () => {
+        // Create a promise that rejects after a short delay
+        const delayedReject = new Promise((_resolve, reject) => {
+            setTimeout(() => reject(new Error("late rejection")), 50);
+        });
+        // The timeout fires first (10ms < 50ms)
+        await expect(withTimeout(delayedReject, 10, "test")).rejects.toThrow(TimeoutError);
+        // Wait for the delayed rejection to fire -- if unhandled rejection
+        // suppression is missing, this would crash the test runner
+        await new Promise((r) => setTimeout(r, 100));
+    });
+});

package/node_modules/@comis/shared/dist/ttl-cache.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Generic TTL-based in-memory cache with optional max-entry eviction.
+ *
+ * Uses lazy expiry on get/has and Map insertion order for oldest-first
+ * eviction when maxEntries is exceeded.
+ *
+ * @module
+ */
+/** Options for creating a TTLCache instance. */
+export interface TTLCacheOptions {
+    /** Time-to-live in milliseconds for each entry. */
+    ttlMs: number;
+    /** Maximum number of entries. When exceeded, oldest entry is evicted. */
+    maxEntries?: number;
+    /** Injectable clock for deterministic testing. Defaults to Date.now. */
+    nowMs?: () => number;
+}
+/** A TTL-based cache with lazy expiry and optional max-entry eviction. */
+export interface TTLCache<T> {
+    /** Get a value by key. Returns undefined if missing or expired (auto-evicts expired). */
+    get(key: string): T | undefined;
+    /** Store a value with TTL. Evicts oldest if maxEntries exceeded. */
+    set(key: string, value: T): void;
+    /** Check if key exists and is not expired (auto-evicts expired). */
+    has(key: string): boolean;
+    /** Remove a key. Returns true if the key existed. */
+    delete(key: string): boolean;
+    /** Remove all entries. */
+    clear(): void;
+    /** Number of entries in the cache (may include expired entries -- lazy eviction). */
+    size(): number;
+    /** Iterate live (non-expired) entries. Expired entries are evicted during iteration. */
+    entries(): IterableIterator<[string, T]>;
+}
+/**
+ * Create a TTL-based in-memory cache.
+ *
+ * @param opts - Cache configuration
+ * @returns TTLCache instance
+ */
+export declare function createTTLCache<T>(opts: TTLCacheOptions): TTLCache<T>;

package/node_modules/@comis/shared/dist/ttl-cache.js

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Generic TTL-based in-memory cache with optional max-entry eviction.
+ *
+ * Uses lazy expiry on get/has and Map insertion order for oldest-first
+ * eviction when maxEntries is exceeded.
+ *
+ * @module
+ */
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+/**
+ * Create a TTL-based in-memory cache.
+ *
+ * @param opts - Cache configuration
+ * @returns TTLCache instance
+ */
+export function createTTLCache(opts) {
+    const { ttlMs, maxEntries } = opts;
+    const getNow = opts.nowMs ?? Date.now;
+    const store = new Map();
+    function get(key) {
+        const entry = store.get(key);
+        if (!entry)
+            return undefined;
+        if (getNow() >= entry.expiresAt) {
+            store.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    function set(key, value) {
+        // Evict oldest entry if at capacity and key is new
+        if (maxEntries != null && store.size >= maxEntries && !store.has(key)) {
+            const oldest = store.keys().next();
+            if (!oldest.done) {
+                store.delete(oldest.value);
+            }
+        }
+        store.set(key, { value, expiresAt: getNow() + ttlMs });
+    }
+    function has(key) {
+        const entry = store.get(key);
+        if (!entry)
+            return false;
+        if (getNow() >= entry.expiresAt) {
+            store.delete(key);
+            return false;
+        }
+        return true;
+    }
+    function del(key) {
+        return store.delete(key);
+    }
+    function clear() {
+        store.clear();
+    }
+    function size() {
+        return store.size;
+    }
+    function* entries() {
+        const now = getNow();
+        for (const [key, entry] of store) {
+            if (now >= entry.expiresAt) {
+                store.delete(key);
+                continue;
+            }
+            yield [key, entry.value];
+        }
+    }
+    return { get, set, has, delete: del, clear, size, entries };
+}

package/node_modules/@comis/shared/dist/ttl-cache.test.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/@comis/shared/dist/ttl-cache.test.js

@@ -0,0 +1,81 @@
+import { describe, it, expect } from "vitest";
+import { createTTLCache } from "./ttl-cache.js";
+describe("TTLCache", () => {
+    it("get() returns undefined for missing key", () => {
+        const cache = createTTLCache({ ttlMs: 1000 });
+        expect(cache.get("missing")).toBeUndefined();
+    });
+    it("set()+get() returns stored value within TTL", () => {
+        let now = 1000;
+        const cache = createTTLCache({ ttlMs: 5000, nowMs: () => now });
+        cache.set("a", 42);
+        now = 4999; // still within TTL
+        expect(cache.get("a")).toBe(42);
+    });
+    it("get() returns undefined after TTL expires", () => {
+        let now = 1000;
+        const cache = createTTLCache({ ttlMs: 5000, nowMs: () => now });
+        cache.set("x", "hello");
+        now = 6001; // past TTL
+        expect(cache.get("x")).toBeUndefined();
+    });
+    it("has() returns true for live entry, false for expired", () => {
+        let now = 0;
+        const cache = createTTLCache({ ttlMs: 100, nowMs: () => now });
+        cache.set("k", "v");
+        expect(cache.has("k")).toBe(true);
+        now = 101;
+        expect(cache.has("k")).toBe(false);
+    });
+    it("delete() removes entry and returns true; returns false for missing", () => {
+        const cache = createTTLCache({ ttlMs: 1000 });
+        cache.set("a", "val");
+        expect(cache.delete("a")).toBe(true);
+        expect(cache.get("a")).toBeUndefined();
+        expect(cache.delete("a")).toBe(false);
+        expect(cache.delete("never-set")).toBe(false);
+    });
+    it("clear() empties all entries", () => {
+        const cache = createTTLCache({ ttlMs: 1000 });
+        cache.set("a", 1);
+        cache.set("b", 2);
+        cache.set("c", 3);
+        expect(cache.size()).toBe(3);
+        cache.clear();
+        expect(cache.size()).toBe(0);
+        expect(cache.get("a")).toBeUndefined();
+    });
+    it("evicts oldest entry when maxEntries reached", () => {
+        const cache = createTTLCache({ ttlMs: 10_000, maxEntries: 3 });
+        cache.set("a", "1");
+        cache.set("b", "2");
+        cache.set("c", "3");
+        // At capacity -- inserting "d" should evict "a" (oldest)
+        cache.set("d", "4");
+        expect(cache.get("a")).toBeUndefined();
+        expect(cache.get("b")).toBe("2");
+        expect(cache.get("c")).toBe("3");
+        expect(cache.get("d")).toBe("4");
+        expect(cache.size()).toBe(3);
+    });
+    it("entries() iterator skips expired entries and yields only live pairs", () => {
+        let now = 0;
+        const cache = createTTLCache({ ttlMs: 100, nowMs: () => now });
+        cache.set("live1", "a");
+        now = 50;
+        cache.set("live2", "b");
+        // Advance past TTL for "live1" but not "live2"
+        now = 110;
+        const result = Array.from(cache.entries());
+        expect(result).toEqual([["live2", "b"]]);
+    });
+    it("size() returns count including potentially expired (lazy eviction)", () => {
+        let now = 0;
+        const cache = createTTLCache({ ttlMs: 100, nowMs: () => now });
+        cache.set("a", "1");
+        cache.set("b", "2");
+        expect(cache.size()).toBe(2);
+        now = 200; // Both expired but not yet evicted lazily
+        expect(cache.size()).toBe(2);
+    });
+});

package/node_modules/@comis/shared/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@comis/shared",
+  "private": true,
+  "version": "1.0.4",
+  "author": "Moshe Anconina",
+  "license": "Apache-2.0",
+  "description": "Shared types and utilities for the Comis platform",
+  "keywords": [
+    "comis",
+    "ai",
+    "agent",
+    "types",
+    "result"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/comisai/comis.git",
+    "directory": "packages/shared"
+  },
+  "homepage": "https://github.com/comisai/comis#readme",
+  "bugs": {
+    "url": "https://github.com/comisai/comis/issues"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run"
+  }
+}

package/node_modules/@comis/skills/dist/audit/skill-audit.d.ts

@@ -0,0 +1,36 @@
+import type { TypedEventBus } from "@comis/core";
+/**
+ * Skill audit action types.
+ */
+export type SkillAuditAction = "skill.prompt.load" | "skill.prompt.invoke" | "skill.validation.coercion" | "skill.scan" | "skill.scan.reject";
+/**
+ * Options for emitting a skill audit event.
+ */
+export interface SkillAuditOptions {
+    /** The agent performing the action */
+    agentId: string;
+    /** Tenant context */
+    tenantId: string;
+    /** User who owns the action */
+    userId: string;
+    /** Name of the skill being audited */
+    skillName: string;
+    /** The action being performed */
+    action: SkillAuditAction;
+    /** Outcome of the action */
+    outcome: "success" | "failure" | "denied";
+    /** Optional metadata (e.g., violations for rejected skills) */
+    metadata?: Record<string, unknown>;
+    /** Optional duration in milliseconds */
+    duration?: number;
+}
+/**
+ * Emit a skill-related audit event on the typed event bus.
+ *
+ * Produces both a generic `audit:event` and a specific skill event
+ * (`skill:prompt_loaded` or `skill:prompt_invoked`) on the bus.
+ *
+ * @param eventBus - The typed event bus to emit on
+ * @param opts - Audit event options
+ */
+export declare function emitSkillAudit(eventBus: TypedEventBus, opts: SkillAuditOptions): void;

package/node_modules/@comis/skills/dist/audit/skill-audit.js

@@ -0,0 +1,72 @@
+import { createAuditEvent, classifyAction } from "@comis/core";
+/**
+ * Emit a skill-related audit event on the typed event bus.
+ *
+ * Produces both a generic `audit:event` and a specific skill event
+ * (`skill:prompt_loaded` or `skill:prompt_invoked`) on the bus.
+ *
+ * @param eventBus - The typed event bus to emit on
+ * @param opts - Audit event options
+ */
+export function emitSkillAudit(eventBus, opts) {
+    const classification = classifyAction(opts.action);
+    // Emit the generic audit:event
+    const auditEvent = createAuditEvent({
+        agentId: opts.agentId,
+        tenantId: opts.tenantId,
+        userId: opts.userId,
+        actionType: opts.action,
+        classification,
+        outcome: opts.outcome,
+        metadata: {
+            skillName: opts.skillName,
+            ...opts.metadata,
+        },
+        duration: opts.duration,
+    });
+    eventBus.emit("audit:event", {
+        timestamp: Date.now(),
+        agentId: auditEvent.agentId,
+        tenantId: auditEvent.tenantId,
+        actionType: auditEvent.actionType,
+        classification: auditEvent.classification,
+        outcome: auditEvent.outcome,
+        metadata: auditEvent.metadata,
+    });
+    // Emit the specific skill event
+    const now = Date.now();
+    switch (opts.action) {
+        case "skill.prompt.load":
+            eventBus.emit("skill:prompt_loaded", {
+                skillName: opts.skillName,
+                source: opts.metadata?.["source"] ?? "unknown",
+                bodyLength: opts.metadata?.["bodyLength"] ?? 0,
+                timestamp: now,
+            });
+            break;
+        case "skill.prompt.invoke":
+            eventBus.emit("skill:prompt_invoked", {
+                skillName: opts.skillName,
+                invokedBy: opts.metadata?.["invokedBy"] ?? "user",
+                args: opts.metadata?.["args"] ?? "",
+                timestamp: now,
+            });
+            break;
+        case "skill.scan":
+            eventBus.emit("skill:rejected", {
+                skillName: opts.skillName,
+                reason: "Content scan findings detected",
+                violations: opts.metadata?.["findings"]?.map(f => f.ruleId) ?? [],
+                timestamp: now,
+            });
+            break;
+        case "skill.scan.reject":
+            eventBus.emit("skill:rejected", {
+                skillName: opts.skillName,
+                reason: "Skill blocked: CRITICAL content scan findings",
+                violations: opts.metadata?.["findings"]?.map(f => f.ruleId) ?? [],
+                timestamp: now,
+            });
+            break;
+    }
+}

package/node_modules/@comis/skills/dist/bridge/credential-injector.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Credential injector: Transparent HTTP credential injection for agent tools.
+ *
+ * Intercepts outbound fetch() calls from agent tools and injects credentials
+ * (bearer tokens, custom headers, query params, basic auth) for matching URLs.
+ * Tool code never sees plaintext API keys -- the injection is transparent.
+ *
+ * Security invariants:
+ * - SSRF validation runs BEFORE credential injection (no creds to private IPs)
+ * - globalThis.fetch is always restored in finally block after tool execution
+ * - Error messages are sanitized to prevent credential leakage in stack traces
+ *
+ * @module
+ */
+import type { SecretManager, TypedEventBus, CredentialMapping } from "@comis/core";
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+/** Credential injector: creates fetch wrappers that inject credentials for matching URLs. */
+export interface CredentialInjector {
+    /** Create a fetch function that injects credentials for a specific tool. */
+    createInjectedFetch(toolName: string): typeof fetch;
+    /** Get a frozen copy of the configured credential mappings. */
+    getMappings(): readonly CredentialMapping[];
+}
+/** Dependencies for creating a credential injector. */
+export interface CredentialInjectorDeps {
+    /** Secret manager for resolving credential values by name. */
+    secretManager: SecretManager;
+    /** Credential mappings defining which URLs get which credentials. */
+    mappings: CredentialMapping[];
+    /** Optional event bus for audit event emission. */
+    eventBus?: TypedEventBus;
+    /** Optional agent ID for audit event attribution. */
+    agentId?: string;
+}
+/**
+ * Check whether a request URL matches a credential mapping URL pattern.
+ *
+ * Matching rules:
+ * 1. Parse both URLs (pattern gets "https://" prepended if no protocol)
+ * 2. Compare hostnames exactly (case-insensitive via URL normalization)
+ * 3. If pattern has a non-root pathname, check request path starts with it
+ *
+ * @param requestUrl - The full URL being fetched
+ * @param urlPattern - The pattern from the credential mapping (hostname or hostname/path)
+ * @returns true if the request URL matches the pattern
+ */
+export declare function matchesUrl(requestUrl: string, urlPattern: string): boolean;
+/**
+ * Inject a credential into an outbound HTTP request based on the mapping type.
+ *
+ * @param init - The RequestInit (headers, body, etc.)
+ * @param url - The parsed request URL
+ * @param mapping - The credential mapping defining injection strategy
+ * @param secretValue - The plaintext secret value to inject
+ * @returns Updated init and url (url may change for query_param injection)
+ */
+export declare function injectCredential(init: RequestInit, url: URL, mapping: CredentialMapping, secretValue: string): {
+    init: RequestInit;
+    url: URL;
+};
+/**
+ * Create a credential injector that wraps fetch() to transparently inject credentials.
+ *
+ * The injector captures a reference to the REAL globalThis.fetch at creation time.
+ * All HTTP calls (both matched and unmatched) go through this captured reference,
+ * not through globalThis.fetch (which will be the wrapper during tool execution).
+ *
+ * @param deps - Injector dependencies (secret manager, mappings, optional event bus)
+ * @returns A frozen CredentialInjector instance
+ */
+export declare function createCredentialInjector(deps: CredentialInjectorDeps): CredentialInjector;
+/**
+ * Wrap an AgentTool to inject credentials into its outbound HTTP requests.
+ *
+ * During tool.execute(), globalThis.fetch is replaced with an injected fetch
+ * that transparently adds credentials for matching URLs. The original fetch
+ * is always restored in the finally block, even if execute() throws.
+ *
+ * @concurrency WARNING: This function mutates globalThis.fetch for the duration
+ * of tool.execute(). If multiple tools execute concurrently in the same Node.js
+ * process, their fetch wrappers will conflict. The current architecture runs
+ * tools sequentially within a single agent execution loop, making this safe.
+ * If parallel tool execution is introduced, migrate to AsyncLocalStorage-based
+ * fetch scoping instead of globalThis mutation.
+ *
+ * @param tool - The AgentTool to wrap
+ * @param injector - The credential injector to use
+ * @returns A new AgentTool with credential injection
+ */
+export declare function wrapWithCredentialInjection(tool: AgentTool<any>, injector: CredentialInjector): AgentTool<any>;