overai 1.4.0

package/dist/guardrails/index.js

@@ -0,0 +1,202 @@
+"use strict";
+/**
+ * Guardrails - Input/output validation and safety checks
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.builtinGuardrails = exports.GuardrailManager = exports.Guardrail = void 0;
+exports.guardrail = guardrail;
+/**
+ * Guardrail class
+ */
+class Guardrail {
+    constructor(config) {
+        this.name = config.name;
+        this.description = config.description || `Guardrail: ${config.name}`;
+        this.check = config.check;
+        this.onFail = config.onFail || 'block';
+    }
+    async run(content, context) {
+        try {
+            return await this.check(content, context);
+        }
+        catch (error) {
+            return {
+                status: 'failed',
+                message: `Guardrail error: ${error.message}`,
+                details: { error: error.message },
+            };
+        }
+    }
+}
+exports.Guardrail = Guardrail;
+/**
+ * Create a guardrail
+ */
+function guardrail(config) {
+    return new Guardrail(config);
+}
+/**
+ * Guardrail Manager - Run multiple guardrails
+ */
+class GuardrailManager {
+    constructor() {
+        this.guardrails = [];
+    }
+    add(g) {
+        this.guardrails.push(g);
+        return this;
+    }
+    async runAll(content, context) {
+        const results = [];
+        let passed = true;
+        for (const g of this.guardrails) {
+            const result = await g.run(content, context);
+            results.push({ name: g.name, result });
+            if (result.status === 'failed') {
+                passed = false;
+                if (g.onFail === 'block') {
+                    break;
+                }
+            }
+        }
+        return { passed, results };
+    }
+    get count() {
+        return this.guardrails.length;
+    }
+}
+exports.GuardrailManager = GuardrailManager;
+/**
+ * Built-in guardrails
+ */
+exports.builtinGuardrails = {
+    /**
+     * Check for maximum length
+     */
+    maxLength: (maxChars) => {
+        return guardrail({
+            name: 'max_length',
+            description: `Ensure content is under ${maxChars} characters`,
+            check: (content) => {
+                if (content.length > maxChars) {
+                    return {
+                        status: 'failed',
+                        message: `Content exceeds maximum length of ${maxChars} characters`,
+                        details: { length: content.length, max: maxChars },
+                    };
+                }
+                return { status: 'passed' };
+            },
+        });
+    },
+    /**
+     * Check for minimum length
+     */
+    minLength: (minChars) => {
+        return guardrail({
+            name: 'min_length',
+            description: `Ensure content is at least ${minChars} characters`,
+            check: (content) => {
+                if (content.length < minChars) {
+                    return {
+                        status: 'failed',
+                        message: `Content is below minimum length of ${minChars} characters`,
+                        details: { length: content.length, min: minChars },
+                    };
+                }
+                return { status: 'passed' };
+            },
+        });
+    },
+    /**
+     * Check for blocked words
+     */
+    blockedWords: (words) => {
+        return guardrail({
+            name: 'blocked_words',
+            description: 'Check for blocked words',
+            check: (content) => {
+                const lowerContent = content.toLowerCase();
+                const found = words.filter(w => lowerContent.includes(w.toLowerCase()));
+                if (found.length > 0) {
+                    return {
+                        status: 'failed',
+                        message: `Content contains blocked words`,
+                        details: { blockedWords: found },
+                    };
+                }
+                return { status: 'passed' };
+            },
+        });
+    },
+    /**
+     * Check for required words
+     */
+    requiredWords: (words) => {
+        return guardrail({
+            name: 'required_words',
+            description: 'Check for required words',
+            check: (content) => {
+                const lowerContent = content.toLowerCase();
+                const missing = words.filter(w => !lowerContent.includes(w.toLowerCase()));
+                if (missing.length > 0) {
+                    return {
+                        status: 'failed',
+                        message: `Content missing required words`,
+                        details: { missingWords: missing },
+                    };
+                }
+                return { status: 'passed' };
+            },
+        });
+    },
+    /**
+     * Regex pattern check
+     */
+    pattern: (regex, mustMatch = true) => {
+        return guardrail({
+            name: 'pattern',
+            description: `Check content against pattern: ${regex}`,
+            check: (content) => {
+                const matches = regex.test(content);
+                if (mustMatch && !matches) {
+                    return {
+                        status: 'failed',
+                        message: `Content does not match required pattern`,
+                        details: { pattern: regex.toString() },
+                    };
+                }
+                if (!mustMatch && matches) {
+                    return {
+                        status: 'failed',
+                        message: `Content matches forbidden pattern`,
+                        details: { pattern: regex.toString() },
+                    };
+                }
+                return { status: 'passed' };
+            },
+        });
+    },
+    /**
+     * JSON validity check
+     */
+    validJson: () => {
+        return guardrail({
+            name: 'valid_json',
+            description: 'Ensure content is valid JSON',
+            check: (content) => {
+                try {
+                    JSON.parse(content);
+                    return { status: 'passed' };
+                }
+                catch (e) {
+                    return {
+                        status: 'failed',
+                        message: 'Content is not valid JSON',
+                        details: { error: e.message },
+                    };
+                }
+            },
+        });
+    },
+};

