@exulu/backend 3.1.0 → 3.3.0

package/dist/index.d.cts

@@ -4,9 +4,9 @@ import { Knex } from 'knex';
 import { RedisClientType } from 'redis';
 import * as bullmq from 'bullmq';
 import { Queue } from 'bullmq';
-import { Request, Express } from 'express';
+import { Express } from 'express';
 import { transport } from 'winston';
-import { LanguageModel, Tool, UIMessage, streamText } from 'ai';
+import { UIMessage, Tool, LanguageModel } from 'ai';
 import { z } from 'zod';
 import { Tiktoken } from 'tiktoken/lite';
 import models from 'tiktoken/model_to_encoding.json';
@@ -92,37 +92,24 @@ declare function redisClient(): Promise<{
     client: RedisClientType | null;
 }>;
 
-type ExuluProviderConfig = {
+interface TestCase {
+    id: string;
     name: string;
-    instructions: string;
-    model: {
-        create: ({ apiKey, user, role, project, agent }: {
-            apiKey?: string | undefined;
-            user?: number;
-            role?: string;
-            project?: string;
-            agent?: string;
-        }) => LanguageModel;
-    };
-    custom?: {
-        name: string;
-        description: string;
-    }[];
-    memory?: {
-        lastMessages: number;
-        vector: boolean;
-        semanticRecall: {
-            topK: number;
-            messageRange: number;
-        };
-    };
-};
+    description?: string;
+    inputs: UIMessage[];
+    expected_output: string;
+    expected_tools?: string[];
+    expected_knowledge_sources?: string[];
+    expected_agent_tools?: string[];
+    createdAt: string;
+    updatedAt: string;
+}
 
 interface ExuluAgent {
     id: string;
     modelName?: string;
     providerName?: string;
-    /** @deprecated Hydrated for read compatibility; the underlying DB column is gone. */
+    /** @deprecated Hydrated for read compatibility; the underlying DB column is gone. Use model instead */
     provider?: string;
     source: "code" | "database";
     memory?: string;
@@ -133,7 +120,6 @@ interface ExuluAgent {
     image?: string;
     /** FK to models.id — replaces legacy provider + providerapikey columns. */
     model?: string;
-    workflows?: ExuluProviderWorkflowConfig;
     firewall?: {
         enabled: boolean;
         scanners?: {
@@ -198,6 +184,61 @@ type fileTypes$1 = '.pdf' | '.docx' | '.xlsx' | '.xls' | '.csv' | '.pptx' | '.pp
 type audioTypes$1 = '.mp3' | '.wav' | '.m4a' | '.mp4' | '.mpeg';
 type videoTypes$1 = '.mp4' | '.m4a' | '.mp3' | '.mpeg' | '.wav';
 
+type ExuluQueueConfig = {
+    queue: Queue;
+    ratelimit: number;
+    timeoutInSeconds?: number;
+    concurrency: {
+        worker: number;
+        queue: number;
+    };
+    retries?: number;
+    backoff?: {
+        type: "exponential" | "linear";
+        delay: number;
+    };
+};
+
+interface ExuluEvalParams {
+    id: string;
+    name: string;
+    description: string;
+    llm: boolean;
+    execute: (params: {
+        agent: ExuluAgent;
+        messages: UIMessage[];
+        testCase: TestCase;
+        config?: Record<string, any>;
+    }) => Promise<number>;
+    config?: {
+        name: string;
+        description: string;
+    }[];
+    queue: Promise<ExuluQueueConfig>;
+}
+declare class ExuluEval {
+    id: string;
+    name: string;
+    description: string;
+    llm: boolean;
+    private execute;
+    config?: {
+        name: string;
+        description: string;
+    }[];
+    queue?: Promise<ExuluQueueConfig>;
+    constructor({ id, name, description, execute, config, queue, llm }: ExuluEvalParams);
+    run(agent: ExuluAgent, testCase: TestCase, messages: UIMessage[], config?: Record<string, any>): Promise<number>;
+}
+
+type ExuluFieldTypes = "text" | "longText" | "shortText" | "number" | "boolean" | "code" | "json" | "enum" | "markdown" | "file" | "date" | "uuid";
+
+type allFileTypes = imageTypes | fileTypes | audioTypes | videoTypes;
+type audioTypes = ".mp3" | ".wav" | ".m4a" | ".mp4" | ".mpeg";
+type videoTypes = ".mp4" | ".m4a" | ".mp3" | ".mpeg" | ".wav";
+type imageTypes = ".png" | ".jpg" | ".jpeg" | ".gif" | ".webp";
+type fileTypes = ".pdf" | ".docx" | ".doc" | ".xlsx" | ".xls" | ".csv" | ".pptx" | ".ppt" | ".txt" | ".md" | ".json" | ".srt" | ".html";
+
 interface Item {
     id?: string;
     name?: string;
@@ -220,163 +261,6 @@ interface Item {
     [key: string]: any;
 }
 
-/**
- * OAuth 2.0 configuration for an {@link ExuluTool}. When a tool is constructed
- * with an `oauth` property, Exulu wraps its `execute` so it only runs when a
- * valid access token exists for the calling (providerKey, userId) pair — where
- * providerKey defaults to the tool's id but can be shared across tools by
- * setting the "provider" field below. When no valid token exists the tool
- * short-circuits and returns an authorization URL the agent can show the user;
- * the generic /oauth/callback route completes the flow and persists the tokens.
- *
- * Only the standard authorization-code grant is supported. All values are
- * declared in code (source them from env vars or however you like) — none of
- * them are exposed as admin-configurable tool config.
- */
-interface ExuluOauthConfig {
-    authType: "oauth";
-    /**
-     * Identifier for the OAuth provider (e.g., "google", "jira", "github").
-     * Tools sharing the same provider share tokens under (provider, userId) —
-     * one consent screen per provider per user instead of per tool. When
-     * omitted, defaults to the tool's `id`, preserving per-tool behavior for
-     * tools that don't opt in.
-     */
-    provider: string;
-    /** The provider's authorization endpoint, e.g. https://app.hubspot.com/oauth/authorize */
-    authorizationUrl: string;
-    /** The provider's token endpoint, e.g. https://api.hubapi.com/oauth/v1/token */
-    tokenUrl: string;
-    clientId: string;
-    /** Never leaves the server: used only in the server-side token exchange. */
-    clientSecret: string;
-    /** Scopes to request; joined with spaces in the authorization URL. */
-    scopes: readonly string[];
-    /** PKCE (S256). Defaults to true; set false for providers that reject PKCE. */
-    pkce?: boolean;
-    /**
-     * Extra query params appended to the authorization URL, e.g.
-     * `{ access_type: "offline", prompt: "consent" }` to make Google return a
-     * refresh token.
-     */
-    extraAuthParams?: Record<string, string>;
-}
-interface CredentialField {
-    name: string;
-    label: string;
-    type: "text" | "password";
-    placeholder?: string;
-    help?: string;
-}
-interface ExuluUserCredentialsConfig {
-    authType: "user_credentials";
-    provider: string;
-    fields: CredentialField[];
-    validate?: (values: Record<string, string>) => Promise<void>;
-}
-type ExuluAuthConfig = ExuluOauthConfig | ExuluUserCredentialsConfig;
-interface ExuluCredentialsToolContext {
-    userId: string;
-    provider: string;
-    credentials: Record<string, string>;
-}
-/** The oauth context injected into an oauth-enabled tool's execute inputs. */
-type ExuluOauthToolContext = {
-    accessToken: string;
-    /** null when the provider did not report an expiry. */
-    expiresAt: Date | null;
-    /** Space-joined scopes the token was granted, when reported by the provider. */
-    scopes: string | null;
-};
-
-declare const PUBLIC_TOOL_TYPES: readonly ["function", "web_search", "skill", "context"];
-type PublicToolType = (typeof PUBLIC_TOOL_TYPES)[number];
-type ToolType = PublicToolType | "agent" | "context";
-declare class ExuluTool {
-    id: string;
-    name: string;
-    description: string;
-    category: string;
-    inputSchema?: z.ZodType;
-    type: ToolType;
-    tool: Tool;
-    needsApproval: boolean;
-    authentication?: ExuluAuthConfig;
-    config: {
-        name: string;
-        description: string;
-        type: "boolean" | "string" | "number" | "variable" | "json";
-        default?: string | boolean | number | object;
-    }[];
-    constructor({ id, name, description, category, inputSchema, type, execute, config, needsApproval, authentication, }: {
-        id: string;
-        name: string;
-        description: string;
-        category?: string;
-        inputSchema?: z.ZodType;
-        type: PublicToolType;
-        config: {
-            name: string;
-            description: string;
-            type: "boolean" | "string" | "number" | "variable" | "json";
-            default?: string | boolean | number | object;
-        }[];
-        needsApproval?: boolean;
-        authentication?: ExuluAuthConfig;
-        execute: (inputs: any, options?: any) => Promise<{
-            result?: string;
-            job?: string;
-            items?: Item[];
-        }> | AsyncGenerator<{
-            result?: string;
-            job?: string;
-            items?: Item[];
-        }>;
-    });
-    /**
-     * Framework-only factory for tools whose `type` is managed by Exulu itself —
-     * "agent" (agent-as-tool instrumentation) and "context" (internal retrieval
-     * tools). NOT part of the public API: package consumers must use
-     * `new ExuluTool(...)`, which only accepts a {@link PublicToolType}. Building
-     * the tool as a "function" and then setting the managed type bypasses the
-     * constructor guard without weakening it for consumers.
-     */
-    static internal(params: Omit<ConstructorParameters<typeof ExuluTool>[0], "type"> & {
-        type: ToolType;
-    }): ExuluTool;
-    execute: ({ agent: agentId, config, user, inputs, project, items, }: {
-        agent: string;
-        config: ExuluConfig;
-        user?: User;
-        inputs: any;
-        project?: string;
-        items?: string[];
-    }) => Promise<any>;
-}
-
-type ExuluFieldTypes = "text" | "longText" | "shortText" | "number" | "boolean" | "code" | "json" | "enum" | "markdown" | "file" | "date" | "uuid";
-
-type allFileTypes = imageTypes | fileTypes | audioTypes | videoTypes;
-type audioTypes = ".mp3" | ".wav" | ".m4a" | ".mp4" | ".mpeg";
-type videoTypes = ".mp4" | ".m4a" | ".mp3" | ".mpeg" | ".wav";
-type imageTypes = ".png" | ".jpg" | ".jpeg" | ".gif" | ".webp";
-type fileTypes = ".pdf" | ".docx" | ".doc" | ".xlsx" | ".xls" | ".csv" | ".pptx" | ".ppt" | ".txt" | ".md" | ".json" | ".srt" | ".html";
-
-type ExuluQueueConfig = {
-    queue: Queue;
-    ratelimit: number;
-    timeoutInSeconds?: number;
-    concurrency: {
-        worker: number;
-        queue: number;
-    };
-    retries?: number;
-    backoff?: {
-        type: "exponential" | "linear";
-        delay: number;
-    };
-};
-
 declare class ExuluStorage {
     private config;
     constructor({ config }: {
@@ -935,190 +819,261 @@ declare class ExuluContext {
     createChunksTable: () => Promise<void>;
 }
 
-type ExuluAgentToolConfig = {
-    id: string;
-    type: string;
-    config: {
-        name: string;
-        variable: string | boolean | number | object;
-        type: "boolean" | "string" | "number" | "variable" | "json";
-        value?: any;
-        default?: string | boolean | number | object;
-    }[];
-};
-
-type ExuluSkill = {
-    id: string;
-    name: string;
-    description: string;
-    s3folder: string;
-    tags: string[];
-    usage_count: number;
-    favorite_count: number;
-    current_version: number;
-};
-
-type ExuluProviderWorkflowConfig = {
-    enabled: boolean;
-    queue?: Promise<ExuluQueueConfig>;
-};
-interface ExuluProviderParams {
-    id: string;
-    name: string;
-    type: "agent";
-    description: string;
-    config?: ExuluProviderConfig | undefined;
-    queue?: ExuluQueueConfig;
-    maxContextLength?: number;
-    authenticationInformation?: string;
+/**
+ * OAuth 2.0 configuration for an {@link ExuluTool}. When a tool is constructed
+ * with an `oauth` property, Exulu wraps its `execute` so it only runs when a
+ * valid access token exists for the calling (providerKey, userId) pair — where
+ * providerKey defaults to the tool's id but can be shared across tools by
+ * setting the "provider" field below. When no valid token exists the tool
+ * short-circuits and returns an authorization URL the agent can show the user;
+ * the generic /oauth/callback route completes the flow and persists the tokens.
+ *
+ * Only the standard authorization-code grant is supported. All values are
+ * declared in code (source them from env vars or however you like) — none of
+ * them are exposed as admin-configurable tool config.
+ */
+interface ExuluOauthConfig {
+    authType: "oauth";
+    /**
+     * Identifier for the OAuth provider (e.g., "google", "jira", "github").
+     * Tools sharing the same provider share tokens under (provider, userId) —
+     * one consent screen per provider per user instead of per tool. When
+     * omitted, defaults to the tool's `id`, preserving per-tool behavior for
+     * tools that don't opt in.
+     */
     provider: string;
-    workflows?: ExuluProviderWorkflowConfig;
-    capabilities?: {
-        text: boolean;
-        images: imageTypes$1[];
-        files: fileTypes$1[];
-        audio: audioTypes$1[];
-        video: videoTypes$1[];
-    };
+    /** The provider's authorization endpoint, e.g. https://app.hubspot.com/oauth/authorize */
+    authorizationUrl: string;
+    /** The provider's token endpoint, e.g. https://api.hubapi.com/oauth/v1/token */
+    tokenUrl: string;
+    clientId: string;
+    /** Never leaves the server: used only in the server-side token exchange. */
+    clientSecret: string;
+    /** Scopes to request; joined with spaces in the authorization URL. */
+    scopes: readonly string[];
+    /** PKCE (S256). Defaults to true; set false for providers that reject PKCE. */
+    pkce?: boolean;
+    /**
+     * Extra query params appended to the authorization URL, e.g.
+     * `{ access_type: "offline", prompt: "consent" }` to make Google return a
+     * refresh token.
+     */
+    extraAuthParams?: Record<string, string>;
 }
-declare class ExuluProvider {
-    id: string;
+interface CredentialField {
     name: string;
+    label: string;
+    type: "text" | "password";
+    placeholder?: string;
+    help?: string;
+}
+interface ExuluUserCredentialsConfig {
+    authType: "user_credentials";
     provider: string;
-    description: string;
-    slug: string;
-    type: "agent";
-    streaming: boolean;
-    authenticationInformation?: string;
-    maxContextLength?: number;
-    workflows?: ExuluProviderWorkflowConfig;
-    queue?: ExuluQueueConfig;
-    config?: ExuluProviderConfig | undefined;
-    model?: {
-        create: ({ apiKey, user, role, project, agent }: {
-            apiKey?: string | undefined;
-            user?: number;
-            role?: string;
-            project?: string;
-            agent?: string;
-        }) => LanguageModel;
-    };
-    capabilities: {
-        text: boolean;
-        images: string[];
-        files: string[];
-        audio: string[];
-        video: string[];
-    };
-    constructor({ id, name, description, config, capabilities, type, maxContextLength, provider, queue, authenticationInformation, workflows, }: ExuluProviderParams);
-    get providerName(): string;
-    get modelName(): string;
-    tool: (instance: string, providers: ExuluProvider[], contexts: ExuluContext[]) => Promise<ExuluTool | null>;
-    generateSync: ({ prompt, req, user, session, inputMessages, approvedTools, currentTools, currentSkills, allExuluTools, statistics, toolConfigs, providerapikey, languageModel, contexts, exuluConfig, agent, instructions, maxStepCount, onTokenUsage, contextWindow, disabledTools, }: {
-        prompt?: string;
-        user?: User;
-        maxStepCount?: number;
-        req?: Request;
-        session?: string;
-        agent?: ExuluAgent;
-        approvedTools?: string[];
-        inputMessages?: UIMessage[];
-        currentTools?: ExuluTool[];
-        currentSkills?: ExuluSkill[];
-        allExuluTools?: ExuluTool[];
-        statistics?: ExuluStatisticParams;
-        toolConfigs?: ExuluAgentToolConfig[];
-        providerapikey?: string | undefined;
-        languageModel: LanguageModel;
-        contexts?: ExuluContext[] | undefined;
-        exuluConfig?: ExuluConfig;
-        instructions?: string;
-        onTokenUsage?: (usage: {
-            inputTokens: number;
-            outputTokens: number;
-        }) => Promise<void> | void;
-        contextWindow?: number;
-        disabledTools?: string[];
-    }) => Promise<any>;
-    /**
-     * Convert file parts in messages to OpenAI Responses API compatible format.
-     * The OpenAI Responses API doesn't support inline file parts with type 'file'.
-     * This function converts:
-     * - Document files (PDF, DOCX, etc.) -> text parts with extracted content using officeparser
-     * - Image files -> image parts (which ARE supported by Responses API)
-     */
-    private processFilePartsInMessages;
-    generateStream: ({ user, session, agent, message, previousMessages, currentTools, currentSkills, approvedTools, allExuluTools, toolConfigs, providerapikey, languageModel, contexts, exuluConfig, instructions, req, maxStepCount, contextWindow, disabledTools, }: {
-        user?: User;
-        session?: string;
-        agent?: ExuluAgent;
-        maxStepCount?: number;
-        message?: UIMessage;
-        previousMessages?: UIMessage[];
-        currentTools?: ExuluTool[];
-        currentSkills?: ExuluSkill[];
-        approvedTools?: string[];
-        allExuluTools?: ExuluTool[];
-        toolConfigs?: ExuluAgentToolConfig[];
-        providerapikey?: string | undefined;
-        languageModel: LanguageModel;
-        contexts?: ExuluContext[] | undefined;
-        exuluConfig?: ExuluConfig;
-        instructions?: string;
-        req?: Request;
-        contextWindow?: number;
-        disabledTools?: string[];
-    }) => Promise<{
-        stream: ReturnType<typeof streamText>;
-        originalMessages: UIMessage[];
-        previousMessages: UIMessage[];
-    }>;
+    fields: CredentialField[];
+    validate?: (values: Record<string, string>) => Promise<void>;
 }
-
-interface TestCase {
-    id: string;
-    name: string;
-    description?: string;
-    inputs: UIMessage[];
-    expected_output: string;
-    expected_tools?: string[];
-    expected_knowledge_sources?: string[];
-    expected_agent_tools?: string[];
-    createdAt: string;
-    updatedAt: string;
+type ExuluAuthConfig = ExuluOauthConfig | ExuluUserCredentialsConfig;
+interface ExuluCredentialsToolContext {
+    userId: string;
+    provider: string;
+    credentials: Record<string, string>;
 }
+/** The oauth context injected into an oauth-enabled tool's execute inputs. */
+type ExuluOauthToolContext = {
+    accessToken: string;
+    /** null when the provider did not report an expiry. */
+    expiresAt: Date | null;
+    /** Space-joined scopes the token was granted, when reported by the provider. */
+    scopes: string | null;
+};
 
-interface ExuluEvalParams {
+declare const PUBLIC_TOOL_TYPES: readonly ["function", "web_search", "skill", "context"];
+type PublicToolType = (typeof PUBLIC_TOOL_TYPES)[number];
+type ToolType = PublicToolType | "agent" | "context";
+declare class ExuluTool {
     id: string;
     name: string;
     description: string;
-    llm: boolean;
-    execute: (params: {
-        agent: ExuluAgent;
-        provider: ExuluProvider;
-        messages: UIMessage[];
-        testCase: TestCase;
-        config?: Record<string, any>;
-    }) => Promise<number>;
-    config?: {
+    category: string;
+    inputSchema?: z.ZodType;
+    type: ToolType;
+    tool: Tool;
+    needsApproval: boolean;
+    authentication?: ExuluAuthConfig;
+    config: {
         name: string;
         description: string;
+        type: "boolean" | "string" | "number" | "variable" | "json";
+        default?: string | boolean | number | object;
     }[];
-    queue: Promise<ExuluQueueConfig>;
-}
-declare class ExuluEval {
-    id: string;
-    name: string;
-    description: string;
-    llm: boolean;
-    private execute;
-    config?: {
+    constructor({ id, name, description, category, inputSchema, type, execute, config, needsApproval, authentication, }: {
+        id: string;
         name: string;
         description: string;
-    }[];
-    queue?: Promise<ExuluQueueConfig>;
-    constructor({ id, name, description, execute, config, queue, llm }: ExuluEvalParams);
-    run(agent: ExuluAgent, provider: ExuluProvider, testCase: TestCase, messages: UIMessage[], config?: Record<string, any>): Promise<number>;
+        category?: string;
+        inputSchema?: z.ZodType;
+        type: PublicToolType;
+        config: {
+            name: string;
+            description: string;
+            type: "boolean" | "string" | "number" | "variable" | "json";
+            default?: string | boolean | number | object;
+        }[];
+        needsApproval?: boolean;
+        authentication?: ExuluAuthConfig;
+        execute: (inputs: any, options?: any) => Promise<{
+            result?: string;
+            job?: string;
+            items?: Item[];
+        }> | AsyncGenerator<{
+            result?: string;
+            job?: string;
+            items?: Item[];
+        }>;
+    });
+    /**
+     * Framework-only factory for tools whose `type` is managed by Exulu itself —
+     * "agent" (agent-as-tool instrumentation) and "context" (internal retrieval
+     * tools). NOT part of the public API: package consumers must use
+     * `new ExuluTool(...)`, which only accepts a {@link PublicToolType}. Building
+     * the tool as a "function" and then setting the managed type bypasses the
+     * constructor guard without weakening it for consumers.
+     */
+    static internal(params: Omit<ConstructorParameters<typeof ExuluTool>[0], "type"> & {
+        type: ToolType;
+    }): ExuluTool;
+    execute: ({ agent: agentId, config, user, inputs, project, items, }: {
+        agent: string;
+        config: ExuluConfig;
+        user?: User;
+        inputs: any;
+        project?: string;
+        items?: string[];
+    }) => Promise<any>;
+}
+
+type S3Target = {
+    s3region: string;
+    s3key: string;
+    s3secret: string;
+    s3Bucket: string;
+    s3endpoint?: string;
+    s3prefix?: string;
+};
+type AuditConfig = {
+    enabled: boolean;
+    s3?: S3Target;
+    retentionDays: number;
+    manageLifecycle?: boolean;
+    spoolDir?: string;
+    flush?: {
+        maxRecords?: number;
+        maxIntervalMs?: number;
+    };
+    payload?: {
+        maxBytes?: number;
+        captureOutput?: boolean;
+        redactKeys?: string[];
+    };
+    failureMode?: "open" | "closed";
+    sources?: {
+        toolCalls?: {
+            enabled?: boolean;
+            include?: string[];
+            exclude?: string[];
+        };
+    };
+};
+
+type AuditClient = {
+    ip?: string;
+    userAgent?: string;
+    referer?: string;
+    origin?: string;
+    forwardedFor?: string;
+};
+type AuditEvent = {
+    v: 1;
+    ts: string;
+    type: string;
+    actor: {
+        kind?: "user" | "agent" | "system";
+        userId?: string;
+        email?: string;
+        roleId?: string;
+        projectId?: string;
+    };
+    context?: {
+        sessionId?: string;
+        agentId?: string;
+        agentName?: string;
+        toolCallId?: string;
+        [k: string]: unknown;
+    };
+    target?: {
+        kind?: string;
+        id?: string;
+        name?: string;
+        [k: string]: unknown;
+    };
+    credential?: {
+        provider: string;
+        authType: "oauth" | "user_credentials";
+        account?: string;
+        scopes?: string[];
+        expiresAt?: string | null;
+    };
+    status: "ok" | "error" | "denied" | "auth_required";
+    error?: {
+        name?: string;
+        message: string;
+    };
+    data?: Record<string, unknown>;
+    durationMs?: number;
+    truncated?: Record<string, boolean>;
+    client?: AuditClient;
+};
+type AuditToolCallInput = {
+    durationMs: number;
+    agent?: {
+        id?: string;
+        name?: string;
+        slug?: string;
+    };
+    tool: {
+        id: string;
+        name: string;
+        category?: string;
+        authentication?: ExuluAuthConfig;
+    };
+    builtin: boolean;
+    user?: {
+        id?: unknown;
+        email?: string;
+        role?: {
+            id?: unknown;
+        };
+    };
+    projectId?: string;
+    sessionID?: string;
+    toolCallId?: string;
+    input: unknown;
+    output: unknown;
+    status: "ok" | "error" | "auth_required";
+    error?: unknown;
+    client?: AuditClient;
+};
+
+interface AuditLogger {
+    enabled: boolean;
+    failClosed: boolean;
+    isBuiltin: (id: string) => boolean;
+    shouldAuditTool: (id: string) => boolean;
+    record: (event: AuditEvent) => void;
+    recordToolCall: (ctx: AuditToolCallInput) => Promise<void>;
+    flush: () => Promise<void>;
+    close: () => Promise<void>;
 }
 
 type ExuluConfig = {
@@ -1155,6 +1110,12 @@ type ExuluConfig = {
     privacy?: {
         systemPromptPersonalization?: boolean;
     };
+    /**
+     * Audit logging. When enabled, structured audit events (starting with one
+     * per tool call) are batched to S3 as NDJSON with configurable retention.
+     * Off by default. See docs/superpowers/specs/2026-07-28-tool-call-audit-layer-design.md.
+     */
+    audit?: AuditConfig;
     /**
      * When true, ExuluApp.create() throws if any required system binary
      * (pandoc / soffice / pdftoppm — needed by built-in skills like docx) is
@@ -1165,7 +1126,6 @@ type ExuluConfig = {
     requireSystemDependencies?: boolean;
 };
 declare class ExuluApp {
-    private _providers;
     private _agents;
     private _config?;
     private _evals;
@@ -1173,14 +1133,15 @@ declare class ExuluApp {
     private _contexts?;
     private _tools;
     private _expressApp;
+    private _audit?;
     constructor();
-    create: ({ contexts, providers, config, agents, tools, evals, }: {
+    create: ({ contexts, config, agents, tools, evals, queues }: {
         contexts?: Record<string, ExuluContext>;
         config: ExuluConfig;
         agents?: ExuluAgent[];
-        providers?: ExuluProvider[];
         evals?: ExuluEval[];
         tools?: ExuluTool[];
+        queues?: Promise<ExuluQueueConfig>[];
     }) => Promise<ExuluApp>;
     express: {
         init: () => Promise<Express>;
@@ -1194,6 +1155,7 @@ declare class ExuluApp {
             database: boolean;
         };
     }): Promise<ExuluAgent | undefined>;
+    queues(): ExuluQueueConfig[];
     agents(include?: {
         source: {
             code: boolean;
@@ -1201,9 +1163,8 @@ declare class ExuluApp {
         };
     }): Promise<ExuluAgent[]>;
     context(id: string): ExuluContext | undefined;
-    provider(id: string): ExuluProvider | undefined;
     get contexts(): ExuluContext[];
-    get providers(): ExuluProvider[];
+    get audit(): AuditLogger;
     embeddings: {
         generate: {
             one: ({ context: contextId, item: itemId }: {
@@ -2577,35 +2538,6 @@ declare const ExuluDefaultTools: {
         };
     };
 };
-declare const ExuluDefaultProviders: {
-    anthropic: {
-        opus4: ExuluProvider;
-        sonnet4: ExuluProvider;
-        sonnet45: ExuluProvider;
-    };
-    cerebras: {
-        gptOss120b: ExuluProvider;
-        llama38b: ExuluProvider;
-        llama3370b: ExuluProvider;
-    };
-    google: {
-        vertexGemini25Flash: ExuluProvider;
-        vertexGemini25Pro: ExuluProvider;
-        vertexGemini3Pro: ExuluProvider;
-        vertexLlamaScout4: ExuluProvider;
-    };
-    openai: {
-        gpt5Mini: ExuluProvider;
-        gpt5: ExuluProvider;
-        gpt5pro: ExuluProvider;
-        gpt5Codex: ExuluProvider;
-        gpt5Nano: ExuluProvider;
-        gpt41: ExuluProvider;
-        gpt41Mini: ExuluProvider;
-        gpt4o: ExuluProvider;
-        gpt4oMini: ExuluProvider;
-    };
-};
 declare const ExuluVariables: {
     get: (name: string) => Promise<string>;
 };
@@ -2668,4 +2600,4 @@ declare const ExuluPython: {
     instructions: typeof getPythonSetupInstructions;
 };
 
-export { type ChunkerOperation, type ChunkerResponse, type CredentialField, CredentialInvalidError, type JOB_STATUS as EXULU_JOB_STATUS, JOB_STATUS_ENUM as EXULU_JOB_STATUS_ENUM, type STATISTICS_TYPE as EXULU_STATISTICS_TYPE, STATISTICS_TYPE_ENUM as EXULU_STATISTICS_TYPE_ENUM, type ExuluAgent, ExuluApp, type ExuluAuthConfig, ExuluAuthentication, ExuluChunkers, ExuluContext, type ExuluContextEmbedder, type ExuluCredentialsToolContext, ExuluDatabase, ExuluDefaultProviders, ExuluDefaultTools, ExuluDocumentProcessor, ExuluEval, type Item as ExuluItem, ExuluJobs, type ExuluOauthConfig, type ExuluOauthToolContext, ExuluOtel, ExuluProvider, ExuluPython, queues as ExuluQueues, ExuluReadApi, ExuluReranker, ExuluTool, type ExuluUserCredentialsConfig, ExuluVariables, type VectorSearchChunkResult, defaultChunker, enableLiteLLMClientMode, postgresClient };
+export { type AuditConfig, type AuditEvent, type AuditLogger, type ChunkerOperation, type ChunkerResponse, type CredentialField, CredentialInvalidError, type JOB_STATUS as EXULU_JOB_STATUS, JOB_STATUS_ENUM as EXULU_JOB_STATUS_ENUM, type STATISTICS_TYPE as EXULU_STATISTICS_TYPE, STATISTICS_TYPE_ENUM as EXULU_STATISTICS_TYPE_ENUM, type ExuluAgent, ExuluApp, type ExuluAuthConfig, ExuluAuthentication, ExuluChunkers, ExuluContext, type ExuluContextEmbedder, type ExuluCredentialsToolContext, ExuluDatabase, ExuluDefaultTools, ExuluDocumentProcessor, ExuluEval, type Item as ExuluItem, ExuluJobs, type ExuluOauthConfig, type ExuluOauthToolContext, ExuluOtel, ExuluPython, queues as ExuluQueues, ExuluReadApi, ExuluReranker, ExuluTool, type ExuluUserCredentialsConfig, ExuluVariables, type VectorSearchChunkResult, defaultChunker, enableLiteLLMClientMode, postgresClient };