avantgate 1.1.1 → 1.2.0

package/dist/agent/index.d.ts

@@ -1,704 +1,18 @@
-import { z } from 'zod';
-
 /**
- * Lifecycle status for durable agent workflow steps.
- */
-type StepStatus = "PENDING" | "RUNNING" | "COMPLETED" | "FAILED" | "WAITING_APPROVAL";
-/**
- * Token usage metrics for LLM calls and tool executions.
- */
-interface TokenUsage {
-    promptTokens?: number;
-    completionTokens?: number;
-    totalTokens?: number;
-}
-/**
- * Record representing a durable step stored in persistence.
- */
-interface StepRecord<TResult = unknown> {
-    workflowId: string;
-    stepId: string;
-    runId?: string;
-    status: StepStatus;
-    result?: TResult;
-    error?: string;
-    piiDetectedCount?: number;
-    tokens?: TokenUsage;
-    costUsd?: number;
-    metadata?: Record<string, unknown>;
-    createdAt: string;
-    updatedAt: string;
-}
-/**
- * Record representing a durable tool execution stored in persistence for hierarchical tracing.
- */
-interface ToolExecutionRecord {
-    executionId: string;
-    workflowId?: string;
-    stepId?: string;
-    runId?: string;
-    toolId: string;
-    parentToolId?: string;
-    aliasUsed?: string;
-    depth: number;
-    inputArgs?: unknown;
-    outputSummary?: unknown;
-    durationMs: number;
-    status: "SUCCESS" | "FAILED";
-    error?: string;
-    cached?: boolean;
-    piiFilteredCount?: number;
-    tokens?: TokenUsage;
-    costUsd?: number;
-    createdAt: string;
-}
-/**
- * Shared Blackboard state interface enabling inter-tool data exchange without context pollution.
- */
-interface ToolSharedState {
-    get<T = unknown>(key: string): Promise<T | null>;
-    set<T = unknown>(key: string, value: T, ttlSeconds?: number): Promise<void>;
-    delete(key: string): Promise<void>;
-    clear?(): Promise<void>;
-}
-/**
- * Hexagonal Port Interface: Pure abstract storage contract.
- * Any storage backend (Prisma, Drizzle, Kysely, SQLite, Mongo, Redis, Supabase)
- * can plug into avantgate/agent by implementing this contract.
- */
-interface StepStorageAdapter {
-    getStep<T = unknown>(workflowId: string, stepId: string): Promise<StepRecord<T> | null>;
-    saveStep<T = unknown>(step: StepRecord<T>): Promise<void>;
-    updateStepStatus<T = unknown>(workflowId: string, stepId: string, status: StepStatus, patch?: Partial<StepRecord<T>>): Promise<void>;
-    listSteps(workflowId: string): Promise<StepRecord[]>;
-    saveToolExecution?(record: ToolExecutionRecord): Promise<void>;
-    listToolExecutions?(workflowId?: string, stepId?: string): Promise<ToolExecutionRecord[]>;
-    getCachedToolResult?<T = unknown>(cacheKey: string): Promise<T | null>;
-    setCachedToolResult?<T = unknown>(cacheKey: string, result: T, ttlSeconds: number): Promise<void>;
-    getStateValue?<T = unknown>(key: string): Promise<T | null>;
-    setStateValue?<T = unknown>(key: string, value: T, ttlSeconds?: number): Promise<void>;
-    deleteStateValue?(key: string): Promise<void>;
-    clearStateValues?(): Promise<void>;
-}
-/**
- * Options for step approval in Human-in-the-Loop workflows.
- */
-interface StepApprovalOptions<T = unknown> {
-    prompt?: string;
-    metadata?: Record<string, unknown>;
-    defaultResult?: T;
-}
-/**
- * Execution context passed to workflow handlers.
- */
-interface StepRunnerContext {
-    workflowId: string;
-    run<T>(stepId: string, executeFn: () => Promise<T>): Promise<T>;
-    waitForApproval<T = unknown>(stepId: string, options?: StepApprovalOptions<T>): Promise<T>;
-}
-/**
- * Configuration options for creating a durable step runner.
- */
-interface StepRunnerConfig {
-    workflowId: string;
-    runId?: string;
-    storage?: StepStorageAdapter;
-}
-/**
- * Context received by tool execution, supporting inter-tool chaining and shared state.
- */
-interface ToolExecutionContext {
-    toolCallId?: string;
-    messages?: unknown[];
-    abortSignal?: AbortSignal;
-    workflowId?: string;
-    runId?: string;
-    stepId?: string;
-    callChain?: readonly string[];
-    callTool?: <TResult = unknown>(toolId: string, args: unknown) => Promise<TResult>;
-    state?: ToolSharedState;
-    storage?: StepStorageAdapter;
-    tokens?: TokenUsage;
-    costUsd?: number;
-    [key: string]: unknown;
-}
-/**
- * User and environment context injected into tools.
- */
-interface ToolContext {
-    userId?: string;
-    tenantId?: string;
-    role?: string;
-    phase?: string;
-    metadata?: Record<string, unknown>;
-    [key: string]: unknown;
-}
-/**
- * Transformer converting raw tool result into a safe, minimal LLM message.
- */
-type LLMSummaryTransformer<TArgs = unknown, TResult = unknown> = (result: TResult, args: TArgs) => unknown;
-/**
- * Out-of-band callback streaming raw or rich tool data directly to the client UI.
- */
-type ClientDataCallback<TResult = unknown> = (data: TResult) => void | Promise<void>;
-/**
- * Configuration for creating an isolated tool with PII protection, Dual-Channel,
- * stable ID, aliasing and caching.
- */
-interface IsolatedToolConfig<TArgs = any, TResult = any> {
-    id?: string;
-    name: string;
-    alias?: string;
-    description: string;
-    parameters: z.ZodType<TArgs> | unknown;
-    cacheTTL?: number;
-    execute: (args: TArgs, context?: ToolExecutionContext) => Promise<TResult>;
-    toLLMSummary?: LLMSummaryTransformer<TArgs, TResult>;
-    toClientData?: ClientDataCallback<TResult>;
-    sanitizePii?: boolean;
-    throwOnPii?: boolean;
-}
-/**
- * Standard tool contract compatible with Vercel AI SDK (ai) tool definition.
- */
-interface VercelAiCoreTool<TArgs = any, TResult = any> {
-    description: string;
-    parameters: any;
-    execute: (args: TArgs, context?: ToolExecutionContext) => Promise<TResult>;
-    /**
-     * Internal identifiers and metadata.
-     */
-    readonly _toolId: string;
-    readonly _toolName: string;
-    readonly _toolAlias?: string;
-    readonly _isIsolated: boolean;
-    readonly _cacheTTL?: number;
-    _lastPiiFilteredCount?: number;
-}
-/**
- * Metadata and descriptor for registered tools in the registry.
- */
-interface RegisteredTool<TArgs = any, TResult = any> {
-    id: string;
-    name: string;
-    alias?: string;
-    description: string;
-    phases?: string[];
-    requiredRoles?: string[];
-    tags?: string[];
-    tool: VercelAiCoreTool<TArgs, TResult>;
-}
-/**
- * Strategy interface for dynamically selecting a subset of tools for LLM prompts.
- */
-interface ToolSelectionStrategy {
-    selectTools(tools: RegisteredTool[], context: ToolContext): RegisteredTool[] | Promise<RegisteredTool[]>;
-}
-
-/**
- * Domain and operational errors for avantgate/agent.
- */
-declare class StepSuspendedError extends Error {
-    readonly stepId: string;
-    readonly workflowId: string;
-    readonly metadata?: Record<string, unknown>;
-    constructor(stepId: string, workflowId: string, metadata?: Record<string, unknown>);
-}
-declare class PiiLeakError extends Error {
-    readonly toolName: string;
-    readonly maskedCount: number;
-    constructor(toolName: string, maskedCount: number);
-}
-declare class StepExecutionError extends Error {
-    readonly stepId: string;
-    readonly workflowId: string;
-    readonly originalError?: unknown;
-    constructor(stepId: string, workflowId: string, message: string, originalError?: unknown);
-}
-declare class ToolAccessDeniedError extends Error {
-    readonly toolName: string;
-    readonly requiredRole?: string;
-    constructor(toolName: string, requiredRole?: string);
-}
-declare class CircularToolCallError extends Error {
-    readonly cycle: string[];
-    constructor(cycle: string[]);
-}
-declare class ToolCallDepthExceededError extends Error {
-    readonly depth: number;
-    readonly maxDepth: number;
-    constructor(depth: number, maxDepth: number);
-}
-declare class ToolSubCallQuotaError extends Error {
-    readonly totalCalls: number;
-    readonly maxCalls: number;
-    constructor(totalCalls: number, maxCalls: number);
-}
-declare class ToolNotFoundError extends Error {
-    readonly toolId: string;
-    constructor(toolId: string);
-}
-
-interface AuditToolResultOutput {
-    sanitizedData: unknown;
-    maskedCount: number;
-}
-interface AuditToolResultOptions {
-    toolName: string;
-    throwOnPii?: boolean;
-}
-/**
- * Audits and sanitizes data returned by tools before sending it to the LLM.
- * Throws PiiLeakError if throwOnPii is enabled and PII is detected.
- */
-declare function auditToolResult(data: unknown, options: AuditToolResultOptions): AuditToolResultOutput;
-
-/**
- * Creates an isolated tool compatible with Vercel AI SDK (ai) tool contract.
- * Features dual-channel separation (client data vs minimal LLM summary),
- * stable ID, aliasing, caching and automatic in-flight PII redaction.
- */
-declare function createIsolatedTool<TArgs = any, TResult = any>(config: IsolatedToolConfig<TArgs, TResult>): VercelAiCoreTool<TArgs, TResult>;
-
-/**
- * Factory for creating isolated tools with injected context and dependencies.
- */
-declare class AgentToolFactory {
-    private readonly context;
-    constructor(defaultContext?: ToolContext);
-    /**
-     * Returns a new factory instance with merged context.
-     */
-    withContext(extraContext: ToolContext): AgentToolFactory;
-    /**
-     * Returns current factory context.
-     */
-    getContext(): ToolContext;
-    /**
-     * Instantiates an isolated tool by injecting factory context into the builder function.
-     */
-    createTool<TArgs = any, TResult = any>(builder: (context: ToolContext) => IsolatedToolConfig<TArgs, TResult>): VercelAiCoreTool<TArgs, TResult>;
-}
-
-interface ToRecordOptions {
-    anonymize?: boolean;
-}
-/**
- * Centralized catalog for managing and filtering tools with permissions and metadata.
- * Supports O(1) Key-Value lookup by technical ID and by public alias.
- */
-declare class ToolRegistry {
-    private readonly toolsById;
-    private readonly toolsByPublicName;
-    /**
-     * Registers a new tool in the registry.
-     */
-    register(toolDef: RegisteredTool): this;
-    /**
-     * Retrieves a tool by its ID or public name/alias.
-     */
-    get(idOrName: string): RegisteredTool | undefined;
-    /**
-     * Retrieves a tool strictly by its immutable technical ID (O(1)).
-     */
-    getById(id: string): RegisteredTool | undefined;
-    /**
-     * Retrieves a tool by its public alias seen by the LLM (O(1)).
-     */
-    getByPublicName(publicName: string): RegisteredTool | undefined;
-    /**
-     * Checks if a tool is registered by ID or public name.
-     */
-    has(idOrName: string): boolean;
-    /**
-     * Returns all registered tools without duplicates.
-     */
-    getAll(): RegisteredTool[];
-    /**
-     * Filters tools matching a specific workflow phase.
-     */
-    getByPhase(phase: string): RegisteredTool[];
-    /**
-     * Filters tools matching the user's roles (RBAC).
-     */
-    filterByRoles(userRoles: string[]): RegisteredTool[];
-    /**
-     * Converts instance registered tools to the record map format required by Vercel AI SDK.
-     */
-    toRecord(options?: ToRecordOptions): Record<string, VercelAiCoreTool>;
-    /**
-     * Converts a list of registered tools to the record map format required by Vercel AI SDK.
-     * If anonymize is true, uses alias (if defined) as dictionary key instead of technical name.
-     */
-    static toRecord(tools: RegisteredTool[], options?: ToRecordOptions): Record<string, VercelAiCoreTool>;
-}
-
-/**
- * Strategy selecting tools that match the current workflow phase.
- */
-declare class PhaseBasedToolStrategy implements ToolSelectionStrategy {
-    selectTools(tools: RegisteredTool[], context: ToolContext): RegisteredTool[];
-}
-/**
- * Strategy selecting tools permitted for the user's role (RBAC).
- */
-declare class RoleBasedToolStrategy implements ToolSelectionStrategy {
-    selectTools(tools: RegisteredTool[], context: ToolContext): RegisteredTool[];
-}
-/**
- * Composite strategy applying multiple selection strategies sequentially (intersection).
- */
-declare class CompositeToolStrategy implements ToolSelectionStrategy {
-    private readonly strategies;
-    constructor(strategies: ToolSelectionStrategy[]);
-    selectTools(tools: RegisteredTool[], context: ToolContext): Promise<RegisteredTool[]>;
-}
-/**
- * Convenience helper to execute a strategy and convert selected tools to Vercel AI SDK format.
- */
-declare function applyToolStrategy(tools: RegisteredTool[], strategy: ToolSelectionStrategy, context: ToolContext): Promise<Record<string, VercelAiCoreTool>>;
-
-interface StepRunnerInstance extends StepRunnerContext {
-    storage: StepStorageAdapter;
-    approveStep<T = unknown>(stepId: string, approvalData?: T): Promise<void>;
-    rejectStep(stepId: string, reason?: string): Promise<void>;
-}
-/**
- * Creates a serverless durable step runner for stateful multi-step agent execution
- * with automatic idempotence and Human-in-the-Loop approval capability.
- */
-declare function createStepRunner(config: StepRunnerConfig): StepRunnerInstance;
-
-interface ToolInvokerOptions {
-    maxDepth?: number;
-    maxTotalSubCalls?: number;
-    workflowId?: string;
-    stepId?: string;
-}
-interface ToolInvoker {
-    invokeTool<TResult = unknown>(toolId: string, args: unknown, context?: ToolExecutionContext): Promise<TResult>;
-}
-/**
- * Creates an intelligent, concurrency-safe tool invoker with cycle detection,
- * depth guard, result caching, and database execution tracing.
- */
-declare function createToolInvoker(registry: ToolRegistry, storage?: StepStorageAdapter, options?: ToolInvokerOptions): ToolInvoker;
-
-/**
- * Creates a shared blackboard state instance for inter-tool data sharing.
- * Backed by the persistent storage adapter if available, otherwise runs in-memory.
- */
-declare function createToolSharedState(storage?: StepStorageAdapter): ToolSharedState;
-
-interface MemoryAdapterOptions {
-    ttlMs?: number;
-}
-/**
- * In-memory storage adapter for development, prototyping, and tests.
- * Zero-infrastructure and ultra-fast with complete tool trace and cache support.
- */
-declare class MemoryStorageAdapter implements StepStorageAdapter {
-    private readonly storage;
-    private readonly toolExecutions;
-    private readonly cacheStorage;
-    private readonly stateStorage;
-    private readonly ttlMs?;
-    constructor(options?: MemoryAdapterOptions);
-    private buildKey;
-    private isExpired;
-    getStep<T = unknown>(workflowId: string, stepId: string): Promise<StepRecord<T> | null>;
-    saveStep<T = unknown>(step: StepRecord<T>): Promise<void>;
-    updateStepStatus<T = unknown>(workflowId: string, stepId: string, status: StepStatus, patch?: Partial<StepRecord<T>>): Promise<void>;
-    listSteps(workflowId: string): Promise<StepRecord[]>;
-    saveToolExecution(record: ToolExecutionRecord): Promise<void>;
-    listToolExecutions(workflowId?: string, stepId?: string): Promise<ToolExecutionRecord[]>;
-    getCachedToolResult<T = unknown>(cacheKey: string): Promise<T | null>;
-    setCachedToolResult<T = unknown>(cacheKey: string, result: T, ttlSeconds: number): Promise<void>;
-    getStateValue<T = unknown>(key: string): Promise<T | null>;
-    setStateValue<T = unknown>(key: string, value: T, ttlSeconds?: number): Promise<void>;
-    deleteStateValue(key: string): Promise<void>;
-    /**
-     * Resets all internal in-memory maps (useful for test isolation).
-     */
-    clear(): void;
-}
-
-interface CustomStorageHandlers {
-    getStep: <T = unknown>(workflowId: string, stepId: string) => Promise<StepRecord<T> | null>;
-    saveStep: <T = unknown>(step: StepRecord<T>) => Promise<void>;
-    updateStepStatus: <T = unknown>(workflowId: string, stepId: string, status: StepStatus, patch?: Partial<StepRecord<T>>) => Promise<void>;
-    listSteps: (workflowId: string) => Promise<StepRecord[]>;
-    saveToolExecution?: (record: ToolExecutionRecord) => Promise<void>;
-    listToolExecutions?: (workflowId?: string, stepId?: string) => Promise<ToolExecutionRecord[]>;
-    getCachedToolResult?: <T = unknown>(cacheKey: string) => Promise<T | null>;
-    setCachedToolResult?: <T = unknown>(cacheKey: string, result: T, ttlSeconds: number) => Promise<void>;
-    getStateValue?: <T = unknown>(key: string) => Promise<T | null>;
-    setStateValue?: <T = unknown>(key: string, value: T, ttlSeconds?: number) => Promise<void>;
-    deleteStateValue?: (key: string) => Promise<void>;
-}
-interface KeyValueStoreClient {
-    get(key: string): Promise<string | null> | string | null;
-    set(key: string, value: string, ttlSeconds?: number): Promise<void | unknown> | void | unknown;
-    del?(key: string): Promise<void | unknown> | void | unknown;
-    keys?(pattern?: string): Promise<string[]> | string[];
-}
-interface KeyValueAdapterOptions {
-    prefix?: string;
-    ttlSeconds?: number;
-}
-/**
- * Universal functional builder for plugging any external storage library
- * (Drizzle, Kysely, Supabase, TypeORM, Mongo, custom REST API...)
- */
-declare function createCustomStorageAdapter(handlers: CustomStorageHandlers): StepStorageAdapter;
-/**
- * Universal Key-Value adapter enabling any KV client (Redis, Upstash, Cloudflare KV,
- * Keyv, Memcached) to be plugged in with simple get/set operations.
- */
-declare class KeyValueStorageAdapter implements StepStorageAdapter {
-    private readonly client;
-    private readonly prefix;
-    private readonly ttlSeconds?;
-    constructor(client: KeyValueStoreClient, options?: KeyValueAdapterOptions);
-    private buildKey;
-    getStep<T = unknown>(workflowId: string, stepId: string): Promise<StepRecord<T> | null>;
-    saveStep<T = unknown>(step: StepRecord<T>): Promise<void>;
-    updateStepStatus<T = unknown>(workflowId: string, stepId: string, status: StepStatus, patch?: Partial<StepRecord<T>>): Promise<void>;
-    listSteps(workflowId: string): Promise<StepRecord[]>;
-    getCachedToolResult<T = unknown>(cacheKey: string): Promise<T | null>;
-    setCachedToolResult<T = unknown>(cacheKey: string, result: T, ttlSeconds: number): Promise<void>;
-    getStateValue<T = unknown>(key: string): Promise<T | null>;
-    setStateValue<T = unknown>(key: string, value: T, ttlSeconds?: number): Promise<void>;
-    deleteStateValue(key: string): Promise<void>;
-}
-
-interface PrismaStepModelDelegate {
-    findUnique(args: {
-        where: {
-            workflowId_stepId: {
-                workflowId: string;
-                stepId: string;
-            };
-        };
-    }): Promise<any>;
-    upsert(args: {
-        where: {
-            workflowId_stepId: {
-                workflowId: string;
-                stepId: string;
-            };
-        };
-        create: any;
-        update: any;
-    }): Promise<any>;
-    findMany(args: {
-        where: {
-            workflowId: string;
-        };
-        orderBy?: any;
-    }): Promise<any[]>;
-}
-interface PrismaToolDelegates {
-    toolExecution?: any;
-    toolCache?: any;
-    sharedState?: any;
-}
-/**
- * Storage adapter integrating with Prisma ORM without imposing a direct dependency.
- */
-declare class PrismaStorageAdapter implements StepStorageAdapter {
-    private readonly model;
-    private readonly toolDelegates?;
-    private readonly volatileCache;
-    private readonly volatileState;
-    private readonly volatileExecutions;
-    constructor(model: PrismaStepModelDelegate, toolDelegates?: PrismaToolDelegates);
-    getStep<T = unknown>(workflowId: string, stepId: string): Promise<StepRecord<T> | null>;
-    saveStep<T = unknown>(step: StepRecord<T>): Promise<void>;
-    updateStepStatus<T = unknown>(workflowId: string, stepId: string, status: StepStatus, patch?: Partial<StepRecord<T>>): Promise<void>;
-    listSteps(workflowId: string): Promise<StepRecord[]>;
-    saveToolExecution(record: ToolExecutionRecord): Promise<void>;
-    listToolExecutions(workflowId?: string, stepId?: string): Promise<ToolExecutionRecord[]>;
-    getCachedToolResult<T = unknown>(cacheKey: string): Promise<T | null>;
-    setCachedToolResult<T = unknown>(cacheKey: string, result: T, ttlSeconds: number): Promise<void>;
-    getStateValue<T = unknown>(key: string): Promise<T | null>;
-    setStateValue<T = unknown>(key: string, value: T, ttlSeconds?: number): Promise<void>;
-    deleteStateValue(key: string): Promise<void>;
-}
-
-interface SQLiteStatementLike {
-    get(...params: any[]): any;
-    all(...params: any[]): any[];
-    run(...params: any[]): any;
-}
-interface SQLiteDatabaseLike {
-    exec(sql: string): void;
-    prepare(sql: string): SQLiteStatementLike;
-}
-/**
- * SQLite storage adapter for local edge execution and serverless durable workflows.
- * Automatically initializes tables for steps, tool executions, cache and blackboard state.
- */
-declare class SQLiteStorageAdapter implements StepStorageAdapter {
-    private readonly db;
-    constructor(db: SQLiteDatabaseLike);
-    private initTables;
-    getStep<T = unknown>(workflowId: string, stepId: string): Promise<StepRecord<T> | null>;
-    saveStep<T = unknown>(step: StepRecord<T>): Promise<void>;
-    updateStepStatus<T = unknown>(workflowId: string, stepId: string, status: StepStatus, patch?: Partial<StepRecord<T>>): Promise<void>;
-    listSteps(workflowId: string): Promise<StepRecord[]>;
-    saveToolExecution(record: ToolExecutionRecord): Promise<void>;
-    listToolExecutions(workflowId?: string, stepId?: string): Promise<ToolExecutionRecord[]>;
-    getCachedToolResult<T = unknown>(cacheKey: string): Promise<T | null>;
-    setCachedToolResult<T = unknown>(cacheKey: string, result: T, ttlSeconds: number): Promise<void>;
-    getStateValue<T = unknown>(key: string): Promise<T | null>;
-    setStateValue<T = unknown>(key: string, value: T, ttlSeconds?: number): Promise<void>;
-    deleteStateValue(key: string): Promise<void>;
-}
-
-/**
- * Supported telemetry event types for the avantGate observability platform.
- */
-type TelemetryEventType = "STEP_START" | "STEP_COMPLETED" | "STEP_FAILED" | "STEP_APPROVAL_REQUEST" | "TOOL_EXECUTION";
-/**
- * Base properties shared across all telemetry events.
- */
-interface BaseTelemetryEvent {
-    type: TelemetryEventType;
-    timestamp: string;
-}
-interface StepStartEvent extends BaseTelemetryEvent {
-    type: "STEP_START";
-    stepName: string;
-    metadata?: Record<string, unknown>;
-}
-interface StepCompletedEvent extends BaseTelemetryEvent {
-    type: "STEP_COMPLETED";
-    stepName: string;
-    durationMs?: number;
-    piiDetectedCount?: number;
-    resultSummary?: unknown;
-    metadata?: Record<string, unknown>;
-}
-interface StepFailedEvent extends BaseTelemetryEvent {
-    type: "STEP_FAILED";
-    stepName: string;
-    durationMs?: number;
-    error: string;
-}
-interface StepApprovalRequestEvent extends BaseTelemetryEvent {
-    type: "STEP_APPROVAL_REQUEST";
-    stepName: string;
-    actionType?: string;
-    payloadSummary?: unknown;
-}
-interface ToolExecutionTelemetryEvent extends BaseTelemetryEvent {
-    type: "TOOL_EXECUTION";
-    toolId: string;
-    toolName: string;
-    aliasUsed?: string;
-    durationMs: number;
-    success: boolean;
-    parentToolId?: string;
-    depth?: number;
-    llmSummary?: unknown;
-    piiFilteredCount?: number;
-    tokenCount?: number;
-    tokens?: {
-        promptTokens?: number;
-        completionTokens?: number;
-        totalTokens?: number;
-    };
-    costUsd?: number;
-    cached?: boolean;
-    error?: string;
-}
-type TelemetryEvent = StepStartEvent | StepCompletedEvent | StepFailedEvent | StepApprovalRequestEvent | ToolExecutionTelemetryEvent;
-/**
- * Consolidates token usage and FinOps metrics for a batch or run.
- */
-interface TelemetryUsageSummary {
-    model?: string;
-    promptTokens?: number;
-    completionTokens?: number;
-    totalTokens?: number;
-    costUsd?: number;
-}
-/**
- * Payload schema ingested by POST /api/v1/ingest/events according to DESIGN-005 §5.1.
- */
-interface TelemetryIngestPayload {
-    runId: string;
-    agentName?: string;
-    timestamp: string;
-    events: TelemetryEvent[];
-    usage?: TelemetryUsageSummary;
-}
-/**
- * Configuration options for the HTTP Telemetry Exporter.
- */
-interface HttpTelemetryExporterOptions {
-    apiKey: string;
-    endpoint?: string;
-    agentName?: string;
-    batchIntervalMs?: number;
-    maxBatchSize?: number;
-    maxQueueSize?: number;
-    fetchFn?: typeof fetch;
-    onError?: (error: Error) => void;
-}
-
-/**
- * Asynchronous, zero-dependency HTTP Telemetry Exporter for the avantGate platform.
- * Batches events in memory and sends them in background without blocking agent execution.
- */
-declare class HttpTelemetryExporter {
-    private readonly apiKey;
-    private readonly endpoint;
-    private readonly agentName?;
-    private readonly batchIntervalMs;
-    private readonly maxBatchSize;
-    private readonly maxQueueSize;
-    private readonly fetchFn;
-    private readonly onError?;
-    private queue;
-    private timer;
-    private isFlushing;
-    constructor(options: HttpTelemetryExporterOptions);
-    private startTimer;
-    enqueue(runId: string, event: TelemetryEvent, usage?: TelemetryUsageSummary): void;
-    flush(): Promise<void>;
-    shutdown(): Promise<void>;
-}
-
-interface PlatformStorageAdapterConfig {
-    exporter: HttpTelemetryExporter;
-    primaryStorage?: StepStorageAdapter;
-}
-/**
- * Hexagonal Hybrid Storage Adapter: persists steps and tool executions locally
- * while mirroring telemetry events asynchronously to avantGate Cloud.
- */
-declare class PlatformStorageAdapter implements StepStorageAdapter {
-    private readonly exporter;
-    private readonly primary;
-    constructor(config: PlatformStorageAdapterConfig);
-    getStep<T = unknown>(workflowId: string, stepId: string): Promise<StepRecord<T> | null>;
-    saveStep<T = unknown>(record: StepRecord<T>): Promise<void>;
-    updateStepStatus(workflowId: string, stepId: string, status: StepStatus, updates?: {
-        result?: unknown;
-        error?: string;
-        metadata?: Record<string, unknown>;
-    }): Promise<void>;
-    listSteps(workflowId: string): Promise<StepRecord[]>;
-    saveToolExecution(record: ToolExecutionRecord): Promise<void>;
-    listToolExecutions(workflowId?: string, stepId?: string): Promise<ToolExecutionRecord[]>;
-    getCachedToolResult<T = unknown>(cacheKey: string): Promise<T | null>;
-    setCachedToolResult<T = unknown>(cacheKey: string, result: T, ttlSeconds: number): Promise<void>;
-    getStateValue<T = unknown>(key: string): Promise<T | null>;
-    setStateValue<T = unknown>(key: string, value: T, ttlSeconds?: number): Promise<void>;
-    deleteStateValue(key: string): Promise<void>;
-    clearStateValues(): Promise<void>;
-}
-
-export { AgentToolFactory, type AuditToolResultOptions, type AuditToolResultOutput, type BaseTelemetryEvent, CircularToolCallError, type ClientDataCallback, CompositeToolStrategy, type CustomStorageHandlers, HttpTelemetryExporter, type HttpTelemetryExporterOptions, type IsolatedToolConfig, type KeyValueAdapterOptions, KeyValueStorageAdapter, type KeyValueStoreClient, type LLMSummaryTransformer, type MemoryAdapterOptions, MemoryStorageAdapter, PhaseBasedToolStrategy, PiiLeakError, PlatformStorageAdapter, type PlatformStorageAdapterConfig, type PrismaStepModelDelegate, PrismaStorageAdapter, type PrismaToolDelegates, type RegisteredTool, RoleBasedToolStrategy, type SQLiteDatabaseLike, type SQLiteStatementLike, SQLiteStorageAdapter, type StepApprovalOptions, type StepApprovalRequestEvent, type StepCompletedEvent, StepExecutionError, type StepFailedEvent, type StepRecord, type StepRunnerConfig, type StepRunnerContext, type StepRunnerInstance, type StepStartEvent, type StepStatus, type StepStorageAdapter, StepSuspendedError, type TelemetryEvent, type TelemetryEventType, type TelemetryIngestPayload, type TelemetryUsageSummary, type ToRecordOptions, type TokenUsage, ToolAccessDeniedError, ToolCallDepthExceededError, type ToolContext, type ToolExecutionContext, type ToolExecutionRecord, type ToolExecutionTelemetryEvent, type ToolInvoker, type ToolInvokerOptions, ToolNotFoundError, ToolRegistry, type ToolSelectionStrategy, type ToolSharedState, ToolSubCallQuotaError, type VercelAiCoreTool, applyToolStrategy, auditToolResult, createCustomStorageAdapter, createIsolatedTool, createStepRunner, createToolInvoker, createToolSharedState };
+ * avantgate/agent
+ * Zero-infrastructure Durable Agent Harness & Tool Data Isolation
+ */
+export * from "./types";
+export * from "./errors";
+export * from "./guardrails";
+export * from "./isolated-tool";
+export * from "./dto";
+export * from "./factory";
+export * from "./registry";
+export * from "./strategy";
+export * from "./step-runner";
+export * from "./tool-invoker";
+export * from "./tool-state";
+export * from "./adapters";
+export * from "./telemetry";
+//# sourceMappingURL=index.d.ts.map