package/dist/guardrails/llm-guardrail.d.ts

@@ -0,0 +1,46 @@
+/**
+ * LLMGuardrail - LLM-based content validation
+ */
+export interface LLMGuardrailConfig {
+    name: string;
+    criteria: string;
+    llm?: string;
+    threshold?: number;
+    verbose?: boolean;
+}
+export interface LLMGuardrailResult {
+    status: 'passed' | 'failed' | 'warning';
+    score: number;
+    message?: string;
+    reasoning?: string;
+}
+/**
+ * LLMGuardrail - Use LLM to validate content against criteria
+ */
+export declare class LLMGuardrail {
+    readonly name: string;
+    readonly criteria: string;
+    private provider;
+    private providerPromise;
+    private llmModel;
+    private threshold;
+    private verbose;
+    constructor(config: LLMGuardrailConfig);
+    /**
+     * Get the LLM provider (lazy initialization with AI SDK backend)
+     */
+    private getProvider;
+    /**
+     * Check content against criteria
+     */
+    check(content: string): Promise<LLMGuardrailResult>;
+    /**
+     * Run guardrail (alias for check)
+     */
+    run(content: string): Promise<LLMGuardrailResult>;
+    private parseResponse;
+}
+/**
+ * Create an LLMGuardrail
+ */
+export declare function createLLMGuardrail(config: LLMGuardrailConfig): LLMGuardrail;

