@lov3kaizen/agentsea-core 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,1346 @@
+import { z } from 'zod';
+import { EventEmitter } from 'events';
+
+interface Message {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string;
+    name?: string;
+    toolCallId?: string;
+}
+type OutputFormat = 'text' | 'markdown' | 'html' | 'react';
+interface FormatOptions {
+    includeMetadata?: boolean;
+    sanitizeHtml?: boolean;
+    highlightCode?: boolean;
+    theme?: 'light' | 'dark' | 'auto';
+}
+interface AgentConfig {
+    name: string;
+    description: string;
+    model: string;
+    provider: string;
+    systemPrompt?: string;
+    tools?: Tool[];
+    temperature?: number;
+    maxTokens?: number;
+    maxIterations?: number;
+    memory?: MemoryConfig;
+    providerConfig?: ProviderInstanceConfig;
+    outputFormat?: OutputFormat;
+    formatOptions?: FormatOptions;
+}
+interface ProviderInstanceConfig {
+    baseUrl?: string;
+    apiKey?: string;
+    timeout?: number;
+    defaultHeaders?: Record<string, string>;
+    organization?: string;
+}
+interface AgentContext {
+    conversationId: string;
+    userId?: string;
+    sessionData: Record<string, any>;
+    history: Message[];
+    metadata?: Record<string, any>;
+}
+interface FormattedContent {
+    raw: string;
+    format: OutputFormat;
+    rendered?: string;
+    metadata?: {
+        hasCodeBlocks?: boolean;
+        hasTables?: boolean;
+        hasLists?: boolean;
+        links?: Array<{
+            text: string;
+            url: string;
+        }>;
+    };
+}
+interface AgentResponse {
+    content: string;
+    formatted?: FormattedContent;
+    toolCalls?: ToolCall[];
+    metadata: {
+        tokensUsed: number;
+        latencyMs: number;
+        iterations: number;
+        cost?: number;
+    };
+    nextAgent?: string;
+    finishReason?: 'stop' | 'length' | 'tool_calls' | 'error';
+}
+interface Tool {
+    name: string;
+    description: string;
+    parameters: z.ZodSchema;
+    execute: (params: any, context: ToolContext) => Promise<any>;
+    retryConfig?: RetryConfig;
+}
+interface ToolContext {
+    agentName: string;
+    conversationId: string;
+    metadata: Record<string, any>;
+}
+interface ToolCall {
+    id: string;
+    tool: string;
+    parameters: any;
+    result?: any;
+    error?: string;
+}
+interface RetryConfig {
+    maxAttempts: number;
+    backoff: 'linear' | 'exponential';
+    initialDelayMs?: number;
+    maxDelayMs?: number;
+    retryableErrors?: string[];
+}
+interface MemoryConfig {
+    type: 'buffer' | 'summary' | 'vector' | 'hybrid';
+    maxMessages?: number;
+    storage?: 'memory' | 'redis' | 'database';
+    ttl?: number;
+    summaryModel?: string;
+}
+interface MemoryStore {
+    save(conversationId: string, messages: Message[]): Promise<void>;
+    load(conversationId: string): Promise<Message[]>;
+    clear(conversationId: string): Promise<void>;
+    search?(query: string, limit?: number): Promise<Message[]>;
+}
+interface LLMProvider {
+    generateResponse(messages: Message[], config: ProviderConfig): Promise<LLMResponse>;
+    streamResponse?(messages: Message[], config: ProviderConfig): AsyncIterable<LLMStreamChunk>;
+    parseToolCalls(response: LLMResponse): ToolCall[];
+}
+interface ProviderConfig {
+    model: string;
+    temperature?: number;
+    maxTokens?: number;
+    tools?: Tool[];
+    systemPrompt?: string;
+    topP?: number;
+    stopSequences?: string[];
+}
+interface LLMResponse {
+    content: string;
+    stopReason: string;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+    rawResponse: any;
+}
+interface LLMStreamChunk {
+    type: 'content' | 'tool_call' | 'done';
+    content?: string;
+    toolCall?: Partial<ToolCall>;
+    done?: boolean;
+}
+type StreamEvent = {
+    type: 'iteration';
+    iteration: number;
+} | {
+    type: 'content';
+    content: string;
+    delta?: boolean;
+} | {
+    type: 'tool_calls';
+    toolCalls: ToolCall[];
+} | {
+    type: 'tool_result';
+    toolCall: ToolCall;
+} | {
+    type: 'done';
+    metadata?: {
+        tokensUsed?: number;
+        latencyMs?: number;
+        iterations?: number;
+    };
+} | {
+    type: 'error';
+    error: string;
+};
+type WorkflowType = 'sequential' | 'parallel' | 'supervisor' | 'custom';
+interface WorkflowConfig {
+    name: string;
+    type: WorkflowType;
+    agents: AgentConfig[];
+    routing?: RoutingLogic;
+    errorHandling?: ErrorHandlingStrategy;
+}
+interface RoutingLogic {
+    strategy: 'conditional' | 'round-robin' | 'dynamic';
+    rules?: RoutingRule[];
+}
+interface RoutingRule {
+    condition: (context: AgentContext, response: AgentResponse) => boolean;
+    nextAgent: string;
+}
+type ErrorHandlingStrategy = 'fail-fast' | 'retry' | 'fallback' | 'continue';
+interface AgentMetrics {
+    agentName: string;
+    latencyMs: number;
+    tokensUsed: number;
+    success: boolean;
+    error?: string;
+    timestamp: Date;
+}
+interface SpanContext {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+}
+
+declare class ToolRegistry {
+    private tools;
+    register(tool: Tool): void;
+    registerMany(tools: Tool[]): void;
+    get(name: string): Tool | undefined;
+    getAll(): Tool[];
+    has(name: string): boolean;
+    unregister(name: string): boolean;
+    clear(): void;
+    execute(toolCall: ToolCall, context: ToolContext): Promise<any>;
+    private executeWithRetry;
+    private calculateDelay;
+    private sleep;
+}
+
+declare class Agent {
+    readonly config: AgentConfig;
+    private readonly provider;
+    private readonly toolRegistry;
+    private readonly memory?;
+    private iterationCount;
+    constructor(config: AgentConfig, provider: LLMProvider, toolRegistry: ToolRegistry, memory?: MemoryStore | undefined);
+    execute(input: string, context: AgentContext): Promise<AgentResponse>;
+    executeStream(input: string, context: AgentContext): AsyncGenerator<StreamEvent, void, unknown>;
+    private executeLoop;
+    private executeLoopStream;
+    private executeToolCalls;
+    private loadHistory;
+    private saveHistory;
+    formatResponse(response: AgentResponse): AgentResponse;
+}
+
+declare const calculatorTool: Tool;
+
+declare const httpRequestTool: Tool;
+
+declare const fileReadTool: Tool;
+declare const fileWriteTool: Tool;
+declare const fileListTool: Tool;
+
+declare const textSummaryTool: Tool;
+declare const stringTransformTool: Tool;
+
+declare const figmaGetFileTool: Tool;
+declare const figmaGetNodesTool: Tool;
+declare const figmaGetImagesTool: Tool;
+declare const figmaGetCommentsTool: Tool;
+declare const figmaPostCommentTool: Tool;
+
+declare const n8nExecuteWorkflowTool: Tool;
+declare const n8nGetExecutionTool: Tool;
+declare const n8nListWorkflowsTool: Tool;
+declare const n8nTriggerWebhookTool: Tool;
+declare const n8nGetWorkflowTool: Tool;
+
+declare class AnthropicProvider implements LLMProvider {
+    private client;
+    constructor(apiKey?: string);
+    generateResponse(messages: Message[], config: ProviderConfig): Promise<LLMResponse>;
+    streamResponse(messages: Message[], config: ProviderConfig): AsyncIterable<LLMStreamChunk>;
+    parseToolCalls(response: LLMResponse): ToolCall[];
+    private convertMessages;
+}
+
+declare class OpenAIProvider implements LLMProvider {
+    private client;
+    constructor(apiKey?: string);
+    generateResponse(messages: Message[], config: ProviderConfig): Promise<LLMResponse>;
+    streamResponse(messages: Message[], config: ProviderConfig): AsyncIterable<LLMStreamChunk>;
+    parseToolCalls(response: LLMResponse): ToolCall[];
+    private convertMessages;
+}
+
+declare class GeminiProvider implements LLMProvider {
+    private client;
+    private model;
+    constructor(apiKey?: string);
+    generateResponse(messages: Message[], config: ProviderConfig): Promise<LLMResponse>;
+    streamResponse(messages: Message[], config: ProviderConfig): AsyncIterable<LLMStreamChunk>;
+    parseToolCalls(response: LLMResponse): ToolCall[];
+    private getModel;
+    private convertMessages;
+    private estimateTokens;
+}
+
+interface OllamaConfig {
+    baseUrl?: string;
+    timeout?: number;
+}
+declare class OllamaProvider implements LLMProvider {
+    private baseUrl;
+    private timeout;
+    constructor(config?: OllamaConfig);
+    generateResponse(messages: Message[], config: ProviderConfig): Promise<LLMResponse>;
+    streamResponse(messages: Message[], config: ProviderConfig): AsyncIterable<LLMStreamChunk>;
+    parseToolCalls(response: LLMResponse): ToolCall[];
+    private convertMessages;
+    private makeRequest;
+    listModels(): Promise<string[]>;
+    pullModel(modelName: string): Promise<void>;
+}
+
+interface OpenAICompatibleConfig {
+    baseUrl: string;
+    apiKey?: string;
+    defaultHeaders?: Record<string, string>;
+    timeout?: number;
+    organization?: string;
+}
+declare class OpenAICompatibleProvider implements LLMProvider {
+    private client;
+    private config;
+    constructor(config: OpenAICompatibleConfig);
+    generateResponse(messages: Message[], config: ProviderConfig): Promise<LLMResponse>;
+    streamResponse(messages: Message[], config: ProviderConfig): AsyncIterable<LLMStreamChunk>;
+    parseToolCalls(response: LLMResponse): ToolCall[];
+    private convertMessages;
+    listModels(): Promise<string[]>;
+    getBaseUrl(): string;
+}
+declare class LMStudioProvider extends OpenAICompatibleProvider {
+    constructor(config?: Partial<OpenAICompatibleConfig>);
+}
+declare class LocalAIProvider extends OpenAICompatibleProvider {
+    constructor(config?: Partial<OpenAICompatibleConfig>);
+}
+declare class TextGenerationWebUIProvider extends OpenAICompatibleProvider {
+    constructor(config?: Partial<OpenAICompatibleConfig>);
+}
+declare class VLLMProvider extends OpenAICompatibleProvider {
+    constructor(config?: Partial<OpenAICompatibleConfig>);
+}
+
+declare class BufferMemory implements MemoryStore {
+    private maxMessages?;
+    private store;
+    constructor(maxMessages?: number | undefined);
+    save(conversationId: string, messages: Message[]): Promise<void>;
+    load(conversationId: string): Promise<Message[]>;
+    clear(conversationId: string): Promise<void>;
+    clearAll(): void;
+    getConversationIds(): string[];
+    size(): number;
+}
+
+declare class RedisMemory implements MemoryStore {
+    private redis;
+    private prefix;
+    private ttl?;
+    constructor(config?: {
+        host?: string;
+        port?: number;
+        password?: string;
+        db?: number;
+        prefix?: string;
+        ttl?: number;
+    });
+    save(conversationId: string, messages: Message[]): Promise<void>;
+    load(conversationId: string): Promise<Message[]>;
+    clear(conversationId: string): Promise<void>;
+    getConversationIds(): Promise<string[]>;
+    disconnect(): Promise<void>;
+    private getKey;
+}
+
+declare class SummaryMemory implements MemoryStore {
+    private provider;
+    private maxRecentMessages;
+    private summaryModel;
+    private store;
+    constructor(provider: LLMProvider, maxRecentMessages?: number, summaryModel?: string);
+    save(conversationId: string, messages: Message[]): Promise<void>;
+    load(conversationId: string): Promise<Message[]>;
+    clear(conversationId: string): Promise<void>;
+    private createSummary;
+}
+
+declare class TenantBufferMemory {
+    private maxMessages?;
+    private store;
+    constructor(maxMessages?: number | undefined);
+    save(conversationId: string, messages: Message[], tenantId?: string): void;
+    load(conversationId: string, tenantId?: string): Message[];
+    clear(conversationId: string, tenantId?: string): void;
+    clearTenant(tenantId: string): void;
+    clearAll(): void;
+    getConversationIds(tenantId?: string): string[];
+    size(tenantId?: string): number;
+    getTenantIds(): string[];
+    getTenantStats(): Array<{
+        tenantId: string;
+        conversationCount: number;
+        messageCount: number;
+    }>;
+}
+
+declare abstract class Workflow {
+    protected config: WorkflowConfig;
+    protected provider: LLMProvider;
+    protected toolRegistry: ToolRegistry;
+    protected memory?: MemoryStore | undefined;
+    protected agents: Map<string, Agent>;
+    constructor(config: WorkflowConfig, provider: LLMProvider, toolRegistry: ToolRegistry, memory?: MemoryStore | undefined);
+    private initializeAgents;
+    abstract execute(input: string, context: AgentContext): Promise<AgentResponse>;
+    protected handleError(error: Error, agentName: string, _context: AgentContext): AgentResponse | null;
+    protected getAgent(name: string): Agent;
+}
+
+declare class SequentialWorkflow extends Workflow {
+    execute(input: string, context: AgentContext): Promise<AgentResponse>;
+}
+
+declare class ParallelWorkflow extends Workflow {
+    execute(input: string, context: AgentContext): Promise<AgentResponse>;
+}
+
+declare class SupervisorWorkflow extends Workflow {
+    execute(input: string, context: AgentContext): Promise<AgentResponse>;
+    private determineNextAgent;
+    private getNextRoundRobinAgent;
+    private getFallbackAgent;
+}
+
+declare class WorkflowFactory {
+    static create(config: WorkflowConfig, provider: LLMProvider, toolRegistry: ToolRegistry, memory?: MemoryStore): Workflow;
+}
+
+type LogLevel = 'error' | 'warn' | 'info' | 'debug';
+interface LoggerConfig {
+    level?: LogLevel;
+    format?: 'json' | 'simple';
+    filename?: string;
+    console?: boolean;
+}
+declare class Logger {
+    private logger;
+    constructor(config?: LoggerConfig);
+    error(message: string, meta?: any): void;
+    warn(message: string, meta?: any): void;
+    info(message: string, meta?: any): void;
+    debug(message: string, meta?: any): void;
+    child(context: Record<string, any>): Logger;
+}
+declare const defaultLogger: Logger;
+
+declare class MetricsCollector {
+    private metrics;
+    private listeners;
+    record(metric: AgentMetrics): void;
+    getAll(): AgentMetrics[];
+    getByAgent(agentName: string): AgentMetrics[];
+    getByTimeRange(start: Date, end: Date): AgentMetrics[];
+    getStats(agentName?: string): {
+        totalCalls: number;
+        successRate: number;
+        avgLatency: number;
+        totalTokens: number;
+        errors: number;
+    };
+    subscribe(listener: (metric: AgentMetrics) => void): () => void;
+    clear(): void;
+    private notifyListeners;
+}
+declare const globalMetrics: MetricsCollector;
+
+interface Span {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    name: string;
+    startTime: Date;
+    endTime?: Date;
+    attributes: Record<string, any>;
+    events: Array<{
+        timestamp: Date;
+        name: string;
+        attributes?: any;
+    }>;
+    status: 'ok' | 'error';
+    error?: Error;
+}
+declare class Tracer {
+    private spans;
+    private activeSpans;
+    startSpan(name: string, context?: SpanContext): {
+        span: Span;
+        context: SpanContext;
+    };
+    endSpan(spanId: string, error?: Error): void;
+    setAttributes(spanId: string, attributes: Record<string, any>): void;
+    addEvent(spanId: string, name: string, attributes?: Record<string, any>): void;
+    getSpan(spanId: string): Span | undefined;
+    getTrace(traceId: string): Span[];
+    getSpanDuration(spanId: string): number | undefined;
+    clear(): void;
+    export(): Span[];
+}
+declare const globalTracer: Tracer;
+
+declare class RateLimiter {
+    private maxTokens;
+    private refillRate;
+    private tokens;
+    private lastRefill;
+    constructor(maxTokens: number, refillRate: number);
+    consume(tokens?: number): boolean;
+    waitForTokens(tokens?: number): Promise<void>;
+    getTokens(): number;
+    reset(): void;
+    private refill;
+    private sleep;
+}
+declare class SlidingWindowRateLimiter {
+    private maxRequests;
+    private windowMs;
+    private requests;
+    constructor(maxRequests: number, windowMs: number);
+    isAllowed(key: string): boolean;
+    getRemaining(key: string): number;
+    reset(key: string): void;
+    clear(): void;
+}
+
+declare class Cache<T = any> {
+    private defaultTTL?;
+    private store;
+    constructor(defaultTTL?: number | undefined);
+    set(key: string, value: T, ttl?: number): void;
+    get(key: string): T | undefined;
+    has(key: string): boolean;
+    delete(key: string): boolean;
+    clear(): void;
+    getStats(): {
+        size: number;
+        keys: string[];
+        totalHits: number;
+    };
+    getOrSet(key: string, factory: () => Promise<T> | T, ttl?: number): Promise<T>;
+    cleanup(): number;
+    get size(): number;
+}
+declare class LRUCache<T = any> {
+    private maxSize;
+    private cache;
+    constructor(maxSize: number);
+    get(key: string): T | undefined;
+    set(key: string, value: T): void;
+    has(key: string): boolean;
+    delete(key: string): boolean;
+    clear(): void;
+    get size(): number;
+}
+
+declare class ContentFormatter {
+    static format(content: string, format: OutputFormat, options?: FormatOptions): FormattedContent;
+    private static formatText;
+    private static formatMarkdown;
+    private static formatHtml;
+    private static formatReact;
+    private static extractMetadata;
+    private static sanitizeHtml;
+    private static addCodeHighlighting;
+    private static wrapWithTheme;
+    private static addReactAttributes;
+    static detectFormat(content: string): OutputFormat;
+}
+
+interface MCPServerConfig {
+    name: string;
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    transport?: 'stdio' | 'sse';
+    url?: string;
+}
+interface MCPTool {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: 'object';
+        properties: Record<string, any>;
+        required?: string[];
+    };
+}
+interface MCPResource {
+    uri: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+}
+interface MCPPrompt {
+    name: string;
+    description?: string;
+    arguments?: Array<{
+        name: string;
+        description?: string;
+        required?: boolean;
+    }>;
+}
+interface MCPServerCapabilities {
+    tools?: {
+        listChanged?: boolean;
+    };
+    resources?: {
+        subscribe?: boolean;
+        listChanged?: boolean;
+    };
+    prompts?: {
+        listChanged?: boolean;
+    };
+    logging?: Record<string, never>;
+}
+interface MCPServerInfo {
+    name: string;
+    version: string;
+    protocolVersion: string;
+    capabilities: MCPServerCapabilities;
+}
+interface MCPCallToolRequest {
+    method: 'tools/call';
+    params: {
+        name: string;
+        arguments?: Record<string, any>;
+    };
+}
+interface MCPCallToolResponse {
+    content: Array<{
+        type: 'text' | 'image' | 'resource';
+        text?: string;
+        data?: string;
+        mimeType?: string;
+    }>;
+    isError?: boolean;
+}
+interface MCPListToolsRequest {
+    method: 'tools/list';
+    params?: {
+        cursor?: string;
+    };
+}
+interface MCPListToolsResponse {
+    tools: MCPTool[];
+    nextCursor?: string;
+}
+interface MCPReadResourceRequest {
+    method: 'resources/read';
+    params: {
+        uri: string;
+    };
+}
+interface MCPReadResourceResponse {
+    contents: Array<{
+        uri: string;
+        mimeType?: string;
+        text?: string;
+        blob?: string;
+    }>;
+}
+interface MCPMessage {
+    jsonrpc: '2.0';
+    id?: string | number;
+    method?: string;
+    params?: any;
+    result?: any;
+    error?: {
+        code: number;
+        message: string;
+        data?: any;
+    };
+}
+
+declare class MCPClient extends EventEmitter {
+    private config;
+    private transport;
+    private serverInfo;
+    private requestId;
+    private pendingRequests;
+    constructor(config: MCPServerConfig);
+    connect(): Promise<void>;
+    private initialize;
+    listTools(): Promise<MCPTool[]>;
+    callTool(name: string, args?: Record<string, any>): Promise<MCPCallToolResponse>;
+    listResources(): Promise<MCPResource[]>;
+    readResource(uri: string): Promise<MCPReadResourceResponse>;
+    listPrompts(): Promise<MCPPrompt[]>;
+    getPrompt(name: string, args?: Record<string, string>): Promise<any>;
+    getServerInfo(): MCPServerInfo | null;
+    disconnect(): void;
+    isConnected(): boolean;
+    private sendRequest;
+    private handleMessage;
+    private nextId;
+}
+
+declare class MCPRegistry {
+    private servers;
+    private tools;
+    addServer(config: MCPServerConfig): Promise<MCPClient>;
+    removeServer(name: string): void;
+    getServer(name: string): MCPClient | undefined;
+    getServers(): Map<string, MCPClient>;
+    getTools(): Tool[];
+    getTool(name: string): Tool | undefined;
+    getServerInfo(name: string): MCPServerInfo | null;
+    disconnectAll(): void;
+    private loadServerTools;
+    private removeServerTools;
+    reloadServerTools(serverName: string): Promise<void>;
+    reloadAllTools(): Promise<void>;
+}
+
+declare function mcpToolToAgenticTool(mcpTool: MCPTool, client: MCPClient): Tool;
+
+interface MCPTransport extends EventEmitter {
+    connect(): Promise<void>;
+    send(message: MCPMessage): void;
+    close(): void;
+    isConnected(): boolean;
+}
+declare class StdioTransport extends EventEmitter implements MCPTransport {
+    private command;
+    private args;
+    private env?;
+    private process;
+    private connected;
+    private buffer;
+    constructor(command: string, args?: string[], env?: Record<string, string> | undefined);
+    connect(): Promise<void>;
+    send(message: MCPMessage): void;
+    close(): void;
+    isConnected(): boolean;
+    private handleData;
+}
+declare class SSETransport extends EventEmitter implements MCPTransport {
+    private url;
+    private eventSource;
+    private connected;
+    constructor(url: string);
+    connect(): Promise<void>;
+    send(message: MCPMessage): Promise<void>;
+    close(): void;
+    isConnected(): boolean;
+}
+
+interface ACPProduct {
+    id: string;
+    name: string;
+    description?: string;
+    price: {
+        amount: number;
+        currency: string;
+    };
+    images?: string[];
+    variants?: ACPProductVariant[];
+    metadata?: Record<string, any>;
+}
+interface ACPProductVariant {
+    id: string;
+    name: string;
+    price: {
+        amount: number;
+        currency: string;
+    };
+    attributes?: Record<string, string>;
+    inventory?: {
+        available: boolean;
+        quantity?: number;
+    };
+}
+interface ACPCartItem {
+    productId: string;
+    variantId?: string;
+    quantity: number;
+    price: {
+        amount: number;
+        currency: string;
+    };
+}
+interface ACPCart {
+    id: string;
+    items: ACPCartItem[];
+    totalAmount: {
+        amount: number;
+        currency: string;
+    };
+    metadata?: Record<string, any>;
+}
+interface ACPCheckoutSession {
+    id: string;
+    cartId: string;
+    status: 'pending' | 'processing' | 'completed' | 'failed' | 'cancelled';
+    customer?: ACPCustomer;
+    shippingAddress?: ACPAddress;
+    billingAddress?: ACPAddress;
+    paymentMethod?: ACPPaymentMethod;
+    totalAmount: {
+        amount: number;
+        currency: string;
+    };
+    createdAt: string;
+    updatedAt: string;
+    metadata?: Record<string, any>;
+}
+interface ACPCustomer {
+    id?: string;
+    email: string;
+    name?: string;
+    phone?: string;
+    metadata?: Record<string, any>;
+}
+interface ACPAddress {
+    line1: string;
+    line2?: string;
+    city: string;
+    state?: string;
+    postalCode: string;
+    country: string;
+}
+interface ACPPaymentMethod {
+    type: 'card' | 'delegated' | 'wallet' | 'bank_transfer';
+    token?: string;
+    delegatedProvider?: string;
+    metadata?: Record<string, any>;
+}
+interface ACPPaymentIntent {
+    id: string;
+    amount: {
+        amount: number;
+        currency: string;
+    };
+    status: 'pending' | 'processing' | 'succeeded' | 'failed' | 'cancelled';
+    paymentMethod?: ACPPaymentMethod;
+    metadata?: Record<string, any>;
+}
+interface ACPOrder {
+    id: string;
+    checkoutSessionId: string;
+    status: 'pending' | 'confirmed' | 'processing' | 'shipped' | 'delivered' | 'cancelled' | 'refunded';
+    items: ACPCartItem[];
+    customer: ACPCustomer;
+    shippingAddress: ACPAddress;
+    billingAddress?: ACPAddress;
+    totalAmount: {
+        amount: number;
+        currency: string;
+    };
+    paymentStatus: 'pending' | 'paid' | 'failed' | 'refunded';
+    trackingNumber?: string;
+    createdAt: string;
+    updatedAt: string;
+    metadata?: Record<string, any>;
+}
+interface ACPProductSearchQuery {
+    query?: string;
+    category?: string;
+    minPrice?: number;
+    maxPrice?: number;
+    limit?: number;
+    offset?: number;
+    sortBy?: 'price' | 'name' | 'popularity' | 'newest';
+    sortOrder?: 'asc' | 'desc';
+}
+interface ACPProductSearchResult {
+    products: ACPProduct[];
+    total: number;
+    hasMore: boolean;
+}
+interface ACPConfig {
+    baseUrl: string;
+    apiKey?: string;
+    merchantId?: string;
+    timeout?: number;
+    headers?: Record<string, string>;
+}
+interface ACPDelegatedPaymentConfig {
+    provider: string;
+    merchantAccountId: string;
+    returnUrl?: string;
+    cancelUrl?: string;
+    metadata?: Record<string, any>;
+}
+interface ACPWebhookEvent {
+    id: string;
+    type: 'checkout.completed' | 'payment.succeeded' | 'payment.failed' | 'order.confirmed' | 'order.shipped' | 'order.delivered' | 'order.cancelled';
+    data: ACPCheckoutSession | ACPPaymentIntent | ACPOrder;
+    createdAt: string;
+}
+interface ACPResponse<T> {
+    data: T;
+    error?: {
+        code: string;
+        message: string;
+        details?: any;
+    };
+}
+interface ACPPaginationMeta {
+    total: number;
+    limit: number;
+    offset: number;
+    hasMore: boolean;
+}
+
+declare class ACPClient {
+    private config;
+    constructor(config: ACPConfig);
+    private request;
+    searchProducts(query: ACPProductSearchQuery): Promise<ACPResponse<ACPProductSearchResult>>;
+    getProduct(productId: string): Promise<ACPResponse<ACPProduct>>;
+    getProducts(productIds: string[]): Promise<ACPResponse<ACPProduct[]>>;
+    createCart(): Promise<ACPResponse<ACPCart>>;
+    getCart(cartId: string): Promise<ACPResponse<ACPCart>>;
+    addToCart(cartId: string, item: ACPCartItem): Promise<ACPResponse<ACPCart>>;
+    updateCartItem(cartId: string, productId: string, quantity: number): Promise<ACPResponse<ACPCart>>;
+    removeFromCart(cartId: string, productId: string): Promise<ACPResponse<ACPCart>>;
+    clearCart(cartId: string): Promise<ACPResponse<ACPCart>>;
+    createCheckoutSession(cartId: string, customer?: ACPCustomer): Promise<ACPResponse<ACPCheckoutSession>>;
+    getCheckoutSession(sessionId: string): Promise<ACPResponse<ACPCheckoutSession>>;
+    updateShippingAddress(sessionId: string, address: ACPAddress): Promise<ACPResponse<ACPCheckoutSession>>;
+    updateBillingAddress(sessionId: string, address: ACPAddress): Promise<ACPResponse<ACPCheckoutSession>>;
+    updatePaymentMethod(sessionId: string, paymentMethod: ACPPaymentMethod): Promise<ACPResponse<ACPCheckoutSession>>;
+    completeCheckout(sessionId: string): Promise<ACPResponse<ACPCheckoutSession>>;
+    createDelegatedPayment(sessionId: string, config: ACPDelegatedPaymentConfig): Promise<ACPResponse<ACPPaymentIntent>>;
+    getPaymentIntent(intentId: string): Promise<ACPResponse<ACPPaymentIntent>>;
+    confirmPayment(intentId: string, paymentToken?: string): Promise<ACPResponse<ACPPaymentIntent>>;
+    getOrder(orderId: string): Promise<ACPResponse<ACPOrder>>;
+    getCustomerOrders(customerId: string, limit?: number, offset?: number): Promise<ACPResponse<ACPOrder[]>>;
+    cancelOrder(orderId: string): Promise<ACPResponse<ACPOrder>>;
+    getOrderTracking(orderId: string): Promise<ACPResponse<{
+        trackingNumber: string;
+        carrier: string;
+        status: string;
+    }>>;
+}
+
+declare function createACPTools(client: ACPClient): Tool[];
+
+interface ConversationTurn {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    metadata?: Record<string, any>;
+    timestamp?: Date;
+}
+interface ConversationState {
+    currentStep: string;
+    data: Record<string, any>;
+    history: ConversationTurn[];
+    metadata: Record<string, any>;
+}
+interface ConversationStep {
+    id: string;
+    prompt: string;
+    schema?: z.ZodSchema;
+    next?: string | ((response: any, state: ConversationState) => string);
+    onComplete?: (response: any, state: ConversationState) => void | Promise<void>;
+    validation?: (response: any) => boolean | Promise<boolean>;
+    errorMessage?: string;
+    maxRetries?: number;
+}
+interface ConversationSchemaConfig {
+    name: string;
+    description?: string;
+    startStep: string;
+    steps: ConversationStep[];
+    onComplete?: (state: ConversationState) => void | Promise<void>;
+    onError?: (error: Error, state: ConversationState) => void | Promise<void>;
+}
+declare class ConversationSchema {
+    private config;
+    private state;
+    constructor(config: ConversationSchemaConfig);
+    getState(): ConversationState;
+    reset(): void;
+    getCurrentStep(): ConversationStep | undefined;
+    processResponse(userResponse: string): Promise<{
+        success: boolean;
+        message?: string;
+        nextPrompt?: string;
+        isComplete: boolean;
+        state: ConversationState;
+    }>;
+    private extractDataFromResponse;
+    getFormattedHistory(): string;
+    exportState(): string;
+    importState(stateJson: string): void;
+}
+declare class ConversationSchemaBuilder {
+    private config;
+    name(name: string): this;
+    description(description: string): this;
+    startAt(stepId: string): this;
+    addStep(step: ConversationStep): this;
+    onComplete(callback: (state: ConversationState) => void | Promise<void>): this;
+    onError(callback: (error: Error, state: ConversationState) => void | Promise<void>): this;
+    build(): ConversationSchema;
+}
+
+declare class ConversationManager {
+    private agent;
+    private schema;
+    private conversationId;
+    constructor(agent: Agent, schema: ConversationSchema, conversationId?: string);
+    start(): {
+        prompt: string;
+        state: ConversationState;
+    };
+    processMessage(userMessage: string): Promise<{
+        response: string;
+        isComplete: boolean;
+        state: ConversationState;
+        aiResponse?: string;
+    }>;
+    private buildAIPrompt;
+    getState(): ConversationState;
+    reset(): void;
+    getHistory(): ConversationTurn[];
+    export(): string;
+    import(stateJson: string): void;
+}
+
+type AudioFormat = 'mp3' | 'opus' | 'aac' | 'flac' | 'wav' | 'pcm';
+type VoiceType = string;
+interface STTConfig {
+    model?: string;
+    language?: string;
+    temperature?: number;
+    prompt?: string;
+    responseFormat?: 'json' | 'text' | 'srt' | 'verbose_json' | 'vtt';
+}
+interface TTSConfig {
+    model?: string;
+    voice?: VoiceType;
+    speed?: number;
+    format?: AudioFormat;
+}
+interface STTResult {
+    text: string;
+    language?: string;
+    duration?: number;
+    segments?: Array<{
+        id: number;
+        start: number;
+        end: number;
+        text: string;
+    }>;
+    words?: Array<{
+        word: string;
+        start: number;
+        end: number;
+    }>;
+}
+interface TTSResult {
+    audio: Buffer;
+    format: AudioFormat;
+    duration?: number;
+    byteLength: number;
+}
+interface STTProvider {
+    transcribe(audio: Buffer | string, config?: STTConfig): Promise<STTResult>;
+    transcribeStream?(audioStream: ReadableStream | NodeJS.ReadableStream, config?: STTConfig): AsyncIterable<Partial<STTResult>>;
+    supportsStreaming(): boolean;
+}
+interface TTSProvider {
+    synthesize(text: string, config?: TTSConfig): Promise<TTSResult>;
+    synthesizeStream?(text: string, config?: TTSConfig): AsyncIterable<Buffer>;
+    supportsStreaming(): boolean;
+    getVoices?(): Promise<Array<{
+        id: string;
+        name: string;
+        language?: string;
+        gender?: 'male' | 'female' | 'neutral';
+    }>>;
+}
+interface VoiceMessage {
+    role: 'user' | 'assistant';
+    text: string;
+    audio?: Buffer;
+    timestamp: Date;
+}
+interface VoiceAgentConfig {
+    sttProvider: STTProvider;
+    ttsProvider: TTSProvider;
+    sttConfig?: STTConfig;
+    ttsConfig?: TTSConfig;
+    autoSpeak?: boolean;
+}
+
+declare class VoiceAgent {
+    private agent;
+    private sttProvider;
+    private ttsProvider;
+    private sttConfig?;
+    private ttsConfig?;
+    private autoSpeak;
+    private conversationHistory;
+    constructor(agent: Agent, config: VoiceAgentConfig);
+    processVoice(audioInput: Buffer | string, context: AgentContext): Promise<{
+        text: string;
+        audio?: Buffer;
+        response: AgentResponse;
+    }>;
+    speak(text: string, context: AgentContext): Promise<{
+        text: string;
+        audio: Buffer;
+        response: AgentResponse;
+    }>;
+    transcribe(audioInput: Buffer | string): Promise<string>;
+    synthesize(text: string): Promise<Buffer>;
+    synthesizeStream(text: string): AsyncIterable<Buffer>;
+    getHistory(): VoiceMessage[];
+    clearHistory(): void;
+    saveAudio(audio: Buffer, outputPath: string): void;
+    exportConversation(outputDir: string): void;
+    setAutoSpeak(enabled: boolean): void;
+    setSTTConfig(config: STTConfig): void;
+    setTTSConfig(config: TTSConfig): void;
+    supportsStreaming(): {
+        stt: boolean;
+        tts: boolean;
+    };
+}
+
+declare class OpenAIWhisperProvider implements STTProvider {
+    private client;
+    constructor(apiKey?: string);
+    transcribe(audio: Buffer | string, config?: STTConfig): Promise<STTResult>;
+    supportsStreaming(): boolean;
+    getSupportedLanguages(): string[];
+}
+
+interface LocalWhisperConfig {
+    whisperPath?: string;
+    modelPath?: string;
+}
+declare class LocalWhisperProvider implements STTProvider {
+    private whisperPath;
+    private modelPath?;
+    constructor(config?: LocalWhisperConfig);
+    transcribe(audio: Buffer | string, config?: STTConfig): Promise<STTResult>;
+    supportsStreaming(): boolean;
+    isInstalled(): Promise<boolean>;
+    getInstallInstructions(): string;
+}
+
+declare class OpenAITTSProvider implements TTSProvider {
+    private client;
+    constructor(apiKey?: string);
+    synthesize(text: string, config?: TTSConfig): Promise<TTSResult>;
+    synthesizeStream(text: string, config?: TTSConfig): AsyncIterable<Buffer>;
+    supportsStreaming(): boolean;
+    getVoices(): Promise<Array<{
+        id: string;
+        name: string;
+        language?: string;
+        gender?: 'male' | 'female' | 'neutral';
+    }>>;
+    getModels(): string[];
+    getFormats(): AudioFormat[];
+}
+
+interface ElevenLabsConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+declare class ElevenLabsTTSProvider implements TTSProvider {
+    private apiKey;
+    private baseUrl;
+    constructor(config?: ElevenLabsConfig);
+    synthesize(text: string, config?: TTSConfig): Promise<TTSResult>;
+    synthesizeStream(text: string, config?: TTSConfig): AsyncIterable<Buffer>;
+    supportsStreaming(): boolean;
+    getVoices(): Promise<Array<{
+        id: string;
+        name: string;
+        language?: string;
+        gender?: 'male' | 'female' | 'neutral';
+    }>>;
+    getModels(): Promise<string[]>;
+}
+
+interface PiperTTSConfig {
+    piperPath?: string;
+    modelPath?: string;
+    configPath?: string;
+}
+declare class PiperTTSProvider implements TTSProvider {
+    private piperPath;
+    private modelPath?;
+    private configPath?;
+    constructor(config?: PiperTTSConfig);
+    synthesize(text: string, config?: TTSConfig): Promise<TTSResult>;
+    supportsStreaming(): boolean;
+    isInstalled(): Promise<boolean>;
+    getInstallInstructions(): string;
+    getVoices(): Promise<Array<{
+        id: string;
+        name: string;
+        language?: string;
+        gender?: 'male' | 'female' | 'neutral';
+    }>>;
+}
+
+interface Tenant {
+    id: string;
+    name: string;
+    slug: string;
+    metadata?: Record<string, unknown>;
+    settings?: TenantSettings;
+    status: TenantStatus;
+    createdAt: Date;
+    updatedAt: Date;
+}
+declare enum TenantStatus {
+    ACTIVE = "active",
+    SUSPENDED = "suspended",
+    INACTIVE = "inactive"
+}
+interface TenantSettings {
+    maxAgents?: number;
+    maxConversations?: number;
+    rateLimit?: number;
+    dataRetentionDays?: number;
+    allowedProviders?: string[];
+    custom?: Record<string, unknown>;
+}
+interface TenantContext {
+    tenant: Tenant;
+    userId?: string;
+    metadata?: Record<string, unknown>;
+}
+interface TenantApiKey {
+    id: string;
+    tenantId: string;
+    key: string;
+    name: string;
+    scopes: string[];
+    expiresAt?: Date;
+    createdAt: Date;
+    lastUsedAt?: Date;
+    isActive: boolean;
+}
+interface TenantQuota {
+    tenantId: string;
+    resource: string;
+    used: number;
+    limit: number;
+    period: 'hourly' | 'daily' | 'monthly';
+    periodStart: Date;
+    periodEnd: Date;
+}
+interface TenantStorage {
+    createTenant(tenant: Omit<Tenant, 'id' | 'createdAt' | 'updatedAt'>): Promise<Tenant>;
+    getTenant(tenantId: string): Promise<Tenant | null>;
+    getTenantBySlug(slug: string): Promise<Tenant | null>;
+    updateTenant(tenantId: string, updates: Partial<Tenant>): Promise<Tenant>;
+    deleteTenant(tenantId: string): Promise<void>;
+    listTenants(options?: {
+        limit?: number;
+        offset?: number;
+        status?: TenantStatus;
+    }): Promise<{
+        tenants: Tenant[];
+        total: number;
+    }>;
+    createApiKey(apiKey: Omit<TenantApiKey, 'id' | 'createdAt'>): Promise<TenantApiKey>;
+    getApiKeyByKey(key: string): Promise<TenantApiKey | null>;
+    revokeApiKey(apiKeyId: string): Promise<void>;
+    updateQuota(quota: TenantQuota): Promise<void>;
+    getQuota(tenantId: string, resource: string, period: string): Promise<TenantQuota | null>;
+}
+interface TenantResolver {
+    resolve(context: unknown): Promise<TenantContext | null>;
+}
+
+interface TenantManagerConfig {
+    storage: TenantStorage;
+    defaultSettings?: Tenant['settings'];
+}
+declare class TenantManager {
+    private storage;
+    private defaultSettings;
+    constructor(config: TenantManagerConfig);
+    createTenant(data: {
+        name: string;
+        slug: string;
+        metadata?: Record<string, unknown>;
+        settings?: Tenant['settings'];
+    }): Promise<Tenant>;
+    getTenant(tenantId: string): Promise<Tenant | null>;
+    getTenantBySlug(slug: string): Promise<Tenant | null>;
+    updateTenant(tenantId: string, updates: Partial<Tenant>): Promise<Tenant>;
+    suspendTenant(tenantId: string): Promise<Tenant>;
+    activateTenant(tenantId: string): Promise<Tenant>;
+    deleteTenant(tenantId: string): Promise<void>;
+    listTenants(options?: {
+        limit?: number;
+        offset?: number;
+        status?: TenantStatus;
+    }): Promise<{
+        tenants: Tenant[];
+        total: number;
+    }>;
+    createApiKey(tenantId: string, data: {
+        name: string;
+        scopes?: string[];
+        expiresAt?: Date;
+    }): Promise<{
+        apiKey: TenantApiKey;
+        plainKey: string;
+    }>;
+    verifyApiKey(plainKey: string): Promise<Tenant | null>;
+    revokeApiKey(apiKeyId: string): Promise<void>;
+    checkQuota(tenantId: string, resource: string, amount?: number): Promise<{
+        allowed: boolean;
+        remaining: number;
+    }>;
+    incrementQuota(tenantId: string, resource: string, amount?: number): Promise<void>;
+    private hashApiKey;
+    private getResourceLimit;
+}
+
+declare class MemoryTenantStorage implements TenantStorage {
+    private tenants;
+    private tenantsBySlug;
+    private apiKeys;
+    private apiKeysByKey;
+    private quotas;
+    private nextId;
+    private nextApiKeyId;
+    createTenant(data: Omit<Tenant, 'id' | 'createdAt' | 'updatedAt'>): Promise<Tenant>;
+    getTenant(tenantId: string): Promise<Tenant | null>;
+    getTenantBySlug(slug: string): Promise<Tenant | null>;
+    updateTenant(tenantId: string, updates: Partial<Tenant>): Promise<Tenant>;
+    deleteTenant(tenantId: string): Promise<void>;
+    listTenants(options?: {
+        limit?: number;
+        offset?: number;
+        status?: TenantStatus;
+    }): Promise<{
+        tenants: Tenant[];
+        total: number;
+    }>;
+    createApiKey(data: Omit<TenantApiKey, 'id' | 'createdAt'>): Promise<TenantApiKey>;
+    getApiKeyByKey(key: string): Promise<TenantApiKey | null>;
+    revokeApiKey(apiKeyId: string): Promise<void>;
+    updateQuota(quota: TenantQuota): Promise<void>;
+    getQuota(tenantId: string, resource: string, period: string): Promise<TenantQuota | null>;
+    clear(): void;
+}
+
+export { type ACPAddress, type ACPCart, type ACPCartItem, type ACPCheckoutSession, ACPClient, type ACPConfig, type ACPCustomer, type ACPDelegatedPaymentConfig, type ACPOrder, type ACPPaginationMeta, type ACPPaymentIntent, type ACPPaymentMethod, type ACPProduct, type ACPProductSearchQuery, type ACPProductSearchResult, type ACPProductVariant, type ACPResponse, type ACPWebhookEvent, Agent, type AgentConfig, type AgentContext, type AgentMetrics, type AgentResponse, AnthropicProvider, type AudioFormat, BufferMemory, Cache, ContentFormatter, ConversationManager, ConversationSchema, ConversationSchemaBuilder, type ConversationSchemaConfig, type ConversationState, type ConversationStep, type ConversationTurn, ElevenLabsTTSProvider, type ErrorHandlingStrategy, type FormatOptions, type FormattedContent, GeminiProvider, type LLMProvider, type LLMResponse, type LLMStreamChunk, LMStudioProvider, LRUCache, LocalAIProvider, LocalWhisperProvider, type LogLevel, Logger, type LoggerConfig, type MCPCallToolRequest, type MCPCallToolResponse, MCPClient, type MCPListToolsRequest, type MCPListToolsResponse, type MCPMessage, type MCPPrompt, type MCPReadResourceRequest, type MCPReadResourceResponse, MCPRegistry, type MCPResource, type MCPServerCapabilities, type MCPServerConfig, type MCPServerInfo, type MCPTool, type MCPTransport, type MemoryConfig, type MemoryStore, MemoryTenantStorage, type Message, MetricsCollector, OllamaProvider, OpenAICompatibleProvider, OpenAIProvider, OpenAITTSProvider, OpenAIWhisperProvider, type OutputFormat, ParallelWorkflow, PiperTTSProvider, type ProviderConfig, type ProviderInstanceConfig, RateLimiter, RedisMemory, type RetryConfig, type RoutingLogic, type RoutingRule, SSETransport, type STTConfig, type STTProvider, type STTResult, SequentialWorkflow, SlidingWindowRateLimiter, type Span, type SpanContext, StdioTransport, type StreamEvent, SummaryMemory, SupervisorWorkflow, type TTSConfig, type TTSProvider, type TTSResult, type Tenant, type TenantApiKey, TenantBufferMemory, type TenantContext, TenantManager, type TenantManagerConfig, type TenantQuota, type TenantResolver, type TenantSettings, TenantStatus, type TenantStorage, TextGenerationWebUIProvider, type Tool, type ToolCall, type ToolContext, ToolRegistry, Tracer, VLLMProvider, VoiceAgent, type VoiceAgentConfig, type VoiceMessage, type VoiceType, Workflow, type WorkflowConfig, WorkflowFactory, type WorkflowType, calculatorTool, createACPTools, defaultLogger, figmaGetCommentsTool, figmaGetFileTool, figmaGetImagesTool, figmaGetNodesTool, figmaPostCommentTool, fileListTool, fileReadTool, fileWriteTool, globalMetrics, globalTracer, httpRequestTool, mcpToolToAgenticTool, n8nExecuteWorkflowTool, n8nGetExecutionTool, n8nGetWorkflowTool, n8nListWorkflowsTool, n8nTriggerWebhookTool, stringTransformTool, textSummaryTool };