package/dist/guardrails/llm-guardrail.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * LLMGuardrail - LLM-based content validation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMGuardrail = void 0;
+exports.createLLMGuardrail = createLLMGuardrail;
+const backend_resolver_1 = require("../llm/backend-resolver");
+/**
+ * LLMGuardrail - Use LLM to validate content against criteria
+ */
+class LLMGuardrail {
+    constructor(config) {
+        this.provider = null;
+        this.providerPromise = null;
+        this.name = config.name;
+        this.criteria = config.criteria;
+        this.llmModel = config.llm || 'openai/gpt-4o-mini';
+        this.threshold = config.threshold ?? 0.7;
+        this.verbose = config.verbose ?? false;
+    }
+    /**
+     * Get the LLM provider (lazy initialization with AI SDK backend)
+     */
+    async getProvider() {
+        if (this.provider) {
+            return this.provider;
+        }
+        if (!this.providerPromise) {
+            this.providerPromise = (async () => {
+                const result = await (0, backend_resolver_1.resolveBackend)(this.llmModel, {
+                    attribution: { agentId: `LLMGuardrail:${this.name}` },
+                });
+                this.provider = result.provider;
+                return result.provider;
+            })();
+        }
+        return this.providerPromise;
+    }
+    /**
+     * Check content against criteria
+     */
+    async check(content) {
+        const prompt = `Evaluate the following content against this criteria:
+
+Criteria: ${this.criteria}
+
+Content: ${content}
+
+Respond with a JSON object containing:
+- score: number from 0 to 1 (1 = fully meets criteria)
+- passed: boolean
+- reasoning: brief explanation
+
+JSON response:`;
+        try {
+            const provider = await this.getProvider();
+            const result = await provider.generateText({
+                messages: [{ role: 'user', content: prompt }]
+            });
+            const parsed = this.parseResponse(result.text);
+            if (this.verbose) {
+                console.log(`[LLMGuardrail:${this.name}] Score: ${parsed.score}, Passed: ${parsed.status}`);
+            }
+            return parsed;
+        }
+        catch (error) {
+            return {
+                status: 'warning',
+                score: 0.5,
+                message: `Guardrail check failed: ${error.message}`
+            };
+        }
+    }
+    /**
+     * Run guardrail (alias for check)
+     */
+    async run(content) {
+        return this.check(content);
+    }
+    parseResponse(response) {
+        try {
+            const jsonMatch = response.match(/\{[\s\S]*\}/);
+            if (jsonMatch) {
+                const parsed = JSON.parse(jsonMatch[0]);
+                const score = typeof parsed.score === 'number' ? parsed.score : 0.5;
+                return {
+                    status: score >= this.threshold ? 'passed' : 'failed',
+                    score,
+                    reasoning: parsed.reasoning
+                };
+            }
+        }
+        catch (e) {
+            // Parse failed
+        }
+        // Fallback parsing
+        const hasPositive = /pass|good|valid|accept|meets/i.test(response);
+        return {
+            status: hasPositive ? 'passed' : 'failed',
+            score: hasPositive ? 0.8 : 0.3,
+            reasoning: response.substring(0, 200)
+        };
+    }
+}
+exports.LLMGuardrail = LLMGuardrail;
+/**
+ * Create an LLMGuardrail
+ */
+function createLLMGuardrail(config) {
+    return new LLMGuardrail(config);
+}

package/dist/index.d.ts

@@ -0,0 +1,92 @@
+/**
+ * OverAI TypeScript SDK
+ *
+ * The primary API surface consists of three core classes:
+ * - Agent: Single AI agent with instructions, tools, and optional persistence
+ * - Agents: Multi-agent orchestration (sequential or parallel)
+ * - Workflow: Step-based workflow execution
+ *
+ * @example Quickstart (3 lines)
+ * ```typescript
+ * import { Agent } from 'overai';
+ * const agent = new Agent({ instructions: "You are helpful" });
+ * await agent.chat("Hello!");
+ * ```
+ *
+ * @example With tools (5 lines)
+ * ```typescript
+ * const getWeather = (city: string) => `Weather in ${city}: 20°C`;
+ * const agent = new Agent({ instructions: "You provide weather", tools: [getWeather] });
+ * await agent.chat("Weather in Paris?");
+ * ```
+ *
+ * @example With persistence (4 lines)
+ * ```typescript
+ * import { Agent, db } from 'overai';
+ * const agent = new Agent({ instructions: "You are helpful", db: db("sqlite:./data.db") });
+ * await agent.chat("Hello!");
+ * ```
+ *
+ * @example Multi-agent (6 lines)
+ * ```typescript
+ * import { Agent, Agents } from 'overai';
+ * const researcher = new Agent({ instructions: "Research the topic" });
+ * const writer = new Agent({ instructions: "Write based on research" });
+ * const agents = new Agents([researcher, writer]);
+ * await agents.start();
+ * ```
+ */
+export { Agent, Agents, PraisonAIAgents, Router } from './agent';
+export type { SimpleAgentConfig, PraisonAIAgentsConfig, SimpleRouterConfig, SimpleRouteConfig } from './agent';
+export { Workflow, parallel, route, loop, repeat } from './workflows';
+export type { WorkflowStep, WorkflowContext, StepResult } from './workflows';
+export { db, createDbAdapter, getDefaultDbAdapter, setDefaultDbAdapter } from './db';
+export type { DbAdapter, DbConfig, DbMessage, DbRun, DbTrace } from './db';
+export { BaseTool, ToolResult, ToolValidationError, validateTool, createTool, FunctionTool, tool, ToolRegistry, getRegistry, registerTool, getTool, type ToolConfig, type ToolContext, type ToolParameters } from './tools';
+export * from './tools/arxivTools';
+export * from './tools/mcpSse';
+export { tools, registerBuiltinTools } from './tools/tools';
+export { getToolsRegistry, createToolsRegistry, resetToolsRegistry, ToolsRegistry } from './tools/registry';
+export type { ToolExecutionContext, ToolLimits, RedactionHooks, ToolLogger, ToolCapabilities, InstallHints, ToolMetadata, ToolExecutionResult, PraisonTool, ToolParameterSchema, ToolParameterProperty, ToolMiddleware, ToolHooks, ToolFactory, RegisteredTool, ToolInstallStatus } from './tools/registry';
+export { MissingDependencyError, MissingEnvVarError } from './tools/registry';
+export { createLoggingMiddleware, createTimeoutMiddleware, createRedactionMiddleware, createRateLimitMiddleware, createRetryMiddleware, createTracingMiddleware, createValidationMiddleware, composeMiddleware } from './tools/registry';
+export { codeExecution, tavilySearch, tavilyExtract, tavilyCrawl, exaSearch, perplexitySearch, parallelSearch, firecrawlScrape, firecrawlCrawl, superagentGuard, superagentRedact, superagentVerify, valyuWebSearch, valyuFinanceSearch, valyuPaperSearch, valyuBioSearch, valyuPatentSearch, valyuSecSearch, valyuEconomicsSearch, valyuCompanyResearch, bedrockCodeInterpreter, bedrockBrowserNavigate, bedrockBrowserClick, bedrockBrowserFill, airweaveSearch, codeMode, registerCustomTool, createCustomTool, registerNpmTool, registerLocalTool } from './tools/builtins';
+export * from './session';
+export * from './knowledge';
+export * from './llm';
+export * from './process';
+export * from './guardrails';
+export { Handoff, handoff, handoffFilters, type HandoffConfig, type HandoffContext, type HandoffResult } from './agent/handoff';
+export { RouterAgent, createRouter, routeConditions, type RouterConfig, type RouteConfig, type RouteContext } from './agent/router';
+export { ContextAgent, createContextAgent, type ContextAgentConfig, type ContextMessage } from './agent/context';
+export { accuracyEval, performanceEval, reliabilityEval, EvalSuite, type EvalResult, type PerformanceResult, type AccuracyEvalConfig, type PerformanceEvalConfig, type ReliabilityEvalConfig } from './eval';
+export { SkillManager, createSkillManager, parseSkillFile, type Skill, type SkillMetadata, type SkillDiscoveryOptions } from './skills';
+export { parseArgs, executeCommand, CLI_SPEC_VERSION } from './cli';
+export { Memory, createMemory } from './memory/memory';
+export type { MemoryEntry, MemoryConfig } from './memory/memory';
+export { FileMemory, createFileMemory, type FileMemoryConfig, type FileMemoryEntry } from './memory/file-memory';
+export { AutoMemory, createAutoMemory, createLLMSummarizer, DEFAULT_POLICIES, type AutoMemoryConfig, type AutoMemoryPolicy, type AutoMemoryContext, type VectorStoreAdapter as AutoMemoryVectorStore, type KnowledgeBaseAdapter as AutoMemoryKnowledgeBase } from './memory/auto-memory';
+export { TelemetryCollector, AgentTelemetry, getTelemetry, enableTelemetry, disableTelemetry, cleanupTelemetry, createAgentTelemetry, type TelemetryEvent, type TelemetryConfig, type AgentStats } from './telemetry';
+export { AutoAgents, createAutoAgents, type AgentConfig, type TaskConfig, type TeamStructure, type AutoAgentsConfig } from './auto';
+export { ImageAgent, createImageAgent, type ImageAgentConfig, type ImageGenerationConfig, type ImageAnalysisConfig } from './agent/image';
+export { DeepResearchAgent, createDeepResearchAgent, type DeepResearchConfig, type ResearchResponse, type Citation, type ReasoningStep } from './agent/research';
+export { QueryRewriterAgent, createQueryRewriterAgent, type QueryRewriterConfig, type RewriteResult, type RewriteStrategy } from './agent/query-rewriter';
+export { PromptExpanderAgent, createPromptExpanderAgent, type PromptExpanderConfig, type ExpandResult, type ExpandStrategy } from './agent/prompt-expander';
+export { LLMGuardrail, createLLMGuardrail, type LLMGuardrailConfig, type LLMGuardrailResult } from './guardrails/llm-guardrail';
+export { Plan, PlanStep, TodoList, TodoItem, PlanStorage, PlanningAgent, TaskAgent, createPlan, createTodoList, createPlanStorage, createPlanningAgent, createTaskAgent, type PlanConfig, type PlanStepConfig, type TodoItemConfig, type PlanStatus, type TodoStatus, type PlanningAgentConfig, type PlanResult } from './planning';
+export { BaseCache, MemoryCache, FileCache, createMemoryCache, createFileCache, type CacheConfig, type CacheEntry } from './cache';
+export { PubSub, EventEmitterPubSub, AgentEventBus, AgentEvents, createEventBus, createPubSub, type Event, type EventHandler } from './events';
+export { parseYAMLWorkflow, createWorkflowFromYAML, loadWorkflowFromFile, validateWorkflowDefinition, type YAMLWorkflowDefinition, type YAMLStepDefinition, type ParsedWorkflow } from './workflows/yaml-parser';
+export { BaseVectorStore, MemoryVectorStore, createMemoryVectorStore, PineconeVectorStore, createPineconeStore, WeaviateVectorStore, createWeaviateStore, QdrantVectorStore, createQdrantStore, ChromaVectorStore, createChromaStore, type VectorDocument, type QueryResult as VectorQueryResult, type IndexStats } from './integrations/vector';
+export { BaseObservabilityProvider, ConsoleObservabilityProvider, MemoryObservabilityProvider, LangfuseObservabilityProvider, createConsoleObservability, createMemoryObservability, createLangfuseObservability, type Span, type TraceContext as ObservabilityTraceContext, type LogEntry, type Metric } from './integrations/observability';
+export { BaseVoiceProvider, OpenAIVoiceProvider, ElevenLabsVoiceProvider, createOpenAIVoice, createElevenLabsVoice, type VoiceConfig, type SpeakOptions, type ListenOptions, type Speaker } from './integrations/voice';
+export { BaseReranker, CohereReranker, CrossEncoderReranker, LLMReranker, createCohereReranker, createCrossEncoderReranker, createLLMReranker, type RerankResult, type RerankConfig } from './knowledge/reranker';
+export { GraphStore, GraphRAG, createGraphRAG, type GraphNode, type GraphEdge, type GraphQueryResult, type GraphRAGConfig } from './knowledge/graph-rag';
+export { createProvider, getDefaultProvider, parseModelString, isProviderAvailable, getAvailableProviders, OpenAIProvider, AnthropicProvider, GoogleProvider, BaseProvider, ProviderRegistry, registerProvider, unregisterProvider, hasProvider, listProviders, getDefaultRegistry, createProviderRegistry, registerBuiltinProviders, type LLMProvider, type ProviderConfig, type ProviderFactory, type ProviderConstructor, type ProviderLoader, type RegisterOptions, type IProviderRegistry, type ProviderInput, type CreateProviderOptions, type GenerateTextOptions, type GenerateTextResult, type StreamTextOptions, type StreamChunk, type GenerateObjectOptions, type GenerateObjectResult, type TokenUsage, type Message as ProviderMessage, type ToolCall, type ToolDefinition as ProviderToolDefinition, } from './llm/providers';
+export { type SpanKind, type SpanStatus, type SpanData, type SpanEvent, type TraceData, type TraceContext, type SpanContext, type ObservabilityAdapter, type AttributionContext, type ProviderMetadata, type ObservabilityToolConfig, type ObservabilityToolName, type ObservabilityToolInfo, OBSERVABILITY_TOOLS, getObservabilityToolInfo, listObservabilityTools, hasObservabilityToolEnvVar, NoopObservabilityAdapter, noopAdapter, MemoryObservabilityAdapter, createMemoryAdapter, ConsoleObservabilityAdapter, createConsoleAdapter, createObservabilityAdapter, clearAdapterCache, setObservabilityAdapter, getObservabilityAdapter, resetObservabilityAdapter, trace, } from './observability';
+export { AISDK_PROVIDERS, PROVIDER_ALIASES, COMMUNITY_PROVIDERS, ADAPTERS, type ProviderInfo, type ProviderModalities, type CommunityProvider, type AdapterInfo, } from './llm/providers/ai-sdk/types';
+export { SlashCommandHandler, createSlashCommandHandler, registerCommand, parseSlashCommand, executeSlashCommand, isSlashCommand, type SlashCommand, type SlashCommandContext, type SlashCommandResult, CostTracker, createCostTracker, estimateTokens, formatCost, MODEL_PRICING, type ModelPricing, type TokenUsage as CostTokenUsage, type RequestStats, type SessionStats, InteractiveTUI, createInteractiveTUI, StatusDisplay, createStatusDisplay, HistoryManager, createHistoryManager, type TUIConfig, type TUIState, RepoMap, createRepoMap, getRepoTree, DEFAULT_IGNORE_PATTERNS, type RepoMapConfig, type FileInfo, type SymbolInfo, type RepoMapResult, GitManager, createGitManager, DiffViewer, createDiffViewer, type GitConfig, type GitStatus, type GitCommit, type GitDiff, type GitDiffFile, SandboxExecutor, createSandboxExecutor, sandboxExec, CommandValidator, DEFAULT_BLOCKED_COMMANDS, DEFAULT_BLOCKED_PATHS, type SandboxMode, type SandboxConfig, type ExecutionResult, AutonomyManager, createAutonomyManager, cliApprovalPrompt, MODE_POLICIES, type AutonomyMode, type ActionType, type ApprovalPolicy, type AutonomyConfig, type ActionRequest, type ActionDecision, Scheduler, createScheduler, cronExpressions, type ScheduleConfig, type ScheduledTask, type SchedulerStats, JobQueue, createJobQueue, MemoryJobStorage, FileJobStorage, createFileJobStorage, type Job, type JobStatus, type JobPriority, type JobQueueConfig, type JobStorageAdapter, type JobHandler, type JobContext, CheckpointManager, createCheckpointManager, MemoryCheckpointStorage, FileCheckpointStorage, createFileCheckpointStorage, type CheckpointData, type CheckpointConfig, type CheckpointStorage, FlowDisplay, createFlowDisplay, renderWorkflow, type FlowNode, type FlowGraph, type FlowDisplayConfig, BaseExternalAgent, ClaudeCodeAgent, GeminiCliAgent, CodexCliAgent, AiderAgent, GenericExternalAgent, getExternalAgentRegistry, createExternalAgent, externalAgentAsTool, type ExternalAgentConfig, type ExternalAgentResult, N8NIntegration, createN8NIntegration, triggerN8NWebhook, type N8NConfig, type N8NWebhookPayload, type N8NWorkflow, type N8NWorkflowNode, FastContext, createFastContext, getQuickContext, type FastContextConfig, type ContextSource, type FastContextResult } from './cli/features';
+export { generateText as aiGenerateText, streamText as aiStreamText, type GenerateTextOptions as AIGenerateTextOptions, type GenerateTextResult as AIGenerateTextResult, type StreamTextOptions as AIStreamTextOptions, type StreamTextResult as AIStreamTextResult, type TextStreamPart, generateObject as aiGenerateObject, streamObject as aiStreamObject, type GenerateObjectOptions as AIGenerateObjectOptions, type GenerateObjectResult as AIGenerateObjectResult, type StreamObjectOptions as AIStreamObjectOptions, type StreamObjectResult as AIStreamObjectResult, generateImage as aiGenerateImage, type GenerateImageOptions as AIGenerateImageOptions, type GenerateImageResult as AIGenerateImageResult, embed as aiEmbed, embedMany as aiEmbedMany, type EmbedOptions as AIEmbedOptions, type EmbedResult as AIEmbedResult, type EmbedManyResult as AIEmbedManyResult, defineTool, createToolSet, functionToTool, type ToolDefinition as AIToolDefinition, type ToolExecuteFunction, type ToolInput, type ToolOutput, createModel, getModel, parseModel, MODEL_ALIASES, listModelAliases, hasModelAlias, resolveModelAlias, type ModelConfig, type ModelId, createCachingMiddleware, createLoggingMiddleware as createAILoggingMiddleware, wrapModel, applyMiddleware, clearCache as clearAICache, getCacheStats as getAICacheStats, type Middleware as AIMiddleware, type MiddlewareConfig as AIMiddlewareConfig, type MiddlewareRequest, type MiddlewareResponse, createImagePart, createFilePart, createPdfPart, createTextPart, createMultimodalMessage, toMessageContent, base64ToUint8Array, uint8ArrayToBase64, isUrl, isDataUrl, type InputPart, type ImagePart as AIImagePart, type FilePart as AIFilePart, type PdfPart, type TextPart as AITextPart, createMCP, getMCPClient, closeMCPClient, closeAllMCPClients, mcpToolsToAITools, type MCPConfig, type MCPClient, type MCPTool, type MCPResource, type MCPPrompt, createHttpHandler, createExpressHandler, createHonoHandler, createFastifyHandler, createNestHandler, type ServerHandler, type ServerHandlerConfig, createRouteHandler, createPagesHandler, type RouteHandlerConfig, type UseChatConfig, createAgentLoop, AgentLoop, stopAfterSteps, stopWhenNoToolCalls, stopWhen, type AgentLoopConfig, type AgentStep as AIAgentStep, type AgentLoopResult, type StopCondition, convertToModelMessages, convertToUIMessages, validateUIMessages, safeValidateUIMessages, createTextMessage, createSystemMessage, hasPendingApprovals, getToolsNeedingApproval, createApprovalResponse, toUIMessageStreamResponse, pipeUIMessageStreamToResponse, type UIMessage, type UIMessagePart, type TextUIPart, type ReasoningUIPart, type ToolUIPart, type FileUIPart, type DataUIPart, type ModelMessage as AIModelMessage, type UIMessageStreamOptions, ApprovalManager, getApprovalManager, setApprovalManager, withApproval, ToolApprovalDeniedError, ToolApprovalTimeoutError, DANGEROUS_PATTERNS, isDangerous, createDangerousPatternChecker, type ToolApprovalConfig, type ToolApprovalRequest, type ToolApprovalResponse, type ApprovalState, type ApprovalHandler, generateSpeech, transcribe, SPEECH_MODELS, TRANSCRIPTION_MODELS, type GenerateSpeechOptions, type GenerateSpeechResult, type TranscribeOptions, type TranscribeResult, type TranscriptionSegment, enableDevTools, disableDevTools, isDevToolsEnabled, getDevToolsState, getDevToolsUrl, createDevToolsMiddleware, autoEnableDevTools, type DevToolsConfig, type DevToolsState, configureTelemetry, getTelemetrySettings, enableAITelemetry, disableAITelemetry, isTelemetryEnabled, initOpenTelemetry, getTracer, createAISpan, withSpan, createTelemetryMiddleware, recordEvent, getEvents, clearEvents, createTelemetrySettings, type TelemetrySettings as AITelemetrySettings, type Tracer as AITracer, type Span as AISpan, type SpanOptions as AISpanOptions, type SpanKind as AISpanKind, type SpanStatus as AISpanStatus, type TelemetryEvent as AITelemetryEvent, type OAuthClientProvider, } from './ai';
+export { createSlackBot, SlackBot, verifySlackSignature, parseSlackMessage, type SlackConfig, type SlackMessage, type SlackResponse, type SlackEventHandler, } from './integrations/slack';
+export { createNLPostgres, NLPostgresClient, createPostgresTool, type PostgresConfig as NLPostgresConfig, type TableSchema, type ColumnSchema, type QueryResult, type NLQueryResult, } from './integrations/postgres';
+export { createComputerUse, ComputerUseClient, createComputerUseAgent, createCLIApprovalPrompt, type ComputerUseConfig, type ComputerUseTools, type ComputerAction, type ScreenshotResult, } from './integrations/computer-use';