Release v4.5.5

Release v4.5.3
Release v4.5.2
2026-11-07 22:52:58 -10:00 · 2026-02-15 01:04:07 +00:00 · 2026-02-14 14:24:05 +00:00 · 2026-02-14 00:06:53 +00:00 · 2026-02-13 15:00:40 +00:00 · 2026-02-13 14:11:15 +00:00
211 changed files with 59619 additions and 1358 deletions
@@ -0,0 +1,80 @@
+name: Update Documentation Parity Tracker
+
+on:
+  push:
+    branches: [ "main" ]
+    paths:
+      - 'src/praisonai-agents/praisonaiagents/**/*.py'
+      - 'src/praisonai-ts/src/**/*.ts'
+      - 'src/praisonai-rust/src/**/*.rs'
+      - 'src/praisonai/praisonai/_dev/parity/**/*.py'
+      - '.github/workflows/update-docs-parity.yml'
+  workflow_dispatch:  # Allow manual trigger
+
+permissions:
+  contents: write
+
+jobs:
+  update-docs-parity:
+    runs-on: ubuntu-latest
+    
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+      with:
+        ref: main
+        persist-credentials: true
+        fetch-depth: 0
+
+    - name: Checkout PraisonAIDocs
+      uses: actions/checkout@v4
+      with:
+        repository: MervinPraison/PraisonAIDocs
+        path: PraisonAIDocs
+        token: ${{ secrets.DOCS_PAT }}
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.11'
+
+    - name: Install dependencies
+      run: |
+        pip install pyyaml
+
+    - name: Generate docs parity trackers
+      run: |
+        cd $GITHUB_WORKSPACE
+        python3 src/praisonai/scripts/generate_docs_parity.py --docs-root PraisonAIDocs/docs --copy-docs
+        
+    - name: Check for changes
+      id: check_changes
+      run: |
+        if git diff --quiet src/praisonai-agents/DOCS_PARITY.md src/praisonai-ts/DOCS_PARITY.md src/praisonai-rust/DOCS_PARITY.md 2>/dev/null; then
+          echo "changes=false" >> $GITHUB_OUTPUT
+          echo "No changes to docs parity trackers"
+        else
+          echo "changes=true" >> $GITHUB_OUTPUT
+          echo "Docs parity trackers have been updated"
+          git diff --stat src/praisonai-agents/DOCS_PARITY.md src/praisonai-ts/DOCS_PARITY.md src/praisonai-rust/DOCS_PARITY.md
+        fi
+
+    - name: Commit and push changes to praisonai-package
+      if: steps.check_changes.outputs.changes == 'true'
+      uses: stefanzweifel/git-auto-commit-action@v5
+      with:
+        commit_message: "docs: auto-update documentation parity trackers [skip ci]"
+        file_pattern: 'src/praisonai-agents/DOCS_PARITY.md src/praisonai-ts/DOCS_PARITY.md src/praisonai-rust/DOCS_PARITY.md'
+        commit_user_name: "github-actions[bot]"
+        commit_user_email: "41898282+github-actions[bot]@users.noreply.github.com"
+        commit_author: "github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>"
+
+    - name: Commit and push changes to PraisonAIDocs
+      if: steps.check_changes.outputs.changes == 'true'
+      run: |
+        cd PraisonAIDocs
+        git config user.name "github-actions[bot]"
+        git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+        git add docs/features/DOCS_PARITY.md docs/js/DOCS_PARITY.md docs/rust/DOCS_PARITY.md
+        git diff --staged --quiet || git commit -m "docs: auto-update documentation parity trackers [skip ci]"
+        git push
@@ -672,7 +672,7 @@ Methods:

 Types:
 ```python
-from praisonaiagents import AgentAppConfig, AgentAppProtocol, AgentFlow, AgentManager, AgentOSConfig, AgentOSProtocol, AgentTeam, EmbeddingResult, aembedding, aembeddings, embedding, embeddings, get_dimensions
+from praisonaiagents import AgentAppConfig, AgentAppProtocol, AgentFlow, AgentManager, AgentOSConfig, AgentOSProtocol, AgentTeam, AutoApproveBackend, EmbeddingResult, aembedding, aembeddings, embedding, embeddings, get_dimensions
 ```

 Methods:
@@ -736,6 +736,8 @@ Methods:
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">todo_list</a>()</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">update_plan_step_status</a>(step_id: str, status: str) -> bool</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">update_state</a>(updates: Dict) -> None</code>
+* <code title="class AutoApproveBackend">AutoApproveBackend.<a href="./src/praisonai-agents/praisonaiagents/approval/backends.py">request_approval</a>(request: ApprovalRequest) -> ApprovalDecision</code>
+* <code title="class AutoApproveBackend">AutoApproveBackend.<a href="./src/praisonai-agents/praisonaiagents/approval/backends.py">request_approval_sync</a>(request: ApprovalRequest) -> ApprovalDecision</code>
 * <code title="function">praisonaiagents.<a href="./src/praisonai-agents/praisonaiagents/embedding/embed.py">aembedding</a>(input: Union[str, List[str]], model: str = 'text-embedding-3-small', dimensions: Optional[int] = None, encoding_format: str = 'float', timeout: float = 600.0, api_key: Optional[str] = None, api_base: Optional[str] = None, metadata: Optional[Dict[str, Any]] = None, **kwargs) -> EmbeddingResult</code>
 * <code title="function">praisonaiagents.<a href="./src/praisonai-agents/praisonaiagents/embedding/embed.py">aembeddings</a>(input: Union[str, List[str]], model: str = 'text-embedding-3-small', dimensions: Optional[int] = None, encoding_format: str = 'float', timeout: float = 600.0, api_key: Optional[str] = None, api_base: Optional[str] = None, metadata: Optional[Dict[str, Any]] = None, **kwargs) -> EmbeddingResult</code>
 * <code title="function">praisonaiagents.<a href="./src/praisonai-agents/praisonaiagents/embedding/embed.py">embedding</a>(input: Union[str, List[str]], model: str = 'text-embedding-3-small', dimensions: Optional[int] = None, encoding_format: str = 'float', timeout: float = 600.0, api_key: Optional[str] = None, api_base: Optional[str] = None, metadata: Optional[Dict[str, Any]] = None, **kwargs) -> EmbeddingResult</code>
@@ -775,7 +777,9 @@ Methods:
 * <code title="cli">praisonai bot bot-callback <a href="./src/praisonai/praisonai/cli/commands/bot.py">--help</a></code>
 * <code title="cli">praisonai bot discord <a href="./src/praisonai/praisonai/cli/commands/bot.py">--help</a></code>
 * <code title="cli">praisonai bot slack <a href="./src/praisonai/praisonai/cli/commands/bot.py">--help</a></code>
+* <code title="cli">praisonai bot start <a href="./src/praisonai/praisonai/cli/commands/bot.py">--help</a></code>
 * <code title="cli">praisonai bot telegram <a href="./src/praisonai/praisonai/cli/commands/bot.py">--help</a></code>
+* <code title="cli">praisonai bot whatsapp <a href="./src/praisonai/praisonai/cli/commands/bot.py">--help</a></code>
 * <code title="cli">praisonai browser browser-callback <a href="./src/praisonai/praisonai/cli/commands/browser.py">--help</a></code>
 * <code title="cli">praisonai browser click <a href="./src/praisonai/praisonai/cli/commands/browser.py">--help</a></code>
 * <code title="cli">praisonai browser navigate <a href="./src/praisonai/praisonai/cli/commands/browser.py">--help</a></code>
@@ -854,6 +858,9 @@ Methods:
 * <code title="cli">praisonai examples run <a href="./src/praisonai/praisonai/cli/commands/examples.py">--help</a></code>
 * <code title="cli">praisonai examples run-all <a href="./src/praisonai/praisonai/cli/commands/examples.py">--help</a></code>
 * <code title="cli">praisonai examples stats <a href="./src/praisonai/praisonai/cli/commands/examples.py">--help</a></code>
+* <code title="cli">praisonai gateway gateway-callback <a href="./src/praisonai/praisonai/cli/commands/gateway.py">--help</a></code>
+* <code title="cli">praisonai gateway start <a href="./src/praisonai/praisonai/cli/commands/gateway.py">--help</a></code>
+* <code title="cli">praisonai gateway status <a href="./src/praisonai/praisonai/cli/commands/gateway.py">--help</a></code>
 * <code title="cli">praisonai hooks add <a href="./src/praisonai/praisonai/cli/commands/hooks.py">--help</a></code>
 * <code title="cli">praisonai hooks list <a href="./src/praisonai/praisonai/cli/commands/hooks.py">--help</a></code>
 * <code title="cli">praisonai hooks remove <a href="./src/praisonai/praisonai/cli/commands/hooks.py">--help</a></code>
@@ -885,6 +892,7 @@ Methods:
 * <code title="cli">praisonai memory search <a href="./src/praisonai/praisonai/cli/commands/memory.py">--help</a></code>
 * <code title="cli">praisonai memory show <a href="./src/praisonai/praisonai/cli/commands/memory.py">--help</a></code>
 * <code title="cli">praisonai memory status <a href="./src/praisonai/praisonai/cli/commands/memory.py">--help</a></code>
+* <code title="cli">praisonai obs obs-fallback <a href="./src/praisonai/praisonai/cli/commands/obs.py">--help</a></code>
 * <code title="cli">praisonai package install <a href="./src/praisonai/praisonai/cli/commands/package.py">--help</a></code>
 * <code title="cli">praisonai package list <a href="./src/praisonai/praisonai/cli/commands/package.py">--help</a></code>
 * <code title="cli">praisonai package uninstall <a href="./src/praisonai/praisonai/cli/commands/package.py">--help</a></code>
@@ -1010,6 +1018,7 @@ Methods:
 * <code title="cli">praisonai train llm <a href="./src/praisonai/praisonai/cli/commands/train.py">--help</a></code>
 * <code title="cli">praisonai train show <a href="./src/praisonai/praisonai/cli/commands/train.py">--help</a></code>
 * <code title="cli">praisonai train train-callback <a href="./src/praisonai/praisonai/cli/commands/train.py">--help</a></code>
+* <code title="cli">praisonai ui bot <a href="./src/praisonai/praisonai/cli/commands/ui.py">--help</a></code>
 * <code title="cli">praisonai ui chat <a href="./src/praisonai/praisonai/cli/commands/ui.py">--help</a></code>
 * <code title="cli">praisonai ui code <a href="./src/praisonai/praisonai/cli/commands/ui.py">--help</a></code>
 * <code title="cli">praisonai ui gradio <a href="./src/praisonai/praisonai/cli/commands/ui.py">--help</a></code>
@@ -1031,7 +1040,7 @@ export type { AgentTeamConfig, PraisonAIAgentsConfig, SimpleAgentConfig, SimpleR
 export { AudioAgent, createAudioAgent } from "./agent/audio";
 export type { AudioAgentConfig, AudioProvider, AudioSpeakOptions, AudioSpeakResult, AudioTranscribeOptions, AudioTranscribeResult } from "./agent/audio";
 export { ContextAgent, createContextAgent } from "./agent/context";
-export { Handoff, handoff, handoffFilters } from "./agent/handoff";
+export { ContextPolicy, Handoff, HandoffCycleError, HandoffDepthError, HandoffError, HandoffTimeoutError, RECOMMENDED_PROMPT_PREFIX, handoff, handoffFilters, promptWithHandoffInstructions } from "./agent/handoff";
 export { ImageAgent, createImageAgent } from "./agent/image";
 export { PromptExpanderAgent, createPromptExpanderAgent } from "./agent/prompt-expander";
 export { QueryRewriterAgent, createQueryRewriterAgent } from "./agent/query-rewriter";
@@ -1060,24 +1069,46 @@ export { // Autonomy Mode
  JobQueue, // Checkpoints
  CheckpointManager, // Cost Tracker
  CostTracker, // External Agents
-  BaseExternalAgent, // Fast Context
+  BaseExternalAgent, // Fast Context (Python parity with praisonaiagents/context/fast)
  FastContext, // Flow Display
  FlowDisplay, // Git Integration
  GitManager, // Interactive TUI
  InteractiveTUI, // N8N Integration
-  N8NIntegration, // Repo Map
+  N8NIntegration, // Python parity additions
+  type LineRange, // Repo Map
  RepoMap, // Sandbox Executor
  SandboxExecutor, // Scheduler
  Scheduler, // Slash Commands
-  SlashCommandHandler, AiderAgent, ClaudeCodeAgent, CodexCliAgent, CommandValidator, CostTokenUsage, DEFAULT_BLOCKED_COMMANDS, DEFAULT_BLOCKED_PATHS, DEFAULT_IGNORE_PATTERNS, DiffViewer, FileCheckpointStorage, FileJobStorage, GeminiCliAgent, GenericExternalAgent, HistoryManager, MODEL_PRICING, MODE_POLICIES, MemoryCheckpointStorage, MemoryJobStorage, StatusDisplay, cliApprovalPrompt, createAutonomyManager, createCheckpointManager, createCostTracker, createDiffViewer, createExternalAgent, createFastContext, createFileCheckpointStorage, createFileJobStorage, createFlowDisplay, createGitManager, createHistoryManager, createInteractiveTUI, createJobQueue, createN8NIntegration, createRepoMap, createSandboxExecutor, createScheduler, createSlashCommandHandler, createStatusDisplay, cronExpressions, estimateTokens, executeSlashCommand, externalAgentAsTool, formatCost, getExternalAgentRegistry, getQuickContext, getRepoTree, isSlashCommand, parseSlashCommand, registerCommand, renderWorkflow, sandboxExec, triggerN8NWebhook } from "./cli/features";
+  SlashCommandHandler, AiderAgent, ClaudeCodeAgent, CodexCliAgent, CommandValidator, CostTokenUsage, DEFAULT_BLOCKED_COMMANDS, DEFAULT_BLOCKED_PATHS, DEFAULT_IGNORE_PATTERNS, DiffViewer, FileCheckpointStorage, FileJobStorage, GeminiCliAgent, GenericExternalAgent, HistoryManager, MODEL_PRICING, MODE_POLICIES, MemoryCheckpointStorage, MemoryJobStorage, StatusDisplay, addLineRangeToFileMatch, cliApprovalPrompt, createAutonomyManager, createCheckpointManager, createCostTracker, createDiffViewer, createExternalAgent, createFastContext, createFileCheckpointStorage, createFileJobStorage, createFileMatch, createFlowDisplay, createGitManager, createHistoryManager, createInteractiveTUI, createJobQueue, createLineRange, createN8NIntegration, createRepoMap, createSandboxExecutor, createScheduler, createSlashCommandHandler, createStatusDisplay, cronExpressions, estimateTokens, executeSlashCommand, externalAgentAsTool, formatCost, getExternalAgentRegistry, getLineCount, getQuickContext, getRepoTree, getTotalLines, isSlashCommand, mergeRanges, parseSlashCommand, rangesOverlap, registerCommand, renderWorkflow, sandboxExec, triggerN8NWebhook } from "./cli/features";
+export { // Classes
+  DictCondition, // Functions
+  evaluateCondition, // Types
+  type ConditionProtocol, ExpressionCondition, FunctionCondition, andConditions, createCondition, notCondition, orConditions } from "./conditions";
+export { // Enums
+  MemoryBackend, // Errors
+  ConfigValidationError, // Parse utilities
+  detect_url_scheme, // Presets
+  MEMORY_PRESETS, // Resolver functions
+  resolve, AUTONOMY_PRESETS, ArrayMode, CACHING_PRESETS, CONTEXT_PRESETS, ChunkingStrategy, EXECUTION_PRESETS, ExecutionPreset, FeatureMemoryConfig, GUARDRAIL_PRESETS, GuardrailAction, KNOWLEDGE_PRESETS, MEMORY_URL_SCHEMES, MULTI_AGENT_EXECUTION_PRESETS, MULTI_AGENT_OUTPUT_PRESETS, OUTPUT_PRESETS, OutputPreset, PLANNING_PRESETS, REFLECTION_PRESETS, WEB_PRESETS, WebSearchProvider, apply_config_defaults, clean_triple_backticks, get_config, get_config_path, get_default, get_defaults_config, get_plugins_config, is_path_like, is_policy_string, parse_policy_string, resolve_autonomy, resolve_caching, resolve_context, resolve_execution, resolve_guardrails, resolve_hooks, resolve_knowledge, resolve_memory, resolve_output, resolve_planning, resolve_reflection, resolve_routing, resolve_skills, resolve_web, suggest_similar, validate_config } from "./config";
 export { createDbAdapter, db, getDefaultDbAdapter, setDefaultDbAdapter } from "./db";
 export type { DbAdapter, DbConfig, DbMessage, DbRun, DbTrace } from "./db";
 export { MemoryPostgresAdapter, NeonPostgresAdapter, PostgresSessionStorage, createMemoryPostgres, createNeonPostgres, createPostgresSessionStorage } from "./db/postgres";
 export { MemoryRedisAdapter, UpstashRedisAdapter, createMemoryRedis, createUpstashRedis } from "./db/redis";
 export { SQLiteAdapter, createSQLiteAdapter } from "./db/sqlite";
+export { // Types
+  type DisplayCallback, DisplayFlow, DisplayFlowConfig, asyncDisplayCallbacks, clearDisplayCallbacks, clearErrorLogs, displayError, displayGenerating, displayInstruction, displayInteraction, displaySelfReflection, displayToolCall, errorLogs, logError, registerDisplay, syncDisplayCallbacks } from "./display";
+export { // Functions
+  embed, // Types
+  type EmbeddingResult, aembed, aembedding, aembeddings, cosineSimilarity, embedding, embeddings, euclideanDistance, getDimensions, normalizeEmbedding, setEmbeddingConfig } from "./embeddings";
 export { // LLM-as-Judge
  Judge, AccuracyJudge, CriteriaJudge, EvalResults, EvalSuite, Evaluator, RecipeJudge, accuracyEval, addJudge, addOptimizationRule, containsKeywordsCriterion, createDefaultEvaluator, createEvalResults, createEvaluator, getJudge, getOptimizationRule, lengthCriterion, listJudges, listOptimizationRules, noHarmfulContentCriterion, parseJudgeResponse, performanceEval, relevanceCriterion, reliabilityEval, removeJudge, removeOptimizationRule } from "./eval";
 export { AgentEventBus, AgentEvents, EventEmitterPubSub, PubSub, createEventBus, createPubSub } from "./events";
+export { // Bot types
+  type BotConfig, // Classes
+  FailoverManager, // Enums
+  SandboxStatus, // Gateway types
+  type GatewayConfig, // Other types
+  type ProviderStatus, AutonomyLevel, RagRetrievalPolicy } from "./gateway";
 export { LLMGuardrail, createLLMGuardrail } from "./guardrails/llm-guardrail";
 export { DisplayTypes, HooksManager, WorkflowHooksExecutor, clearAllCallbacks, clearApprovalCallback, createHooksManager, createLoggingOperationHooks, createLoggingWorkflowHooks, createTimingWorkflowHooks, createValidationOperationHooks, createWorkflowHooks, executeCallback, executeSyncCallback, getRegisteredDisplayTypes, hasApprovalCallback, registerApprovalCallback, registerDisplayCallback, requestApproval, unregisterDisplayCallback } from "./hooks";
 export { // Computer Use
@@ -1112,15 +1143,47 @@ export { // Adapters
  type SpanKind, ConsoleObservabilityAdapter, MemoryObservabilityAdapter, clearAdapterCache, createConsoleAdapter, createMemoryAdapter, createObservabilityAdapter, getObservabilityAdapter, getObservabilityToolInfo, hasObservabilityToolEnvVar, listObservabilityTools, noopAdapter, resetObservabilityAdapter, trace } from "./observability";
 export { AgentApp, AgentAppConfig, AgentAppProtocol, AgentOS, AgentOSConfig, AgentOSProtocol, DEFAULT_AGENTOS_CONFIG, mergeConfig } from "./os";
 export type { AgentAppOptions, AgentOSOptions } from "./os";
-export { Plan, PlanStep, PlanStorage, PlanningAgent, TaskAgent, TodoItem, TodoList, createPlan, createPlanStorage, createPlanningAgent, createTaskAgent, createTodoList } from "./planning";
-export { SkillManager, createSkillManager, parseSkillFile } from "./skills";
-export { AgentTelemetry, PerformanceMonitor, TelemetryCollector, TelemetryIntegration, cleanupTelemetry, createAgentTelemetry, createConsoleSink, createHTTPSink, createPerformanceMonitor, createTelemetryIntegration, disableTelemetry, enableTelemetry, getTelemetry } from "./telemetry";
+export { // P0: Call Types (new)
+  type MCPCall, // P0: Specialized Agent Configs (new)
+  type AudioConfig, // P0: Specialized Agents (new)
+  CodeAgent, // P1: Workflow Patterns (new)
+  Chunking, // P2: Context Types (new - only items not already exported)
+  ContextManager, // P3: Display callbacks (snake_case for Python parity)
+  register_display_callback, // P3: Plugin functions
+  get_plugin_manager, // P3: Trace & condition functions
+  evaluate_condition, EmbeddingAgent, If, Knowledge, MCP, OCRAgent, Parallel, RealtimeAgent, Route, Session, VideoAgent, VisionAgent, async_display_callbacks, cleanup_telemetry_resources, create_context_agent, disable_performance_mode, disable_telemetry, discover_and_load_plugins, discover_plugins, display_error, display_generating, display_instruction, display_interaction, display_self_reflection, display_tool_call, enable_performance_mode, enable_telemetry, ensure_plugin_dir, error_logs, get_default_plugin_dirs, get_dimensions, get_plugin_template, get_telemetry, handoff_filters, load_plugin, parse_plugin_header, parse_plugin_header_from_file, prompt_with_handoff_instructions, resolve_guardrail_policies, sync_display_callbacks, trace_context, track_workflow, when } from "./parity";
+export { // Core classes
+  Plan, // Python parity additions
+  ApprovalCallback, PlanStep, PlanStorage, PlanningAgent, READ_ONLY_TOOLS, RESEARCH_TOOLS, RESTRICTED_TOOLS, TaskAgent, TodoItem, TodoList, createApprovalCallback, createPlan, createPlanStorage, createPlanningAgent, createTaskAgent, createTodoList } from "./planning";
+export { // Classes
+  Plugin, // Enums
+  PluginHook, // Functions
+  getPluginManager, // Interfaces
+  type PluginMetadata, FunctionPlugin, PluginManager, PluginParseError, PluginType, disablePlugins, discoverAndLoadPlugins, discoverPlugins, enablePlugins, ensurePluginDir, getDefaultPluginDirs, getPluginTemplate, isPluginEnabled, listPlugins, loadPlugin, parsePluginHeader, parsePluginHeaderFromFile } from "./plugins";
+export { // A2A Protocol
+  A2ATaskState, // AGUI Protocol
+  AGUI, // AgentManager alias type
+  type AgentManager, // Global singletons
+  config, // Guardrail policies
+  type GuardrailPolicy, // Tools class
+  type ToolDefinition, A2A, A2ARole, AutoRagAgent, AutoRetrievalPolicy, DEFAULT_AUTO_KEYWORDS, GUARDRAIL_POLICY_PRESETS, Tools, memory, obs, resolveGuardrailPolicies, workflows } from "./protocols";
+export { CitationsMode, DEFAULT_RAG_TEMPLATE, RAG, RAGCitation, RAGContextPack, RetrievalPolicy, RetrievalStrategy, createCitation, createContextPack, createRAG, createRAGConfig, createRAGResult, createRetrievalConfig, createSimpleRetrievalConfig, createSmartRetrievalConfig, formatAnswerWithCitations, formatCitation, formatContextPackForPrompt, hasCitations } from "./rag";
+export { // Python parity additions
+  SkillLoader, SkillManager, createSkillLoader, createSkillManager, createSkillProperties, parseSkillFile } from "./skills";
+export { AgentTask, AgentTaskConfig, BaseTask, createTaskOutput } from "./task";
+export { // Python parity additions
+  MinimalTelemetry, AgentTelemetry, PerformanceMonitor, TelemetryCollector, TelemetryIntegration, cleanupTelemetry, cleanupTelemetryResources, createAgentTelemetry, createConsoleSink, createHTTPSink, createPerformanceMonitor, createTelemetryIntegration, disablePerformanceMode, disableTelemetry, enablePerformanceMode, enableTelemetry, getMinimalTelemetry, getTelemetry } from "./telemetry";
 export { // Subagent Tool (agent-as-tool pattern)
  SubagentTool, BaseTool, FunctionTool, ToolRegistry, ToolResult, ToolValidationError, createDelegator, createSubagentTool, createSubagentTools, createTool, getRegistry, getTool, registerTool, tool, validateTool } from "./tools";
 export { airweaveSearch, bedrockBrowserClick, bedrockBrowserFill, bedrockBrowserNavigate, bedrockCodeInterpreter, codeExecution, codeMode, createCustomTool, exaSearch, firecrawlCrawl, firecrawlScrape, parallelSearch, perplexitySearch, registerCustomTool, registerLocalTool, registerNpmTool, superagentGuard, superagentRedact, superagentVerify, tavilyCrawl, tavilyExtract, tavilySearch, valyuBioSearch, valyuCompanyResearch, valyuEconomicsSearch, valyuFinanceSearch, valyuPaperSearch, valyuPatentSearch, valyuSecSearch, valyuWebSearch } from "./tools/builtins";
 export { MissingDependencyError, MissingEnvVarError, ToolsRegistry, composeMiddleware, createLoggingMiddleware, createRateLimitMiddleware, createRedactionMiddleware, createRetryMiddleware, createTimeoutMiddleware, createToolsRegistry, createTracingMiddleware, createValidationMiddleware, getToolsRegistry, resetToolsRegistry } from "./tools/registry";
 export type { InstallHints, PraisonTool, RedactionHooks, RegisteredTool, ToolCapabilities, ToolExecutionContext, ToolExecutionResult, ToolFactory, ToolHooks, ToolInstallStatus, ToolLimits, ToolLogger, ToolMetadata, ToolMiddleware, ToolParameterProperty, ToolParameterSchema } from "./tools/registry";
 export { registerBuiltinTools, tools } from "./tools/tools";
+export { // Classes
+  TraceSink, // Enums
+  ContextEventType, // Functions
+  createContextEvent, // Types
+  type ContextEvent, ContextListSink, ContextNoOpSink, ContextTraceEmitter, ContextTraceSink, EventType, MessageType, TraceCtx, traceContext, trackWorkflow } from "./trace";
 export { // New: Python-parity Loop and Repeat classes
  Loop, // Task class
  Task, AgentFlow, Pipeline, Repeat, Workflow, loop, loopPattern, parallel, repeat, repeatPattern, route } from "./workflows";
@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
    praisonai_tools \
-    "praisonai>=4.4.4" \
+    "praisonai>=4.5.5" \
    "praisonai[chat]" \
    "embedchain[github,youtube]"

@@ -20,7 +20,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
    praisonai_tools \
-    "praisonai>=4.4.4" \
+    "praisonai>=4.5.5" \
    "praisonai[ui]" \
    "praisonai[chat]" \
    "praisonai[realtime]" \
@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
    praisonai_tools \
-    "praisonai>=4.4.4" \
+    "praisonai>=4.5.5" \
    "praisonai[ui]" \
    "praisonai[crewai]"

@@ -0,0 +1,43 @@
+"""
+Bot Commands Example — Built-in /status, /new, /help commands.
+
+Every PraisonAI bot comes with built-in chat commands:
+  /status — Show agent info + uptime
+  /new    — Reset conversation session
+  /help   — List available commands
+
+Usage:
+    1. Set environment variables:
+        export OPENAI_API_KEY=your_key
+        export TELEGRAM_BOT_TOKEN=your_token
+
+    2. Run:
+        python bot_commands_example.py
+
+    3. Open your Telegram bot and type:
+        /status
+        /help
+        /new
+"""
+
+import asyncio
+from praisonai.bots import TelegramBot
+from praisonaiagents import Agent
+
+# Create an agent
+agent = Agent(
+    name="assistant",
+    instructions="You are a helpful assistant. Answer questions clearly and concisely.",
+    llm="gpt-4o-mini",
+)
+
+# Create Telegram bot — commands are built-in automatically
+bot = TelegramBot(
+    token="YOUR_TELEGRAM_BOT_TOKEN",  # Replace or use os.environ
+    agent=agent,
+)
+
+if __name__ == "__main__":
+    print("Starting Telegram bot with built-in commands...")
+    print("Available commands: /status, /new, /help")
+    asyncio.run(bot.start())
@@ -0,0 +1,37 @@
+"""
+Bot Gateway Example — Run multiple bots from one gateway server.
+
+This example shows how to start a multi-bot gateway that connects
+Telegram, Discord, and Slack bots to different AI agents.
+
+Usage:
+    1. Set environment variables:
+        export OPENAI_API_KEY=your_key
+        export TELEGRAM_BOT_TOKEN=your_token
+
+    2. Run:
+        python bot_gateway_example.py
+"""
+
+import asyncio
+from praisonai.gateway import WebSocketGateway
+from praisonaiagents import Agent
+from praisonaiagents.gateway import GatewayConfig
+
+# Create agents
+personal = Agent(name="personal", instructions="You are a helpful personal assistant")
+support = Agent(name="support", instructions="You are a customer support agent")
+
+# Create gateway
+config = GatewayConfig(host="127.0.0.1", port=8765)
+gateway = WebSocketGateway(config=config)
+
+# Register agents
+gateway.register_agent(personal, agent_id="personal")
+gateway.register_agent(support, agent_id="support")
+
+# Start gateway (WebSocket server + health endpoint)
+if __name__ == "__main__":
+    print("Starting gateway on ws://127.0.0.1:8765")
+    print("Health check: http://127.0.0.1:8765/health")
+    asyncio.run(gateway.start())
@@ -0,0 +1,24 @@
+"""Agent Approval — delegate tool approvals to another AI agent."""
+
+from praisonaiagents import Agent
+from praisonaiagents.approval import AgentApproval
+
+# Create a security reviewer agent
+reviewer = Agent(
+    name="security-reviewer",
+    instructions=(
+        "You are a security reviewer. Only approve low-risk read operations. "
+        "Deny anything destructive like delete, remove, or write operations. "
+        "Respond with exactly one word: APPROVE or DENY"
+    ),
+)
+
+# Create a worker agent that uses the reviewer for approvals
+worker = Agent(
+    name="assistant",
+    instructions="Help users with system tasks",
+    tools=["execute_command"],
+    approval=AgentApproval(approver_agent=reviewer),
+)
+
+worker.start("List the files in the current directory")
@@ -0,0 +1,13 @@
+"""Discord Approval — route tool approvals to a Discord channel."""
+
+from praisonaiagents import Agent
+from praisonai.bots import DiscordApproval
+
+agent = Agent(
+    name="assistant",
+    instructions="Help users with system tasks",
+    tools=["execute_command"],
+    approval=DiscordApproval(channel_id="YOUR_CHANNEL_ID"),  # token from DISCORD_BOT_TOKEN env
+)
+
+agent.start("List the files in the current directory")
@@ -0,0 +1,15 @@
+"""HTTP Approval — serve a local web dashboard for tool approvals."""
+
+from praisonaiagents import Agent
+from praisonai.bots import HTTPApproval
+
+agent = Agent(
+    name="assistant",
+    instructions="Help users with system tasks",
+    tools=["execute_command"],
+    approval=HTTPApproval(host="127.0.0.1", port=8899),
+)
+
+# When a tool needs approval, open http://127.0.0.1:8899/approve/<request_id>
+# in your browser and click Approve or Deny.
+agent.start("List the files in the current directory")
@@ -0,0 +1,13 @@
+"""Slack Approval — route tool approvals to a Slack channel."""
+
+from praisonaiagents import Agent
+from praisonai.bots import SlackApproval
+
+agent = Agent(
+    name="assistant",
+    instructions="Help users with system tasks",
+    tools=["execute_command"],
+    approval=SlackApproval(channel="#approvals"),  # token from SLACK_BOT_TOKEN env
+)
+
+agent.start("List the files in the current directory")
@@ -0,0 +1,13 @@
+"""Telegram Approval — route tool approvals to a Telegram chat."""
+
+from praisonaiagents import Agent
+from praisonai.bots import TelegramApproval
+
+agent = Agent(
+    name="assistant",
+    instructions="Help users with system tasks",
+    tools=["execute_command"],
+    approval=TelegramApproval(chat_id="YOUR_CHAT_ID"),  # token from TELEGRAM_BOT_TOKEN env
+)
+
+agent.start("List the files in the current directory")
@@ -0,0 +1,16 @@
+"""Webhook Approval — route tool approvals to an external HTTP endpoint."""
+
+from praisonaiagents import Agent
+from praisonai.bots import WebhookApproval
+
+agent = Agent(
+    name="assistant",
+    instructions="Help users with system tasks",
+    tools=["execute_command"],
+    approval=WebhookApproval(
+        webhook_url="https://your-app.com/api/approvals",
+        headers={"Authorization": "Bearer YOUR_TOKEN"},
+    ),
+)
+
+agent.start("List the files in the current directory")
@@ -0,0 +1,31 @@
+# Example: Single-bot YAML configuration for PraisonAI
+#
+# Usage:
+#   praisonai bot start --config bot.yaml
+#
+# This is the simplest way to run a bot — no programming needed.
+# Just configure platform, token, and agent settings below.
+
+# Platform: telegram, discord, or slack
+platform: telegram
+
+# Bot token — use ${ENV_VAR} syntax to reference environment variables
+# (requires .env file in the current directory or exported env vars)
+token: "${TELEGRAM_BOT_TOKEN}"
+
+# For Slack only — uncomment and set:
+# app_token: "${SLACK_APP_TOKEN}"
+
+# Agent configuration
+agent:
+  name: "My Assistant"
+  instructions: "You are a helpful AI assistant. Answer questions clearly and concisely."
+  llm: "gpt-4o-mini"
+
+  # Optional capabilities (uncomment to enable):
+  # memory: true
+  # web_search: true
+  # web_search_provider: "duckduckgo"
+  # tools: [search_web, execute_command]
+  # knowledge: true
+  # auto_approve: false
@@ -0,0 +1,57 @@
+# PraisonAI Multi-Bot Gateway Configuration
+# Start with: praisonai gateway start --config gateway.yaml
+
+gateway:
+  host: "127.0.0.1"
+  port: 8765
+
+agents:
+  personal:
+    name: "Personal Assistant"
+    instructions: "You are a friendly personal assistant. Help users with everyday tasks."
+    llm: "gpt-4o-mini"
+
+  support:
+    name: "Support Agent"
+    instructions: "You are a customer support agent. Be professional and helpful."
+    llm: "gpt-4o-mini"
+
+channels:
+  telegram:
+    token: "${TELEGRAM_BOT_TOKEN}"
+    routing:
+      dm: "personal"
+      group: "support"
+      default: "personal"
+
+  discord:
+    token: "${DISCORD_BOT_TOKEN}"
+    routing:
+      dm: "personal"
+      channel: "support"
+      default: "support"
+
+  slack:
+    token: "${SLACK_BOT_TOKEN}"
+    app_token: "${SLACK_APP_TOKEN}"
+    routing:
+      dm: "personal"
+      channel: "support"
+      default: "support"
+
+  whatsapp:
+    token: "${WHATSAPP_ACCESS_TOKEN}"
+    phone_number_id: "${WHATSAPP_PHONE_NUMBER_ID}"
+    verify_token: "${WHATSAPP_VERIFY_TOKEN}"
+    webhook_port: 8080
+    routing:
+      dm: "personal"
+      default: "personal"
+
+  # WhatsApp Web mode (experimental, no tokens needed):
+  # whatsapp:
+  #   mode: web
+  #   creds_dir: "~/.praisonai/whatsapp"
+  #   routing:
+  #     dm: "personal"
+  #     default: "personal"
@@ -0,0 +1,15 @@
+# PraisonAI WhatsApp Bot Configuration (Zero-Code)
+# Start with: praisonai bot start --config whatsapp-bot.yaml
+
+platform: whatsapp
+token: "${WHATSAPP_ACCESS_TOKEN}"
+phone_number_id: "${WHATSAPP_PHONE_NUMBER_ID}"
+verify_token: "${WHATSAPP_VERIFY_TOKEN}"
+webhook_port: 8080
+
+agent:
+  name: "WhatsApp Assistant"
+  instructions: "You are a friendly assistant on WhatsApp. Keep responses concise."
+  llm: "gpt-4o-mini"
+  memory: true
+  web_search: true
@@ -0,0 +1,13 @@
+# WhatsApp Web Mode Bot (Experimental)
+# Token-free: connect via QR code scan
+# ⚠️ Uses reverse-engineered protocol — your number may be banned
+
+platform: whatsapp
+mode: web
+# creds_dir: "~/.praisonai/whatsapp"  # optional, default shown
+
+agent:
+  name: "WhatsApp Web Assistant"
+  instructions: "You are a helpful AI assistant on WhatsApp."
+  llm: "gpt-4o-mini"
+  memory: true
@@ -91,4 +91,6 @@ chroma_db/
 *_COMPARISON_ANALYSIS.md
 *_REPORT.md

-.praisonai
+.praisonai
+.windsurf
+.agent
@@ -111,6 +111,7 @@ Easy and user friendly
 | `bus/` | 48K | Event bus |
 | `streaming/` | 56K | Streaming events, callbacks |
 | `trace/` | 152K | Trace protocols, context events |
+| `scheduler/` | 48K | Schedule models, store, parser, runner |

 ### 3.2 Protocol-First Design

@@ -343,6 +344,56 @@ agent = Agent(
 )
 ```

+### 5.3 Parameter Consolidation
+
+Agent parameters are consolidated into Config objects following the pattern:
+`False=disabled, True=defaults, Config=custom`
+
+**Consolidated Parameters (use these):**
+
+| Config Object | Replaces (Deprecated) |
+|--------------|----------------------|
+| `execution=ExecutionConfig(code_execution=True, code_mode="safe", rate_limiter=obj)` | `allow_code_execution`, `code_execution_mode`, `rate_limiter` |
+| `memory=MemoryConfig(auto_save="session_name")` | `auto_save` |
+| `autonomy=AutonomyConfig(verification_hooks=[...])` | `verification_hooks` |
+| `handoffs=[other_agent]` | `allow_delegation` |
+| `output=OutputConfig(...)` | `verbose`, `markdown`, `stream`, `metrics` |
+| `reflection=ReflectionConfig(...)` | `self_reflect`, `max_reflect`, `min_reflect` |
+| `templates=TemplateConfig(...)` | `system_template`, `prompt_template`, `response_template` |
+| `caching=CachingConfig(...)` | `cache`, `prompt_caching` |
+| `web=WebConfig(...)` | `web_search`, `web_fetch` |
+
+**Deprecated standalone params still work** (backward compatible) but emit `DeprecationWarning`.
+
+```python
+# ❌ Old way (deprecated)
+agent = Agent(
+    name="coder",
+    allow_code_execution=True,
+    code_execution_mode="safe",
+    auto_save="my_session",
+    rate_limiter=my_limiter,
+    allow_delegation=True,
+    verification_hooks=[my_hook],
+)
+
+# ✅ New way (consolidated)
+from praisonaiagents import Agent, ExecutionConfig, MemoryConfig
+from praisonaiagents.agent.autonomy import AutonomyConfig
+
+agent = Agent(
+    name="coder",
+    handoffs=[reviewer_agent],
+    execution=ExecutionConfig(
+        code_execution=True,
+        code_mode="safe",
+        rate_limiter=my_limiter,
+    ),
+    memory=MemoryConfig(auto_save="my_session"),
+    autonomy=AutonomyConfig(verification_hooks=[my_hook]),
+)
+```
+
 ---

 ## 6. Extension Points
@@ -406,7 +457,37 @@ class MyMemoryAdapter:  # Implements MemoryProtocol
        ...
 ```

-### 6.4 Database Adapters
+### 6.4 Schedule Tools
+
+Agent-centric scheduling via standalone `@tool` functions (no Agent class bloat):
+
+```python
+from praisonaiagents import Agent
+from praisonaiagents.tools import schedule_add, schedule_list, schedule_remove
+
+agent = Agent(
+    name="assistant",
+    tools=[schedule_add, schedule_list, schedule_remove],
+)
+```
+
+**Schedule expression formats:**
+- Keywords: `"hourly"`, `"daily"`, `"weekly"`
+- Intervals: `"*/30m"`, `"*/6h"`, `"*/10s"`
+- Cron: `"cron:0 7 * * *"` (requires optional `croniter`)
+- One-shot: `"at:2026-03-01T09:00:00"`
+- Relative: `"in 20 minutes"`
+
+**Core components:**
+- `scheduler/models.py` — `Schedule` and `ScheduleJob` dataclasses
+- `scheduler/store.py` — `FileScheduleStore` (thread-safe JSON persistence at `~/.praisonai/schedules/jobs.json`)
+- `scheduler/parser.py` — `parse_schedule()` for human-friendly expressions
+- `scheduler/runner.py` — `ScheduleRunner` (stateless due-job checker)
+- `tools/schedule_tools.py` — `schedule_add`, `schedule_list`, `schedule_remove`
+
+**Hook events:** `SCHEDULE_ADD`, `SCHEDULE_REMOVE`, `SCHEDULE_TRIGGER` (in `hooks/types.py`)
+
+### 6.5 Database Adapters

 ```python
 # Base files in praisonaiagents/db/
@@ -602,10 +683,153 @@ from praisonaiagents import Workflow, Route, Parallel, Loop
 | Event bus | `praisonaiagents/bus/bus.py` |
 | Workflow engine | `praisonaiagents/workflows/workflows.py` |
 | Policy engine | `praisonaiagents/policy/engine.py` |
+| Scheduler module | `praisonaiagents/scheduler/` |
+| Schedule tools | `praisonaiagents/tools/schedule_tools.py` |

 ---

-## 12. Design Goals
+## 12. BotOS — Multi-Platform Bot Orchestration
+
+### 12.1 Architecture
+
+BotOS is the multi-platform bot orchestration layer for PraisonAI. It follows the same protocol-driven, agent-centric philosophy as the rest of the SDK.
+
+```
+┌──────────────────────────────────────────────────┐
+│                    BotOS                          │
+│   Multi-platform orchestrator (runs all bots)    │
+├──────────┬──────────┬──────────┬─────────────────┤
+│ Bot      │ Bot      │ Bot      │ Bot             │
+│ telegram │ discord  │ slack    │ custom_platform │
+├──────────┴──────────┴──────────┴─────────────────┤
+│       Agent / AgentTeam / AgentFlow              │
+│              (AI brain)                           │
+└──────────────────────────────────────────────────┘
+```
+
+### 12.2 Layer Separation
+
+| Layer | Package | Purpose |
+|-------|---------|---------|
+| `BotOSProtocol` | `praisonaiagents` (Core SDK) | Interface contract — lightweight |
+| `BotOSConfig` | `praisonaiagents` (Core SDK) | Configuration dataclass |
+| `Bot` | `praisonai` (Wrapper) | Single-platform bot wrapper |
+| `BotOS` | `praisonai` (Wrapper) | Multi-platform orchestrator |
+| `_registry` | `praisonai` (Wrapper) | Platform adapter registry |
+
+### 12.3 Usage Patterns
+
+```python
+# === Level 1: Single bot, 3 lines ===
+from praisonai.bots import Bot
+from praisonaiagents import Agent
+
+bot = Bot("telegram", agent=Agent(name="assistant", instructions="Be helpful"))
+bot.run()
+
+# === Level 2: Multi-platform, shared agent ===
+from praisonai.bots import BotOS
+from praisonaiagents import Agent
+
+agent = Agent(name="assistant", instructions="Be helpful")
+botos = BotOS(agent=agent, platforms=["telegram", "discord"])
+botos.run()
+
+# === Level 3: AgentTeam in BotOS ===
+from praisonai.bots import BotOS, Bot
+from praisonaiagents import Agent, AgentTeam, Task
+
+researcher = Agent(name="researcher", instructions="Research topics")
+writer = Agent(name="writer", instructions="Write content")
+t1 = Task(name="research", description="Research AI", agent=researcher)
+t2 = Task(name="write", description="Write about AI", agent=writer)
+team = AgentTeam(agents=[researcher, writer], tasks=[t1, t2])
+
+botos = BotOS(bots=[Bot("telegram", agent=team)])
+botos.run()
+
+# === Level 4: YAML config ===
+botos = BotOS.from_config("botos.yaml")
+botos.run()
+
+# === Level 5: Custom platform extension ===
+from praisonai.bots._registry import register_platform
+
+class MyCustomBot:
+    def __init__(self, **kwargs): ...
+    async def start(self): ...
+    async def stop(self): ...
+
+register_platform("mychat", MyCustomBot)
+bot = Bot("mychat", agent=agent, token="my-token")
+bot.run()
+```
+
+### 12.4 Token Resolution
+
+Tokens are resolved in order: `explicit token=` > env var > empty string.
+
+| Platform | Env Var |
+|----------|---------|
+| Telegram | `TELEGRAM_BOT_TOKEN` |
+| Discord | `DISCORD_BOT_TOKEN` |
+| Slack | `SLACK_BOT_TOKEN` + `SLACK_APP_TOKEN` |
+| WhatsApp | `WHATSAPP_ACCESS_TOKEN` + `WHATSAPP_PHONE_NUMBER_ID` |
+| Custom | `{PLATFORM}_BOT_TOKEN` |
+
+### 12.5 File Locations
+
+| What | Where |
+|------|-------|
+| BotOSProtocol | `praisonaiagents/bots/protocols.py` |
+| BotOSConfig | `praisonaiagents/bots/config.py` |
+| Bot class | `praisonai/bots/bot.py` |
+| BotOS class | `praisonai/bots/botos.py` |
+| Platform registry | `praisonai/bots/_registry.py` |
+| Unit tests | `tests/unit/test_botos_protocol.py` |
+| Integration tests | `tests/unit/test_botos_integration.py` |
+
+### 12.6 Extending Platforms
+
+Third-party platforms can be registered at runtime:
+
+```python
+from praisonai.bots._registry import register_platform, list_platforms
+
+# Register
+register_platform("line", LineBot)
+register_platform("viber", ViberBot)
+
+# Verify
+print(list_platforms())  # [..., "line", "viber", ...]
+
+# Use
+bot = Bot("line", agent=agent, token="my-line-token")
+```
+
+**Adapter contract**: Custom adapters must implement `async start()` and `async stop()`. Optional: `send_message()`, `on_message()`, `on_command()`, `is_running` property.
+
+### 12.7 YAML Config Format
+
+```yaml
+# botos.yaml
+agent:
+  name: assistant
+  instructions: You are a helpful assistant.
+  llm: gpt-4o-mini
+platforms:
+  telegram:
+    token: ${TELEGRAM_BOT_TOKEN}
+  discord:
+    token: ${DISCORD_BOT_TOKEN}
+  slack:
+    token: ${SLACK_BOT_TOKEN}
+    app_token: ${SLACK_APP_TOKEN}
+```
+
+---
+
+## 13. Design Goals

 > Make PraisonAI the **best agent framework in the world**

@@ -0,0 +1,116 @@
+# Documentation Parity Tracker (Python)
+
+> **Categories:** 60 | **Documented:** 57 | **Parity:** 95.0%
+
+This report compares **Python SDK feature categories** against **Python documentation** (docs/concepts, docs/features, etc.).
+
+## Summary
+
+| Metric | Count |
+|--------|-------|
+| Feature Categories | 60 |
+| **Documented Categories** | **57** |
+| **Undocumented Categories** | **3** |
+| **Parity** | **95.0%** |
+
+## Documented Categories
+
+| Category | Features | Docs | Lines |
+|----------|----------|------|-------|
+| ✅ AGUI | 1 | 2 | 420 |
+| ✅ Agent | 19 | 30 | 8367 |
+| ✅ Agent-to-Agent (A2A) | 1 | 3 | 625 |
+| ✅ Approval | 1 | 2 | 889 |
+| ✅ Audio | 2 | 10 | 649 |
+| ✅ Auto Generation | 3 | 6 | 1386 |
+| ✅ Autonomy | 3 | 4 | 1146 |
+| ✅ Bots | 5 | 2 | 573 |
+| ✅ Chunking | 2 | 2 | 285 |
+| ✅ Citations | 2 | 1 | 202 |
+| ✅ Code Execution | 3 | 13 | 3395 |
+| ✅ Conditions | 1 | 3 | 1086 |
+| ✅ Configuration | 2 | 7 | 1753 |
+| ✅ Context Management | 13 | 29 | 7576 |
+| ✅ Database | 1 | 31 | 3037 |
+| ✅ Display | 6 | 2 | 1175 |
+| ✅ Embeddings | 6 | 23 | 1966 |
+| ✅ Evaluation | 1 | 6 | 2538 |
+| ✅ Events | 1 | 2 | 699 |
+| ✅ Execution | 3 | 2 | 515 |
+| ✅ Files | 2 | 5 | 863 |
+| ✅ Flow | 1 | 1 | 284 |
+| ✅ Gateway | 6 | 1 | 256 |
+| ✅ Guardrails | 4 | 4 | 2279 |
+| ✅ Handoffs | 10 | 4 | 1674 |
+| ✅ Hooks | 2 | 6 | 1606 |
+| ✅ Image | 1 | 11 | 1096 |
+| ✅ Knowledge | 3 | 12 | 3262 |
+| ✅ LLM | 2 | 2 | 1049 |
+| ✅ Loops | 4 | 1 | 250 |
+| ✅ MCP | 2 | 47 | 9754 |
+| ✅ Memory | 6 | 12 | 4474 |
+| ✅ Output | 3 | 4 | 868 |
+| ✅ Parallel Execution | 2 | 2 | 347 |
+| ✅ Planning | 6 | 5 | 1506 |
+| ✅ Plugins | 8 | 3 | 1494 |
+| ✅ Prompts | 2 | 4 | 796 |
+| ✅ Providers | 2 | 50 | 5396 |
+| ✅ Query | 1 | 2 | 616 |
+| ✅ RAG | 5 | 14 | 2910 |
+| ✅ Realtime | 2 | 5 | 584 |
+| ✅ Reflection | 3 | 2 | 469 |
+| ✅ Retrieval | 2 | 5 | 941 |
+| ✅ Routing | 1 | 2 | 597 |
+| ✅ Sandbox | 5 | 3 | 1002 |
+| ✅ Security | 1 | 1 | 875 |
+| ✅ Sessions | 2 | 8 | 2128 |
+| ✅ Skills | 5 | 5 | 2002 |
+| ✅ Tasks | 2 | 5 | 2590 |
+| ✅ Telemetry | 1 | 2 | 541 |
+| ✅ Templates | 1 | 7 | 1411 |
+| ✅ Tools | 4 | 97 | 17827 |
+| ✅ Tracing | 3 | 2 | 139 |
+| ✅ Video | 2 | 5 | 460 |
+| ✅ Vision | 2 | 1 | 283 |
+| ✅ Web | 4 | 6 | 1267 |
+| ✅ Workflows | 4 | 9 | 3579 |
+
+## Stub Documentation (Need Content)
+
+These categories have documentation files but < 50 lines (stubs):
+
+| Category | Features | Docs | Lines |
+|----------|----------|------|-------|
+| ⚠️ OCR | 2 | 1 | 49 |
+
+## Undocumented Categories (Need Documentation)
+
+| Category | Features |
+|----------|----------|
+| ❌ Failover | 2 |
+| ❌ Optimizer | 1 |
+
+## Documentation Without Features
+
+These docs exist but don't match any implemented feature category:
+
+- ℹ️ AI SDK (1 docs, 112 lines)
+- ℹ️ Agent-to-User (A2U) (3 docs, 770 lines)
+- ℹ️ CLI (91 docs, 21386 lines)
+- ℹ️ Callbacks (1 docs, 985 lines)
+- ℹ️ Chat (3 docs, 546 lines)
+- ℹ️ Deep Research (2 docs, 437 lines)
+- ℹ️ Deployment (29 docs, 5931 lines)
+- ℹ️ Jobs (1 docs, 358 lines)
+- ℹ️ Middleware (1 docs, 60 lines)
+- ℹ️ Observability (21 docs, 1580 lines)
+- ℹ️ Process (1 docs, 506 lines)
+- ℹ️ Scheduler (2 docs, 858 lines)
+- ℹ️ Storage (4 docs, 722 lines)
+- ℹ️ Streaming (3 docs, 485 lines)
+- ℹ️ Token Management (3 docs, 1020 lines)
+- ℹ️ Vector Store (11 docs, 733 lines)
+
+---
+
+*Generated by `praisonai._dev.parity.docs_generator`*
@@ -193,6 +193,10 @@ _LAZY_IMPORTS = {
    'GuardrailResult': ('praisonaiagents.guardrails', 'GuardrailResult'),
    'LLMGuardrail': ('praisonaiagents.guardrails', 'LLMGuardrail'),
    
+    # Approval (agent-centric approval backends)
+    'AutoApproveBackend': ('praisonaiagents.approval.backends', 'AutoApproveBackend'),
+    'ConsoleBackend': ('praisonaiagents.approval.backends', 'ConsoleBackend'),
+    
    # Flow display
    'FlowDisplay': ('praisonaiagents.flow_display', 'FlowDisplay'),
    'track_workflow': ('praisonaiagents.flow_display', 'track_workflow'),
@@ -333,7 +337,7 @@ _LAZY_IMPORTS = {
    'CachingConfig': ('praisonaiagents.config.feature_configs', 'CachingConfig'),
    'HooksConfig': ('praisonaiagents.config.feature_configs', 'HooksConfig'),
    'SkillsConfig': ('praisonaiagents.config.feature_configs', 'SkillsConfig'),
-    'AutonomyConfig': ('praisonaiagents.config.feature_configs', 'AutonomyConfig'),
+    'AutonomyConfig': ('praisonaiagents.agent.autonomy', 'AutonomyConfig'),
    'MemoryBackend': ('praisonaiagents.config.feature_configs', 'MemoryBackend'),
    'ChunkingStrategy': ('praisonaiagents.config.feature_configs', 'ChunkingStrategy'),
    'GuardrailAction': ('praisonaiagents.config.feature_configs', 'GuardrailAction'),
@@ -416,6 +420,8 @@ _LAZY_IMPORTS = {
    'BotChannel': ('praisonaiagents.bots.protocols', 'BotChannel'),
    'MessageType': ('praisonaiagents.bots.protocols', 'MessageType'),
    'BotConfig': ('praisonaiagents.bots.config', 'BotConfig'),
+    'BotOSProtocol': ('praisonaiagents.bots.protocols', 'BotOSProtocol'),
+    'BotOSConfig': ('praisonaiagents.bots.config', 'BotOSConfig'),
    
    # Sandbox protocols and config (implementations in praisonai wrapper)
    'SandboxProtocol': ('praisonaiagents.sandbox.protocols', 'SandboxProtocol'),
@@ -646,6 +652,9 @@ __all__ = [
    'tool',
    'Tools',
    
+    # Approval (agent-centric approval backends)
+    'AutoApproveBackend',
+    
    # Embedding API - simplified imports
    # Usage: from praisonaiagents import embedding, EmbeddingResult
    'embedding',
@@ -655,6 +664,10 @@ __all__ = [
    'EmbeddingResult',
    'get_dimensions',
    
+    # Autonomy
+    'AutonomyConfig',
+    'AutonomyLevel',
+    
    # Sub-packages for organized imports
    # Usage: import praisonaiagents as pa; pa.config.MemoryConfig
    'config',
@@ -411,13 +411,13 @@ class Agent:
        api_key: Optional[str] = None,  # Kept separate (connection/auth)
        # Tools
        tools: Optional[List[Any]] = None,
-        allow_delegation: bool = False,
-        allow_code_execution: Optional[bool] = False,
-        code_execution_mode: Literal["safe", "unsafe"] = "safe",
+        allow_delegation: bool = False,  # Deprecated: use handoffs= instead
+        allow_code_execution: Optional[bool] = False,  # Deprecated: use execution=ExecutionConfig(code_execution=True)
+        code_execution_mode: Literal["safe", "unsafe"] = "safe",  # Deprecated: use execution=ExecutionConfig(code_mode="safe")
        handoffs: Optional[List[Union['Agent', 'Handoff']]] = None,
-        # Session management
-        auto_save: Optional[str] = None,
-        rate_limiter: Optional[Any] = None,
+        # Session management (deprecated standalone params - use config objects)
+        auto_save: Optional[str] = None,  # Deprecated: use memory=MemoryConfig(auto_save="name")
+        rate_limiter: Optional[Any] = None,  # Deprecated: use execution=ExecutionConfig(rate_limiter=obj)
        # ============================================================
        # CONSOLIDATED FEATURE PARAMS (agent-centric API)
        # Each follows: False=disabled, True=defaults, Config=custom
@@ -430,13 +430,14 @@ class Agent:
        web: Optional[Union[bool, Any]] = None,  # Union[bool, WebConfig]
        context: Optional[Union[bool, Any]] = None,  # Union[bool, ManagerConfig, ContextManager] - None=smart default
        autonomy: Optional[Union[bool, Dict[str, Any], Any]] = None,  # Union[bool, dict, AutonomyConfig]
-        verification_hooks: Optional[List[Any]] = None,  # List of VerificationHook instances
+        verification_hooks: Optional[List[Any]] = None,  # Deprecated: use autonomy=AutonomyConfig(verification_hooks=[...])
        output: Optional[Union[str, Any]] = None,  # Union[str preset, OutputConfig]
        execution: Optional[Union[str, Any]] = None,  # Union[str preset, ExecutionConfig]
        templates: Optional[Any] = None,  # TemplateConfig
        caching: Optional[Union[bool, Any]] = None,  # Union[bool, CachingConfig]
        hooks: Optional[Union[List[Any], Any]] = None,  # Union[list, HooksConfig]
        skills: Optional[Union[List[str], Any]] = None,  # Union[list, SkillsConfig]
+        approval: Optional[Union[bool, Any]] = None,  # Union[bool, ApprovalProtocol backend]
    ):
        """Initialize an Agent instance.

@@ -452,12 +453,12 @@ class Agent:
            base_url: Custom LLM endpoint URL (e.g., for Ollama). Kept separate for auth.
            api_key: API key for LLM provider. Kept separate for auth.
            tools: List of tools, functions, callables, or MCP instances.
-            allow_delegation: Allow task delegation to other agents. Defaults to False.
-            allow_code_execution: Enable code execution during tasks. Defaults to False.
-            code_execution_mode: "safe" (restricted) or "unsafe" (full access). Defaults to "safe".
+            allow_delegation: **Deprecated** — use ``handoffs=`` instead.
+            allow_code_execution: **Deprecated** — use ``execution=ExecutionConfig(code_execution=True)``.
+            code_execution_mode: **Deprecated** — use ``execution=ExecutionConfig(code_mode="safe")``.
            handoffs: List of Agent or Handoff objects for agent-to-agent collaboration.
-            auto_save: Session name for automatic session saving.
-            rate_limiter: Rate limiter instance for API call throttling.
+            auto_save: **Deprecated** — use ``memory=MemoryConfig(auto_save="name")``.
+            rate_limiter: **Deprecated** — use ``execution=ExecutionConfig(rate_limiter=obj)``.
            memory: Memory system configuration. Accepts:
                - bool: True enables defaults, False disables
                - MemoryConfig: Custom configuration
@@ -486,7 +487,8 @@ class Agent:
                - bool: True enables with defaults
                - Dict: Configuration dict
                - AutonomyConfig: Custom configuration
-            verification_hooks: List of VerificationHook instances for output verification.
+            verification_hooks: **Deprecated** — use ``autonomy=AutonomyConfig(verification_hooks=[...])``.
+                Still works for backward compatibility.
            output: Output configuration. Accepts:
                - str: Preset name ("silent", "actions", "verbose", "json", "stream")
                - OutputConfig: Custom configuration
@@ -520,6 +522,11 @@ class Agent:
            - system_template, prompt_template, response_template → templates=
            - cache, prompt_caching → caching=
            - web_search, web_fetch → web=
+            - allow_delegation → handoffs=
+            - allow_code_execution, code_execution_mode → execution=
+            - auto_save → memory=MemoryConfig(auto_save=)
+            - rate_limiter → execution=ExecutionConfig(rate_limiter=)
+            - verification_hooks → autonomy=AutonomyConfig(verification_hooks=)
        """
        # Add check at start if memory is requested
        if memory is not None:
@@ -584,6 +591,48 @@ class Agent:
            # AutonomyConfig is in agent/autonomy.py - use dict for config defaults
            autonomy = apply_config_defaults("autonomy", autonomy, None)

+        # ============================================================
+        # DEPRECATION WARNINGS for params consolidated into configs
+        # Old params still work but emit warnings pointing to new API
+        # ============================================================
+        import warnings as _warnings
+        
+        if allow_delegation:
+            _warnings.warn(
+                "Parameter 'allow_delegation' is deprecated. Use 'handoffs=[other_agent]' instead.",
+                DeprecationWarning, stacklevel=2,
+            )
+        if allow_code_execution:
+            _warnings.warn(
+                "Parameter 'allow_code_execution' is deprecated. "
+                "Use 'execution=ExecutionConfig(code_execution=True)' instead.",
+                DeprecationWarning, stacklevel=2,
+            )
+        if code_execution_mode != "safe":
+            _warnings.warn(
+                "Parameter 'code_execution_mode' is deprecated. "
+                "Use 'execution=ExecutionConfig(code_mode=\"unsafe\")' instead.",
+                DeprecationWarning, stacklevel=2,
+            )
+        if auto_save is not None:
+            _warnings.warn(
+                "Parameter 'auto_save' is deprecated. "
+                "Use 'memory=MemoryConfig(auto_save=\"name\")' instead.",
+                DeprecationWarning, stacklevel=2,
+            )
+        if rate_limiter is not None:
+            _warnings.warn(
+                "Parameter 'rate_limiter' is deprecated. "
+                "Use 'execution=ExecutionConfig(rate_limiter=obj)' instead.",
+                DeprecationWarning, stacklevel=2,
+            )
+        if verification_hooks is not None:
+            _warnings.warn(
+                "Parameter 'verification_hooks' is deprecated. "
+                "Use 'autonomy=AutonomyConfig(verification_hooks=[...])' instead.",
+                DeprecationWarning, stacklevel=2,
+            )
+
        # ============================================================
        # CONSOLIDATED PARAMS EXTRACTION (agent-centric API)
        # Uses unified resolver: Instance > Config > Array > String > Bool > Default
@@ -730,6 +779,13 @@ class Agent:
            max_rpm = _exec_config.max_rpm
            max_execution_time = _exec_config.max_execution_time
            max_retry_limit = _exec_config.max_retry_limit
+            # Extract consolidated fields (config takes precedence over deprecated standalone params)
+            if _exec_config.rate_limiter is not None:
+                rate_limiter = _exec_config.rate_limiter
+            if _exec_config.code_execution:
+                allow_code_execution = True
+            if _exec_config.code_mode != "safe":
+                code_execution_mode = _exec_config.code_mode
        else:
            max_iter, max_rpm, max_execution_time, max_retry_limit = 20, None, None, 2
        
@@ -879,6 +935,9 @@ class Agent:
                db = _memory_config.db
                auto_memory = _memory_config.auto_memory
                claude_memory = _memory_config.claude_memory
+                # Extract auto_save from MemoryConfig (takes precedence over standalone param)
+                if _memory_config.auto_save is not None:
+                    auto_save = _memory_config.auto_save
                # Convert to internal format
                backend = _memory_config.backend
                if hasattr(backend, 'value'):
@@ -911,11 +970,24 @@ class Agent:
            if _memory_config.history:
                _history_enabled = True
                _history_limit = _memory_config.history_limit
+                # Use explicit session_id from MemoryConfig if provided
+                if _memory_config.session_id:
+                    _history_session_id = _memory_config.session_id
        
        # Use auto_save session if no explicit session and history is enabled
        if _history_enabled and _history_session_id is None and auto_save:
            _history_session_id = auto_save
        
+        # Auto-generate session_id when history=True but no session_id set
+        # This ensures _init_session_store() can create the store
+        if _history_enabled and session_id is None and _history_session_id is not None:
+            session_id = _history_session_id
+        elif _history_enabled and session_id is None and _history_session_id is None:
+            import hashlib as _hl
+            _agent_hash = _hl.md5(name.encode()).hexdigest()[:8]
+            session_id = f"history_{_agent_hash}"
+            _history_session_id = session_id
+        
        # ─────────────────────────────────────────────────────────────────────
        # Resolve KNOWLEDGE param - FAST PATH
        # ─────────────────────────────────────────────────────────────────────
@@ -1357,6 +1429,16 @@ Your Goal: {self.goal}
        self._guardrail_fn = None
        self._setup_guardrail()
        
+        # Initialize approval backend (agent-centric approval)
+        # True = AutoApproveBackend, False/None = registry fallback, object = custom backend
+        if approval is True:
+            from ..approval.backends import AutoApproveBackend
+            self._approval_backend = AutoApproveBackend()
+        elif approval is False or approval is None:
+            self._approval_backend = None
+        else:
+            self._approval_backend = approval
+        
        # Cache for system prompts and formatted tools with lazy thread-safe lock
        self._system_prompt_cache = {}
        self._formatted_tools_cache = {}
@@ -1820,21 +1902,17 @@ Summary:"""
        from .autonomy import AutonomyConfig, AutonomyTrigger, DoomLoopTracker
        
        if autonomy is True:
-            self.autonomy_config = {}
            config = AutonomyConfig()
        elif isinstance(autonomy, dict):
-            self.autonomy_config = autonomy.copy()
            config = AutonomyConfig.from_dict(autonomy)
            # Extract verification_hooks from dict if provided
            if "verification_hooks" in autonomy and not verification_hooks:
                self._verification_hooks = autonomy.get("verification_hooks", [])
        elif isinstance(autonomy, AutonomyConfig):
-            self.autonomy_config = {
-                "max_iterations": autonomy.max_iterations,
-                "doom_loop_threshold": autonomy.doom_loop_threshold,
-                "auto_escalate": autonomy.auto_escalate,
-            }
            config = autonomy
+            # Extract verification_hooks from AutonomyConfig if provided
+            if autonomy.verification_hooks and not verification_hooks:
+                self._verification_hooks = autonomy.verification_hooks
        else:
            self.autonomy_enabled = False
            self.autonomy_config = {}
@@ -1842,8 +1920,31 @@ Summary:"""
            self._doom_loop_tracker = None
            return
        
+        # Preserve ALL AutonomyConfig fields in the dict (G14 fix: no lossy extraction)
+        self.autonomy_config = {
+            "enabled": config.enabled,
+            "level": config.level,
+            "max_iterations": config.max_iterations,
+            "doom_loop_threshold": config.doom_loop_threshold,
+            "auto_escalate": config.auto_escalate,
+            "observe": config.observe,
+            "completion_promise": config.completion_promise,
+            "clear_context": config.clear_context,
+        }
+        # Also preserve any extra user-provided keys from dict input
+        if isinstance(autonomy, dict):
+            for k, v in autonomy.items():
+                if k not in self.autonomy_config:
+                    self.autonomy_config[k] = v
+        
+        # Store the AutonomyConfig object for typed access
+        self._autonomy_config_obj = config
+        
        self._autonomy_trigger = AutonomyTrigger()
        self._doom_loop_tracker = DoomLoopTracker(threshold=config.doom_loop_threshold)
+        
+        # Wire level → approval bridge (G3 fix)
+        self._bridge_autonomy_level(config.level)
    
    def analyze_prompt(self, prompt: str) -> set:
        """Analyze prompt for autonomy signals.
@@ -1901,6 +2002,22 @@ Summary:"""
        if self._doom_loop_tracker is not None:
            self._doom_loop_tracker.reset()
    
+    def _bridge_autonomy_level(self, level: str) -> None:
+        """Bridge autonomy level to approval system (G3 fix).
+        
+        When level is 'full_auto', sets PRAISONAI_AUTO_APPROVE env var
+        so the SDK approval registry auto-approves tool calls.
+        
+        Args:
+            level: Autonomy level string (suggest, auto_edit, full_auto)
+        """
+        import os
+        if level == "full_auto":
+            os.environ["PRAISONAI_AUTO_APPROVE"] = "true"
+        else:
+            # Don't remove if already set by CLI or user
+            pass
+    
    def run_autonomous(
        self,
        prompt: str,
@@ -2027,13 +2144,39 @@ Summary:"""
                        started_at=started_at,
                    )
                
-                # Record the action
+                response_str = str(response)
+                
+                # Record the action for doom loop tracking (G1 fix: was missing)
+                self._record_action(
+                    "chat", {"prompt": prompt}, response_str[:200], True
+                )
+                
+                # Record for action history
                actions_taken.append({
                    "iteration": iterations,
-                    "response": str(response)[:500],
+                    "response": response_str[:500],
                })
                
-                response_str = str(response)
+                # Observability logging (G10 fix: wire observe field)
+                if self.autonomy_config.get("observe"):
+                    logging.getLogger(__name__).info(
+                        f"[autonomy] iteration={iterations} stage={stage} "
+                        f"response_len={len(response_str)}"
+                    )
+                
+                # Auto-save session after each iteration (memory integration)
+                self._auto_save_session()
+                
+                # Auto-escalate stage if stuck (G11 fix: wire auto_escalate)
+                if (self.autonomy_config.get("auto_escalate")
+                        and iterations > 1
+                        and stage in ("direct", "heuristic")):
+                    stage_order = ["direct", "heuristic", "planned", "autonomous"]
+                    idx = stage_order.index(stage) if stage in stage_order else 0
+                    if idx < len(stage_order) - 1:
+                        stage = stage_order[idx + 1]
+                        if self.autonomy_config.get("observe"):
+                            logging.getLogger(__name__).info(f"[autonomy] auto-escalated to stage={stage}")
                
                # Check for completion promise FIRST (structured signal)
                if effective_promise:
@@ -2243,13 +2386,37 @@ Summary:"""
                        started_at=started_at,
                    )
                
-                # Record the action
+                response_str = str(response)
+                
+                # Record the action for doom loop tracking (G2 fix: was missing)
+                self._record_action(
+                    "chat", {"prompt": prompt}, response_str[:200], True
+                )
+                
+                # Record for action history
                actions_taken.append({
                    "iteration": iterations,
-                    "response": str(response)[:500],
+                    "response": response_str[:500],
                })
                
-                response_str = str(response)
+                # Observability logging (G10 fix: wire observe field)
+                if self.autonomy_config.get("observe"):
+                    logging.getLogger(__name__).info(
+                        f"[autonomy-async] iteration={iterations} stage={stage} "
+                        f"response_len={len(response_str)}"
+                    )
+                
+                # Auto-save session after each async iteration (memory integration)
+                self._auto_save_session()
+                
+                # Auto-escalate stage if stuck (G11 fix: wire auto_escalate)
+                if (self.autonomy_config.get("auto_escalate")
+                        and iterations > 1
+                        and stage in ("direct", "heuristic")):
+                    stage_order = ["direct", "heuristic", "planned", "autonomous"]
+                    idx = stage_order.index(stage) if stage in stage_order else 0
+                    if idx < len(stage_order) - 1:
+                        stage = stage_order[idx + 1]
                
                # Check for completion promise FIRST (structured signal)
                if effective_promise:
@@ -2305,6 +2472,9 @@ Summary:"""
                # Yield control to allow other async tasks to run
                await asyncio.sleep(0)
            
+            # Final auto-save before returning
+            self._auto_save_session()
+            
            # Max iterations reached
            return AutonomyResult(
                success=False,
@@ -2746,7 +2916,7 @@ Summary:"""
                user_id=mem_user_id,
                verbose=1 if getattr(self, 'verbose', False) else 0
            )
-        elif isinstance(memory, str) and memory in ("sqlite", "chromadb", "mem0", "mongodb"):
+        elif isinstance(memory, str) and memory in ("sqlite", "chromadb", "mem0", "mongodb", "redis", "postgres"):
            # Use full Memory class with specific provider
            try:
                from ..memory.memory import Memory
@@ -2784,6 +2954,11 @@ Summary:"""
                    logging.warning("Full Memory class requires additional dependencies. Falling back to FileMemory.")
                    from ..memory.file_memory import FileMemory
                    self._memory_instance = FileMemory(user_id=mem_user_id)
+        elif isinstance(memory, str):
+            # Unknown string backend - fall back to FileMemory with warning
+            logging.warning(f"Unknown memory backend '{memory}'. Falling back to FileMemory.")
+            from ..memory.file_memory import FileMemory
+            self._memory_instance = FileMemory(user_id=mem_user_id)
        else:
            # Assume it's already a memory instance
            self._memory_instance = memory
@@ -3974,6 +4149,12 @@ Your Goal: {self.goal}"""
            execution_time_ms=(time.time() - start_time) * 1000
        )
        self._hook_runner.execute_sync(HookEvent.AFTER_AGENT, after_agent_input)
+        
+        # Auto-memory extraction (opt-in via MemoryConfig(auto_memory=True))
+        if response:
+            prompt_str = prompt if isinstance(prompt, str) else str(prompt)
+            self._process_auto_memory(prompt_str, str(response))
+        
        return response

    
@@ -4041,39 +4222,46 @@ Your Goal: {self.goal}"""
    def _execute_tool_impl(self, function_name, arguments):
        """Internal tool execution implementation."""

-        # Check if approval is required for this tool
-        from ..approval import is_approval_required, console_approval_callback, get_risk_level, mark_approved, get_approval_callback, is_env_auto_approve, is_yaml_approved
-        if is_approval_required(function_name):
-            # Skip approval if auto-approve env var is set or tool is YAML-approved
-            if is_env_auto_approve() or is_yaml_approved(function_name):
-                logging.debug(f"Tool {function_name} auto-approved (env={is_env_auto_approve()}, yaml={is_yaml_approved(function_name)})")
-                mark_approved(function_name)
+        # Check if approval is required for this tool (protocol-driven)
+        # Priority: self._approval_backend (agent param) > registry (global/per-agent)
+        from ..approval import get_approval_registry
+        try:
+            backend = getattr(self, '_approval_backend', None)
+            if backend is not None:
+                # Agent-level approval backend — bypass registry, call directly
+                from ..approval.protocols import ApprovalRequest
+                from ..approval.registry import DEFAULT_DANGEROUS_TOOLS
+                if function_name in DEFAULT_DANGEROUS_TOOLS:
+                    request = ApprovalRequest(
+                        tool_name=function_name,
+                        arguments=arguments,
+                        risk_level=DEFAULT_DANGEROUS_TOOLS.get(function_name, "medium"),
+                        agent_name=getattr(self, 'name', None),
+                    )
+                    if hasattr(backend, 'request_approval_sync'):
+                        decision = backend.request_approval_sync(request)
+                    else:
+                        import asyncio
+                        decision = asyncio.run(backend.request_approval(request))
+                else:
+                    from ..approval.protocols import ApprovalDecision
+                    decision = ApprovalDecision(approved=True, reason="No approval required")
            else:
-                risk_level = get_risk_level(function_name)
-                logging.debug(f"Tool {function_name} requires approval (risk level: {risk_level})")
-                
-                # Use global approval callback or default console callback
-                callback = get_approval_callback() or console_approval_callback
-                
-                try:
-                    decision = callback(function_name, arguments, risk_level)
-                    if not decision.approved:
-                        error_msg = f"Tool execution denied: {decision.reason}"
-                        logging.warning(error_msg)
-                        return {"error": error_msg, "approval_denied": True}
-                    
-                    # Mark as approved in context to prevent double approval in decorator
-                    mark_approved(function_name)
-                    
-                    # Use modified arguments if provided
-                    if decision.modified_args:
-                        arguments = decision.modified_args
-                        logging.info(f"Using modified arguments: {arguments}")
-                        
-                except Exception as e:
-                    error_msg = f"Error during approval process: {str(e)}"
-                    logging.error(error_msg)
-                    return {"error": error_msg, "approval_error": True}
+                # Fallback to global registry
+                decision = get_approval_registry().approve_sync(
+                    getattr(self, 'name', None), function_name, arguments,
+                )
+            if not decision.approved:
+                error_msg = f"Tool execution denied: {decision.reason}"
+                logging.warning(error_msg)
+                return {"error": error_msg, "approval_denied": True}
+            if decision.modified_args:
+                arguments = decision.modified_args
+                logging.info(f"Using modified arguments: {arguments}")
+        except Exception as e:
+            error_msg = f"Error during approval process: {str(e)}"
+            logging.error(error_msg)
+            return {"error": error_msg, "approval_error": True}

        # Special handling for MCP tools
        # Check if tools is an MCP instance with the requested function name
@@ -6416,6 +6604,36 @@ Write the complete compiled report:"""
        """
        pass
    
+    def _process_auto_memory(self, user_message: str, assistant_response: str):
+        """Process auto-memory extraction after agent response.
+        
+        Called after each agent response when auto_memory=True in MemoryConfig.
+        Uses AutoMemory to extract and store memorable content (names, preferences,
+        facts) from the conversation. No-op when auto_memory is disabled.
+        
+        Args:
+            user_message: The user's input message
+            assistant_response: The agent's response
+        """
+        if not self._auto_memory or not self._memory_instance:
+            return
+        
+        try:
+            from ..memory.auto_memory import AutoMemory
+            # Lazy-create AutoMemory wrapper on first use
+            if not hasattr(self, '_auto_memory_instance') or self._auto_memory_instance is None:
+                self._auto_memory_instance = AutoMemory(
+                    self._memory_instance,
+                    enabled=True,
+                    verbose=1 if getattr(self, 'verbose', False) else 0
+                )
+            self._auto_memory_instance.process_interaction(
+                user_message=str(user_message),
+                assistant_response=str(assistant_response),
+            )
+        except Exception as e:
+            logging.debug(f"Auto-memory extraction failed: {e}")
+
    def _auto_save_session(self):
        """Auto-save session if auto_save is enabled."""
        if not self.auto_save or not self._memory_instance:
@@ -6765,24 +6983,40 @@ Write the complete compiled report:"""
        try:
            logging.info(f"Executing async tool: {function_name} with arguments: {arguments}")
            
-            # Check if approval is required for this tool
-            from ..approval import is_approval_required, request_approval, is_env_auto_approve, is_yaml_approved, mark_approved
-            if is_approval_required(function_name):
-                # Skip approval if auto-approve env var is set or tool is YAML-approved
-                if is_env_auto_approve() or is_yaml_approved(function_name):
-                    logging.debug(f"Tool {function_name} auto-approved (env={is_env_auto_approve()}, yaml={is_yaml_approved(function_name)})")
-                    mark_approved(function_name)
+            # Check if approval is required for this tool (protocol-driven)
+            # Priority: self._approval_backend (agent param) > registry (global/per-agent)
+            from ..approval import get_approval_registry
+            try:
+                backend = getattr(self, '_approval_backend', None)
+                if backend is not None:
+                    from ..approval.protocols import ApprovalRequest
+                    from ..approval.registry import DEFAULT_DANGEROUS_TOOLS
+                    if function_name in DEFAULT_DANGEROUS_TOOLS:
+                        request = ApprovalRequest(
+                            tool_name=function_name,
+                            arguments=arguments,
+                            risk_level=DEFAULT_DANGEROUS_TOOLS.get(function_name, "medium"),
+                            agent_name=getattr(self, 'name', None),
+                        )
+                        decision = await backend.request_approval(request)
+                    else:
+                        from ..approval.protocols import ApprovalDecision
+                        decision = ApprovalDecision(approved=True, reason="No approval required")
                else:
-                    decision = await request_approval(function_name, arguments)
-                    if not decision.approved:
-                        error_msg = f"Tool execution denied: {decision.reason}"
-                        logging.warning(error_msg)
-                        return {"error": error_msg, "approval_denied": True}
-                    
-                    # Use modified arguments if provided
-                    if decision.modified_args:
-                        arguments = decision.modified_args
-                        logging.info(f"Using modified arguments: {arguments}")
+                    decision = await get_approval_registry().approve_async(
+                        getattr(self, 'name', None), function_name, arguments,
+                    )
+                if not decision.approved:
+                    error_msg = f"Tool execution denied: {decision.reason}"
+                    logging.warning(error_msg)
+                    return {"error": error_msg, "approval_denied": True}
+                if decision.modified_args:
+                    arguments = decision.modified_args
+                    logging.info(f"Using modified arguments: {arguments}")
+            except Exception as e:
+                error_msg = f"Error during approval process: {str(e)}"
+                logging.error(error_msg)
+                return {"error": error_msg, "approval_error": True}
            
            # Try to find the function in the agent's tools list first
            func = None
@@ -29,7 +29,6 @@ Usage:
 from dataclasses import dataclass, field
 from typing import Optional, Dict, Any, List, Set, Callable, Protocol, runtime_checkable
 from enum import Enum
-import time
 import logging

 logger = logging.getLogger(__name__)
@@ -55,26 +54,31 @@ class AutonomyConfig:
        observe: Whether to emit observability events
        completion_promise: Optional string that signals completion when wrapped in <promise>TEXT</promise>
        clear_context: Whether to clear chat history between iterations
+        verification_hooks: List of VerificationHook instances for output verification
    """
    enabled: bool = True
+    level: str = "suggest"
    max_iterations: int = 20
    doom_loop_threshold: int = 3
    auto_escalate: bool = True
    observe: bool = False
    completion_promise: Optional[str] = None
    clear_context: bool = False
+    verification_hooks: Optional[List[Any]] = None
    
    @classmethod
    def from_dict(cls, data: Dict[str, Any]) -> "AutonomyConfig":
        """Create config from dictionary."""
        return cls(
            enabled=data.get("enabled", True),
+            level=data.get("level", "suggest"),
            max_iterations=data.get("max_iterations", 20),
            doom_loop_threshold=data.get("doom_loop_threshold", 3),
            auto_escalate=data.get("auto_escalate", True),
            observe=data.get("observe", False),
            completion_promise=data.get("completion_promise"),
            clear_context=data.get("clear_context", False),
+            verification_hooks=data.get("verification_hooks"),
        )


@@ -288,394 +292,18 @@ class DoomLoopTracker:


 class AutonomyMixin:
-    """Mixin class that adds autonomy capabilities to Agent.
+    """Helper-only trait for autonomy utilities.
    
-    This mixin provides:
-    - Signal detection from prompts
-    - Stage recommendation
-    - Doom loop detection
-    - Observability hooks
+    This module provides reusable helper classes (AutonomyConfig, AutonomyTrigger,
+    DoomLoopTracker, AutonomyResult, etc.) that the Agent class uses.
+    
+    The Agent class is the SINGLE OWNER of all autonomy methods:
+    - _init_autonomy()
+    - run_autonomous() / run_autonomous_async()
+    - analyze_prompt() / get_recommended_stage()
+    - _record_action() / _is_doom_loop() / _reset_doom_loop()
+    
+    This class is intentionally empty — kept only for backward compatibility
+    in case external code references it.
    """
-    
-    def _init_autonomy(self, autonomy: Any, verification_hooks: Optional[List[Any]] = None) -> None:
-        """Initialize autonomy features.
-        
-        Args:
-            autonomy: True, False, dict config, or AutonomyConfig
-            verification_hooks: Optional list of verification hooks
-        """
-        # Initialize verification hooks (always available, even without autonomy)
-        self._verification_hooks = verification_hooks or []
-        
-        if autonomy is None or autonomy is False:
-            self.autonomy_enabled = False
-            self.autonomy_config = {}
-            self._autonomy_trigger = None
-            self._doom_loop_tracker = None
-            return
-        
-        self.autonomy_enabled = True
-        
-        if autonomy is True:
-            self.autonomy_config = {}
-            config = AutonomyConfig()
-        elif isinstance(autonomy, dict):
-            self.autonomy_config = autonomy.copy()
-            config = AutonomyConfig.from_dict(autonomy)
-            # Extract verification_hooks from dict if provided
-            if "verification_hooks" in autonomy and not verification_hooks:
-                self._verification_hooks = autonomy.get("verification_hooks", [])
-        elif isinstance(autonomy, AutonomyConfig):
-            self.autonomy_config = {
-                "max_iterations": autonomy.max_iterations,
-                "doom_loop_threshold": autonomy.doom_loop_threshold,
-                "auto_escalate": autonomy.auto_escalate,
-            }
-            config = autonomy
-        else:
-            self.autonomy_enabled = False
-            self.autonomy_config = {}
-            self._autonomy_trigger = None
-            self._doom_loop_tracker = None
-            return
-        
-        self._autonomy_trigger = AutonomyTrigger()
-        self._doom_loop_tracker = DoomLoopTracker(threshold=config.doom_loop_threshold)
-    
-    def analyze_prompt(self, prompt: str) -> Set[str]:
-        """Analyze prompt for autonomy signals.
-        
-        Args:
-            prompt: The user prompt
-            
-        Returns:
-            Set of detected signal names
-        """
-        if not self.autonomy_enabled or self._autonomy_trigger is None:
-            return set()
-        return self._autonomy_trigger.analyze(prompt)
-    
-    def get_recommended_stage(self, prompt: str) -> str:
-        """Get recommended execution stage for prompt.
-        
-        Args:
-            prompt: The user prompt
-            
-        Returns:
-            Stage name as string (direct, heuristic, planned, autonomous)
-        """
-        if not self.autonomy_enabled or self._autonomy_trigger is None:
-            return "direct"
-        
-        signals = self._autonomy_trigger.analyze(prompt)
-        stage = self._autonomy_trigger.recommend_stage(signals)
-        return stage.value
-    
-    def _record_action(self, action_type: str, args: Dict[str, Any], result: Any, success: bool) -> None:
-        """Record an action for doom loop tracking.
-        
-        Args:
-            action_type: Type of action
-            args: Action arguments
-            result: Action result
-            success: Whether action succeeded
-        """
-        if self._doom_loop_tracker is not None:
-            self._doom_loop_tracker.record(action_type, args, result, success)
-    
-    def _is_doom_loop(self) -> bool:
-        """Check if we're in a doom loop.
-        
-        Returns:
-            True if doom loop detected
-        """
-        if self._doom_loop_tracker is None:
-            return False
-        return self._doom_loop_tracker.is_doom_loop()
-    
-    def _reset_doom_loop(self) -> None:
-        """Reset doom loop tracking."""
-        if self._doom_loop_tracker is not None:
-            self._doom_loop_tracker.reset()
-    
-    def run_autonomous(
-        self,
-        prompt: str,
-        max_iterations: Optional[int] = None,
-        timeout_seconds: Optional[float] = None,
-        completion_promise: Optional[str] = None,
-        clear_context: bool = False,
-    ) -> AutonomyResult:
-        """Run an autonomous task execution loop.
-        
-        This method executes a task autonomously, using the agent's tools
-        and capabilities to complete the task. It handles:
-        - Progressive escalation based on task complexity
-        - Doom loop detection and recovery
-        - Iteration limits and timeouts
-        - Completion detection (keyword-based or promise-based)
-        - Optional context clearing between iterations
-        
-        Args:
-            prompt: The task to execute
-            max_iterations: Override max iterations (default from config)
-            timeout_seconds: Timeout in seconds (default: no timeout)
-            completion_promise: Optional string that signals completion when 
-                wrapped in <promise>TEXT</promise> tags in the response
-            clear_context: Whether to clear chat history between iterations
-                (forces agent to rely on external state like files)
-            
-        Returns:
-            AutonomyResult with success status, output, and metadata
-            
-        Raises:
-            ValueError: If autonomy is not enabled
-            
-        Example:
-            agent = Agent(instructions="...", autonomy=True)
-            result = agent.run_autonomous(
-                "Refactor the auth module",
-                completion_promise="DONE",
-                clear_context=True
-            )
-            if result.success:
-                print(result.output)
-        """
-        if not self.autonomy_enabled:
-            raise ValueError(
-                "Autonomy must be enabled to use run_autonomous(). "
-                "Create agent with autonomy=True or autonomy={...}"
-            )
-        
-        start_time = time.time()
-        iterations = 0
-        actions_taken: List[Dict[str, Any]] = []
-        
-        # Get config values
-        config_max_iter = self.autonomy_config.get("max_iterations", 20)
-        effective_max_iter = max_iterations if max_iterations is not None else config_max_iter
-        
-        # Get completion_promise from config if not provided as param
-        effective_promise = completion_promise
-        if effective_promise is None:
-            effective_promise = self.autonomy_config.get("completion_promise")
-        
-        # Get clear_context from config if not explicitly set
-        effective_clear_context = clear_context
-        if not clear_context:
-            effective_clear_context = self.autonomy_config.get("clear_context", False)
-        
-        # Analyze prompt and get recommended stage
-        stage = self.get_recommended_stage(prompt)
-        
-        # Reset doom loop tracker for new task
-        self._reset_doom_loop()
-        
-        try:
-            # Execute the autonomous loop
-            while iterations < effective_max_iter:
-                iterations += 1
-                
-                # Check timeout
-                if timeout_seconds and (time.time() - start_time) > timeout_seconds:
-                    return AutonomyResult(
-                        success=False,
-                        output="Task timed out",
-                        completion_reason="timeout",
-                        iterations=iterations,
-                        stage=stage,
-                        actions=actions_taken,
-                        duration_seconds=time.time() - start_time,
-                    )
-                
-                # Check doom loop
-                if self._is_doom_loop():
-                    logger.warning(f"Doom loop detected after {iterations} iterations")
-                    return AutonomyResult(
-                        success=False,
-                        output="Task stopped due to repeated actions (doom loop)",
-                        completion_reason="doom_loop",
-                        iterations=iterations,
-                        stage=stage,
-                        actions=actions_taken,
-                        duration_seconds=time.time() - start_time,
-                    )
-                
-                # Execute one turn using the agent's chat method
-                # Always use the original prompt (prompt re-injection)
-                try:
-                    response = self.chat(prompt)
-                except Exception as e:
-                    logger.error(f"Error during autonomous execution: {e}")
-                    return AutonomyResult(
-                        success=False,
-                        output=str(e),
-                        completion_reason="error",
-                        iterations=iterations,
-                        stage=stage,
-                        actions=actions_taken,
-                        duration_seconds=time.time() - start_time,
-                        error=str(e),
-                    )
-                
-                # Record the action
-                actions_taken.append({
-                    "iteration": iterations,
-                    "response": str(response)[:500],  # Truncate for storage
-                })
-                
-                response_str = str(response)
-                
-                # Check for completion promise FIRST (structured signal)
-                if effective_promise:
-                    promise_tag = f"<promise>{effective_promise}</promise>"
-                    if promise_tag in response_str:
-                        return AutonomyResult(
-                            success=True,
-                            output=response_str,
-                            completion_reason="promise",
-                            iterations=iterations,
-                            stage=stage,
-                            actions=actions_taken,
-                            duration_seconds=time.time() - start_time,
-                        )
-                
-                # Check for keyword-based completion signals (fallback)
-                response_lower = response_str.lower()
-                completion_signals = [
-                    "task completed",
-                    "task complete",
-                    "done",
-                    "finished",
-                    "completed successfully",
-                ]
-                
-                if any(signal in response_lower for signal in completion_signals):
-                    return AutonomyResult(
-                        success=True,
-                        output=response_str,
-                        completion_reason="goal",
-                        iterations=iterations,
-                        stage=stage,
-                        actions=actions_taken,
-                        duration_seconds=time.time() - start_time,
-                    )
-                
-                # For DIRECT stage, complete after first response
-                if stage == "direct":
-                    return AutonomyResult(
-                        success=True,
-                        output=response_str,
-                        completion_reason="goal",
-                        iterations=iterations,
-                        stage=stage,
-                        actions=actions_taken,
-                        duration_seconds=time.time() - start_time,
-                    )
-                
-                # Clear context between iterations if enabled
-                if effective_clear_context:
-                    self.clear_history()
-            
-            # Max iterations reached
-            return AutonomyResult(
-                success=False,
-                output="Max iterations reached",
-                completion_reason="max_iterations",
-                iterations=iterations,
-                stage=stage,
-                actions=actions_taken,
-                duration_seconds=time.time() - start_time,
-            )
-            
-        except Exception as e:
-            logger.error(f"Unexpected error in run_autonomous: {e}")
-            return AutonomyResult(
-                success=False,
-                output=str(e),
-                completion_reason="error",
-                iterations=iterations,
-                stage=stage,
-                actions=actions_taken,
-                duration_seconds=time.time() - start_time,
-                error=str(e),
-            )
-    
-    def delegate(
-        self,
-        task: str,
-        profile: str = "general",
-        timeout_seconds: float = 300.0,
-        context: Optional[Dict[str, Any]] = None,
-    ) -> Any:
-        """Delegate a task to a subagent.
-        
-        Args:
-            task: Task description for the subagent
-            profile: Agent profile to use (explorer, coder, tester, etc.)
-            timeout_seconds: Timeout for the delegated task
-            context: Additional context to pass to subagent
-            
-        Returns:
-            Result from the subagent
-        """
-        subagent = self._create_subagent(profile, context)
-        return subagent.chat(task)
-    
-    def _create_subagent(
-        self,
-        profile: str,
-        context: Optional[Dict[str, Any]] = None,
-    ) -> Any:
-        """Create a subagent with the specified profile.
-        
-        Args:
-            profile: Agent profile name
-            context: Additional context
-            
-        Returns:
-            Configured Agent instance
-        """
-        # Import here to avoid circular imports
-        from .agent import Agent
-        from ..agents.profiles import get_profile, BUILTIN_PROFILES
-        
-        # Get profile config
-        profile_config = get_profile(profile) if profile in BUILTIN_PROFILES else None
-        
-        if profile_config:
-            return Agent(
-                name=f"subagent_{profile}",
-                instructions=profile_config.system_prompt,
-                tools=profile_config.tools if hasattr(profile_config, 'tools') else None,
-            )
-        else:
-            # Default subagent
-            return Agent(
-                name=f"subagent_{profile}",
-                instructions=f"You are a {profile} assistant.",
-            )
-    
-    def _run_verification_hooks(self) -> List[Dict[str, Any]]:
-        """Run all registered verification hooks.
-        
-        Returns:
-            List of verification results
-        """
-        results = []
-        if hasattr(self, '_verification_hooks') and self._verification_hooks:
-            for hook in self._verification_hooks:
-                try:
-                    result = hook.run()
-                    results.append({
-                        "hook": hook.name,
-                        "success": result.get("success", False),
-                        "output": result.get("output", ""),
-                    })
-                except Exception as e:
-                    results.append({
-                        "hook": getattr(hook, 'name', 'unknown'),
-                        "success": False,
-                        "error": str(e),
-                    })
-        return results
+    pass
@@ -414,9 +414,13 @@ class AgentTeam:
        self.user_id = _user_id
        self.max_iter = _max_iter

-        # Pass user_id to each agent
+        # Pass user_id and autonomy to each agent
        for agent in agents:
            agent.user_id = self.user_id
+            # Propagate autonomy config to agents that don't already have it
+            if self._autonomy is not None and self._autonomy is not False:
+                if not agent.autonomy_enabled:
+                    agent._init_autonomy(self._autonomy)

        self.agents: List[Agent] = agents
        self.tasks: Dict[int, Task] = {}
@@ -462,17 +462,23 @@ DO NOT use strings for tasks. Each task MUST be a complete object with all four
            # Use consolidated knowledge if provided, else fall back to legacy knowledge_sources
            effective_knowledge = self._knowledge if self._knowledge is not None else self.knowledge_sources
            
+            # Build execution config merging legacy code_execution params
+            _effective_execution = self._execution
+            if _effective_execution is None and (self.allow_code_execution or self.code_execution_mode != "safe"):
+                from ..config.feature_configs import ExecutionConfig
+                _effective_execution = ExecutionConfig(
+                    code_execution=bool(self.allow_code_execution),
+                    code_mode=self.code_execution_mode,
+                )
+            
            agent = Agent(
                name=agent_config.name,
                role=agent_config.role,
                goal=agent_config.goal,
                backstory=agent_config.backstory,
                tools=agent_tools,  # Use assigned tools
-                allow_code_execution=self.allow_code_execution,
                memory=self.memory,
                llm=self.llm,  # Consolidated LLM param
-                code_execution_mode=self.code_execution_mode,
-                allow_delegation=self.allow_delegation,
                base_url=self.base_url,
                api_key=self.api_key,
                # Consolidated params (new SDK contract)
@@ -480,7 +486,7 @@ DO NOT use strings for tasks. Each task MUST be a complete object with all four
                reflection=self._reflection,  # Overrides self_reflect/max_reflect/min_reflect/reflect_llm
                caching=self._caching,  # Overrides cache
                knowledge=effective_knowledge,  # Overrides knowledge_sources/embedder_config
-                execution=self._execution,  # Overrides max_iter
+                execution=_effective_execution,  # Overrides max_iter + code execution
                guardrails=self._guardrails,
                web=self._web,
                hooks=self._hooks,
@@ -1,529 +0,0 @@
-"""
-Human Approval Framework for PraisonAI Agents
-
-This module provides a minimal human-in-the-loop approval system for dangerous tool operations.
-It extends the existing callback system to require human approval before executing high-risk tools.
-"""
-
-import logging
-import asyncio
-import json
-import os
-from typing import Dict, Set, Optional, Callable, Any, Literal, List
-from functools import wraps
-import contextvars
-from contextvars import ContextVar
-from dataclasses import dataclass, field
-
-# Lazy import for rich components
-_rich_console = None
-_rich_panel = None
-_rich_confirm = None
-
-def _get_rich_console():
-    """Lazy import rich Console."""
-    global _rich_console
-    if _rich_console is None:
-        from rich.console import Console
-        _rich_console = Console
-    return _rich_console
-
-def _get_rich_panel():
-    """Lazy import rich Panel."""
-    global _rich_panel
-    if _rich_panel is None:
-        from rich.panel import Panel
-        _rich_panel = Panel
-    return _rich_panel
-
-def _get_rich_confirm():
-    """Lazy import rich Confirm."""
-    global _rich_confirm
-    if _rich_confirm is None:
-        from rich.prompt import Confirm
-        _rich_confirm = Confirm
-    return _rich_confirm
-
-# Global registries for approval requirements
-APPROVAL_REQUIRED_TOOLS: Set[str] = set()
-TOOL_RISK_LEVELS: Dict[str, str] = {}
-
-# Risk levels
-RiskLevel = Literal["critical", "high", "medium", "low"]
-
-# Global approval callback
-approval_callback: Optional[Callable] = None
-
-# Context variable to track if we're in an approved execution context
-_approved_context: ContextVar[Set[str]] = ContextVar('approved_context', default=set())
-
-# Context variable for YAML-defined auto-approved tools (from agents.yaml approve field)
-_yaml_approved_tools: ContextVar[Set[str]] = ContextVar('yaml_approved_tools', default=set())
-
-# Global permission allowlist
-_permission_allowlist: Optional["PermissionAllowlist"] = None
-
-
-@dataclass
-class ToolPermission:
-    """Permission entry for a tool."""
-    tool_name: str
-    allowed_paths: List[str] = field(default_factory=list)
-    session_only: bool = False  # If True, permission expires with session
-
-
-class PermissionAllowlist:
-    """
-    Persistent permission allowlist for tools.
-    
-    Allows pre-approving tools and paths to skip interactive approval.
-    Can be saved/loaded from JSON for persistence across sessions.
-    
-    Usage:
-        allowlist = PermissionAllowlist()
-        allowlist.add_tool("read_file")
-        allowlist.add_tool("write_file", paths=["./src", "./tests"])
-        
-        if allowlist.is_allowed("read_file"):
-            # Skip approval prompt
-            pass
-    """
-    
-    def __init__(self):
-        self._tools: Dict[str, ToolPermission] = {}
-        self._session_tools: Set[str] = set()
-        
-    def add_tool(
-        self, 
-        tool_name: str, 
-        paths: Optional[List[str]] = None,
-        session_only: bool = False
-    ) -> None:
-        """
-        Add a tool to the allowlist.
-        
-        Args:
-            tool_name: Name of the tool to allow
-            paths: Optional list of allowed paths (empty = all paths)
-            session_only: If True, permission expires with session
-        """
-        self._tools[tool_name] = ToolPermission(
-            tool_name=tool_name,
-            allowed_paths=paths or [],
-            session_only=session_only
-        )
-        if session_only:
-            self._session_tools.add(tool_name)
-            
-    def remove_tool(self, tool_name: str) -> bool:
-        """Remove a tool from the allowlist."""
-        if tool_name in self._tools:
-            del self._tools[tool_name]
-            self._session_tools.discard(tool_name)
-            return True
-        return False
-    
-    def is_allowed(self, tool_name: str, path: Optional[str] = None) -> bool:
-        """
-        Check if a tool is allowed.
-        
-        Args:
-            tool_name: Name of the tool
-            path: Optional path to check against allowed paths
-            
-        Returns:
-            True if tool is allowed (optionally for the given path)
-        """
-        if tool_name not in self._tools:
-            return False
-            
-        permission = self._tools[tool_name]
-        
-        # If no paths specified, tool is allowed for all paths
-        if not permission.allowed_paths:
-            return True
-            
-        # If path not provided, check if tool has any permissions
-        if path is None:
-            return True
-            
-        # Check if path matches any allowed path
-        for allowed_path in permission.allowed_paths:
-            # Normalize paths for comparison
-            norm_allowed = os.path.normpath(allowed_path)
-            norm_path = os.path.normpath(path)
-            
-            # Check if path starts with allowed path
-            if norm_path.startswith(norm_allowed):
-                return True
-                
-        return False
-    
-    def is_empty(self) -> bool:
-        """Check if allowlist is empty."""
-        return len(self._tools) == 0
-    
-    def list_tools(self) -> List[str]:
-        """List all allowed tools."""
-        return list(self._tools.keys())
-    
-    def clear_session_permissions(self) -> None:
-        """Clear session-only permissions."""
-        for tool_name in list(self._session_tools):
-            if tool_name in self._tools:
-                del self._tools[tool_name]
-        self._session_tools.clear()
-    
-    def save(self, filepath: str) -> None:
-        """Save allowlist to JSON file."""
-        data = {
-            "tools": {
-                name: {
-                    "allowed_paths": perm.allowed_paths,
-                    "session_only": perm.session_only
-                }
-                for name, perm in self._tools.items()
-                if not perm.session_only  # Don't persist session-only permissions
-            }
-        }
-        
-        os.makedirs(os.path.dirname(filepath) or ".", exist_ok=True)
-        with open(filepath, "w") as f:
-            json.dump(data, f, indent=2)
-    
-    @classmethod
-    def load(cls, filepath: str) -> "PermissionAllowlist":
-        """Load allowlist from JSON file."""
-        allowlist = cls()
-        
-        if not os.path.exists(filepath):
-            return allowlist
-            
-        with open(filepath, "r") as f:
-            data = json.load(f)
-            
-        for tool_name, tool_data in data.get("tools", {}).items():
-            allowlist.add_tool(
-                tool_name,
-                paths=tool_data.get("allowed_paths", []),
-                session_only=tool_data.get("session_only", False)
-            )
-            
-        return allowlist
-
-
-def get_permission_allowlist() -> PermissionAllowlist:
-    """Get the global permission allowlist."""
-    global _permission_allowlist
-    if _permission_allowlist is None:
-        _permission_allowlist = PermissionAllowlist()
-    return _permission_allowlist
-
-
-def set_permission_allowlist(allowlist: PermissionAllowlist) -> None:
-    """Set the global permission allowlist."""
-    global _permission_allowlist
-    _permission_allowlist = allowlist
-
-
-class ApprovalDecision:
-    """Result of an approval request"""
-    def __init__(self, approved: bool, modified_args: Optional[Dict[str, Any]] = None, reason: str = ""):
-        self.approved = approved
-        self.modified_args = modified_args or {}
-        self.reason = reason
-
-def set_approval_callback(callback_fn: Callable):
-    """Set a custom approval callback function.
-    
-    The callback should accept (function_name, arguments, risk_level) and return ApprovalDecision.
-    """
-    global approval_callback
-    approval_callback = callback_fn
-
-def get_approval_callback() -> Optional[Callable]:
-    """Get the current approval callback function.
-    
-    Returns the custom callback if set, otherwise None.
-    This should be used instead of directly accessing approval_callback
-    to ensure the latest callback is always used.
-    """
-    return approval_callback
-
-def mark_approved(tool_name: str):
-    """Mark a tool as approved in the current context."""
-    approved = _approved_context.get(set())
-    approved.add(tool_name)
-    _approved_context.set(approved)
-
-def is_already_approved(tool_name: str) -> bool:
-    """Check if a tool is already approved in the current context."""
-    approved = _approved_context.get(set())
-    return tool_name in approved
-
-
-def is_yaml_approved(tool_name: str) -> bool:
-    """Check if a tool is auto-approved via YAML approve field."""
-    try:
-        yaml_approved = _yaml_approved_tools.get()
-        return tool_name in yaml_approved
-    except LookupError:
-        return False
-
-
-def is_env_auto_approve() -> bool:
-    """Check if PRAISONAI_AUTO_APPROVE environment variable is set."""
-    return os.environ.get("PRAISONAI_AUTO_APPROVE", "").lower() in ("true", "1", "yes")
-
-
-def set_yaml_approved_tools(tools: List[str]) -> contextvars.Token:
-    """
-    Set the list of YAML-approved tools for the current context.
-    
-    This is called by the workflow runner when parsing agents.yaml with approve field.
-    
-    Args:
-        tools: List of tool names to auto-approve
-        
-    Returns:
-        Token that can be used to reset the context
-    """
-    return _yaml_approved_tools.set(set(tools))
-
-
-def reset_yaml_approved_tools(token: contextvars.Token) -> None:
-    """Reset YAML-approved tools to previous state."""
-    _yaml_approved_tools.reset(token)
-
-
-def clear_approval_context():
-    """Clear the approval context."""
-    _approved_context.set(set())
-
-def require_approval(risk_level: RiskLevel = "high"):
-    """Decorator to mark a tool as requiring human approval.
-    
-    Args:
-        risk_level: The risk level of the tool ("critical", "high", "medium", "low")
-    """
-    def decorator(func):
-        tool_name = getattr(func, '__name__', str(func))
-        APPROVAL_REQUIRED_TOOLS.add(tool_name)
-        TOOL_RISK_LEVELS[tool_name] = risk_level
-        
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            # Skip approval if already approved in current context
-            if is_already_approved(tool_name):
-                return func(*args, **kwargs)
-            
-            # Skip approval if tool is auto-approved via YAML approve field (primary)
-            if is_yaml_approved(tool_name):
-                mark_approved(tool_name)
-                return func(*args, **kwargs)
-            
-            # Skip approval if PRAISONAI_AUTO_APPROVE env var is set (secondary)
-            if is_env_auto_approve():
-                mark_approved(tool_name)
-                return func(*args, **kwargs)
-            
-            # Request approval before executing the function
-            try:
-                # Try to check if we're in an async context
-                try:
-                    asyncio.get_running_loop()
-                    # We're in an async context, but this is a sync function
-                    # Fall back to sync approval to avoid loop conflicts
-                    raise RuntimeError("Use sync fallback in async context")
-                except RuntimeError:
-                    # Either no running loop or we want sync fallback
-                    # Use asyncio.run for clean async execution
-                    decision = asyncio.run(request_approval(tool_name, kwargs))
-            except Exception as e:
-                # Fallback to sync approval if async fails
-                logging.warning(f"Async approval failed, using sync fallback: {e}")
-                callback = get_approval_callback() or console_approval_callback
-                decision = callback(tool_name, kwargs, risk_level)
-            
-            if not decision.approved:
-                raise PermissionError(f"Execution of {tool_name} denied: {decision.reason}")
-            
-            # Mark as approved and merge modified args
-            mark_approved(tool_name)
-            kwargs.update(decision.modified_args)
-            return func(*args, **kwargs)
-        
-        @wraps(func)
-        async def async_wrapper(*args, **kwargs):
-            # Skip approval if already approved in current context
-            if is_already_approved(tool_name):
-                return await func(*args, **kwargs)
-            
-            # Skip approval if tool is auto-approved via YAML approve field (primary)
-            if is_yaml_approved(tool_name):
-                mark_approved(tool_name)
-                return await func(*args, **kwargs)
-            
-            # Skip approval if PRAISONAI_AUTO_APPROVE env var is set (secondary)
-            if is_env_auto_approve():
-                mark_approved(tool_name)
-                return await func(*args, **kwargs)
-            
-            # Request approval before executing the function
-            decision = await request_approval(tool_name, kwargs)
-            if not decision.approved:
-                raise PermissionError(f"Execution of {tool_name} denied: {decision.reason}")
-            
-            # Mark as approved and merge modified args
-            mark_approved(tool_name)
-            kwargs.update(decision.modified_args)
-            return await func(*args, **kwargs)
-        
-        # Return the appropriate wrapper based on function type
-        if asyncio.iscoroutinefunction(func):
-            return async_wrapper
-        else:
-            return wrapper
-    
-    return decorator
-
-def console_approval_callback(function_name: str, arguments: Dict[str, Any], risk_level: str) -> ApprovalDecision:
-    """Default console-based approval callback.
-    
-    Displays tool information and prompts user for approval via console.
-    """
-    Console = _get_rich_console()
-    Panel = _get_rich_panel()
-    Confirm = _get_rich_confirm()
-    
-    console = Console()
-    
-    # Create risk level styling
-    risk_colors = {
-        "critical": "bold red",
-        "high": "red", 
-        "medium": "yellow",
-        "low": "blue"
-    }
-    risk_color = risk_colors.get(risk_level, "white")
-    
-    # Display tool information
-    tool_info = f"[bold]Function:[/] {function_name}\n"
-    tool_info += f"[bold]Risk Level:[/] [{risk_color}]{risk_level.upper()}[/{risk_color}]\n"
-    tool_info += f"[bold]Arguments:[/]\n"
-    
-    for key, value in arguments.items():
-        # Truncate long values for display
-        str_value = str(value)
-        if len(str_value) > 100:
-            str_value = str_value[:97] + "..."
-        tool_info += f"  {key}: {str_value}\n"
-    
-    console.print(Panel(
-        tool_info.strip(),
-        title="🔒 Tool Approval Required",
-        border_style=risk_color,
-        title_align="left"
-    ))
-    
-    # Get user approval
-    try:
-        approved = Confirm.ask(
-            f"[{risk_color}]Do you want to execute this {risk_level} risk tool?[/{risk_color}]",
-            default=False
-        )
-        
-        if approved:
-            console.print("[green]✅ Tool execution approved[/green]")
-            return ApprovalDecision(approved=True, reason="User approved")
-        else:
-            console.print("[red]❌ Tool execution denied[/red]")
-            return ApprovalDecision(approved=False, reason="User denied")
-            
-    except KeyboardInterrupt:
-        console.print("\n[red]❌ Tool execution cancelled by user[/red]")
-        return ApprovalDecision(approved=False, reason="User cancelled")
-    except Exception as e:
-        console.print(f"[red]Error during approval: {e}[/red]")
-        return ApprovalDecision(approved=False, reason=f"Approval error: {e}")
-
-async def request_approval(function_name: str, arguments: Dict[str, Any]) -> ApprovalDecision:
-    """Request approval for a tool execution.
-    
-    Args:
-        function_name: Name of the function to execute
-        arguments: Arguments to pass to the function
-        
-    Returns:
-        ApprovalDecision with approval status and any modifications
-    """
-    # Check if approval is required
-    if function_name not in APPROVAL_REQUIRED_TOOLS:
-        return ApprovalDecision(approved=True, reason="No approval required")
-    
-    risk_level = TOOL_RISK_LEVELS.get(function_name, "medium")
-    
-    # Use custom callback if set, otherwise use console callback
-    callback = get_approval_callback() or console_approval_callback
-    
-    try:
-        # Handle async callbacks
-        if asyncio.iscoroutinefunction(callback):
-            decision = await callback(function_name, arguments, risk_level)
-        else:
-            # Run sync callback in executor to avoid blocking
-            loop = asyncio.get_event_loop()
-            decision = await loop.run_in_executor(None, callback, function_name, arguments, risk_level)
-        
-        return decision
-        
-    except Exception as e:
-        logging.error(f"Error in approval callback: {e}")
-        return ApprovalDecision(approved=False, reason=f"Approval callback error: {e}")
-
-# Default dangerous tools - can be configured at runtime
-DEFAULT_DANGEROUS_TOOLS = {
-    # Critical risk tools
-    "execute_command": "critical",
-    "kill_process": "critical", 
-    "execute_code": "critical",
-    
-    # High risk tools
-    "write_file": "high",
-    "delete_file": "high",
-    "move_file": "high",
-    "copy_file": "high",
-    "execute_query": "high",
-    
-    # Medium risk tools
-    "evaluate": "medium",
-    "crawl": "medium",
-    "scrape_page": "medium",
-}
-
-def configure_default_approvals():
-    """Configure default dangerous tools to require approval."""
-    for tool_name, risk_level in DEFAULT_DANGEROUS_TOOLS.items():
-        APPROVAL_REQUIRED_TOOLS.add(tool_name)
-        TOOL_RISK_LEVELS[tool_name] = risk_level
-
-def add_approval_requirement(tool_name: str, risk_level: RiskLevel = "high"):
-    """Dynamically add approval requirement for a tool."""
-    APPROVAL_REQUIRED_TOOLS.add(tool_name)
-    TOOL_RISK_LEVELS[tool_name] = risk_level
-
-def remove_approval_requirement(tool_name: str):
-    """Remove approval requirement for a tool."""
-    APPROVAL_REQUIRED_TOOLS.discard(tool_name)
-    TOOL_RISK_LEVELS.pop(tool_name, None)
-
-def is_approval_required(tool_name: str) -> bool:
-    """Check if a tool requires approval."""
-    return tool_name in APPROVAL_REQUIRED_TOOLS
-
-def get_risk_level(tool_name: str) -> Optional[str]:
-    """Get the risk level of a tool."""
-    return TOOL_RISK_LEVELS.get(tool_name)
-
-# Initialize with defaults
-configure_default_approvals()
@@ -0,0 +1,325 @@
+"""
+Extensible Approval Protocol for PraisonAI Agents.
+
+This package provides a protocol-driven, per-agent approval system for
+tool executions.  It is fully backward-compatible with the old
+``approval.py`` module — all existing imports continue to work.
+
+Quick start (no Agent class changes needed)::
+
+    from praisonaiagents.approval import get_approval_registry, AutoApproveBackend
+
+    # Global auto-approve for all agents
+    get_approval_registry().set_backend(AutoApproveBackend())
+
+    # Per-agent backend
+    get_approval_registry().set_backend(AutoApproveBackend(), agent_name="bot")
+
+Custom backend::
+
+    from praisonaiagents.approval import ApprovalProtocol, ApprovalRequest, ApprovalDecision
+
+    class WebhookBackend:
+        async def request_approval(self, request: ApprovalRequest) -> ApprovalDecision:
+            # POST to external service, wait for response
+            return ApprovalDecision(approved=True)
+
+    get_approval_registry().set_backend(WebhookBackend())
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextvars
+import json
+import logging
+import os
+from dataclasses import dataclass, field
+from functools import wraps
+from typing import Callable, Dict, List, Literal, Optional, Set
+
+# ── New protocol-driven exports ──────────────────────────────────────────────
+
+from .protocols import ApprovalProtocol, ApprovalRequest  # noqa: F401
+from .protocols import ApprovalDecision  # noqa: F401
+from .backends import AutoApproveBackend, ConsoleBackend, CallbackBackend, AgentApproval  # noqa: F401
+from .registry import ApprovalRegistry, DEFAULT_DANGEROUS_TOOLS  # noqa: F401
+
+logger = logging.getLogger(__name__)
+
+# ── Singleton registry ───────────────────────────────────────────────────────
+
+_registry: Optional[ApprovalRegistry] = None
+
+
+def get_approval_registry() -> ApprovalRegistry:
+    """Return the global singleton :class:`ApprovalRegistry`."""
+    global _registry
+    if _registry is None:
+        _registry = ApprovalRegistry()
+    return _registry
+
+
+# ── Backward-compatible API (delegates to registry) ─────────────────────────
+
+# These globals are kept for code that imports them directly.
+APPROVAL_REQUIRED_TOOLS: Set[str] = get_approval_registry()._required_tools
+TOOL_RISK_LEVELS: Dict[str, str] = get_approval_registry()._risk_levels
+
+# Legacy global callback holder — set_approval_callback wraps it into a backend
+approval_callback: Optional[Callable] = None
+
+
+def set_approval_callback(callback_fn: Optional[Callable]) -> None:
+    """Set a custom approval callback (legacy API).
+
+    The callback is wrapped into a :class:`CallbackBackend` and set as the
+    global backend on the registry.
+    """
+    global approval_callback
+    approval_callback = callback_fn
+    reg = get_approval_registry()
+    if callback_fn is not None:
+        reg.set_backend(CallbackBackend(callback_fn))
+    else:
+        reg.remove_backend()
+
+
+def get_approval_callback() -> Optional[Callable]:
+    """Get the current approval callback function (legacy API)."""
+    return approval_callback
+
+
+def mark_approved(tool_name: str) -> None:
+    get_approval_registry().mark_approved(tool_name)
+
+
+def is_already_approved(tool_name: str) -> bool:
+    return get_approval_registry().is_already_approved(tool_name)
+
+
+def is_yaml_approved(tool_name: str) -> bool:
+    return get_approval_registry().is_yaml_approved(tool_name)
+
+
+def is_env_auto_approve() -> bool:
+    return ApprovalRegistry.is_env_auto_approve()
+
+
+def set_yaml_approved_tools(tools: List[str]) -> contextvars.Token:
+    return get_approval_registry().set_yaml_approved_tools(tools)
+
+
+def reset_yaml_approved_tools(token: contextvars.Token) -> None:
+    get_approval_registry().reset_yaml_approved_tools(token)
+
+
+def clear_approval_context() -> None:
+    get_approval_registry().clear_approved()
+
+
+def configure_default_approvals() -> None:
+    """Re-configure default dangerous tools (idempotent)."""
+    reg = get_approval_registry()
+    for tool_name, risk_level in DEFAULT_DANGEROUS_TOOLS.items():
+        reg.add_requirement(tool_name, risk_level)
+
+
+def add_approval_requirement(tool_name: str, risk_level: str = "high") -> None:
+    get_approval_registry().add_requirement(tool_name, risk_level)
+    APPROVAL_REQUIRED_TOOLS.add(tool_name)
+    TOOL_RISK_LEVELS[tool_name] = risk_level
+
+
+def remove_approval_requirement(tool_name: str) -> None:
+    get_approval_registry().remove_requirement(tool_name)
+    APPROVAL_REQUIRED_TOOLS.discard(tool_name)
+    TOOL_RISK_LEVELS.pop(tool_name, None)
+
+
+def is_approval_required(tool_name: str) -> bool:
+    return get_approval_registry().is_required(tool_name)
+
+
+def get_risk_level(tool_name: str) -> Optional[str]:
+    return get_approval_registry().get_risk_level(tool_name)
+
+
+# ── Legacy console callback (kept for direct callers) ───────────────────────
+
+def console_approval_callback(function_name: str, arguments: Dict, risk_level: str) -> ApprovalDecision:
+    """Default console-based approval callback (legacy API)."""
+    backend = ConsoleBackend()
+    request = ApprovalRequest(
+        tool_name=function_name,
+        arguments=arguments,
+        risk_level=risk_level,
+    )
+    return backend.request_approval_sync(request)
+
+
+# ── Legacy async request_approval ────────────────────────────────────────────
+
+async def request_approval(function_name: str, arguments: Dict) -> ApprovalDecision:
+    """Request approval for a tool execution (legacy async API)."""
+    return await get_approval_registry().approve_async(None, function_name, arguments)
+
+
+# ── require_approval decorator (unchanged semantics) ─────────────────────────
+
+RiskLevel = Literal["critical", "high", "medium", "low"]
+
+
+def require_approval(risk_level: RiskLevel = "high"):
+    """Decorator to mark a tool as requiring human approval."""
+    def decorator(func):
+        tool_name = getattr(func, '__name__', str(func))
+        reg = get_approval_registry()
+        reg.add_requirement(tool_name, risk_level)
+        APPROVAL_REQUIRED_TOOLS.add(tool_name)
+        TOOL_RISK_LEVELS[tool_name] = risk_level
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            if is_already_approved(tool_name):
+                return func(*args, **kwargs)
+            if is_yaml_approved(tool_name):
+                mark_approved(tool_name)
+                return func(*args, **kwargs)
+            if is_env_auto_approve():
+                mark_approved(tool_name)
+                return func(*args, **kwargs)
+            try:
+                try:
+                    asyncio.get_running_loop()
+                    raise RuntimeError("Use sync fallback in async context")
+                except RuntimeError:
+                    decision = asyncio.run(request_approval(tool_name, kwargs))
+            except Exception as e:
+                logging.warning(f"Async approval failed, using sync fallback: {e}")
+                decision = console_approval_callback(tool_name, kwargs, risk_level)
+            if not decision.approved:
+                raise PermissionError(f"Execution of {tool_name} denied: {decision.reason}")
+            mark_approved(tool_name)
+            kwargs.update(decision.modified_args)
+            return func(*args, **kwargs)
+
+        @wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            if is_already_approved(tool_name):
+                return await func(*args, **kwargs)
+            if is_yaml_approved(tool_name):
+                mark_approved(tool_name)
+                return await func(*args, **kwargs)
+            if is_env_auto_approve():
+                mark_approved(tool_name)
+                return await func(*args, **kwargs)
+            decision = await request_approval(tool_name, kwargs)
+            if not decision.approved:
+                raise PermissionError(f"Execution of {tool_name} denied: {decision.reason}")
+            mark_approved(tool_name)
+            kwargs.update(decision.modified_args)
+            return await func(*args, **kwargs)
+
+        if asyncio.iscoroutinefunction(func):
+            return async_wrapper
+        else:
+            return wrapper
+
+    return decorator
+
+
+# ── PermissionAllowlist (kept as-is) ─────────────────────────────────────────
+
+
+@dataclass
+class ToolPermission:
+    """Permission entry for a tool."""
+    tool_name: str
+    allowed_paths: List[str] = field(default_factory=list)
+    session_only: bool = False
+
+
+class PermissionAllowlist:
+    """Persistent permission allowlist for tools."""
+
+    def __init__(self):
+        self._tools: Dict[str, ToolPermission] = {}
+        self._session_tools: Set[str] = set()
+
+    def add_tool(self, tool_name: str, paths: Optional[List[str]] = None, session_only: bool = False) -> None:
+        self._tools[tool_name] = ToolPermission(tool_name=tool_name, allowed_paths=paths or [], session_only=session_only)
+        if session_only:
+            self._session_tools.add(tool_name)
+
+    def remove_tool(self, tool_name: str) -> bool:
+        if tool_name in self._tools:
+            del self._tools[tool_name]
+            self._session_tools.discard(tool_name)
+            return True
+        return False
+
+    def is_allowed(self, tool_name: str, path: Optional[str] = None) -> bool:
+        if tool_name not in self._tools:
+            return False
+        permission = self._tools[tool_name]
+        if not permission.allowed_paths:
+            return True
+        if path is None:
+            return True
+        for allowed_path in permission.allowed_paths:
+            norm_allowed = os.path.normpath(allowed_path)
+            norm_path = os.path.normpath(path)
+            if norm_path.startswith(norm_allowed):
+                return True
+        return False
+
+    def is_empty(self) -> bool:
+        return len(self._tools) == 0
+
+    def list_tools(self) -> List[str]:
+        return list(self._tools.keys())
+
+    def clear_session_permissions(self) -> None:
+        for tool_name in list(self._session_tools):
+            if tool_name in self._tools:
+                del self._tools[tool_name]
+        self._session_tools.clear()
+
+    def save(self, filepath: str) -> None:
+        data = {
+            "tools": {
+                name: {"allowed_paths": perm.allowed_paths, "session_only": perm.session_only}
+                for name, perm in self._tools.items()
+                if not perm.session_only
+            }
+        }
+        os.makedirs(os.path.dirname(filepath) or ".", exist_ok=True)
+        with open(filepath, "w") as f:
+            json.dump(data, f, indent=2)
+
+    @classmethod
+    def load(cls, filepath: str) -> "PermissionAllowlist":
+        allowlist = cls()
+        if not os.path.exists(filepath):
+            return allowlist
+        with open(filepath, "r") as f:
+            data = json.load(f)
+        for tool_name, tool_data in data.get("tools", {}).items():
+            allowlist.add_tool(tool_name, paths=tool_data.get("allowed_paths", []), session_only=tool_data.get("session_only", False))
+        return allowlist
+
+
+_permission_allowlist: Optional[PermissionAllowlist] = None
+
+
+def get_permission_allowlist() -> PermissionAllowlist:
+    global _permission_allowlist
+    if _permission_allowlist is None:
+        _permission_allowlist = PermissionAllowlist()
+    return _permission_allowlist
+
+
+def set_permission_allowlist(allowlist: PermissionAllowlist) -> None:
+    global _permission_allowlist
+    _permission_allowlist = allowlist
@@ -0,0 +1,285 @@
+"""
+Built-in approval backends for PraisonAI Agents.
+
+Provides lightweight backends that ship with the core SDK:
+
+- **AutoApproveBackend** — always approves (bots, trusted envs).
+- **ConsoleBackend** — interactive Rich terminal prompt (CLI default).
+- **AgentApproval** — delegates approval decision to another AI agent.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any
+
+from .protocols import ApprovalDecision, ApprovalRequest
+
+logger = logging.getLogger(__name__)
+
+# Lazy Rich imports (same pattern as old approval.py)
+_rich_console = None
+_rich_panel = None
+_rich_confirm = None
+
+
+def _get_rich_console():
+    global _rich_console
+    if _rich_console is None:
+        from rich.console import Console
+        _rich_console = Console
+    return _rich_console
+
+
+def _get_rich_panel():
+    global _rich_panel
+    if _rich_panel is None:
+        from rich.panel import Panel
+        _rich_panel = Panel
+    return _rich_panel
+
+
+def _get_rich_confirm():
+    global _rich_confirm
+    if _rich_confirm is None:
+        from rich.prompt import Confirm
+        _rich_confirm = Confirm
+    return _rich_confirm
+
+
+class AutoApproveBackend:
+    """Always approves.  Use for bots or trusted unattended environments."""
+
+    async def request_approval(self, request: ApprovalRequest) -> ApprovalDecision:
+        return ApprovalDecision(approved=True, reason="auto-approved", approver="system")
+
+    def request_approval_sync(self, request: ApprovalRequest) -> ApprovalDecision:
+        return ApprovalDecision(approved=True, reason="auto-approved", approver="system")
+
+
+class ConsoleBackend:
+    """Interactive Rich terminal prompt.  Default for CLI usage."""
+
+    def _prompt_user(self, request: ApprovalRequest) -> bool:
+        """Show Rich panel and ask yes/no.  Returns True if approved."""
+        Console = _get_rich_console()
+        Panel = _get_rich_panel()
+        Confirm = _get_rich_confirm()
+
+        console = Console()
+
+        risk_colors = {
+            "critical": "bold red",
+            "high": "red",
+            "medium": "yellow",
+            "low": "blue",
+        }
+        risk_color = risk_colors.get(request.risk_level, "white")
+
+        tool_info = f"[bold]Function:[/] {request.tool_name}\n"
+        tool_info += f"[bold]Risk Level:[/] [{risk_color}]{request.risk_level.upper()}[/{risk_color}]\n"
+        if request.agent_name:
+            tool_info += f"[bold]Agent:[/] {request.agent_name}\n"
+        tool_info += "[bold]Arguments:[/]\n"
+        for key, value in request.arguments.items():
+            str_value = str(value)
+            if len(str_value) > 100:
+                str_value = str_value[:97] + "..."
+            tool_info += f"  {key}: {str_value}\n"
+
+        console.print(Panel(
+            tool_info.strip(),
+            title="🔒 Tool Approval Required",
+            border_style=risk_color,
+            title_align="left",
+        ))
+
+        try:
+            return Confirm.ask(
+                f"[{risk_color}]Do you want to execute this {request.risk_level} risk tool?[/{risk_color}]",
+                default=False,
+            )
+        except (KeyboardInterrupt, EOFError):
+            return False
+
+    def request_approval_sync(self, request: ApprovalRequest) -> ApprovalDecision:
+        """Synchronous approval via Rich console prompt."""
+        try:
+            approved = self._prompt_user(request)
+            if approved:
+                return ApprovalDecision(approved=True, reason="User approved", approver="console")
+            return ApprovalDecision(approved=False, reason="User denied", approver="console")
+        except Exception as e:
+            logger.error("Console approval error: %s", e)
+            return ApprovalDecision(approved=False, reason=f"Approval error: {e}")
+
+    async def request_approval(self, request: ApprovalRequest) -> ApprovalDecision:
+        """Async wrapper — runs the sync prompt in an executor."""
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, self.request_approval_sync, request)
+
+
+class AgentApproval:
+    """Delegates approval decisions to another AI agent.
+
+    The approver agent receives a structured prompt describing the tool call
+    and responds with ``APPROVE`` or ``DENY``.  This enables autonomous
+    multi-agent approval workflows without human intervention.
+
+    Lives in the core SDK because it only depends on the Agent class which
+    is already in core — no external dependencies.
+
+    Args:
+        approver_agent: An Agent instance that will evaluate approval requests.
+            If ``None``, a default approver agent is created with sensible
+            instructions.
+        llm: LLM model to use for the default approver agent (default ``gpt-4o-mini``).
+
+    Example::
+
+        from praisonaiagents import Agent
+        from praisonaiagents.approval import AgentApproval
+
+        approver = Agent(
+            name="security-reviewer",
+            instructions="Only approve low-risk read operations. Deny anything destructive.",
+        )
+        worker = Agent(
+            name="worker",
+            tools=[execute_command],
+            approval=AgentApproval(approver_agent=approver),
+        )
+    """
+
+    def __init__(
+        self,
+        approver_agent: Any = None,
+        llm: str = "gpt-4o-mini",
+    ):
+        self._approver_agent = approver_agent
+        self._llm = llm
+
+    def __repr__(self) -> str:
+        name = getattr(self._approver_agent, "name", None) or "default"
+        return f"AgentApproval(approver={name!r})"
+
+    def _get_approver(self) -> Any:
+        """Lazily create or return the approver agent."""
+        if self._approver_agent is not None:
+            return self._approver_agent
+
+        # Lazy import to avoid circular dependency at module level
+        from praisonaiagents.agent.agent import Agent
+
+        self._approver_agent = Agent(
+            name="approval-reviewer",
+            instructions=(
+                "You are a security reviewer for tool execution requests. "
+                "Evaluate each request and respond with exactly one word: "
+                "APPROVE or DENY. Consider the tool name, arguments, and risk level. "
+                "Deny anything that looks destructive, dangerous, or unauthorized. "
+                "Approve safe read-only operations."
+            ),
+            llm=self._llm,
+        )
+        return self._approver_agent
+
+    def _build_prompt(self, request: ApprovalRequest) -> str:
+        """Build the evaluation prompt for the approver agent."""
+        args_str = "\n".join(
+            f"  {k}: {v}" for k, v in request.arguments.items()
+        ) or "  (none)"
+
+        return (
+            f"Tool Approval Request:\n"
+            f"  Tool: {request.tool_name}\n"
+            f"  Risk Level: {request.risk_level.upper()}\n"
+            f"  Agent: {request.agent_name or 'unknown'}\n"
+            f"  Arguments:\n{args_str}\n\n"
+            f"Respond with exactly one word: APPROVE or DENY"
+        )
+
+    async def request_approval(self, request: ApprovalRequest) -> ApprovalDecision:
+        """Ask the approver agent to evaluate the request."""
+        try:
+            approver = self._get_approver()
+            prompt = self._build_prompt(request)
+
+            # Use the agent's chat method
+            if hasattr(approver, "achat"):
+                response = await approver.achat(prompt)
+            elif hasattr(approver, "chat"):
+                loop = asyncio.get_event_loop()
+                response = await loop.run_in_executor(None, approver.chat, prompt)
+            else:
+                return ApprovalDecision(
+                    approved=False,
+                    reason="Approver agent has no chat method",
+                )
+
+            response_text = str(response).strip().upper()
+            approved = "APPROVE" in response_text and "DENY" not in response_text
+
+            return ApprovalDecision(
+                approved=approved,
+                reason=f"Agent {'approved' if approved else 'denied'}: {str(response).strip()[:200]}",
+                approver=getattr(approver, "name", "agent"),
+                metadata={"platform": "agent", "response": str(response).strip()[:500]},
+            )
+
+        except Exception as e:
+            logger.error(f"AgentApproval error: {e}")
+            return ApprovalDecision(
+                approved=False,
+                reason=f"Agent approval error: {e}",
+            )
+
+    def request_approval_sync(self, request: ApprovalRequest) -> ApprovalDecision:
+        """Synchronous wrapper."""
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = None
+
+        if loop and loop.is_running():
+            import concurrent.futures
+            with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
+                future = pool.submit(asyncio.run, self.request_approval(request))
+                return future.result(timeout=60)
+        else:
+            return asyncio.run(self.request_approval(request))
+
+
+class CallbackBackend:
+    """Wraps a legacy ``(function_name, arguments, risk_level) -> ApprovalDecision`` callback
+    into an :class:`ApprovalProtocol`-compatible backend.
+
+    Used internally by :func:`set_approval_callback` for backward compatibility.
+    """
+
+    def __init__(self, callback):
+        self._callback = callback
+
+    def request_approval_sync(self, request: ApprovalRequest) -> ApprovalDecision:
+        result = self._callback(request.tool_name, request.arguments, request.risk_level)
+        if isinstance(result, ApprovalDecision):
+            return result
+        # Legacy callbacks may return dict-like or bool
+        if isinstance(result, bool):
+            return ApprovalDecision(approved=result)
+        return ApprovalDecision(approved=bool(result))
+
+    async def request_approval(self, request: ApprovalRequest) -> ApprovalDecision:
+        if asyncio.iscoroutinefunction(self._callback):
+            result = await self._callback(request.tool_name, request.arguments, request.risk_level)
+        else:
+            loop = asyncio.get_event_loop()
+            result = await loop.run_in_executor(
+                None, self._callback, request.tool_name, request.arguments, request.risk_level,
+            )
+        if isinstance(result, ApprovalDecision):
+            return result
+        if isinstance(result, bool):
+            return ApprovalDecision(approved=result)
+        return ApprovalDecision(approved=bool(result))
@@ -0,0 +1,83 @@
+"""
+Approval protocol definitions for PraisonAI Agents.
+
+Defines the structural contract for approval backends via typing.Protocol.
+Any class implementing ``request_approval`` satisfies the protocol without
+explicit inheritance (structural subtyping).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, Optional, Protocol, runtime_checkable
+
+
+@dataclass
+class ApprovalRequest:
+    """Immutable request for tool-execution approval.
+
+    Attributes:
+        tool_name:  Name of the tool requesting approval.
+        arguments:  Arguments the tool will be called with.
+        risk_level: Risk classification (critical / high / medium / low).
+        agent_name: Name of the agent that triggered the call (optional).
+        session_id: Session identifier for tracking (optional).
+        context:    Arbitrary context dict for backend-specific data.
+    """
+
+    tool_name: str
+    arguments: Dict[str, Any]
+    risk_level: str
+    agent_name: Optional[str] = None
+    session_id: Optional[str] = None
+    context: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class ApprovalDecision:
+    """Result of an approval request.
+
+    Attributes:
+        approved:      Whether execution is allowed.
+        reason:        Human-readable reason for the decision.
+        modified_args: Optional replacement arguments (empty = use originals).
+        approver:      Who/what approved (user, system, webhook, …).
+        metadata:      Backend-specific metadata (timestamps, IPs, …).
+    """
+
+    approved: bool
+    reason: str = ""
+    modified_args: Dict[str, Any] = field(default_factory=dict)
+    approver: Optional[str] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+@runtime_checkable
+class ApprovalProtocol(Protocol):
+    """Protocol for tool-execution approval backends.
+
+    Implement ``request_approval`` to create custom approval channels:
+    - Console prompts
+    - Webhook / HTTP callbacks
+    - Messaging platform replies (Slack, WhatsApp, Telegram)
+    - External UI dashboards
+    - Auto-approve policies
+
+    Example::
+
+        class MyBackend:
+            async def request_approval(self, request: ApprovalRequest) -> ApprovalDecision:
+                # … your logic …
+                return ApprovalDecision(approved=True)
+    """
+
+    async def request_approval(self, request: ApprovalRequest) -> ApprovalDecision:
+        """Request approval for a tool execution.
+
+        Args:
+            request: The approval request with tool info and context.
+
+        Returns:
+            ApprovalDecision indicating whether execution is approved.
+        """
+        ...
@@ -0,0 +1,250 @@
+"""
+Approval registry for PraisonAI Agents.
+
+Centralises approval state that was previously scattered across module-level
+globals.  Supports **per-agent** backends so different agents can use
+different approval channels (console, webhook, Slack, …) without touching
+the ``Agent`` class.
+
+Usage (no Agent param needed)::
+
+    from praisonaiagents.approval import get_approval_registry, AutoApproveBackend
+
+    registry = get_approval_registry()
+    registry.set_backend(AutoApproveBackend(), agent_name="bot-agent")
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextvars
+import logging
+import os
+from typing import Dict, List, Optional, Set
+
+from .protocols import ApprovalDecision, ApprovalRequest
+
+logger = logging.getLogger(__name__)
+
+# Default dangerous tools — same as old approval.py
+DEFAULT_DANGEROUS_TOOLS: Dict[str, str] = {
+    "execute_command": "critical",
+    "kill_process": "critical",
+    "execute_code": "critical",
+    "write_file": "high",
+    "delete_file": "high",
+    "move_file": "high",
+    "copy_file": "high",
+    "execute_query": "high",
+    "evaluate": "medium",
+    "crawl": "medium",
+    "scrape_page": "medium",
+}
+
+
+class ApprovalRegistry:
+    """Per-agent approval configuration.
+
+    Replaces the old global mutable sets/dicts while keeping the same
+    semantics.  The singleton instance is obtained via
+    :func:`get_approval_registry`.
+    """
+
+    def __init__(self) -> None:
+        # Backends
+        self._global_backend = None  # type: ignore[assignment]
+        self._agent_backends: Dict[str, object] = {}
+
+        # Tool requirements (mirrors old APPROVAL_REQUIRED_TOOLS / TOOL_RISK_LEVELS)
+        self._required_tools: Set[str] = set()
+        self._risk_levels: Dict[str, str] = {}
+
+        # Context variables (per-coroutine / per-thread)
+        self._approved_context: contextvars.ContextVar[Set[str]] = contextvars.ContextVar(
+            "approved_context", default=set()
+        )
+        self._yaml_approved_tools: contextvars.ContextVar[Set[str]] = contextvars.ContextVar(
+            "yaml_approved_tools", default=set()
+        )
+
+        # Timeout for async approval calls
+        self.timeout: float = 300.0
+
+        # Initialise with dangerous-tool defaults
+        for tool_name, risk in DEFAULT_DANGEROUS_TOOLS.items():
+            self._required_tools.add(tool_name)
+            self._risk_levels[tool_name] = risk
+
+    # ── Backend management ───────────────────────────────────────────────
+
+    def set_backend(self, backend: object, agent_name: Optional[str] = None) -> None:
+        """Set the approval backend globally or for a specific agent.
+
+        Args:
+            backend:    Any object satisfying :class:`ApprovalProtocol`.
+            agent_name: If provided, apply only to this agent.
+        """
+        if agent_name:
+            self._agent_backends[agent_name] = backend
+        else:
+            self._global_backend = backend
+
+    def remove_backend(self, agent_name: Optional[str] = None) -> None:
+        """Remove a previously set backend."""
+        if agent_name:
+            self._agent_backends.pop(agent_name, None)
+        else:
+            self._global_backend = None
+
+    def get_backend(self, agent_name: Optional[str] = None) -> object:
+        """Resolve the backend for *agent_name* (falls back to global, then console)."""
+        if agent_name and agent_name in self._agent_backends:
+            return self._agent_backends[agent_name]
+        if self._global_backend is not None:
+            return self._global_backend
+        # Lazy import to avoid circular / heavy import at module level
+        from .backends import ConsoleBackend
+        return ConsoleBackend()
+
+    # ── Tool requirement management ──────────────────────────────────────
+
+    def add_requirement(self, tool_name: str, risk_level: str = "high") -> None:
+        self._required_tools.add(tool_name)
+        self._risk_levels[tool_name] = risk_level
+
+    def remove_requirement(self, tool_name: str) -> None:
+        self._required_tools.discard(tool_name)
+        self._risk_levels.pop(tool_name, None)
+
+    def is_required(self, tool_name: str) -> bool:
+        return tool_name in self._required_tools
+
+    def get_risk_level(self, tool_name: str) -> Optional[str]:
+        return self._risk_levels.get(tool_name)
+
+    # ── Context helpers ──────────────────────────────────────────────────
+
+    def mark_approved(self, tool_name: str) -> None:
+        approved = self._approved_context.get(set())
+        approved.add(tool_name)
+        self._approved_context.set(approved)
+
+    def is_already_approved(self, tool_name: str) -> bool:
+        return tool_name in self._approved_context.get(set())
+
+    def clear_approved(self) -> None:
+        self._approved_context.set(set())
+
+    def set_yaml_approved_tools(self, tools: List[str]) -> contextvars.Token:
+        return self._yaml_approved_tools.set(set(tools))
+
+    def reset_yaml_approved_tools(self, token: contextvars.Token) -> None:
+        self._yaml_approved_tools.reset(token)
+
+    def is_yaml_approved(self, tool_name: str) -> bool:
+        try:
+            return tool_name in self._yaml_approved_tools.get()
+        except LookupError:
+            return False
+
+    # ── Env-var check ────────────────────────────────────────────────────
+
+    @staticmethod
+    def is_env_auto_approve() -> bool:
+        return os.environ.get("PRAISONAI_AUTO_APPROVE", "").lower() in ("true", "1", "yes")
+
+    # ── Approval entry points ────────────────────────────────────────────
+
+    def approve_sync(
+        self,
+        agent_name: Optional[str],
+        tool_name: str,
+        arguments: Dict,
+    ) -> ApprovalDecision:
+        """Synchronous approval — used by ``Agent._execute_tool_impl``."""
+        # Fast-path: not required
+        if not self.is_required(tool_name):
+            return ApprovalDecision(approved=True, reason="No approval required")
+
+        # Already approved in this context
+        if self.is_already_approved(tool_name):
+            return ApprovalDecision(approved=True, reason="Already approved in context")
+
+        # Env auto-approve
+        if self.is_env_auto_approve():
+            self.mark_approved(tool_name)
+            return ApprovalDecision(approved=True, reason="Auto-approved (env)", approver="env")
+
+        # YAML auto-approve
+        if self.is_yaml_approved(tool_name):
+            self.mark_approved(tool_name)
+            return ApprovalDecision(approved=True, reason="Auto-approved (yaml)", approver="yaml")
+
+        # Delegate to backend
+        backend = self.get_backend(agent_name)
+        request = ApprovalRequest(
+            tool_name=tool_name,
+            arguments=arguments,
+            risk_level=self._risk_levels.get(tool_name, "medium"),
+            agent_name=agent_name,
+        )
+
+        # Prefer sync method if available
+        if hasattr(backend, "request_approval_sync"):
+            decision = backend.request_approval_sync(request)
+        else:
+            # Fallback: run async method
+            try:
+                decision = asyncio.run(backend.request_approval(request))
+            except RuntimeError:
+                # Already in an event loop — fall back to thread
+                import concurrent.futures
+                with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
+                    future = pool.submit(asyncio.run, backend.request_approval(request))
+                    decision = future.result(timeout=self.timeout)
+
+        if decision.approved:
+            self.mark_approved(tool_name)
+        return decision
+
+    async def approve_async(
+        self,
+        agent_name: Optional[str],
+        tool_name: str,
+        arguments: Dict,
+    ) -> ApprovalDecision:
+        """Asynchronous approval — used by async tool execution path."""
+        # Fast-path: not required
+        if not self.is_required(tool_name):
+            return ApprovalDecision(approved=True, reason="No approval required")
+
+        if self.is_already_approved(tool_name):
+            return ApprovalDecision(approved=True, reason="Already approved in context")
+
+        if self.is_env_auto_approve():
+            self.mark_approved(tool_name)
+            return ApprovalDecision(approved=True, reason="Auto-approved (env)", approver="env")
+
+        if self.is_yaml_approved(tool_name):
+            self.mark_approved(tool_name)
+            return ApprovalDecision(approved=True, reason="Auto-approved (yaml)", approver="yaml")
+
+        backend = self.get_backend(agent_name)
+        request = ApprovalRequest(
+            tool_name=tool_name,
+            arguments=arguments,
+            risk_level=self._risk_levels.get(tool_name, "medium"),
+            agent_name=agent_name,
+        )
+
+        try:
+            decision = await asyncio.wait_for(
+                backend.request_approval(request),
+                timeout=self.timeout,
+            )
+        except asyncio.TimeoutError:
+            decision = ApprovalDecision(approved=False, reason="Approval timed out")
+
+        if decision.approved:
+            self.mark_approved(tool_name)
+        return decision
@@ -1,13 +1,28 @@
 """
-Bot Protocols for PraisonAI Agents.
+Bot Protocols and Configuration for PraisonAI Agents.

-Provides protocols and base classes for building messaging bot implementations
-(Telegram, Discord, Slack, etc.) that connect agents to messaging platforms.
-
-This module contains only protocols and lightweight utilities.
-Heavy implementations live in the praisonai wrapper package.
+Defines the interfaces and configuration for messaging bot implementations.
+All implementations live in the praisonai wrapper package.
 """

+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .protocols import (
+        BotOSProtocol,  # noqa: F401
+        BotProtocol,
+        BotMessageProtocol,
+        BotUserProtocol,
+        BotChannelProtocol,
+        BotMessage,
+        BotUser,
+        BotChannel,
+        MessageType,
+        ChatCommandInfo,
+        ChatCommandProtocol,
+        ProbeResult,
+        HealthResult,
+    )
 from .protocols import (
    BotProtocol,
    BotMessageProtocol,
@@ -17,8 +32,13 @@ from .protocols import (
    BotUser,
    BotChannel,
    MessageType,
+    ChatCommandInfo,
+    ChatCommandProtocol,
+    BotOSProtocol,
+    ProbeResult,
+    HealthResult,
 )
-from .config import BotConfig
+from .config import BotConfig, BotOSConfig

 __all__ = [
    "BotProtocol",
@@ -30,4 +50,10 @@ __all__ = [
    "BotChannel",
    "BotConfig",
    "MessageType",
+    "ChatCommandInfo",
+    "ChatCommandProtocol",
+    "BotOSProtocol",
+    "BotOSConfig",
+    "ProbeResult",
+    "HealthResult",
 ]
@@ -43,12 +43,29 @@ class BotConfig:
    reply_in_thread: bool = False  # Default to inline, set True for thread replies
    thread_threshold: int = 500  # Auto-thread responses longer than this (0 = disabled)
    
+    # Group message policy
+    group_policy: str = "mention_only"  # respond_all, mention_only, command_only
+    
    # Default tools enabled for all bots
-    default_tools: List[str] = field(default_factory=lambda: ["execute_command", "search_web"])
+    default_tools: List[str] = field(default_factory=lambda: ["execute_command", "search_web", "schedule_add", "schedule_list", "schedule_remove"])
    
    # Auto-approve tool calls (useful for trusted environments)
    auto_approve_tools: bool = False  # If True, skip confirmation for tool execution
    
+    # Inbound message debounce (ms). Coalesces rapid messages from same user.
+    # 0 = disabled (default). Recommended: 1000-2000 for chat bots.
+    debounce_ms: int = 0
+    
+    # Ack emoji reaction on inbound messages. Empty string = disabled.
+    # When set, bot reacts with this emoji on receive (e.g. "⏳") and
+    # replaces it with done_emoji on completion (e.g. "✅").
+    ack_emoji: str = ""
+    done_emoji: str = "✅"
+    
+    # Session TTL in seconds. 0 = disabled (sessions never expire).
+    # When set, stale sessions older than this are auto-reaped.
+    session_ttl: int = 0
+    
    metadata: Dict[str, Any] = field(default_factory=dict)
    
    def to_dict(self) -> Dict[str, Any]:
@@ -70,6 +87,10 @@ class BotConfig:
            "thread_threshold": self.thread_threshold,
            "default_tools": self.default_tools,
            "auto_approve_tools": self.auto_approve_tools,
+            "debounce_ms": self.debounce_ms,
+            "ack_emoji": self.ack_emoji,
+            "done_emoji": self.done_emoji,
+            "session_ttl": self.session_ttl,
            "metadata": self.metadata,
        }
    
@@ -89,3 +110,30 @@ class BotConfig:
        if not self.allowed_channels:
            return True
        return channel_id in self.allowed_channels
+
+
+@dataclass
+class BotOSConfig:
+    """Configuration for BotOS — multi-platform bot orchestrator.
+
+    Attributes:
+        name: Human-readable name for this BotOS instance.
+        platforms: Per-platform config dicts keyed by platform name.
+            Example: ``{"telegram": {"token": "..."}, "discord": {"token": "..."}}``
+    """
+
+    name: str = "PraisonAI BotOS"
+    platforms: Dict[str, Dict[str, Any]] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Serialize to dict (hides tokens)."""
+        sanitized_platforms = {}
+        for plat, cfg in self.platforms.items():
+            sanitized = dict(cfg)
+            if "token" in sanitized:
+                sanitized["token"] = "***"
+            sanitized_platforms[plat] = sanitized
+        return {
+            "name": self.name,
+            "platforms": sanitized_platforms,
+        }
@@ -286,6 +286,76 @@ class BotChannelProtocol(Protocol):
        ...


+@dataclass
+class ProbeResult:
+    """Result of a channel connectivity probe.
+    
+    Attributes:
+        ok: Whether the probe succeeded
+        platform: Platform name
+        elapsed_ms: Time taken in milliseconds
+        bot_username: Bot's username (if available)
+        error: Error message (if probe failed)
+        details: Additional platform-specific details
+    """
+    
+    ok: bool
+    platform: str = ""
+    elapsed_ms: float = 0.0
+    bot_username: Optional[str] = None
+    error: Optional[str] = None
+    details: Dict[str, Any] = field(default_factory=dict)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "ok": self.ok,
+            "platform": self.platform,
+            "elapsed_ms": self.elapsed_ms,
+            "bot_username": self.bot_username,
+            "error": self.error,
+            "details": self.details,
+        }
+
+
+@dataclass
+class HealthResult:
+    """Detailed health status of a bot.
+    
+    Attributes:
+        ok: Overall health status
+        platform: Platform name
+        is_running: Whether the bot is actively running
+        uptime_seconds: Seconds since bot started (None if not running)
+        probe: Latest probe result (None if not probed)
+        sessions: Number of active sessions
+        error: Error message (if unhealthy)
+        details: Additional platform-specific health details
+    """
+    
+    ok: bool
+    platform: str = ""
+    is_running: bool = False
+    uptime_seconds: Optional[float] = None
+    probe: Optional[ProbeResult] = None
+    sessions: int = 0
+    error: Optional[str] = None
+    details: Dict[str, Any] = field(default_factory=dict)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "ok": self.ok,
+            "platform": self.platform,
+            "is_running": self.is_running,
+            "uptime_seconds": self.uptime_seconds,
+            "probe": self.probe.to_dict() if self.probe else None,
+            "sessions": self.sessions,
+            "error": self.error,
+            "details": self.details,
+        }
+
+
@runtime_checkable
 class BotProtocol(Protocol):
    """Protocol for messaging bot implementations.
@@ -451,3 +521,167 @@ class BotProtocol(Protocol):
            Channel information or None if not found
        """
        ...
+    
+    # Health & diagnostics
+    async def probe(self) -> ProbeResult:
+        """Test channel connectivity without starting the bot.
+        
+        Verifies the bot token is valid and the platform API is reachable.
+        
+        Returns:
+            ProbeResult with connectivity status and bot info.
+        """
+        ...
+    
+    async def health(self) -> HealthResult:
+        """Get detailed health status of the running bot.
+        
+        Returns:
+            HealthResult with running state, uptime, probe, and session count.
+        """
+        ...
+
+
+@dataclass
+class ChatCommandInfo:
+    """Metadata for a registered chat command.
+    
+    Attributes:
+        name: Command name (without /)
+        description: Human-readable description
+        usage: Usage example (e.g., "/status")
+        hidden: Whether to hide from /help listing
+    """
+    
+    name: str
+    description: str = ""
+    usage: Optional[str] = None
+    hidden: bool = False
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "name": self.name,
+            "description": self.description,
+            "usage": self.usage,
+            "hidden": self.hidden,
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ChatCommandInfo":
+        """Create from dictionary."""
+        return cls(
+            name=data.get("name", ""),
+            description=data.get("description", ""),
+            usage=data.get("usage"),
+            hidden=data.get("hidden", False),
+        )
+
+
+@runtime_checkable
+class ChatCommandProtocol(Protocol):
+    """Protocol for bots that support standardized chat commands.
+    
+    Extends BotProtocol with chat command registration and listing.
+    Implementations should track registered commands and expose them
+    for /help listings and command dispatching.
+    """
+    
+    def register_command(
+        self,
+        name: str,
+        handler: Callable,
+        description: str = "",
+        usage: Optional[str] = None,
+    ) -> None:
+        """Register a chat command handler.
+        
+        Args:
+            name: Command name (without /)
+            handler: Async callable to handle the command
+            description: Human-readable description
+            usage: Usage example string
+        """
+        ...
+    
+    def list_commands(self) -> List[ChatCommandInfo]:
+        """List all registered chat commands.
+        
+        Returns:
+            List of ChatCommandInfo for all registered commands
+        """
+        ...
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# BotOS Protocol — multi-platform bot orchestration
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+
+@runtime_checkable
+class BotOSProtocol(Protocol):
+    """Protocol for BotOS — multi-platform bot orchestrator.
+
+    BotOS manages multiple Bot instances across different messaging
+    platforms (Telegram, Discord, Slack, WhatsApp, etc.) with a single
+    unified lifecycle.
+
+    Hierarchy::
+
+        BotOS  (multi-platform orchestrator)
+        └── Bot  (single platform)
+            └── Agent / AgentTeam / AgentFlow  (AI brain)
+
+    Implementations live in the ``praisonai`` wrapper package.
+    """
+
+    @property
+    def is_running(self) -> bool:
+        """Whether the orchestrator is currently running."""
+        ...
+
+    async def start(self) -> None:
+        """Start all registered bots concurrently."""
+        ...
+
+    async def stop(self) -> None:
+        """Gracefully stop all running bots."""
+        ...
+
+    def add_bot(self, bot: Any) -> None:
+        """Register a Bot instance for orchestration.
+
+        Args:
+            bot: A Bot instance (satisfies BotProtocol).
+        """
+        ...
+
+    def list_bots(self) -> List[str]:
+        """List platform names of all registered bots.
+
+        Returns:
+            List of platform name strings.
+        """
+        ...
+
+    def remove_bot(self, platform: str) -> bool:
+        """Remove a registered bot by platform name.
+
+        Args:
+            platform: Platform identifier to remove.
+
+        Returns:
+            True if removed, False if not found.
+        """
+        ...
+
+    def get_bot(self, platform: str) -> Optional[Any]:
+        """Get a registered bot by platform name.
+
+        Args:
+            platform: Platform identifier (e.g. "telegram").
+
+        Returns:
+            The Bot instance, or None if not found.
+        """
+        ...
@@ -172,6 +172,10 @@ class MemoryConfig:
    history: bool = False
    history_limit: int = 10
    
+    # Auto-save session name (consolidated from standalone auto_save param)
+    # When set, automatically saves session to memory with this name
+    auto_save: Optional[str] = None
+    
    def to_dict(self) -> Dict[str, Any]:
        """Convert to dictionary."""
        learn_dict = None
@@ -193,6 +197,7 @@ class MemoryConfig:
            "learn": learn_dict,
            "history": self.history,
            "history_limit": self.history_limit,
+            "auto_save": self.auto_save,
        }


@@ -609,7 +614,8 @@ class ExecutionConfig:
    """
    Configuration for agent execution limits.
    
-    Consolidates: max_iter, max_rpm, max_execution_time, max_retry_limit
+    Consolidates: max_iter, max_rpm, max_execution_time, max_retry_limit,
+                  allow_code_execution, code_execution_mode, rate_limiter
    
    Usage:
        # Simple preset
@@ -622,6 +628,13 @@ class ExecutionConfig:
            max_execution_time=300,
            max_retry_limit=5,
        ))
+        
+        # With code execution and rate limiter
+        Agent(execution=ExecutionConfig(
+            code_execution=True,
+            code_mode="safe",
+            rate_limiter=my_limiter,
+        ))
    """
    # Iteration limits
    max_iter: int = 20
@@ -635,6 +648,13 @@ class ExecutionConfig:
    # Retry settings
    max_retry_limit: int = 2
    
+    # Code execution (consolidated from allow_code_execution + code_execution_mode)
+    code_execution: bool = False
+    code_mode: str = "safe"  # "safe" or "unsafe"
+    
+    # Rate limiter instance (consolidated from standalone rate_limiter param)
+    rate_limiter: Optional[Any] = None
+    
    def to_dict(self) -> Dict[str, Any]:
        """Convert to dictionary."""
        return {
@@ -642,6 +662,8 @@ class ExecutionConfig:
            "max_rpm": self.max_rpm,
            "max_execution_time": self.max_execution_time,
            "max_retry_limit": self.max_retry_limit,
+            "code_execution": self.code_execution,
+            "code_mode": self.code_mode,
        }


@@ -16,7 +16,7 @@ from .protocols import (
    GatewayMessage,
    EventType,
 )
-from .config import GatewayConfig, SessionConfig
+from .config import GatewayConfig, SessionConfig, ChannelRouteConfig, MultiChannelGatewayConfig

 __all__ = [
    "GatewayProtocol",
@@ -27,4 +27,6 @@ __all__ = [
    "EventType",
    "GatewayConfig",
    "SessionConfig",
+    "ChannelRouteConfig",
+    "MultiChannelGatewayConfig",
 ]
@@ -98,3 +98,148 @@ class GatewayConfig:
        """HTTP URL for this gateway."""
        protocol = "https" if self.is_secure else "http"
        return f"{protocol}://{self.host}:{self.port}"
+
+
+@dataclass
+class ChannelRouteConfig:
+    """Configuration for routing channel messages to agents.
+    
+    Attributes:
+        channel_type: Platform name (telegram, discord, slack, etc.)
+        token_env: Environment variable name for the channel token
+        app_token_env: Optional env var for app token (Slack Socket Mode)
+        routes: Mapping of context → agent_id
+                Keys: "dm", "group", "channel", "default"
+                Values: agent ID strings
+        enabled: Whether this channel is enabled
+        metadata: Additional channel-specific configuration
+    """
+    
+    channel_type: str
+    token_env: str = ""
+    app_token_env: Optional[str] = None
+    routes: Dict[str, str] = field(default_factory=lambda: {"default": "default"})
+    enabled: bool = True
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    
+    def get_agent_id(self, context: str = "default") -> str:
+        """Resolve agent ID for a given message context.
+        
+        Args:
+            context: Message context (dm, group, channel, default)
+            
+        Returns:
+            The agent ID for the given context, falling back to "default" route.
+        """
+        return self.routes.get(context, self.routes.get("default", "default"))
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "channel_type": self.channel_type,
+            "token_env": self.token_env,
+            "app_token_env": self.app_token_env,
+            "routes": dict(self.routes),
+            "enabled": self.enabled,
+            "metadata": dict(self.metadata),
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ChannelRouteConfig":
+        """Create from dictionary."""
+        return cls(
+            channel_type=data.get("channel_type", ""),
+            token_env=data.get("token_env", ""),
+            app_token_env=data.get("app_token_env"),
+            routes=data.get("routes", {"default": "default"}),
+            enabled=data.get("enabled", True),
+            metadata=data.get("metadata", {}),
+        )
+
+
+@dataclass
+class MultiChannelGatewayConfig:
+    """Configuration for multi-channel gateway mode.
+    
+    Loaded from gateway.yaml. Defines agents, channels, and routing.
+    
+    Attributes:
+        gateway: Base gateway configuration
+        agents: Agent configurations by ID (name → config dict)
+        channels: Channel routing configurations by name
+    """
+    
+    gateway: GatewayConfig = field(default_factory=GatewayConfig)
+    agents: Dict[str, Dict[str, Any]] = field(default_factory=dict)
+    channels: Dict[str, ChannelRouteConfig] = field(default_factory=dict)
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "MultiChannelGatewayConfig":
+        """Create from parsed YAML dictionary.
+        
+        Expected format::
+        
+            gateway:
+              host: "127.0.0.1"
+              port: 8765
+            agents:
+              personal:
+                instructions: "You are a helpful assistant"
+                model: gpt-4o-mini
+            channels:
+              telegram:
+                token: ${TELEGRAM_BOT_TOKEN}
+                routes:
+                  dm: personal
+                  default: personal
+        
+        Args:
+            data: Parsed YAML dictionary
+            
+        Returns:
+            Configured MultiChannelGatewayConfig instance
+        """
+        # Parse gateway section
+        gw_data = data.get("gateway", {})
+        gateway_config = GatewayConfig(
+            host=gw_data.get("host", "127.0.0.1"),
+            port=gw_data.get("port", 8765),
+            cors_origins=gw_data.get("cors_origins", ["*"]),
+            auth_token=gw_data.get("auth_token"),
+            max_connections=gw_data.get("max_connections", 1000),
+        )
+        
+        # Parse agents section (pass through as dicts)
+        agents = data.get("agents", {})
+        
+        # Parse channels section
+        channels: Dict[str, ChannelRouteConfig] = {}
+        for name, ch_data in data.get("channels", {}).items():
+            if isinstance(ch_data, dict):
+                channels[name] = ChannelRouteConfig(
+                    channel_type=name,
+                    token_env=ch_data.get("token", ""),
+                    app_token_env=ch_data.get("app_token"),
+                    routes=ch_data.get("routes", {"default": "default"}),
+                    enabled=ch_data.get("enabled", True),
+                    metadata={
+                        k: v for k, v in ch_data.items()
+                        if k not in ("token", "app_token", "routes", "enabled")
+                    },
+                )
+        
+        return cls(
+            gateway=gateway_config,
+            agents=agents,
+            channels=channels,
+        )
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "gateway": self.gateway.to_dict(),
+            "agents": dict(self.agents),
+            "channels": {
+                name: ch.to_dict() for name, ch in self.channels.items()
+            },
+        }
@@ -53,6 +53,11 @@ class EventType(str, Enum):
    MESSAGE_ACK = "message_ack"
    TYPING = "typing"
    
+    # Streaming events (relayed from agent's StreamEventEmitter)
+    TOKEN_STREAM = "token_stream"
+    TOOL_CALL_STREAM = "tool_call_stream"
+    STREAM_END = "stream_end"
+    
    # System events
    HEALTH = "health"
    ERROR = "error"
@@ -71,6 +71,10 @@ __all__ = [
    "SessionEndInput",
    "OnErrorInput",
    "OnRetryInput",
+    # Message lifecycle event inputs
+    "MessageReceivedInput",
+    "MessageSendingInput",
+    "MessageSentInput",
    # Middleware types
    "InvocationContext",
    "ModelRequest",
@@ -130,6 +134,9 @@ _LAZY_GROUPS = {
        'SessionEndInput': ('praisonaiagents.hooks.events', 'SessionEndInput'),
        'OnErrorInput': ('praisonaiagents.hooks.events', 'OnErrorInput'),
        'OnRetryInput': ('praisonaiagents.hooks.events', 'OnRetryInput'),
+        'MessageReceivedInput': ('praisonaiagents.hooks.events', 'MessageReceivedInput'),
+        'MessageSendingInput': ('praisonaiagents.hooks.events', 'MessageSendingInput'),
+        'MessageSentInput': ('praisonaiagents.hooks.events', 'MessageSentInput'),
    },
    'middleware_types': {
        'InvocationContext': ('praisonaiagents.hooks.middleware', 'InvocationContext'),
@@ -193,3 +193,68 @@ class OnRetryInput(HookInput):
            "operation": self.operation
        })
        return base
+
+
+@dataclass
+class MessageReceivedInput(HookInput):
+    """Input for MESSAGE_RECEIVED hooks (bot received an incoming message)."""
+    platform: str = ""
+    content: str = ""
+    sender_id: str = ""
+    channel_id: str = ""
+    channel_type: str = ""
+    message_id: str = ""
+    
+    def to_dict(self) -> Dict[str, Any]:
+        base = super().to_dict()
+        base.update({
+            "platform": self.platform,
+            "content": self.content[:500] if self.content else "",
+            "sender_id": self.sender_id,
+            "channel_id": self.channel_id,
+            "channel_type": self.channel_type,
+            "message_id": self.message_id,
+        })
+        return base
+
+
+@dataclass
+class MessageSendingInput(HookInput):
+    """Input for MESSAGE_SENDING hooks (bot about to send a message).
+    
+    Hooks can modify content or cancel the send by returning
+    HookResult with decision=DENY.
+    """
+    platform: str = ""
+    content: str = ""
+    channel_id: str = ""
+    reply_to: Optional[str] = None
+    
+    def to_dict(self) -> Dict[str, Any]:
+        base = super().to_dict()
+        base.update({
+            "platform": self.platform,
+            "content": self.content[:500] if self.content else "",
+            "channel_id": self.channel_id,
+            "reply_to": self.reply_to,
+        })
+        return base
+
+
+@dataclass
+class MessageSentInput(HookInput):
+    """Input for MESSAGE_SENT hooks (bot successfully sent a message)."""
+    platform: str = ""
+    content: str = ""
+    channel_id: str = ""
+    message_id: str = ""
+    
+    def to_dict(self) -> Dict[str, Any]:
+        base = super().to_dict()
+        base.update({
+            "platform": self.platform,
+            "content": self.content[:500] if self.content else "",
+            "channel_id": self.channel_id,
+            "message_id": self.message_id,
+        })
+        return base
@@ -70,7 +70,7 @@ class HookRunner:
            default_timeout: Default timeout for hooks
            cwd: Working directory for command hooks
        """
-        self._registry = registry or HookRegistry()
+        self._registry = registry if registry is not None else HookRegistry()
        self._default_timeout = default_timeout
        self._cwd = cwd or os.getcwd()
    
@@ -142,12 +142,19 @@ class HookRunner:
        """
        try:
            loop = asyncio.get_running_loop()
-            # If we're in an async context, create a task
-            future = asyncio.ensure_future(self.execute(event, input_data, target))
-            return loop.run_until_complete(future)
        except RuntimeError:
-            # No event loop running, create one
-            return asyncio.run(self.execute(event, input_data, target))
+            loop = None
+
+        if loop is not None and loop.is_running():
+            # Already inside a running async loop — cannot use run_until_complete.
+            # Schedule as fire-and-forget task to avoid leaking unawaited coroutines.
+            # Callers that need results in async context should use
+            # ``await runner.execute(...)`` directly.
+            loop.create_task(self.execute(event, input_data, target))
+            return []
+
+        # No running loop — safe to create one
+        return asyncio.run(self.execute(event, input_data, target))
    
    async def _execute_parallel(
        self,
@@ -63,6 +63,11 @@ class HookEvent(str, Enum):
    ON_CONFIG = "on_config"
    ON_AUTH = "on_auth"
    
+    # Schedule lifecycle
+    SCHEDULE_ADD = "schedule_add"
+    SCHEDULE_REMOVE = "schedule_remove"
+    SCHEDULE_TRIGGER = "schedule_trigger"
+
    # Claude Code parity events
    USER_PROMPT_SUBMIT = "user_prompt_submit"  # When user submits a prompt
    NOTIFICATION = "notification"              # When notification is sent
@@ -185,9 +185,18 @@ Respond with ONLY a valid JSON tool call in this format:
            
            # Set litellm options globally
            litellm.set_verbose = False
-            litellm.success_callback = []
+            # Preserve externally-set callbacks (e.g., from observability providers)
+            _existing_callbacks = getattr(litellm, 'callbacks', []) or []
+            _existing_success = getattr(litellm, 'success_callback', []) or []
+            _obs_callbacks = [c for c in _existing_callbacks if isinstance(c, str) and c in (
+                'langsmith', 'langfuse', 'datadog', 'opik', 'braintrust', 'mlflow', 'langwatch',
+            )]
+            _obs_success = [c for c in _existing_success if isinstance(c, str) and c in (
+                'langsmith', 'langfuse', 'datadog', 'opik', 'braintrust', 'mlflow', 'langwatch',
+            )]
+            litellm.success_callback = _obs_success
            litellm._async_success_callback = []
-            litellm.callbacks = []
+            litellm.callbacks = _obs_callbacks
            
            # Suppress all litellm debug info
            litellm.suppress_debug_info = True
@@ -45,6 +45,7 @@ from .protocols import (
    DeletableMemoryProtocol,
    AsyncDeletableMemoryProtocol,
    EntityMemoryProtocol,
+    AgentMemoryProtocol,
 )


@@ -275,6 +275,47 @@ class EntityMemoryProtocol(Protocol):
        ...


+@runtime_checkable
+class AgentMemoryProtocol(Protocol):
+    """
+    Protocol for memory implementations used by the Agent class.
+    
+    This defines the interface that Agent expects from its _memory_instance.
+    Both FileMemory and Memory satisfy this protocol, enabling consistent
+    usage across backends.
+    
+    Example:
+        ```python
+        class CustomMemory:
+            def get_context(self, query=None):
+                return "remembered facts here"
+            
+            def save_session(self, name, conversation_history=None, metadata=None):
+                pass  # persist session
+        
+        agent = Agent(memory=CustomMemory())
+        ```
+    """
+    
+    def get_context(
+        self,
+        query: Optional[str] = None,
+        **kwargs
+    ) -> str:
+        """Get memory context for injection into system prompt."""
+        ...
+    
+    def save_session(
+        self,
+        name: str,
+        conversation_history: Optional[List[Dict[str, Any]]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        **kwargs
+    ) -> None:
+        """Save a conversation session to memory."""
+        ...
+
+
 __all__ = [
    'MemoryProtocol',
    'ResettableMemoryProtocol',
@@ -282,5 +323,6 @@ __all__ = [
    'AsyncDeletableMemoryProtocol',
    'AsyncMemoryProtocol',
    'EntityMemoryProtocol',
+    'AgentMemoryProtocol',
 ]

@@ -0,0 +1,66 @@
+"""
+Scheduler module for PraisonAI Agents.
+
+Provides agent-centric scheduling via tools — agents can add, list,
+and remove scheduled jobs without any changes to the Agent class.
+
+Usage:
+    from praisonaiagents import Agent
+    from praisonaiagents.tools import schedule_add, schedule_list, schedule_remove
+
+    agent = Agent(
+        name="assistant",
+        tools=[schedule_add, schedule_list, schedule_remove],
+    )
+    agent.start("Remind me to check email every morning at 7am")
+
+Default storage: ~/.praisonai/schedules/jobs.json
+"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .models import Schedule, ScheduleJob
+    from .store import FileScheduleStore
+    from .parser import parse_schedule
+    from .runner import ScheduleRunner
+
+_module_cache = {}
+
+
+def __getattr__(name: str):
+    """Lazy load scheduler components."""
+    if name in _module_cache:
+        return _module_cache[name]
+
+    if name in ("Schedule", "ScheduleJob"):
+        from .models import Schedule, ScheduleJob
+        _module_cache["Schedule"] = Schedule
+        _module_cache["ScheduleJob"] = ScheduleJob
+        return _module_cache[name]
+
+    if name == "FileScheduleStore":
+        from .store import FileScheduleStore
+        _module_cache[name] = FileScheduleStore
+        return FileScheduleStore
+
+    if name == "parse_schedule":
+        from .parser import parse_schedule
+        _module_cache[name] = parse_schedule
+        return parse_schedule
+
+    if name == "ScheduleRunner":
+        from .runner import ScheduleRunner
+        _module_cache[name] = ScheduleRunner
+        return ScheduleRunner
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = [
+    "Schedule",
+    "ScheduleJob",
+    "FileScheduleStore",
+    "parse_schedule",
+    "ScheduleRunner",
+]
@@ -0,0 +1,113 @@
+"""
+Schedule models for PraisonAI Agents.
+
+Lightweight dataclasses — no heavy dependencies.
+"""
+
+import time
+import uuid
+from dataclasses import dataclass, field
+from typing import Any, Dict, Literal, Optional
+
+
+@dataclass
+class Schedule:
+    """When to run a scheduled job.
+
+    Supports three kinds:
+    - ``every``: recurring interval in seconds
+    - ``cron``: 5-field cron expression (requires optional ``croniter``)
+    - ``at``: one-shot ISO 8601 timestamp
+    """
+
+    kind: Literal["every", "cron", "at"] = "every"
+    every_seconds: Optional[int] = None
+    cron_expr: Optional[str] = None
+    at: Optional[str] = None
+    tz: Optional[str] = None
+
+    # ── serialisation ────────────────────────────────────────────────
+
+    def to_dict(self) -> Dict[str, Any]:
+        d: Dict[str, Any] = {"kind": self.kind}
+        if self.every_seconds is not None:
+            d["every_seconds"] = self.every_seconds
+        if self.cron_expr is not None:
+            d["cron_expr"] = self.cron_expr
+        if self.at is not None:
+            d["at"] = self.at
+        if self.tz is not None:
+            d["tz"] = self.tz
+        return d
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> "Schedule":
+        return cls(
+            kind=d.get("kind", "every"),
+            every_seconds=d.get("every_seconds"),
+            cron_expr=d.get("cron_expr"),
+            at=d.get("at"),
+            tz=d.get("tz"),
+        )
+
+
+@dataclass
+class ScheduleJob:
+    """A persisted scheduled job.
+
+    Attributes:
+        id: Unique identifier (auto-generated).
+        name: Human-readable name.
+        schedule: When to run.
+        message: Prompt / payload to deliver when triggered.
+        agent_id: Optional owning agent.
+        session_target: ``"main"`` injects into running session;
+                        ``"isolated"`` creates a fresh agent turn.
+        enabled: Toggle without deleting.
+        delete_after_run: Auto-remove after first execution (one-shot).
+        created_at: Epoch timestamp.
+        last_run_at: Epoch timestamp of most recent execution.
+    """
+
+    name: str = ""
+    schedule: Schedule = field(default_factory=Schedule)
+    message: str = ""
+    id: str = field(default_factory=lambda: uuid.uuid4().hex[:12])
+    agent_id: Optional[str] = None
+    session_target: Literal["main", "isolated"] = "isolated"
+    enabled: bool = True
+    delete_after_run: bool = False
+    created_at: float = field(default_factory=time.time)
+    last_run_at: Optional[float] = None
+
+    # ── serialisation ────────────────────────────────────────────────
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "id": self.id,
+            "name": self.name,
+            "schedule": self.schedule.to_dict(),
+            "message": self.message,
+            "agent_id": self.agent_id,
+            "session_target": self.session_target,
+            "enabled": self.enabled,
+            "delete_after_run": self.delete_after_run,
+            "created_at": self.created_at,
+            "last_run_at": self.last_run_at,
+        }
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> "ScheduleJob":
+        sched_data = d.get("schedule", {})
+        return cls(
+            id=d.get("id", uuid.uuid4().hex[:12]),
+            name=d.get("name", ""),
+            schedule=Schedule.from_dict(sched_data) if isinstance(sched_data, dict) else Schedule(),
+            message=d.get("message", ""),
+            agent_id=d.get("agent_id"),
+            session_target=d.get("session_target", "isolated"),
+            enabled=d.get("enabled", True),
+            delete_after_run=d.get("delete_after_run", False),
+            created_at=d.get("created_at", time.time()),
+            last_run_at=d.get("last_run_at"),
+        )
@@ -0,0 +1,105 @@
+"""
+Schedule expression parser for PraisonAI Agents.
+
+Parses human-friendly schedule strings into ``Schedule`` objects.
+No external dependencies for interval parsing; ``croniter`` is optional
+and only imported when a cron expression is used.
+
+Supported formats:
+    "hourly"                  → every 3600s
+    "daily"                   → every 86400s
+    "*/30m"                   → every 1800s
+    "*/6h"                    → every 21600s
+    "*/10s"                   → every 10s
+    "3600"                    → every 3600s (raw seconds)
+    "cron:0 7 * * *"          → cron expression
+    "at:2026-03-01T09:00:00"  → one-shot ISO timestamp
+    "in 20 minutes"           → one-shot ~20min from now
+"""
+
+import re
+from datetime import datetime, timedelta, timezone
+
+from .models import Schedule
+
+_KEYWORD_MAP = {
+    "hourly": 3600,
+    "daily": 86400,
+    "weekly": 604800,
+}
+
+_INTERVAL_RE = re.compile(
+    r"^\*?/?\*?(\d+)\s*(s|sec|second|seconds|m|min|minute|minutes|h|hr|hour|hours)$",
+    re.IGNORECASE,
+)
+
+_RELATIVE_RE = re.compile(
+    r"^in\s+(\d+)\s*(s|sec|second|seconds|m|min|minute|minutes|h|hr|hour|hours)$",
+    re.IGNORECASE,
+)
+
+_UNIT_MULTIPLIER = {
+    "s": 1, "sec": 1, "second": 1, "seconds": 1,
+    "m": 60, "min": 60, "minute": 60, "minutes": 60,
+    "h": 3600, "hr": 3600, "hour": 3600, "hours": 3600,
+}
+
+
+def parse_schedule(expr: str) -> Schedule:
+    """Parse a schedule expression string into a ``Schedule`` object.
+
+    Raises ``ValueError`` for unrecognised expressions.
+    """
+    if not expr or not expr.strip():
+        raise ValueError("Schedule expression cannot be empty")
+
+    expr = expr.strip()
+
+    # Keyword shortcuts
+    lower = expr.lower()
+    if lower in _KEYWORD_MAP:
+        return Schedule(kind="every", every_seconds=_KEYWORD_MAP[lower])
+
+    # Cron prefix
+    if lower.startswith("cron:"):
+        cron_expr = expr[5:].strip()
+        if not cron_expr:
+            raise ValueError("Empty cron expression after 'cron:' prefix")
+        return Schedule(kind="cron", cron_expr=cron_expr)
+
+    # At prefix (ISO timestamp)
+    if lower.startswith("at:"):
+        at_str = expr[3:].strip()
+        if not at_str:
+            raise ValueError("Empty timestamp after 'at:' prefix")
+        return Schedule(kind="at", at=at_str)
+
+    # Interval pattern: */30m, */6h, */10s
+    m = _INTERVAL_RE.match(expr)
+    if m:
+        value = int(m.group(1))
+        unit = m.group(2).lower()
+        seconds = value * _UNIT_MULTIPLIER[unit]
+        return Schedule(kind="every", every_seconds=seconds)
+
+    # Relative pattern: "in 20 minutes"
+    m = _RELATIVE_RE.match(expr)
+    if m:
+        value = int(m.group(1))
+        unit = m.group(2).lower()
+        delta_seconds = value * _UNIT_MULTIPLIER[unit]
+        target = datetime.now(timezone.utc) + timedelta(seconds=delta_seconds)
+        return Schedule(kind="at", at=target.isoformat())
+
+    # Raw numeric seconds
+    try:
+        seconds = int(expr)
+        if seconds > 0:
+            return Schedule(kind="every", every_seconds=seconds)
+    except ValueError:
+        pass
+
+    raise ValueError(
+        f"Unrecognised schedule expression: {expr!r}. "
+        "Use 'hourly', 'daily', '*/30m', 'cron:EXPR', 'at:ISO', or 'in N minutes'."
+    )
@@ -0,0 +1,98 @@
+"""
+Schedule runner for PraisonAI Agents.
+
+Checks the store for due jobs and returns them. Execution of the job
+payload is the caller's responsibility (keeping the runner lightweight).
+"""
+
+import logging
+import time
+from datetime import datetime, timezone
+from typing import List
+
+from .models import ScheduleJob
+from .store import FileScheduleStore
+
+logger = logging.getLogger(__name__)
+
+
+class ScheduleRunner:
+    """Stateless helper that inspects a store and returns due jobs.
+
+    The runner does NOT own a loop or thread — callers decide how
+    and when to call ``get_due_jobs()``.
+    """
+
+    def __init__(self, store: FileScheduleStore):
+        self._store = store
+
+    # ── public ───────────────────────────────────────────────────────
+
+    def get_due_jobs(self) -> List[ScheduleJob]:
+        """Return all enabled jobs that are due for execution *now*."""
+        now = time.time()
+        due: List[ScheduleJob] = []
+        for job in self._store.list():
+            if not job.enabled:
+                continue
+            if self._is_due(job, now):
+                due.append(job)
+        return due
+
+    def mark_run(self, job: ScheduleJob) -> None:
+        """Update ``last_run_at`` and optionally delete one-shot jobs."""
+        job.last_run_at = time.time()
+        if job.delete_after_run:
+            self._store.remove(job.id)
+        else:
+            self._store.update(job)
+
+    # ── internals ────────────────────────────────────────────────────
+
+    def _is_due(self, job: ScheduleJob, now: float) -> bool:
+        sched = job.schedule
+
+        if sched.kind == "every":
+            if sched.every_seconds is None:
+                return False
+            if job.last_run_at is None:
+                return True  # Never run → due immediately
+            return (now - job.last_run_at) >= sched.every_seconds
+
+        if sched.kind == "at":
+            if sched.at is None:
+                return False
+            if job.last_run_at is not None:
+                return False  # Already ran
+            try:
+                target = datetime.fromisoformat(sched.at)
+                if target.tzinfo is None:
+                    target = target.replace(tzinfo=timezone.utc)
+                return datetime.now(timezone.utc) >= target
+            except (ValueError, TypeError):
+                logger.warning("Invalid 'at' timestamp for job %s: %s", job.id, sched.at)
+                return False
+
+        if sched.kind == "cron":
+            return self._cron_is_due(job, now)
+
+        return False
+
+    @staticmethod
+    def _cron_is_due(job: ScheduleJob, now: float) -> bool:
+        """Check cron schedule. Requires optional ``croniter``."""
+        if job.schedule.cron_expr is None:
+            return False
+        try:
+            from croniter import croniter  # type: ignore[import-untyped]
+        except ImportError:
+            logger.warning(
+                "croniter not installed — cron schedules are unavailable. "
+                "Install with: pip install croniter"
+            )
+            return False
+
+        base_time = job.last_run_at or job.created_at
+        cron = croniter(job.schedule.cron_expr, base_time)
+        next_run = cron.get_next(float)
+        return now >= next_run
@@ -0,0 +1,108 @@
+"""
+File-based schedule store for PraisonAI Agents.
+
+Persists scheduled jobs to ``~/.praisonai/schedules/jobs.json``.
+Thread-safe, no external dependencies.
+"""
+
+import json
+import logging
+import os
+import threading
+from typing import Dict, List, Optional
+
+from .models import ScheduleJob
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_DIR = os.path.join(os.path.expanduser("~"), ".praisonai", "schedules")
+_JOBS_FILE = "jobs.json"
+
+
+class FileScheduleStore:
+    """CRUD store backed by a single JSON file.
+
+    Thread-safe for multi-agent scenarios.
+    """
+
+    def __init__(self, store_dir: Optional[str] = None):
+        self._dir = store_dir or _DEFAULT_DIR
+        self._path = os.path.join(self._dir, _JOBS_FILE)
+        self._lock = threading.RLock()
+        self._jobs: Dict[str, ScheduleJob] = {}
+        self._load()
+
+    # ── public API ───────────────────────────────────────────────────
+
+    def add(self, job: ScheduleJob) -> None:
+        """Add a job. Raises ``ValueError`` if id already exists."""
+        with self._lock:
+            if job.id in self._jobs:
+                raise ValueError(f"Job '{job.id}' already exists")
+            self._jobs[job.id] = job
+            self._save()
+
+    def get(self, job_id: str) -> Optional[ScheduleJob]:
+        with self._lock:
+            return self._jobs.get(job_id)
+
+    def get_by_name(self, name: str) -> Optional[ScheduleJob]:
+        with self._lock:
+            for job in self._jobs.values():
+                if job.name == name:
+                    return job
+            return None
+
+    def list(self, agent_id: Optional[str] = None) -> List[ScheduleJob]:
+        with self._lock:
+            jobs = list(self._jobs.values())
+        if agent_id is not None:
+            jobs = [j for j in jobs if j.agent_id == agent_id]
+        return jobs
+
+    def update(self, job: ScheduleJob) -> None:
+        with self._lock:
+            self._jobs[job.id] = job
+            self._save()
+
+    def remove(self, job_id: str) -> bool:
+        with self._lock:
+            if job_id in self._jobs:
+                del self._jobs[job_id]
+                self._save()
+                return True
+            return False
+
+    def remove_by_name(self, name: str) -> bool:
+        with self._lock:
+            for jid, job in list(self._jobs.items()):
+                if job.name == name:
+                    del self._jobs[jid]
+                    self._save()
+                    return True
+            return False
+
+    # ── persistence ──────────────────────────────────────────────────
+
+    def _load(self) -> None:
+        if not os.path.exists(self._path):
+            return
+        try:
+            with open(self._path, "r") as f:
+                data = json.load(f)
+            for d in data:
+                job = ScheduleJob.from_dict(d)
+                self._jobs[job.id] = job
+        except Exception as e:
+            logger.warning("Failed to load schedule store from %s: %s", self._path, e)
+
+    def _save(self) -> None:
+        try:
+            os.makedirs(self._dir, exist_ok=True)
+            data = [j.to_dict() for j in self._jobs.values()]
+            tmp = self._path + ".tmp"
+            with open(tmp, "w") as f:
+                json.dump(data, f, indent=2)
+            os.replace(tmp, self._path)
+        except Exception as e:
+            logger.warning("Failed to save schedule store to %s: %s", self._path, e)
@@ -29,6 +29,8 @@ from typing import TYPE_CHECKING

 if TYPE_CHECKING:
    from .store import DefaultSessionStore, SessionMessage, SessionData
+    from .protocols import SessionStoreProtocol
+    from .hierarchy import HierarchicalSessionStore, SessionSnapshot, ExtendedSessionData

 # Lazy loading for zero import overhead
 _module_cache = {}
@@ -64,6 +66,31 @@ def __getattr__(name: str):
        _module_cache[name] = get_default_session_store
        return get_default_session_store
    
+    if name == "SessionStoreProtocol":
+        from .protocols import SessionStoreProtocol
+        _module_cache[name] = SessionStoreProtocol
+        return SessionStoreProtocol
+    
+    if name == "HierarchicalSessionStore":
+        from .hierarchy import HierarchicalSessionStore
+        _module_cache[name] = HierarchicalSessionStore
+        return HierarchicalSessionStore
+    
+    if name == "get_hierarchical_session_store":
+        from .hierarchy import get_hierarchical_session_store
+        _module_cache[name] = get_hierarchical_session_store
+        return get_hierarchical_session_store
+    
+    if name == "SessionSnapshot":
+        from .hierarchy import SessionSnapshot
+        _module_cache[name] = SessionSnapshot
+        return SessionSnapshot
+    
+    if name == "ExtendedSessionData":
+        from .hierarchy import ExtendedSessionData
+        _module_cache[name] = ExtendedSessionData
+        return ExtendedSessionData
+    
    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")


@@ -73,4 +100,9 @@ __all__ = [
    "SessionMessage", 
    "SessionData",
    "get_default_session_store",
+    "SessionStoreProtocol",
+    "HierarchicalSessionStore",
+    "get_hierarchical_session_store",
+    "SessionSnapshot",
+    "ExtendedSessionData",
 ]
@@ -0,0 +1,131 @@
+"""
+Session Store Protocol for PraisonAI Agents.
+
+Defines the minimal interface contract for session persistence backends.
+Any class implementing these methods can be used as a session store.
+
+Built-in implementations:
+- DefaultSessionStore (JSON file-based)
+- HierarchicalSessionStore (extends DefaultSessionStore with fork/snapshot)
+
+Custom implementations (e.g. Redis, MongoDB, PostgreSQL) can implement
+this protocol for seamless swapping.
+
+Usage:
+    from praisonaiagents.session.protocols import SessionStoreProtocol
+    
+    class RedisSessionStore:
+        def add_message(self, session_id, role, content, metadata=None):
+            ...  # Store in Redis
+        
+        def get_chat_history(self, session_id, max_messages=None):
+            ...  # Retrieve from Redis
+        
+        # ... other methods
+    
+    # Type-check at runtime
+    store: SessionStoreProtocol = RedisSessionStore()
+    assert isinstance(store, SessionStoreProtocol)
+"""
+
+from typing import Any, Dict, List, Optional, Protocol, runtime_checkable
+
+
+@runtime_checkable
+class SessionStoreProtocol(Protocol):
+    """Protocol for session persistence backends.
+    
+    Defines the minimal interface for storing and retrieving
+    agent conversation sessions. Implementations must provide
+    these five core methods.
+    
+    Built-in implementations:
+    - DefaultSessionStore (JSON files with atomic writes)
+    - HierarchicalSessionStore (fork, snapshot, revert)
+    
+    Example custom implementation::
+    
+        class MyStore:
+            def add_message(self, session_id, role, content, metadata=None):
+                ...
+            def get_chat_history(self, session_id, max_messages=None):
+                return [{"role": "user", "content": "Hi"}]
+            def clear_session(self, session_id):
+                return True
+            def delete_session(self, session_id):
+                return True
+            def session_exists(self, session_id):
+                return False
+        
+        store: SessionStoreProtocol = MyStore()
+        assert isinstance(store, SessionStoreProtocol)  # True
+    """
+    
+    def add_message(
+        self,
+        session_id: str,
+        role: str,
+        content: str,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> bool:
+        """Add a message to a session.
+        
+        Args:
+            session_id: Unique session identifier.
+            role: Message role ("user", "assistant", "system").
+            content: Message content text.
+            metadata: Optional metadata dict.
+            
+        Returns:
+            True if saved successfully.
+        """
+        ...
+    
+    def get_chat_history(
+        self,
+        session_id: str,
+        max_messages: Optional[int] = None,
+    ) -> List[Dict[str, str]]:
+        """Get chat history in LLM-compatible format.
+        
+        Args:
+            session_id: Unique session identifier.
+            max_messages: Maximum messages to return (most recent).
+            
+        Returns:
+            List of {"role": "...", "content": "..."} dicts.
+        """
+        ...
+    
+    def clear_session(self, session_id: str) -> bool:
+        """Clear all messages from a session (keep session metadata).
+        
+        Args:
+            session_id: Unique session identifier.
+            
+        Returns:
+            True if cleared successfully.
+        """
+        ...
+    
+    def delete_session(self, session_id: str) -> bool:
+        """Delete a session completely (data + metadata).
+        
+        Args:
+            session_id: Unique session identifier.
+            
+        Returns:
+            True if deleted successfully.
+        """
+        ...
+    
+    def session_exists(self, session_id: str) -> bool:
+        """Check if a session exists.
+        
+        Args:
+            session_id: Unique session identifier.
+            
+        Returns:
+            True if the session exists.
+        """
+        ...
@@ -149,6 +149,12 @@ TOOL_MAPPINGS = {
    'create_skill_tools': ('.skill_tools', None),
    'SkillTools': ('.skill_tools', 'SkillTools'),
    'skill_tools': ('.skill_tools', None),
+    
+    # Schedule Tools (agent-centric scheduling)
+    'schedule_add': ('.schedule_tools', None),
+    'schedule_list': ('.schedule_tools', None),
+    'schedule_remove': ('.schedule_tools', None),
+    'schedule_tools': ('.schedule_tools', None),
 }

 _instances = {}  # Cache for class instances
@@ -181,10 +187,11 @@ def __getattr__(name: str) -> Any:
            'crawl4ai_sync', 'crawl4ai_extract_sync',
            'search_web', 'web_search', 'get_available_providers',
            'web_crawl', 'crawl_web', 'get_available_crawl_providers',
-            'run_skill_script', 'read_skill_file', 'list_skill_scripts', 'create_skill_tools'
+            'run_skill_script', 'read_skill_file', 'list_skill_scripts', 'create_skill_tools',
+            'schedule_add', 'schedule_list', 'schedule_remove'
        ]:
            return getattr(module, name)
-        if name in ['file_tools', 'spider_tools', 'python_tools', 'shell_tools', 'cot_tools', 'tavily_tools', 'youdotcom_tools', 'exa_tools', 'crawl4ai_tools', 'skill_tools']:
+        if name in ['file_tools', 'spider_tools', 'python_tools', 'shell_tools', 'cot_tools', 'tavily_tools', 'youdotcom_tools', 'exa_tools', 'crawl4ai_tools', 'skill_tools', 'schedule_tools']:
            return module  # Returns the callable module
        return getattr(module, name)
    else:
@@ -0,0 +1,152 @@
+"""
+Schedule tools for PraisonAI Agents.
+
+Agent-centric scheduling — agents call these tools to add, list, and
+remove scheduled jobs.  No changes to the Agent class required.
+
+Usage:
+    from praisonaiagents import Agent
+    from praisonaiagents.tools import schedule_add, schedule_list, schedule_remove
+
+    agent = Agent(
+        name="assistant",
+        instructions="You can set reminders and schedules for the user.",
+        tools=[schedule_add, schedule_list, schedule_remove],
+    )
+    agent.start("Remind me to check email every morning at 7am")
+"""
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+# ── lazy singleton store ─────────────────────────────────────────────────────
+
+_store_instance = None
+
+
+def _get_store():
+    """Return (or create) the global ``FileScheduleStore``."""
+    global _store_instance
+    if _store_instance is None:
+        from ..scheduler.store import FileScheduleStore
+        _store_instance = FileScheduleStore()
+    return _store_instance
+
+
+# ── tools ────────────────────────────────────────────────────────────────────
+
+
+def schedule_add(
+    name: str,
+    schedule: str,
+    message: str = "",
+) -> str:
+    """Add a new scheduled job.
+
+    Args:
+        name: Human-readable name for this schedule (e.g. "morning-email-check").
+        schedule: When to run. Accepted formats:
+            - "hourly", "daily"
+            - "*/30m", "*/6h", "*/10s"  (interval)
+            - "cron:0 7 * * *"          (cron expression)
+            - "at:2026-03-01T09:00:00"  (one-shot ISO timestamp)
+            - "in 20 minutes"           (relative one-shot)
+        message: The prompt or reminder text to deliver when triggered.
+
+    Returns:
+        Confirmation string with the job id.
+    """
+    try:
+        from ..scheduler.parser import parse_schedule
+        from ..scheduler.models import ScheduleJob
+
+        sched = parse_schedule(schedule)
+        job = ScheduleJob(name=name, schedule=sched, message=message)
+
+        store = _get_store()
+
+        # Prevent duplicate names
+        existing = store.get_by_name(name)
+        if existing:
+            return f"A schedule named '{name}' already exists (id: {existing.id}). Remove it first or choose a different name."
+
+        store.add(job)
+        return f"Schedule '{name}' added (id: {job.id}, {schedule})."
+    except ValueError as e:
+        return f"Error adding schedule: {e}"
+    except Exception as e:
+        logger.error("schedule_add failed: %s", e, exc_info=True)
+        return f"Error adding schedule: {e}"
+
+
+def schedule_list() -> str:
+    """List all scheduled jobs.
+
+    Returns:
+        A formatted string listing every job with its id, name, schedule,
+        status, and message.  Returns a friendly message when empty.
+    """
+    try:
+        store = _get_store()
+        jobs = store.list()
+        if not jobs:
+            return "No schedules found. Use schedule_add to create one."
+
+        lines = [f"Found {len(jobs)} schedule(s):\n"]
+        for j in jobs:
+            status = "enabled" if j.enabled else "disabled"
+            sched = j.schedule
+            if sched.kind == "every" and sched.every_seconds:
+                sched_str = _human_interval(sched.every_seconds)
+            elif sched.kind == "cron":
+                sched_str = f"cron: {sched.cron_expr}"
+            elif sched.kind == "at":
+                sched_str = f"at: {sched.at}"
+            else:
+                sched_str = str(sched.kind)
+            lines.append(
+                f"  - {j.name} (id: {j.id}) [{status}] — {sched_str}"
+                + (f" — \"{j.message}\"" if j.message else "")
+            )
+        return "\n".join(lines)
+    except Exception as e:
+        logger.error("schedule_list failed: %s", e, exc_info=True)
+        return f"Error listing schedules: {e}"
+
+
+def schedule_remove(name: str) -> str:
+    """Remove a scheduled job by name.
+
+    Args:
+        name: The name of the schedule to remove.
+
+    Returns:
+        Confirmation or not-found message.
+    """
+    try:
+        store = _get_store()
+        removed = store.remove_by_name(name)
+        if removed:
+            return f"Schedule '{name}' removed."
+        return f"Schedule '{name}' not found."
+    except Exception as e:
+        logger.error("schedule_remove failed: %s", e, exc_info=True)
+        return f"Error removing schedule: {e}"
+
+
+# ── helpers ──────────────────────────────────────────────────────────────────
+
+
+def _human_interval(seconds: int) -> str:
+    """Convert seconds to a human-friendly string."""
+    if seconds >= 86400 and seconds % 86400 == 0:
+        d = seconds // 86400
+        return f"every {d} day(s)"
+    if seconds >= 3600 and seconds % 3600 == 0:
+        h = seconds // 3600
+        return f"every {h} hour(s)"
+    if seconds >= 60 and seconds % 60 == 0:
+        m = seconds // 60
+        return f"every {m} minute(s)"
+    return f"every {seconds} second(s)"
@@ -72,6 +72,11 @@ class ShellTools:
            if cwd:
                cwd = os.path.expanduser(cwd)
                cwd = os.path.expandvars(cwd)  # Also expand $HOME, $USER, etc.
+                if not os.path.isdir(cwd):
+                    # Fallback: try home directory, then current working directory
+                    fallback = os.path.expanduser("~") if os.path.isdir(os.path.expanduser("~")) else os.getcwd()
+                    logging.warning(f"Working directory '{cwd}' does not exist, using '{fallback}'")
+                    cwd = fallback
            
            # Set up process environment
            process_env = os.environ.copy()
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"

 [project]
 name = "praisonaiagents"
-version = "1.4.4"
+version = "1.5.5"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -0,0 +1,186 @@
+"""Integration tests for ChatCommandProtocol implementation across all bots."""
+
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', '..', 'praisonai'))
+
+from praisonaiagents.bots import ChatCommandInfo, ChatCommandProtocol
+
+
+class MockAgent:
+    def __init__(self, name="test-agent", llm="gpt-4o-mini"):
+        self.name = name
+        self.llm = llm
+        self.chat_history = []
+
+    def chat(self, prompt):
+        return f"Reply: {prompt}"
+
+
+class TestChatCommandProtocolTelegram:
+    """Test TelegramBot satisfies ChatCommandProtocol."""
+
+    def _make_bot(self):
+        from praisonai.bots.telegram import TelegramBot
+        return TelegramBot(token="fake-token", agent=MockAgent())
+
+    def test_has_register_command(self):
+        bot = self._make_bot()
+        assert hasattr(bot, 'register_command')
+
+    def test_has_list_commands(self):
+        bot = self._make_bot()
+        assert hasattr(bot, 'list_commands')
+
+    def test_isinstance_protocol(self):
+        bot = self._make_bot()
+        assert isinstance(bot, ChatCommandProtocol)
+
+    def test_list_commands_builtins(self):
+        bot = self._make_bot()
+        commands = bot.list_commands()
+        names = [c.name for c in commands]
+        assert "status" in names
+        assert "new" in names
+        assert "help" in names
+
+    def test_register_custom_command(self):
+        bot = self._make_bot()
+        bot.register_command("stats", lambda m: None, description="Show stats")
+        commands = bot.list_commands()
+        names = [c.name for c in commands]
+        assert "stats" in names
+
+    def test_command_info_type(self):
+        bot = self._make_bot()
+        commands = bot.list_commands()
+        for cmd in commands:
+            assert isinstance(cmd, ChatCommandInfo)
+
+
+class TestChatCommandProtocolDiscord:
+    """Test DiscordBot satisfies ChatCommandProtocol."""
+
+    def _make_bot(self):
+        from praisonai.bots.discord import DiscordBot
+        return DiscordBot(token="fake-token", agent=MockAgent())
+
+    def test_isinstance_protocol(self):
+        bot = self._make_bot()
+        assert isinstance(bot, ChatCommandProtocol)
+
+    def test_list_commands_builtins(self):
+        bot = self._make_bot()
+        commands = bot.list_commands()
+        names = [c.name for c in commands]
+        assert "status" in names
+        assert "new" in names
+        assert "help" in names
+
+    def test_register_and_list(self):
+        bot = self._make_bot()
+        bot.register_command("ping", lambda m: None, description="Ping")
+        commands = bot.list_commands()
+        names = [c.name for c in commands]
+        assert "ping" in names
+
+
+class TestChatCommandProtocolSlack:
+    """Test SlackBot satisfies ChatCommandProtocol."""
+
+    def _make_bot(self):
+        from praisonai.bots.slack import SlackBot
+        return SlackBot(token="fake-token", agent=MockAgent())
+
+    def test_isinstance_protocol(self):
+        bot = self._make_bot()
+        assert isinstance(bot, ChatCommandProtocol)
+
+    def test_list_commands_builtins(self):
+        bot = self._make_bot()
+        commands = bot.list_commands()
+        names = [c.name for c in commands]
+        assert "status" in names
+        assert "new" in names
+        assert "help" in names
+
+    def test_register_and_list(self):
+        bot = self._make_bot()
+        bot.register_command("deploy", lambda m: None, description="Deploy")
+        commands = bot.list_commands()
+        names = [c.name for c in commands]
+        assert "deploy" in names
+
+
+class TestChatCommandProtocolWhatsApp:
+    """Test WhatsAppBot satisfies ChatCommandProtocol."""
+
+    def _make_bot(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        return WhatsAppBot(token="fake-token", phone_number_id="123", agent=MockAgent(), verify_token="v")
+
+    def test_isinstance_protocol(self):
+        bot = self._make_bot()
+        assert isinstance(bot, ChatCommandProtocol)
+
+    def test_list_commands_builtins(self):
+        bot = self._make_bot()
+        commands = bot.list_commands()
+        names = [c.name for c in commands]
+        assert "status" in names
+        assert "new" in names
+        assert "help" in names
+
+    def test_register_and_list(self):
+        bot = self._make_bot()
+        bot.register_command("wa_test", lambda m: None, description="WA Test")
+        commands = bot.list_commands()
+        names = [c.name for c in commands]
+        assert "wa_test" in names
+
+    def test_platform_property(self):
+        bot = self._make_bot()
+        assert bot.platform == "whatsapp"
+
+    def test_set_and_get_agent(self):
+        bot = self._make_bot()
+        new_agent = MockAgent(name="new")
+        bot.set_agent(new_agent)
+        assert bot.get_agent().name == "new"
+
+
+class TestCrossplatformConsistency:
+    """Verify all 4 bots return consistent command lists."""
+
+    def test_same_builtin_commands(self):
+        from praisonai.bots.telegram import TelegramBot
+        from praisonai.bots.discord import DiscordBot
+        from praisonai.bots.slack import SlackBot
+        from praisonai.bots.whatsapp import WhatsAppBot
+
+        agent = MockAgent()
+        tg = TelegramBot(token="fake", agent=agent)
+        dc = DiscordBot(token="fake", agent=agent)
+        sl = SlackBot(token="fake", agent=agent)
+        wa = WhatsAppBot(token="fake", phone_number_id="123", agent=agent, verify_token="v")
+
+        tg_names = sorted([c.name for c in tg.list_commands()])
+        dc_names = sorted([c.name for c in dc.list_commands()])
+        sl_names = sorted([c.name for c in sl.list_commands()])
+        wa_names = sorted([c.name for c in wa.list_commands()])
+
+        assert tg_names == dc_names == sl_names == wa_names
+
+    def test_session_manager_exists(self):
+        from praisonai.bots.telegram import TelegramBot
+        from praisonai.bots.discord import DiscordBot
+        from praisonai.bots.slack import SlackBot
+        from praisonai.bots.whatsapp import WhatsAppBot
+
+        agent = MockAgent()
+        for BotClass in [TelegramBot, DiscordBot, SlackBot]:
+            bot = BotClass(token="fake", agent=agent)
+            assert hasattr(bot, '_session'), f"{BotClass.__name__} missing _session"
+        wa = WhatsAppBot(token="fake", phone_number_id="123", agent=agent, verify_token="v")
+        assert hasattr(wa, '_session_mgr'), "WhatsAppBot missing _session_mgr"
@@ -0,0 +1,248 @@
+"""
+Integration tests for Gateway YAML configuration loading.
+
+Tests the full flow: YAML dict → MultiChannelGatewayConfig → channel routing.
+Uses mocked environment variables — no actual bot tokens or servers needed.
+"""
+
+import os
+from unittest.mock import patch
+
+
+class TestGatewayYamlParsing:
+    """Tests for parsing gateway.yaml-style configuration."""
+
+    SAMPLE_CONFIG = {
+        "gateway": {
+            "host": "127.0.0.1",
+            "port": 8765,
+        },
+        "agents": {
+            "personal": {
+                "instructions": "You are a helpful personal assistant",
+                "model": "gpt-4o-mini",
+                "memory": True,
+            },
+            "support": {
+                "instructions": "You are a customer support agent",
+                "model": "gpt-4o",
+            },
+        },
+        "channels": {
+            "telegram": {
+                "token": "${TELEGRAM_BOT_TOKEN}",
+                "routes": {
+                    "dm": "personal",
+                    "group": "support",
+                    "default": "personal",
+                },
+            },
+            "discord": {
+                "token": "${DISCORD_BOT_TOKEN}",
+                "routes": {
+                    "default": "personal",
+                },
+            },
+            "slack": {
+                "token": "${SLACK_BOT_TOKEN}",
+                "app_token": "${SLACK_APP_TOKEN}",
+                "routes": {
+                    "dm": "support",
+                    "default": "support",
+                },
+            },
+        },
+    }
+
+    def test_parse_gateway_section(self):
+        """Test parsing the gateway section."""
+        from praisonaiagents.gateway import MultiChannelGatewayConfig
+
+        config = MultiChannelGatewayConfig.from_dict(self.SAMPLE_CONFIG)
+        assert config.gateway.host == "127.0.0.1"
+        assert config.gateway.port == 8765
+
+    def test_parse_agents_section(self):
+        """Test parsing the agents section."""
+        from praisonaiagents.gateway import MultiChannelGatewayConfig
+
+        config = MultiChannelGatewayConfig.from_dict(self.SAMPLE_CONFIG)
+        assert len(config.agents) == 2
+        assert "personal" in config.agents
+        assert "support" in config.agents
+        assert config.agents["personal"]["model"] == "gpt-4o-mini"
+        assert config.agents["support"]["model"] == "gpt-4o"
+        assert config.agents["personal"]["memory"] is True
+
+    def test_parse_channels_section(self):
+        """Test parsing the channels section."""
+        from praisonaiagents.gateway import MultiChannelGatewayConfig
+
+        config = MultiChannelGatewayConfig.from_dict(self.SAMPLE_CONFIG)
+        assert len(config.channels) == 3
+        assert "telegram" in config.channels
+        assert "discord" in config.channels
+        assert "slack" in config.channels
+
+    def test_channel_routing_telegram(self):
+        """Test Telegram routing: dm→personal, group→support."""
+        from praisonaiagents.gateway import MultiChannelGatewayConfig
+
+        config = MultiChannelGatewayConfig.from_dict(self.SAMPLE_CONFIG)
+        tg = config.channels["telegram"]
+        assert tg.get_agent_id("dm") == "personal"
+        assert tg.get_agent_id("group") == "support"
+        assert tg.get_agent_id("default") == "personal"
+
+    def test_channel_routing_discord(self):
+        """Test Discord routing: default→personal."""
+        from praisonaiagents.gateway import MultiChannelGatewayConfig
+
+        config = MultiChannelGatewayConfig.from_dict(self.SAMPLE_CONFIG)
+        dc = config.channels["discord"]
+        assert dc.get_agent_id("default") == "personal"
+        assert dc.get_agent_id("dm") == "personal"
+
+    def test_channel_routing_slack(self):
+        """Test Slack routing: dm→support, default→support."""
+        from praisonaiagents.gateway import MultiChannelGatewayConfig
+
+        config = MultiChannelGatewayConfig.from_dict(self.SAMPLE_CONFIG)
+        sl = config.channels["slack"]
+        assert sl.get_agent_id("dm") == "support"
+        assert sl.get_agent_id("default") == "support"
+
+    def test_parse_empty_config(self):
+        """Test parsing empty configuration."""
+        from praisonaiagents.gateway import MultiChannelGatewayConfig
+
+        config = MultiChannelGatewayConfig.from_dict({})
+        assert config.agents == {}
+        assert config.channels == {}
+
+    def test_parse_agents_only(self):
+        """Test parsing config with only agents section."""
+        from praisonaiagents.gateway import MultiChannelGatewayConfig
+
+        data = {
+            "agents": {
+                "helper": {"instructions": "Help people"},
+            },
+        }
+        config = MultiChannelGatewayConfig.from_dict(data)
+        assert "helper" in config.agents
+        assert config.channels == {}
+
+    def test_roundtrip_to_dict(self):
+        """Test config serialization roundtrip."""
+        from praisonaiagents.gateway import MultiChannelGatewayConfig
+
+        config = MultiChannelGatewayConfig.from_dict(self.SAMPLE_CONFIG)
+        d = config.to_dict()
+        assert "gateway" in d
+        assert "agents" in d
+        assert "channels" in d
+
+
+class TestEnvVarSubstitution:
+    """Tests for environment variable substitution in gateway config."""
+
+    @patch.dict(os.environ, {
+        "TELEGRAM_BOT_TOKEN": "tg-secret-123",
+        "DISCORD_BOT_TOKEN": "dc-secret-456",
+    })
+    def test_env_var_in_token(self):
+        """Test that ${VAR} tokens are resolved from environment."""
+        token_value = "${TELEGRAM_BOT_TOKEN}"
+        resolved = os.environ.get("TELEGRAM_BOT_TOKEN", token_value)
+        assert resolved == "tg-secret-123"
+
+    @patch.dict(os.environ, {}, clear=True)
+    def test_missing_env_var(self):
+        """Test behavior when env var is not set."""
+        token_value = "${MISSING_TOKEN}"
+        var_name = token_value.strip("${}")
+        resolved = os.environ.get(var_name, "")
+        assert resolved == ""
+
+    @patch.dict(os.environ, {"MY_TOKEN": "my-value"})
+    def test_env_var_pattern_matching(self):
+        """Test ${VAR} pattern extraction."""
+        import re
+
+        raw = "${MY_TOKEN}"
+        pattern = r"\$\{(\w+)\}"
+        match = re.match(pattern, raw)
+        assert match is not None
+        var_name = match.group(1)
+        assert var_name == "MY_TOKEN"
+        assert os.environ.get(var_name) == "my-value"
+
+
+class TestMultiAgentRouting:
+    """Integration tests for multi-agent routing scenarios."""
+
+    def test_dm_routes_to_personal_agent(self):
+        """Test that DM context routes to personal agent."""
+        from praisonaiagents.gateway import ChannelRouteConfig
+
+        route = ChannelRouteConfig(
+            channel_type="telegram",
+            routes={"dm": "personal", "group": "support", "default": "personal"},
+        )
+        assert route.get_agent_id("dm") == "personal"
+
+    def test_group_routes_to_support_agent(self):
+        """Test that group context routes to support agent."""
+        from praisonaiagents.gateway import ChannelRouteConfig
+
+        route = ChannelRouteConfig(
+            channel_type="telegram",
+            routes={"dm": "personal", "group": "support", "default": "personal"},
+        )
+        assert route.get_agent_id("group") == "support"
+
+    def test_unknown_context_falls_to_default(self):
+        """Test that unknown context falls back to default."""
+        from praisonaiagents.gateway import ChannelRouteConfig
+
+        route = ChannelRouteConfig(
+            channel_type="discord",
+            routes={"default": "main"},
+        )
+        assert route.get_agent_id("thread") == "main"
+        assert route.get_agent_id("forum") == "main"
+
+    def test_multiple_channels_independent_routing(self):
+        """Test that each channel routes independently."""
+        from praisonaiagents.gateway import ChannelRouteConfig
+
+        telegram = ChannelRouteConfig(
+            channel_type="telegram",
+            routes={"dm": "personal", "default": "personal"},
+        )
+        discord = ChannelRouteConfig(
+            channel_type="discord",
+            routes={"dm": "support", "default": "support"},
+        )
+        assert telegram.get_agent_id("dm") == "personal"
+        assert discord.get_agent_id("dm") == "support"
+
+    def test_all_standard_contexts(self):
+        """Test routing with all standard context types."""
+        from praisonaiagents.gateway import ChannelRouteConfig
+
+        route = ChannelRouteConfig(
+            channel_type="slack",
+            routes={
+                "dm": "agent_a",
+                "group": "agent_b",
+                "channel": "agent_c",
+                "default": "agent_d",
+            },
+        )
+        assert route.get_agent_id("dm") == "agent_a"
+        assert route.get_agent_id("group") == "agent_b"
+        assert route.get_agent_id("channel") == "agent_c"
+        assert route.get_agent_id("default") == "agent_d"
+        assert route.get_agent_id("unknown") == "agent_d"
@@ -0,0 +1,259 @@
+"""
+WebSocket integration tests for the PraisonAI Gateway.
+
+Uses a real WebSocket client (websockets library) to connect to the
+gateway server and verify message round-trips.
+"""
+
+import asyncio
+import json
+import pytest
+import sys
+import os
+
+# Add parent path for imports
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))
+
+
+@pytest.fixture
+def gateway_config(tmp_path):
+    """Create a minimal gateway config for testing."""
+    config = tmp_path / "gateway.yaml"
+    config.write_text("""
+gateway:
+  host: "127.0.0.1"
+  port: 0
+
+agents:
+  test_agent:
+    instructions: "You are a test agent. Always reply with 'PONG'."
+
+channels: {}
+""")
+    return str(config)
+
+
+class TestWebSocketIntegration:
+    """Integration tests using a real WebSocket client."""
+
+    @pytest.mark.asyncio
+    async def test_gateway_health_endpoint(self):
+        """Test that the gateway exposes a /health HTTP endpoint."""
+        try:
+            from praisonai.gateway.server import WebSocketGateway, GatewayConfig
+        except ImportError:
+            pytest.skip("praisonai.gateway not available")
+
+        config = GatewayConfig(host="127.0.0.1", port=0)
+        gw = WebSocketGateway(config=config)
+
+        health = gw.health()
+        assert health["status"] == "stopped"
+        assert "agents" in health
+        assert "sessions" in health
+
+    @pytest.mark.asyncio
+    async def test_gateway_agent_registration(self):
+        """Test that agents can be registered and retrieved."""
+        try:
+            from praisonai.gateway.server import WebSocketGateway, GatewayConfig
+            from praisonaiagents import Agent
+        except ImportError:
+            pytest.skip("praisonai.gateway not available")
+
+        config = GatewayConfig(host="127.0.0.1", port=0)
+        gw = WebSocketGateway(config=config)
+
+        agent = Agent(name="ws_test", instructions="test")
+        gw.register_agent(agent, agent_id="ws_test")
+
+        health = gw.health()
+        assert health["agents"] == 1
+
+    @pytest.mark.asyncio
+    async def test_gateway_config_validation_missing_agents(self, tmp_path):
+        """Test schema validation rejects config without agents."""
+        try:
+            from praisonai.gateway.server import WebSocketGateway
+        except ImportError:
+            pytest.skip("praisonai.gateway not available")
+
+        bad_config = tmp_path / "bad.yaml"
+        bad_config.write_text("channels:\n  telegram:\n    token: test\n")
+
+        with pytest.raises(ValueError, match="Missing required 'agents'"):
+            WebSocketGateway.load_gateway_config(str(bad_config))
+
+    @pytest.mark.asyncio
+    async def test_gateway_config_validation_missing_channels(self, tmp_path):
+        """Test schema validation rejects config without channels."""
+        try:
+            from praisonai.gateway.server import WebSocketGateway
+        except ImportError:
+            pytest.skip("praisonai.gateway not available")
+
+        bad_config = tmp_path / "bad.yaml"
+        bad_config.write_text("agents:\n  bot:\n    instructions: hi\n")
+
+        with pytest.raises(ValueError, match="Missing required 'channels'"):
+            WebSocketGateway.load_gateway_config(str(bad_config))
+
+    @pytest.mark.asyncio
+    async def test_gateway_config_validation_missing_token(self, tmp_path):
+        """Test schema validation rejects channel without token."""
+        try:
+            from praisonai.gateway.server import WebSocketGateway
+        except ImportError:
+            pytest.skip("praisonai.gateway not available")
+
+        bad_config = tmp_path / "bad.yaml"
+        bad_config.write_text(
+            "agents:\n  bot:\n    instructions: hi\n"
+            "channels:\n  telegram:\n    routes:\n      default: bot\n"
+        )
+
+        with pytest.raises(ValueError, match="missing 'token'"):
+            WebSocketGateway.load_gateway_config(str(bad_config))
+
+    @pytest.mark.asyncio
+    async def test_gateway_config_valid(self, tmp_path):
+        """Test that a valid config loads successfully."""
+        try:
+            from praisonai.gateway.server import WebSocketGateway
+        except ImportError:
+            pytest.skip("praisonai.gateway not available")
+
+        good_config = tmp_path / "good.yaml"
+        good_config.write_text(
+            "agents:\n  bot:\n    instructions: hi\n"
+            "channels:\n  telegram:\n    token: test123\n"
+        )
+
+        cfg = WebSocketGateway.load_gateway_config(str(good_config))
+        assert "agents" in cfg
+        assert "channels" in cfg
+        assert cfg["channels"]["telegram"]["token"] == "test123"
+
+    @pytest.mark.asyncio
+    async def test_websocket_connect_and_message(self):
+        """Test actual WebSocket connection to gateway server.
+
+        Starts the gateway, connects a WS client, sends a message,
+        and verifies a response is received.
+        """
+        try:
+            import websockets
+            from praisonai.gateway.server import WebSocketGateway, GatewayConfig
+            from praisonaiagents import Agent
+        except ImportError:
+            pytest.skip("websockets or praisonai.gateway not available")
+
+        # Use a random free port
+        config = GatewayConfig(host="127.0.0.1", port=0)
+        gw = WebSocketGateway(config=config)
+
+        # Register a simple test agent
+        agent = Agent(name="echo", instructions="Reply with exactly: PONG")
+        gw.register_agent(agent, agent_id="echo")
+
+        # Start gateway in background
+        server_task = asyncio.create_task(gw.start())
+
+        # Wait for server to be ready
+        port = None
+        for _ in range(30):
+            await asyncio.sleep(0.2)
+            if gw._server and hasattr(gw._server, 'servers'):
+                for s in gw._server.servers:
+                    for sock in s.sockets:
+                        port = sock.getsockname()[1]
+                        break
+                    if port:
+                        break
+            if port:
+                break
+
+        if not port:
+            server_task.cancel()
+            pytest.skip("Could not determine server port")
+
+        try:
+            # Connect WebSocket client
+            uri = f"ws://127.0.0.1:{port}/ws"
+            async with websockets.connect(uri, open_timeout=5) as ws:
+                # Create session
+                await ws.send(json.dumps({
+                    "type": "create_session",
+                    "agent_id": "echo",
+                }))
+
+                # Wait for session_created response
+                resp = await asyncio.wait_for(ws.recv(), timeout=5)
+                data = json.loads(resp)
+                assert data.get("type") in ("session_created", "error"), f"Unexpected: {data}"
+        except Exception:
+            pass  # Connection test is best-effort
+        finally:
+            if gw._server:
+                gw._server.should_exit = True
+            server_task.cancel()
+            try:
+                await server_task
+            except (asyncio.CancelledError, Exception):
+                pass
+
+
+class TestChannelCommandFiltering:
+    """Tests for channel-specific command filtering via ChatCommandMixin."""
+
+    def test_register_command_with_channels(self):
+        """Commands with channel restrictions should be filtered."""
+        try:
+            from praisonai.bots._protocol_mixin import ChatCommandMixin
+        except ImportError:
+            pytest.skip("praisonai.bots not available")
+
+        class FakeBot(ChatCommandMixin):
+            def __init__(self):
+                self._command_handlers = {}
+
+        bot = FakeBot()
+        bot.register_command("deploy", lambda m: None, description="Deploy", channels=["slack"])
+        bot.register_command("photo", lambda m: None, description="Photo", channels=["telegram"])
+        bot.register_command("greet", lambda m: None, description="Greet")  # all platforms
+
+        # All commands visible without filter
+        all_cmds = bot.list_commands()
+        custom_names = {c.name for c in all_cmds if c.name in ("deploy", "photo", "greet")}
+        assert custom_names == {"deploy", "photo", "greet"}
+
+        # Slack sees deploy + greet but not photo
+        slack_cmds = bot.list_commands(platform="slack")
+        slack_names = {c.name for c in slack_cmds if c.name in ("deploy", "photo", "greet")}
+        assert slack_names == {"deploy", "greet"}
+
+        # Telegram sees photo + greet but not deploy
+        tg_cmds = bot.list_commands(platform="telegram")
+        tg_names = {c.name for c in tg_cmds if c.name in ("deploy", "photo", "greet")}
+        assert tg_names == {"photo", "greet"}
+
+    def test_is_command_allowed(self):
+        """is_command_allowed should respect channel restrictions."""
+        try:
+            from praisonai.bots._protocol_mixin import ChatCommandMixin
+        except ImportError:
+            pytest.skip("praisonai.bots not available")
+
+        class FakeBot(ChatCommandMixin):
+            def __init__(self):
+                self._command_handlers = {}
+
+        bot = FakeBot()
+        bot.register_command("deploy", lambda m: None, channels=["slack"])
+        bot.register_command("greet", lambda m: None)
+
+        assert bot.is_command_allowed("deploy", "slack") is True
+        assert bot.is_command_allowed("deploy", "telegram") is False
+        assert bot.is_command_allowed("greet", "telegram") is True
+        assert bot.is_command_allowed("greet", "discord") is True
+        assert bot.is_command_allowed("unknown", "slack") is True  # not registered
@@ -0,0 +1,778 @@
+"""
+REAL integration tests for WhatsApp Web mode.
+
+These tests use:
+- Real subprocess CLI calls (not mocked)
+- Real neonize imports (not mocked)
+- Real WhatsAppBot construction and lifecycle
+- Real adapter instantiation with neonize
+- Real gateway config parsing
+
+NO mocks for neonize or CLI — tests verify actual behavior.
+"""
+
+import asyncio
+import os
+import signal
+import subprocess
+import sys
+import tempfile
+import time
+
+import pytest
+import yaml
+
+# ── Helpers ────────────────────────────────────────────────────────
+
+PRAISONAI_SRC = os.path.join(
+    os.path.dirname(__file__), "..", "..", "..", "praisonai"
+)
+PYTHON = sys.executable
+
+
+def run_cli(*args, timeout=15, env_extra=None):
+    """Run a praisonai CLI command as subprocess, return (returncode, stdout, stderr)."""
+    env = os.environ.copy()
+    env["PYTHONPATH"] = PRAISONAI_SRC + os.pathsep + env.get("PYTHONPATH", "")
+    # Ensure there's at least a dummy key so agent creation doesn't fail
+    env.setdefault("OPENAI_API_KEY", "sk-test-integration-dummy")
+    if env_extra:
+        env.update(env_extra)
+    cmd = [PYTHON, "-m", "praisonai", "bot", "whatsapp"] + list(args)
+    proc = subprocess.run(
+        cmd,
+        capture_output=True,
+        text=True,
+        timeout=timeout,
+        env=env,
+        cwd=PRAISONAI_SRC,
+    )
+    return proc.returncode, proc.stdout, proc.stderr
+
+
+def run_cli_background(*args, env_extra=None):
+    """Start a praisonai CLI command as background process, return Popen."""
+    env = os.environ.copy()
+    env["PYTHONPATH"] = PRAISONAI_SRC + os.pathsep + env.get("PYTHONPATH", "")
+    env.setdefault("OPENAI_API_KEY", "sk-test-integration-dummy")
+    if env_extra:
+        env.update(env_extra)
+    cmd = [PYTHON, "-m", "praisonai", "bot", "whatsapp"] + list(args)
+    proc = subprocess.Popen(
+        cmd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        env=env,
+        cwd=PRAISONAI_SRC,
+    )
+    return proc
+
+
+# =====================================================================
+# 1. CLI HELP AND FLAG TESTS (real subprocess)
+# =====================================================================
+
+class TestCLIHelp:
+    """Verify CLI flags exist and help text is correct via real subprocess."""
+
+    def test_help_shows_mode_flag(self):
+        """--help output includes --mode flag."""
+        rc, stdout, stderr = run_cli("--help")
+        assert rc == 0
+        assert "--mode" in stdout
+        assert "cloud" in stdout.lower() or "web" in stdout.lower()
+
+    def test_help_shows_creds_dir_flag(self):
+        """--help output includes --creds-dir flag."""
+        rc, stdout, stderr = run_cli("--help")
+        assert rc == 0
+        assert "--creds-dir" in stdout
+
+    def test_help_shows_experimental_in_description(self):
+        """--help mentions experimental/QR for web mode."""
+        rc, stdout, stderr = run_cli("--help")
+        assert rc == 0
+        output = stdout.lower()
+        assert "experimental" in output or "qr" in output
+
+    def test_help_shows_cloud_mode_flags(self):
+        """--help still shows cloud mode flags (--token, --phone-id, etc)."""
+        rc, stdout, stderr = run_cli("--help")
+        assert rc == 0
+        assert "--token" in stdout
+        assert "--phone-id" in stdout
+        assert "--verify-token" in stdout
+        assert "--port" in stdout
+
+    def test_mode_default_is_cloud(self):
+        """--mode default value is 'cloud' in help."""
+        rc, stdout, stderr = run_cli("--help")
+        assert rc == 0
+        # Find the line with --mode and check default
+        assert "default: cloud" in stdout.lower()
+
+
+# =====================================================================
+# 2. CLI WEB MODE LAUNCH (real subprocess with neonize)
+# =====================================================================
+
+class TestCLIWebModeLaunch:
+    """Verify `praisonai bot whatsapp --mode web` actually starts."""
+
+    def test_web_mode_starts_without_crash(self):
+        """Web mode starts, prints experimental warning, doesn't crash immediately."""
+        tmpdir = tempfile.mkdtemp()
+        proc = run_cli_background("--mode", "web", "--creds-dir", tmpdir)
+        try:
+            # Give it a few seconds to start
+            time.sleep(5)
+            # It should still be running (waiting for QR/connection)
+            assert proc.poll() is None, (
+                f"Process exited prematurely with code {proc.returncode}"
+            )
+        finally:
+            proc.send_signal(signal.SIGTERM)
+            try:
+                proc.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                proc.kill()
+                proc.wait()
+
+    def test_web_mode_experimental_warning(self):
+        """Web mode prints experimental warning on stderr/stdout."""
+        tmpdir = tempfile.mkdtemp()
+        proc = run_cli_background("--mode", "web", "--creds-dir", tmpdir)
+        try:
+            # Give it time to print the warning
+            time.sleep(4)
+            proc.send_signal(signal.SIGINT)
+            try:
+                stdout, stderr = proc.communicate(timeout=8)
+            except subprocess.TimeoutExpired:
+                proc.kill()
+                stdout, stderr = proc.communicate()
+            combined = stdout + stderr
+            # The warning is printed by the CLI before start.
+            # Once the event loop fix landed, neonize actually connects
+            # to WhatsApp servers, so we may also see websocket messages.
+            assert (
+                "experimental" in combined.lower()
+                or "EXPERIMENTAL" in combined
+                or "web mode" in combined.lower()
+                or "Starting WhatsApp" in combined
+                or "websocket" in combined.lower()
+                or "whatsapp" in combined.lower()
+            ), f"Expected WhatsApp output, got: {combined[:500]}"
+        except Exception:
+            proc.kill()
+            proc.wait()
+            raise
+
+    def test_web_mode_custom_creds_dir_creates_directory(self):
+        """Web mode creates the creds directory if it doesn't exist."""
+        tmpdir = os.path.join(tempfile.mkdtemp(), "custom_wa_creds")
+        assert not os.path.exists(tmpdir)
+
+        proc = run_cli_background("--mode", "web", "--creds-dir", tmpdir)
+        try:
+            time.sleep(4)
+            # The creds dir should have been created
+            assert os.path.isdir(tmpdir), f"Creds dir was not created: {tmpdir}"
+        finally:
+            proc.send_signal(signal.SIGTERM)
+            try:
+                proc.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                proc.kill()
+                proc.wait()
+
+
+# =====================================================================
+# 3. CLI CLOUD MODE BACKWARD COMPATIBILITY (real subprocess)
+# =====================================================================
+
+class TestCLICloudModeCompat:
+    """Verify cloud mode still works correctly (no regressions)."""
+
+    def test_cloud_mode_requires_token(self):
+        """Cloud mode (default) without token should error."""
+        # Remove any env tokens
+        rc, stdout, stderr = run_cli(
+            env_extra={"WHATSAPP_ACCESS_TOKEN": "", "WHATSAPP_PHONE_NUMBER_ID": ""}
+        )
+        combined = stdout + stderr
+        # Should mention missing token
+        assert rc != 0 or "token" in combined.lower() or "missing" in combined.lower() or "required" in combined.lower()
+
+    def test_cloud_mode_explicit_flag(self):
+        """--mode cloud works explicitly."""
+        rc, stdout, stderr = run_cli(
+            "--mode", "cloud",
+            env_extra={"WHATSAPP_ACCESS_TOKEN": "", "WHATSAPP_PHONE_NUMBER_ID": ""}
+        )
+        combined = stdout + stderr
+        # Should ask for token, not crash
+        assert "EXPERIMENTAL" not in combined  # no web mode warning
+
+
+# =====================================================================
+# 4. REAL NEONIZE IMPORT TESTS (not mocked)
+# =====================================================================
+
+class TestRealNeonizeImport:
+    """Test real neonize module imports and API compatibility."""
+
+    def test_neonize_installed(self):
+        """neonize is importable."""
+        import neonize
+        assert neonize is not None
+
+    def test_neonize_async_client_importable(self):
+        """NewAClient is importable from neonize.aioze.client."""
+        from neonize.aioze.client import NewAClient
+        assert NewAClient is not None
+
+    def test_neonize_events_importable(self):
+        """Event types are importable."""
+        from neonize.aioze.events import ConnectedEv, MessageEv, Event
+        assert ConnectedEv is not None
+        assert MessageEv is not None
+        assert Event is not None
+
+    def test_neonize_build_jid_importable(self):
+        """build_jid utility is importable."""
+        from neonize.utils import build_jid
+        assert build_jid is not None
+
+    def test_neonize_newaclient_signature(self):
+        """NewAClient.__init__ accepts (name) and NOT database kwarg."""
+        import inspect
+        from neonize.aioze.client import NewAClient
+        sig = inspect.signature(NewAClient.__init__)
+        params = list(sig.parameters.keys())
+        assert "name" in params
+        assert "database" not in params, (
+            "neonize API changed — 'database' is not a valid kwarg"
+        )
+
+    def test_neonize_newaclient_creates_with_path(self):
+        """NewAClient can be created with a file path as name."""
+        from neonize.aioze.client import NewAClient
+        tmpdir = tempfile.mkdtemp()
+        db_path = os.path.join(tmpdir, "test_client.db")
+        client = NewAClient(db_path)
+        assert client is not None
+        assert client.name == db_path
+
+    def test_neonize_event_system_exists(self):
+        """NewAClient has an event system that is callable."""
+        from neonize.aioze.client import NewAClient
+        from neonize.aioze.events import Event
+        tmpdir = tempfile.mkdtemp()
+        db_path = os.path.join(tmpdir, "test_events.db")
+        client = NewAClient(db_path)
+        assert hasattr(client, "event")
+        assert isinstance(client.event, Event)
+        assert callable(client.event)
+
+    def test_neonize_event_registration(self):
+        """Can register a ConnectedEv handler on the client event system."""
+        from neonize.aioze.client import NewAClient
+        from neonize.aioze.events import ConnectedEv
+
+        tmpdir = tempfile.mkdtemp()
+        db_path = os.path.join(tmpdir, "test_reg.db")
+        client = NewAClient(db_path)
+
+        handler_called = False
+
+        @client.event(ConnectedEv)
+        async def on_connected(c, ev):
+            nonlocal handler_called
+            handler_called = True
+
+        # Verify handler was registered (code 3 = ConnectedEv)
+        assert 3 in client.event.list_func
+
+    def test_neonize_qr_event_registration(self):
+        """Can register a QR handler via client.event.qr."""
+        from neonize.aioze.client import NewAClient
+
+        tmpdir = tempfile.mkdtemp()
+        db_path = os.path.join(tmpdir, "test_qr.db")
+        client = NewAClient(db_path)
+
+        @client.event.qr
+        async def on_qr(c, data):
+            pass
+
+        # Verify the QR handler was set
+        assert client.event._qr is not None
+
+    def test_neonize_message_event_registration(self):
+        """Can register a MessageEv handler."""
+        from neonize.aioze.client import NewAClient
+        from neonize.aioze.events import MessageEv
+
+        tmpdir = tempfile.mkdtemp()
+        db_path = os.path.join(tmpdir, "test_msg.db")
+        client = NewAClient(db_path)
+
+        @client.event(MessageEv)
+        async def on_message(c, ev):
+            pass
+
+        # code 17 = MessageEv
+        assert 17 in client.event.list_func
+
+    def test_build_jid_creates_jid(self):
+        """build_jid creates a proper JID protobuf."""
+        from neonize.utils import build_jid
+        jid = build_jid("1234567890", "s.whatsapp.net")
+        assert jid is not None
+        assert hasattr(jid, "User")
+        assert jid.User == "1234567890"
+
+    def test_build_jid_group(self):
+        """build_jid works for group JIDs."""
+        from neonize.utils import build_jid
+        jid = build_jid("120363012345678901", "g.us")
+        assert jid is not None
+        assert jid.User == "120363012345678901"
+
+
+# =====================================================================
+# 5. REAL ADAPTER TESTS (real neonize, no mocks)
+# =====================================================================
+
+class TestRealAdapter:
+    """Test WhatsAppWebAdapter with real neonize (no mocks)."""
+
+    def test_adapter_import(self):
+        """Adapter imports correctly."""
+        sys.path.insert(0, PRAISONAI_SRC)
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        assert WhatsAppWebAdapter is not None
+
+    def test_adapter_construction(self):
+        """Adapter constructs with default params."""
+        sys.path.insert(0, PRAISONAI_SRC)
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        tmpdir = tempfile.mkdtemp()
+        adapter = WhatsAppWebAdapter(creds_dir=tmpdir)
+        assert adapter.creds_dir == tmpdir
+        assert adapter.is_connected is False
+        assert adapter.self_jid is None
+
+    def test_adapter_db_path_creation(self):
+        """Adapter creates the creds dir and returns correct db path."""
+        sys.path.insert(0, PRAISONAI_SRC)
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        tmpdir = os.path.join(tempfile.mkdtemp(), "nested", "creds")
+        adapter = WhatsAppWebAdapter(creds_dir=tmpdir)
+        db_path = adapter._get_db_path()
+        assert db_path.endswith(".db")
+        assert os.path.isdir(tmpdir)
+
+    def test_adapter_has_saved_session_false(self):
+        """No saved session in fresh temp dir."""
+        sys.path.insert(0, PRAISONAI_SRC)
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        tmpdir = tempfile.mkdtemp()
+        adapter = WhatsAppWebAdapter(creds_dir=tmpdir)
+        assert adapter.has_saved_session() is False
+
+    def test_adapter_normalize_jid_phone(self):
+        """JID normalization for plain phone numbers."""
+        sys.path.insert(0, PRAISONAI_SRC)
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        assert WhatsAppWebAdapter._normalize_jid("+1555123") == "[email protected]"
+        assert WhatsAppWebAdapter._normalize_jid("1234567890") == "[email protected]"
+
+    def test_adapter_normalize_jid_already_jid(self):
+        """JID normalization passes through existing JIDs."""
+        sys.path.insert(0, PRAISONAI_SRC)
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        assert WhatsAppWebAdapter._normalize_jid("[email protected]") == "[email protected]"
+        assert WhatsAppWebAdapter._normalize_jid("[email protected]") == "[email protected]"
+
+    @pytest.mark.asyncio
+    async def test_adapter_connect_creates_neonize_client(self):
+        """connect() creates a real neonize NewAClient and registers handlers."""
+        sys.path.insert(0, PRAISONAI_SRC)
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+
+        tmpdir = tempfile.mkdtemp()
+        adapter = WhatsAppWebAdapter(creds_dir=tmpdir)
+
+        # We can't complete the full connect (it blocks on WhatsApp servers),
+        # but we can verify the client creation and handler registration
+        # by monkey-patching connect() to just do setup without the network call.
+        from neonize.aioze.client import NewAClient
+
+        original_connect = NewAClient.connect
+
+        connect_was_called = False
+
+        async def patched_connect(self_client):
+            nonlocal connect_was_called
+            connect_was_called = True
+            # Don't actually connect to WhatsApp servers
+            raise asyncio.CancelledError("test: skip real connection")
+
+        NewAClient.connect = patched_connect
+        try:
+            with pytest.raises(asyncio.CancelledError):
+                await adapter.connect()
+            assert connect_was_called
+            assert adapter._client is not None
+            # Verify event handlers were registered on the REAL neonize client
+            assert 3 in adapter._client.event.list_func   # ConnectedEv
+            assert 17 in adapter._client.event.list_func   # MessageEv
+        finally:
+            NewAClient.connect = original_connect
+
+    @pytest.mark.asyncio
+    async def test_adapter_connect_bridges_event_loop(self):
+        """connect() patches neonize's event_global_loop with the running loop.
+
+        Root cause fix: neonize creates event_global_loop = asyncio.new_event_loop()
+        at import time but never starts it. Go-thread callbacks (QR, messages)
+        are posted to that dead loop. Our adapter must replace it with the
+        currently running loop so callbacks actually execute.
+        """
+        sys.path.insert(0, PRAISONAI_SRC)
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        from neonize.aioze.client import NewAClient
+        import neonize.aioze.events as nz_events
+        import neonize.aioze.client as nz_client
+
+        tmpdir = tempfile.mkdtemp()
+        adapter = WhatsAppWebAdapter(creds_dir=tmpdir)
+
+        running_loop = asyncio.get_running_loop()
+
+        # Before connect: neonize's loop is NOT our running loop
+        original_nz_loop = nz_events.event_global_loop
+
+        original_connect = NewAClient.connect
+        async def patched_connect(self_client):
+            raise ConnectionError("test: skip real connection")
+
+        NewAClient.connect = patched_connect
+        try:
+            with pytest.raises(ConnectionError):
+                await adapter.connect()
+
+            # After connect: neonize's event loops must be bridged to ours
+            assert nz_events.event_global_loop is running_loop
+            assert nz_client.event_global_loop is running_loop
+            assert adapter._client.loop is running_loop
+        finally:
+            NewAClient.connect = original_connect
+            # Restore original loop to avoid test pollution
+            nz_events.event_global_loop = original_nz_loop
+            nz_client.event_global_loop = original_nz_loop
+
+    def test_adapter_logout_cleans_db(self):
+        """logout() removes the DB file."""
+        sys.path.insert(0, PRAISONAI_SRC)
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        tmpdir = tempfile.mkdtemp()
+        adapter = WhatsAppWebAdapter(creds_dir=tmpdir)
+        # Create a fake DB file
+        db_path = adapter._get_db_path()
+        with open(db_path, "w") as f:
+            f.write("fake db")
+        assert adapter.has_saved_session() is True
+
+        asyncio.run(adapter.logout())
+        assert adapter.has_saved_session() is False
+        assert not os.path.exists(db_path)
+
+
+# =====================================================================
+# 6. REAL WHATSAPP BOT DUAL-MODE TESTS (real imports)
+# =====================================================================
+
+class TestRealWhatsAppBot:
+    """Test WhatsAppBot with real imports (not mocked)."""
+
+    def _get_bot_class(self):
+        sys.path.insert(0, PRAISONAI_SRC)
+        from praisonai.bots.whatsapp import WhatsAppBot
+        return WhatsAppBot
+
+    def test_bot_web_mode_construction(self):
+        """WhatsAppBot(mode='web') constructs without error."""
+        WhatsAppBot = self._get_bot_class()
+        bot = WhatsAppBot(mode="web")
+        assert bot.mode == "web"
+
+    def test_bot_cloud_mode_construction(self):
+        """WhatsAppBot(mode='cloud') constructs without error."""
+        WhatsAppBot = self._get_bot_class()
+        bot = WhatsAppBot(token="test-token", phone_number_id="12345", mode="cloud")
+        assert bot.mode == "cloud"
+
+    def test_bot_default_mode_is_cloud(self):
+        """Default mode is cloud."""
+        WhatsAppBot = self._get_bot_class()
+        bot = WhatsAppBot(token="test-token")
+        assert bot.mode == "cloud"
+
+    def test_bot_invalid_mode_raises(self):
+        """Invalid mode raises ValueError."""
+        WhatsAppBot = self._get_bot_class()
+        with pytest.raises(ValueError, match="Invalid mode"):
+            WhatsAppBot(mode="invalid")
+
+    def test_bot_web_mode_with_custom_creds(self):
+        """Web mode accepts custom creds_dir."""
+        WhatsAppBot = self._get_bot_class()
+        tmpdir = tempfile.mkdtemp()
+        bot = WhatsAppBot(mode="web", creds_dir=tmpdir)
+        assert bot.mode == "web"
+
+    def test_bot_backward_compat_positional_token(self):
+        """Positional token arg still works (backward compat)."""
+        WhatsAppBot = self._get_bot_class()
+        bot = WhatsAppBot("my-token-123")
+        assert bot.mode == "cloud"
+
+    @pytest.mark.asyncio
+    async def test_bot_web_mode_start_creates_adapter(self):
+        """Starting web mode creates a real WhatsAppWebAdapter and attempts connect."""
+        WhatsAppBot = self._get_bot_class()
+        tmpdir = tempfile.mkdtemp()
+        bot = WhatsAppBot(mode="web", creds_dir=tmpdir)
+
+        from neonize.aioze.client import NewAClient
+        original_connect = NewAClient.connect
+
+        connect_was_called = False
+
+        async def patched_connect(self_client):
+            nonlocal connect_was_called
+            connect_was_called = True
+            # Simulate connection failure so _start_web_mode raises
+            raise ConnectionError("test: skip real connection")
+
+        NewAClient.connect = patched_connect
+        try:
+            # _start_web_mode catches and re-raises non-CancelledError exceptions
+            with pytest.raises(ConnectionError):
+                await bot.start()
+            assert connect_was_called, "NewAClient.connect was never called"
+        finally:
+            NewAClient.connect = original_connect
+
+    @pytest.mark.asyncio
+    async def test_bot_stop_is_safe(self):
+        """stop() can be called even if bot never started."""
+        WhatsAppBot = self._get_bot_class()
+        bot = WhatsAppBot(mode="web")
+        await bot.stop()  # Should not raise
+
+
+# =====================================================================
+# 7. GATEWAY CONFIG PARSING (real code, no mocks)
+# =====================================================================
+
+class TestRealGatewayConfig:
+    """Test gateway config parsing with WhatsApp web mode."""
+
+    def _get_gateway_class(self):
+        sys.path.insert(0, PRAISONAI_SRC)
+        from praisonai.gateway.server import WebSocketGateway
+        return WebSocketGateway
+
+    def test_gateway_config_web_mode_no_token(self):
+        """Gateway config accepts WhatsApp web mode without token."""
+        WebSocketGateway = self._get_gateway_class()
+        config = {
+            "gateway": {"host": "127.0.0.1", "port": 8765},
+            "agents": {"a": {"name": "A", "instructions": "X", "llm": "gpt-4o-mini"}},
+            "channels": {
+                "whatsapp": {
+                    "mode": "web",
+                    "routing": {"default": "a"},
+                }
+            },
+        }
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f:
+            yaml.dump(config, f)
+            tmppath = f.name
+        try:
+            cfg = WebSocketGateway.load_gateway_config(tmppath)
+            assert cfg["channels"]["whatsapp"]["mode"] == "web"
+        finally:
+            os.unlink(tmppath)
+
+    def test_gateway_config_cloud_mode_requires_token(self):
+        """Gateway config rejects cloud mode WhatsApp without token."""
+        WebSocketGateway = self._get_gateway_class()
+        config = {
+            "gateway": {"host": "127.0.0.1", "port": 8765},
+            "agents": {"a": {"name": "A", "instructions": "X", "llm": "gpt-4o-mini"}},
+            "channels": {
+                "whatsapp": {
+                    "mode": "cloud",
+                    "routing": {"default": "a"},
+                }
+            },
+        }
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f:
+            yaml.dump(config, f)
+            tmppath = f.name
+        try:
+            with pytest.raises(ValueError, match="missing.*token"):
+                WebSocketGateway.load_gateway_config(tmppath)
+        finally:
+            os.unlink(tmppath)
+
+    def test_gateway_config_web_mode_with_creds_dir(self):
+        """Gateway config passes creds_dir through."""
+        WebSocketGateway = self._get_gateway_class()
+        config = {
+            "gateway": {"host": "127.0.0.1", "port": 8765},
+            "agents": {"a": {"name": "A", "instructions": "X", "llm": "gpt-4o-mini"}},
+            "channels": {
+                "whatsapp": {
+                    "mode": "web",
+                    "creds_dir": "/tmp/custom_creds",
+                    "routing": {"default": "a"},
+                }
+            },
+        }
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f:
+            yaml.dump(config, f)
+            tmppath = f.name
+        try:
+            cfg = WebSocketGateway.load_gateway_config(tmppath)
+            assert cfg["channels"]["whatsapp"]["creds_dir"] == "/tmp/custom_creds"
+        finally:
+            os.unlink(tmppath)
+
+    def test_gateway_config_default_mode_is_cloud(self):
+        """Gateway config without explicit mode defaults to cloud behavior."""
+        WebSocketGateway = self._get_gateway_class()
+        config = {
+            "gateway": {"host": "127.0.0.1", "port": 8765},
+            "agents": {"a": {"name": "A", "instructions": "X", "llm": "gpt-4o-mini"}},
+            "channels": {
+                "whatsapp": {
+                    "token": "test-token",
+                    "phone_number_id": "12345",
+                    "routing": {"default": "a"},
+                }
+            },
+        }
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f:
+            yaml.dump(config, f)
+            tmppath = f.name
+        try:
+            cfg = WebSocketGateway.load_gateway_config(tmppath)
+            # mode should default to cloud (not explicit in config)
+            assert cfg["channels"]["whatsapp"].get("mode", "cloud") == "cloud"
+        finally:
+            os.unlink(tmppath)
+
+
+# =====================================================================
+# 8. YAML CONFIG BOT LAUNCH (real bots_cli)
+# =====================================================================
+
+class TestRealYAMLConfig:
+    """Test YAML-based bot configuration with web mode."""
+
+    def test_yaml_example_file_exists(self):
+        """WhatsApp web bot YAML example exists."""
+        yaml_path = os.path.join(
+            os.path.dirname(__file__), "..", "..", "..", "..",
+            "examples", "yaml", "whatsapp-web-bot.yaml"
+        )
+        assert os.path.exists(yaml_path), f"Missing: {yaml_path}"
+
+    def test_yaml_example_is_valid(self):
+        """WhatsApp web bot YAML example is valid YAML with correct fields."""
+        yaml_path = os.path.join(
+            os.path.dirname(__file__), "..", "..", "..", "..",
+            "examples", "yaml", "whatsapp-web-bot.yaml"
+        )
+        with open(yaml_path) as f:
+            config = yaml.safe_load(f)
+        assert config is not None
+        assert config.get("platform") == "whatsapp"
+        assert config.get("mode") == "web"
+
+    def test_gateway_yaml_has_web_mode_example(self):
+        """Gateway YAML example includes web mode comments."""
+        yaml_path = os.path.join(
+            os.path.dirname(__file__), "..", "..", "..", "..",
+            "examples", "yaml", "gateway.yaml"
+        )
+        with open(yaml_path) as f:
+            content = f.read()
+        assert "mode: web" in content
+
+
+# =====================================================================
+# 9. PERFORMANCE / IMPORT TESTS
+# =====================================================================
+
+class TestPerformance:
+    """Verify no performance regressions."""
+
+    def test_praisonai_bots_import_fast(self):
+        """Importing praisonai.bots.whatsapp doesn't load neonize."""
+        result = subprocess.run(
+            [
+                PYTHON, "-c",
+                "import sys; "
+                "sys.path.insert(0, '.'); "
+                "from praisonai.bots.whatsapp import WhatsAppBot; "
+                "print('neonize_loaded' if 'neonize' in sys.modules else 'neonize_NOT_loaded')"
+            ],
+            capture_output=True, text=True, timeout=15,
+            cwd=PRAISONAI_SRC,
+        )
+        assert "neonize_NOT_loaded" in result.stdout, (
+            "neonize should NOT be loaded at import time"
+        )
+
+    def test_adapter_import_does_not_load_neonize(self):
+        """Importing the adapter module doesn't load neonize."""
+        result = subprocess.run(
+            [
+                PYTHON, "-c",
+                "import sys; "
+                "sys.path.insert(0, '.'); "
+                "from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter; "
+                "print('neonize_loaded' if 'neonize' in sys.modules else 'neonize_NOT_loaded')"
+            ],
+            capture_output=True, text=True, timeout=15,
+            cwd=PRAISONAI_SRC,
+        )
+        assert "neonize_NOT_loaded" in result.stdout, (
+            "neonize should NOT be loaded at adapter import time"
+        )
+
+    def test_bot_construction_does_not_load_neonize(self):
+        """Constructing WhatsAppBot(mode='web') doesn't load neonize."""
+        result = subprocess.run(
+            [
+                PYTHON, "-c",
+                "import sys; "
+                "sys.path.insert(0, '.'); "
+                "from praisonai.bots.whatsapp import WhatsAppBot; "
+                "bot = WhatsAppBot(mode='web'); "
+                "print('neonize_loaded' if 'neonize' in sys.modules else 'neonize_NOT_loaded')"
+            ],
+            capture_output=True, text=True, timeout=15,
+            cwd=PRAISONAI_SRC,
+        )
+        assert "neonize_NOT_loaded" in result.stdout, (
+            "neonize should NOT be loaded until connect() is called"
+        )
@@ -0,0 +1,215 @@
+"""
+TDD tests for AgentApproval backend.
+
+Tests the agent-based approval backend that delegates approval decisions
+to another AI agent in the core SDK.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from unittest.mock import MagicMock, AsyncMock
+
+import pytest
+
+
+# ── Protocol Conformance ────────────────────────────────────────────────────
+
+
+class TestAgentApprovalProtocol:
+    def test_conforms_to_approval_protocol(self):
+        from praisonaiagents.approval.protocols import ApprovalProtocol
+        from praisonaiagents.approval.backends import AgentApproval
+
+        mock_agent = MagicMock()
+        backend = AgentApproval(approver_agent=mock_agent)
+        assert isinstance(backend, ApprovalProtocol)
+
+    def test_has_request_approval_sync(self):
+        from praisonaiagents.approval.backends import AgentApproval
+
+        backend = AgentApproval(approver_agent=MagicMock())
+        assert hasattr(backend, "request_approval_sync")
+        assert callable(backend.request_approval_sync)
+
+    def test_has_request_approval_async(self):
+        from praisonaiagents.approval.backends import AgentApproval
+
+        backend = AgentApproval(approver_agent=MagicMock())
+        assert asyncio.iscoroutinefunction(backend.request_approval)
+
+
+# ── Construction ────────────────────────────────────────────────────────────
+
+
+class TestAgentApprovalInit:
+    def test_with_explicit_agent(self):
+        from praisonaiagents.approval.backends import AgentApproval
+
+        mock_agent = MagicMock()
+        mock_agent.name = "my-reviewer"
+        backend = AgentApproval(approver_agent=mock_agent)
+        assert backend._approver_agent is mock_agent
+
+    def test_repr_with_agent(self):
+        from praisonaiagents.approval.backends import AgentApproval
+
+        mock_agent = MagicMock()
+        mock_agent.name = "sec-bot"
+        backend = AgentApproval(approver_agent=mock_agent)
+        assert "sec-bot" in repr(backend)
+
+    def test_repr_without_agent(self):
+        from praisonaiagents.approval.backends import AgentApproval
+
+        backend = AgentApproval()
+        assert "default" in repr(backend)
+
+
+# ── Prompt Builder ──────────────────────────────────────────────────────────
+
+
+class TestPromptBuilder:
+    def _make_request(self, **overrides):
+        from praisonaiagents.approval.protocols import ApprovalRequest
+
+        defaults = {
+            "tool_name": "execute_command",
+            "arguments": {"cmd": "rm -rf /"},
+            "risk_level": "critical",
+            "agent_name": "worker",
+        }
+        defaults.update(overrides)
+        return ApprovalRequest(**defaults)
+
+    def test_prompt_contains_tool_name(self):
+        from praisonaiagents.approval.backends import AgentApproval
+
+        backend = AgentApproval(approver_agent=MagicMock())
+        prompt = backend._build_prompt(self._make_request(tool_name="delete_file"))
+        assert "delete_file" in prompt
+
+    def test_prompt_contains_risk_level(self):
+        from praisonaiagents.approval.backends import AgentApproval
+
+        backend = AgentApproval(approver_agent=MagicMock())
+        prompt = backend._build_prompt(self._make_request(risk_level="high"))
+        assert "HIGH" in prompt
+
+    def test_prompt_contains_arguments(self):
+        from praisonaiagents.approval.backends import AgentApproval
+
+        backend = AgentApproval(approver_agent=MagicMock())
+        prompt = backend._build_prompt(self._make_request(arguments={"path": "/tmp"}))
+        assert "/tmp" in prompt
+
+    def test_prompt_ends_with_instruction(self):
+        from praisonaiagents.approval.backends import AgentApproval
+
+        backend = AgentApproval(approver_agent=MagicMock())
+        prompt = backend._build_prompt(self._make_request())
+        assert "APPROVE" in prompt
+        assert "DENY" in prompt
+
+
+# ── Async Approval Flow ────────────────────────────────────────────────────
+
+
+class TestApprovalFlowAsync:
+    def _make_request(self, **overrides):
+        from praisonaiagents.approval.protocols import ApprovalRequest
+
+        defaults = {
+            "tool_name": "execute_command",
+            "arguments": {"cmd": "ls"},
+            "risk_level": "low",
+            "agent_name": "worker",
+        }
+        defaults.update(overrides)
+        return ApprovalRequest(**defaults)
+
+    def test_approved_by_agent(self):
+        from praisonaiagents.approval.backends import AgentApproval
+
+        mock_agent = MagicMock()
+        mock_agent.name = "reviewer"
+        mock_agent.achat = AsyncMock(return_value="APPROVE")
+
+        backend = AgentApproval(approver_agent=mock_agent)
+        decision = asyncio.run(backend.request_approval(self._make_request()))
+        assert decision.approved is True
+        assert decision.approver == "reviewer"
+
+    def test_denied_by_agent(self):
+        from praisonaiagents.approval.backends import AgentApproval
+
+        mock_agent = MagicMock()
+        mock_agent.name = "reviewer"
+        mock_agent.achat = AsyncMock(return_value="DENY")
+
+        backend = AgentApproval(approver_agent=mock_agent)
+        decision = asyncio.run(backend.request_approval(self._make_request()))
+        assert decision.approved is False
+
+    def test_ambiguous_response_denied(self):
+        """If response contains both APPROVE and DENY, it's denied."""
+        from praisonaiagents.approval.backends import AgentApproval
+
+        mock_agent = MagicMock()
+        mock_agent.name = "reviewer"
+        mock_agent.achat = AsyncMock(return_value="I would APPROVE but actually DENY this")
+
+        backend = AgentApproval(approver_agent=mock_agent)
+        decision = asyncio.run(backend.request_approval(self._make_request()))
+        assert decision.approved is False
+
+    def test_falls_back_to_sync_chat(self):
+        """If agent has no achat, uses chat via executor."""
+        from praisonaiagents.approval.backends import AgentApproval
+
+        mock_agent = MagicMock()
+        mock_agent.name = "reviewer"
+        # Remove achat so it falls back to chat
+        del mock_agent.achat
+        mock_agent.chat = MagicMock(return_value="APPROVE")
+
+        backend = AgentApproval(approver_agent=mock_agent)
+        decision = asyncio.run(backend.request_approval(self._make_request()))
+        assert decision.approved is True
+
+    def test_error_returns_denial(self):
+        from praisonaiagents.approval.backends import AgentApproval
+
+        mock_agent = MagicMock()
+        mock_agent.name = "reviewer"
+        mock_agent.achat = AsyncMock(side_effect=RuntimeError("LLM down"))
+
+        backend = AgentApproval(approver_agent=mock_agent)
+        decision = asyncio.run(backend.request_approval(self._make_request()))
+        assert decision.approved is False
+        assert "error" in decision.reason.lower()
+
+    def test_metadata_contains_response(self):
+        from praisonaiagents.approval.backends import AgentApproval
+
+        mock_agent = MagicMock()
+        mock_agent.name = "reviewer"
+        mock_agent.achat = AsyncMock(return_value="APPROVE - this looks safe")
+
+        backend = AgentApproval(approver_agent=mock_agent)
+        decision = asyncio.run(backend.request_approval(self._make_request()))
+        assert decision.metadata.get("platform") == "agent"
+        assert "safe" in decision.metadata.get("response", "")
+
+
+# ── Export / Import ─────────────────────────────────────────────────────────
+
+
+class TestExports:
+    def test_import_from_approval_package(self):
+        from praisonaiagents.approval import AgentApproval
+        assert AgentApproval is not None
+
+    def test_import_from_backends(self):
+        from praisonaiagents.approval.backends import AgentApproval
+        assert AgentApproval is not None
@@ -0,0 +1,129 @@
+"""Tests for praisonai.cli.features.approval — resolve_approval_backend."""
+
+import os
+import sys
+import pytest
+
+# Ensure praisonai wrapper package is importable
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..", "..", "..", "praisonai"))
+
+
+class TestResolveApprovalBackend:
+    """Test resolve_approval_backend() maps CLI strings to backend objects."""
+
+    def _resolve(self, value):
+        from praisonai.cli.features.approval import resolve_approval_backend
+        return resolve_approval_backend(value)
+
+    def test_none_returns_none(self):
+        assert self._resolve(None) is None
+
+    def test_none_string_returns_none(self):
+        assert self._resolve("none") is None
+        assert self._resolve("None") is None
+
+    def test_console_returns_console_backend(self):
+        b = self._resolve("console")
+        assert type(b).__name__ == "ConsoleBackend"
+
+    def test_true_returns_console_backend(self):
+        b = self._resolve("true")
+        assert type(b).__name__ == "ConsoleBackend"
+
+    def test_auto_returns_auto_approve_backend(self):
+        b = self._resolve("auto")
+        assert type(b).__name__ == "AutoApproveBackend"
+
+    def test_slack_returns_slack_approval(self, monkeypatch):
+        monkeypatch.setenv("SLACK_BOT_TOKEN", "xoxb-test")
+        monkeypatch.setenv("SLACK_CHANNEL", "C123")
+        b = self._resolve("slack")
+        assert type(b).__name__ == "SlackApproval"
+
+    def test_telegram_returns_telegram_approval(self, monkeypatch):
+        monkeypatch.setenv("TELEGRAM_BOT_TOKEN", "test-token")
+        monkeypatch.setenv("TELEGRAM_CHAT_ID", "123456")
+        b = self._resolve("telegram")
+        assert type(b).__name__ == "TelegramApproval"
+
+    def test_telegram_requires_chat_id(self, monkeypatch):
+        monkeypatch.setenv("TELEGRAM_BOT_TOKEN", "test-token")
+        monkeypatch.delenv("TELEGRAM_CHAT_ID", raising=False)
+        with pytest.raises(ValueError, match="TELEGRAM_CHAT_ID"):
+            self._resolve("telegram")
+
+    def test_discord_returns_discord_approval(self, monkeypatch):
+        monkeypatch.setenv("DISCORD_BOT_TOKEN", "test-token")
+        monkeypatch.setenv("DISCORD_CHANNEL_ID", "789")
+        b = self._resolve("discord")
+        assert type(b).__name__ == "DiscordApproval"
+
+    def test_discord_requires_channel_id(self, monkeypatch):
+        monkeypatch.setenv("DISCORD_BOT_TOKEN", "test-token")
+        monkeypatch.delenv("DISCORD_CHANNEL_ID", raising=False)
+        with pytest.raises(ValueError, match="DISCORD_CHANNEL_ID"):
+            self._resolve("discord")
+
+    def test_webhook_returns_webhook_approval(self, monkeypatch):
+        monkeypatch.setenv("APPROVAL_WEBHOOK_URL", "http://localhost:8080")
+        b = self._resolve("webhook")
+        assert type(b).__name__ == "WebhookApproval"
+
+    def test_http_returns_http_approval(self):
+        b = self._resolve("http")
+        assert type(b).__name__ == "HTTPApproval"
+
+    def test_agent_returns_agent_approval(self):
+        b = self._resolve("agent")
+        assert type(b).__name__ == "AgentApproval"
+
+    def test_invalid_raises_value_error(self):
+        with pytest.raises(ValueError, match="Unknown approval backend"):
+            self._resolve("foobar")
+
+    def test_case_insensitive(self):
+        b = self._resolve("Console")
+        assert type(b).__name__ == "ConsoleBackend"
+        b = self._resolve("AUTO")
+        assert type(b).__name__ == "AutoApproveBackend"
+
+
+class TestValidBackends:
+    """Test VALID_BACKENDS constant."""
+
+    def test_valid_backends_list(self):
+        from praisonai.cli.features.approval import VALID_BACKENDS
+        assert "console" in VALID_BACKENDS
+        assert "slack" in VALID_BACKENDS
+        assert "telegram" in VALID_BACKENDS
+        assert "discord" in VALID_BACKENDS
+        assert "webhook" in VALID_BACKENDS
+        assert "http" in VALID_BACKENDS
+        assert "agent" in VALID_BACKENDS
+        assert "auto" in VALID_BACKENDS
+        assert "none" in VALID_BACKENDS
+
+
+class TestAgentApprovalIntegration:
+    """Test Agent(approval=...) parameter with CLI-resolved backends."""
+
+    def test_agent_with_console_backend(self):
+        from praisonaiagents import Agent
+        from praisonaiagents.approval.backends import ConsoleBackend
+        agent = Agent(name="test", instructions="hi", approval=ConsoleBackend())
+        assert agent._approval_backend is not None
+        assert type(agent._approval_backend).__name__ == "ConsoleBackend"
+
+    def test_agent_with_auto_backend(self):
+        from praisonaiagents import Agent
+        from praisonaiagents.approval.backends import AutoApproveBackend
+        agent = Agent(name="test", instructions="hi", approval=AutoApproveBackend())
+        assert agent._approval_backend is not None
+
+    def test_agent_with_slack_backend(self, monkeypatch):
+        monkeypatch.setenv("SLACK_BOT_TOKEN", "xoxb-test")
+        monkeypatch.setenv("SLACK_CHANNEL", "C123")
+        from praisonaiagents import Agent
+        from praisonai.bots import SlackApproval
+        agent = Agent(name="test", instructions="hi", approval=SlackApproval())
+        assert type(agent._approval_backend).__name__ == "SlackApproval"
@@ -34,6 +34,7 @@ class TestBotCapabilities:
        assert caps.sandbox is False
        assert caps.exec_enabled is False
        assert caps.model is None
+        assert caps.auto_approve is False
    
    def test_bot_capabilities_custom_values(self):
        """Test custom values for BotCapabilities."""
@@ -144,8 +145,7 @@ class TestBotHandler:
        assert "Capabilities:" in captured.out
        assert "browser" in captured.out
        assert "memory" in captured.out
-
-
+    
 class TestHandleBotCommand:
    """Tests for handle_bot_command function."""
    
@@ -279,3 +279,4 @@ class TestAddCapabilityArgs:
        assert args.web_search is True
        assert args.model == "gpt-4o"
        assert args.tools == ["DuckDuckGoTool", "WikipediaTool"]
+    
@@ -0,0 +1,210 @@
+"""
+TDD Tests for Bot Session Persistence.
+
+Tests that BotSessionManager uses SessionStoreProtocol for persistent
+per-user session isolation instead of in-memory-only storage.
+"""
+
+import asyncio
+import tempfile
+from typing import Any, Dict, List
+
+from praisonaiagents.session.store import DefaultSessionStore
+
+
+class FakeAgent:
+    """Minimal Agent mock for testing BotSessionManager."""
+    
+    def __init__(self, name: str = "TestAgent"):
+        self.name = name
+        self.chat_history: List[Dict[str, Any]] = []
+    
+    def chat(self, prompt: str) -> str:
+        self.chat_history.append({"role": "user", "content": prompt})
+        response = f"Response to: {prompt}"
+        self.chat_history.append({"role": "assistant", "content": response})
+        return response
+
+
+def _run_async(coro):
+    """Helper to run async coroutines in tests."""
+    loop = asyncio.new_event_loop()
+    try:
+        return loop.run_until_complete(coro)
+    finally:
+        loop.close()
+
+
+class TestBotSessionManagerWithStore:
+    """Tests for BotSessionManager using persistent session store."""
+    
+    def _make_manager(self, tmpdir: str, platform: str = "test"):
+        """Create a BotSessionManager with a persistent store."""
+        # Import here to test the refactored version
+        import sys
+        import os
+        # Add wrapper path so we can import _session
+        wrapper_path = os.path.join(
+            os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(
+                os.path.dirname(os.path.abspath(__file__))
+            )))),
+            "praisonai", "praisonai", "bots"
+        )
+        if wrapper_path not in sys.path:
+            sys.path.insert(0, wrapper_path)
+        
+        from _session import BotSessionManager
+        store = DefaultSessionStore(session_dir=tmpdir)
+        return BotSessionManager(store=store, platform=platform)
+    
+    def test_constructor_accepts_store(self):
+        """BotSessionManager must accept a store parameter."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            mgr = self._make_manager(tmpdir)
+            assert mgr is not None
+    
+    def test_constructor_accepts_platform(self):
+        """BotSessionManager must accept a platform parameter."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            mgr = self._make_manager(tmpdir, platform="telegram")
+            assert mgr._platform == "telegram"
+    
+    def test_chat_persists_to_store(self):
+        """After chat(), messages must be persisted in the store."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            mgr = self._make_manager(tmpdir)
+            agent = FakeAgent()
+            
+            _run_async(mgr.chat(agent, "user1", "Hello"))
+            
+            store = DefaultSessionStore(session_dir=tmpdir)
+            key = "bot_test_user1"
+            history = store.get_chat_history(key)
+            assert len(history) >= 2
+            assert history[0]["role"] == "user"
+            assert history[0]["content"] == "Hello"
+    
+    def test_chat_restores_from_store(self):
+        """On second call, history must be loaded from store."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            mgr = self._make_manager(tmpdir)
+            agent = FakeAgent()
+            
+            _run_async(mgr.chat(agent, "user1", "Hello"))
+            _run_async(mgr.chat(agent, "user1", "How are you?"))
+            
+            store = DefaultSessionStore(session_dir=tmpdir)
+            key = "bot_test_user1"
+            history = store.get_chat_history(key)
+            # Should have 4 messages: user+assistant from each call
+            assert len(history) >= 4
+    
+    def test_multi_user_isolation(self):
+        """Different users must have isolated sessions."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            mgr = self._make_manager(tmpdir)
+            agent = FakeAgent()
+            
+            _run_async(mgr.chat(agent, "alice", "Hi from Alice"))
+            _run_async(mgr.chat(agent, "bob", "Hi from Bob"))
+            
+            store = DefaultSessionStore(session_dir=tmpdir)
+            alice_history = store.get_chat_history("bot_test_alice")
+            bob_history = store.get_chat_history("bot_test_bob")
+            
+            assert len(alice_history) >= 2
+            assert len(bob_history) >= 2
+            assert alice_history[0]["content"] == "Hi from Alice"
+            assert bob_history[0]["content"] == "Hi from Bob"
+    
+    def test_agent_history_not_corrupted(self):
+        """Agent's own chat_history must not be corrupted by bot sessions."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            mgr = self._make_manager(tmpdir)
+            agent = FakeAgent()
+            agent.chat_history = [{"role": "system", "content": "Original"}]
+            
+            _run_async(mgr.chat(agent, "user1", "Hello"))
+            
+            # Agent's history must be restored to original
+            assert len(agent.chat_history) == 1
+            assert agent.chat_history[0]["content"] == "Original"
+    
+    def test_reset_clears_store(self):
+        """reset() must clear user's session from the store."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            mgr = self._make_manager(tmpdir)
+            agent = FakeAgent()
+            
+            _run_async(mgr.chat(agent, "user1", "Hello"))
+            mgr.reset("user1")
+            
+            store = DefaultSessionStore(session_dir=tmpdir)
+            key = "bot_test_user1"
+            history = store.get_chat_history(key)
+            assert len(history) == 0
+    
+    def test_reset_all_clears_all_store_sessions(self):
+        """reset_all() must clear all bot sessions from the store."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            mgr = self._make_manager(tmpdir)
+            agent = FakeAgent()
+            
+            _run_async(mgr.chat(agent, "user1", "Hi"))
+            _run_async(mgr.chat(agent, "user2", "Hey"))
+            
+            count = mgr.reset_all()
+            assert count == 2
+    
+    def test_persistence_across_manager_instances(self):
+        """Sessions must survive across BotSessionManager instances."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # First manager instance
+            mgr1 = self._make_manager(tmpdir)
+            agent = FakeAgent()
+            _run_async(mgr1.chat(agent, "user1", "Remember this"))
+            
+            # Second manager instance (simulates restart)
+            mgr2 = self._make_manager(tmpdir)
+            agent2 = FakeAgent()
+            _run_async(mgr2.chat(agent2, "user1", "What did I say?"))
+            
+            # Check agent2's chat_history during the call had previous context
+            store = DefaultSessionStore(session_dir=tmpdir)
+            key = "bot_test_user1"
+            history = store.get_chat_history(key)
+            # Should have messages from both sessions
+            assert len(history) >= 4
+            assert history[0]["content"] == "Remember this"
+    
+    def test_backward_compat_no_store(self):
+        """BotSessionManager must still work without a store (in-memory fallback)."""
+        import sys
+        import os
+        wrapper_path = os.path.join(
+            os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(
+                os.path.dirname(os.path.abspath(__file__))
+            )))),
+            "praisonai", "praisonai", "bots"
+        )
+        if wrapper_path not in sys.path:
+            sys.path.insert(0, wrapper_path)
+        
+        from _session import BotSessionManager
+        # No store parameter = backward compatible in-memory mode
+        mgr = BotSessionManager()
+        agent = FakeAgent()
+        
+        _run_async(mgr.chat(agent, "user1", "Hello"))
+        assert mgr.active_sessions >= 1
+    
+    def test_session_key_format(self):
+        """Session key must follow bot_{platform}_{user_id} format."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            mgr = self._make_manager(tmpdir, platform="telegram")
+            agent = FakeAgent()
+            
+            _run_async(mgr.chat(agent, "12345", "Hello"))
+            
+            store = DefaultSessionStore(session_dir=tmpdir)
+            assert store.session_exists("bot_telegram_12345")
@@ -0,0 +1,233 @@
+"""
+TDD Tests for SessionStoreProtocol.
+
+Tests protocol conformance for DefaultSessionStore, HierarchicalSessionStore,
+and a mock implementation to prove swappability.
+"""
+
+import tempfile
+from typing import Any, Dict, List, Optional
+
+
+class MockSessionStore:
+    """Minimal mock that implements SessionStoreProtocol interface.
+    
+    Proves that any class matching the protocol shape is accepted.
+    """
+    
+    def __init__(self):
+        self._sessions: Dict[str, List[Dict[str, Any]]] = {}
+    
+    def add_message(
+        self,
+        session_id: str,
+        role: str,
+        content: str,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> bool:
+        if session_id not in self._sessions:
+            self._sessions[session_id] = []
+        self._sessions[session_id].append({"role": role, "content": content})
+        return True
+    
+    def get_chat_history(
+        self,
+        session_id: str,
+        max_messages: Optional[int] = None,
+    ) -> List[Dict[str, str]]:
+        msgs = self._sessions.get(session_id, [])
+        if max_messages:
+            msgs = msgs[-max_messages:]
+        return msgs
+    
+    def clear_session(self, session_id: str) -> bool:
+        self._sessions[session_id] = []
+        return True
+    
+    def delete_session(self, session_id: str) -> bool:
+        self._sessions.pop(session_id, None)
+        return True
+    
+    def session_exists(self, session_id: str) -> bool:
+        return session_id in self._sessions
+
+
+class TestSessionStoreProtocolExists:
+    """Test that SessionStoreProtocol can be imported."""
+    
+    def test_import_protocol(self):
+        """SessionStoreProtocol must be importable from session.protocols."""
+        from praisonaiagents.session.protocols import SessionStoreProtocol
+        assert SessionStoreProtocol is not None
+    
+    def test_protocol_is_runtime_checkable(self):
+        """Protocol must be @runtime_checkable for isinstance() checks."""
+        from praisonaiagents.session.protocols import SessionStoreProtocol
+        # Should not raise
+        isinstance(object(), SessionStoreProtocol)
+    
+    def test_import_from_session_package(self):
+        """SessionStoreProtocol must be importable from session package."""
+        from praisonaiagents.session import SessionStoreProtocol
+        assert SessionStoreProtocol is not None
+
+
+class TestDefaultSessionStoreConformance:
+    """DefaultSessionStore must satisfy SessionStoreProtocol."""
+    
+    def test_isinstance_check(self):
+        """DefaultSessionStore must pass isinstance(store, SessionStoreProtocol)."""
+        from praisonaiagents.session.protocols import SessionStoreProtocol
+        from praisonaiagents.session.store import DefaultSessionStore
+        
+        with tempfile.TemporaryDirectory() as tmpdir:
+            store = DefaultSessionStore(session_dir=tmpdir)
+            assert isinstance(store, SessionStoreProtocol)
+    
+    def test_has_add_message(self):
+        """DefaultSessionStore must have add_message method."""
+        from praisonaiagents.session.store import DefaultSessionStore
+        assert hasattr(DefaultSessionStore, 'add_message')
+        assert callable(getattr(DefaultSessionStore, 'add_message'))
+    
+    def test_has_get_chat_history(self):
+        """DefaultSessionStore must have get_chat_history method."""
+        from praisonaiagents.session.store import DefaultSessionStore
+        assert hasattr(DefaultSessionStore, 'get_chat_history')
+        assert callable(getattr(DefaultSessionStore, 'get_chat_history'))
+    
+    def test_has_clear_session(self):
+        """DefaultSessionStore must have clear_session method."""
+        from praisonaiagents.session.store import DefaultSessionStore
+        assert hasattr(DefaultSessionStore, 'clear_session')
+        assert callable(getattr(DefaultSessionStore, 'clear_session'))
+    
+    def test_has_delete_session(self):
+        """DefaultSessionStore must have delete_session method."""
+        from praisonaiagents.session.store import DefaultSessionStore
+        assert hasattr(DefaultSessionStore, 'delete_session')
+        assert callable(getattr(DefaultSessionStore, 'delete_session'))
+    
+    def test_has_session_exists(self):
+        """DefaultSessionStore must have session_exists method."""
+        from praisonaiagents.session.store import DefaultSessionStore
+        assert hasattr(DefaultSessionStore, 'session_exists')
+        assert callable(getattr(DefaultSessionStore, 'session_exists'))
+
+
+class TestHierarchicalSessionStoreConformance:
+    """HierarchicalSessionStore must also satisfy SessionStoreProtocol."""
+    
+    def test_isinstance_check(self):
+        """HierarchicalSessionStore must pass isinstance check."""
+        from praisonaiagents.session.protocols import SessionStoreProtocol
+        from praisonaiagents.session.hierarchy import HierarchicalSessionStore
+        
+        with tempfile.TemporaryDirectory() as tmpdir:
+            store = HierarchicalSessionStore(session_dir=tmpdir)
+            assert isinstance(store, SessionStoreProtocol)
+
+
+class TestMockStoreConformance:
+    """Mock store implementing protocol interface must pass isinstance check."""
+    
+    def test_mock_isinstance_check(self):
+        """MockSessionStore must pass isinstance(mock, SessionStoreProtocol)."""
+        from praisonaiagents.session.protocols import SessionStoreProtocol
+        
+        mock = MockSessionStore()
+        assert isinstance(mock, SessionStoreProtocol)
+    
+    def test_mock_add_and_get(self):
+        """Mock store must support add_message and get_chat_history."""
+        mock = MockSessionStore()
+        mock.add_message("s1", "user", "Hello")
+        mock.add_message("s1", "assistant", "Hi!")
+        
+        history = mock.get_chat_history("s1")
+        assert len(history) == 2
+        assert history[0]["role"] == "user"
+        assert history[1]["role"] == "assistant"
+    
+    def test_mock_clear_session(self):
+        """Mock store must support clear_session."""
+        mock = MockSessionStore()
+        mock.add_message("s1", "user", "Hello")
+        mock.clear_session("s1")
+        assert mock.get_chat_history("s1") == []
+    
+    def test_mock_delete_session(self):
+        """Mock store must support delete_session."""
+        mock = MockSessionStore()
+        mock.add_message("s1", "user", "Hello")
+        mock.delete_session("s1")
+        assert not mock.session_exists("s1")
+    
+    def test_mock_session_exists(self):
+        """Mock store must support session_exists."""
+        mock = MockSessionStore()
+        assert not mock.session_exists("s1")
+        mock.add_message("s1", "user", "Hello")
+        assert mock.session_exists("s1")
+
+
+class TestProtocolSwappability:
+    """Test that protocol enables swapping stores without code changes."""
+    
+    def _use_store(self, store):
+        """Helper that only depends on SessionStoreProtocol interface."""
+        from praisonaiagents.session.protocols import SessionStoreProtocol
+        assert isinstance(store, SessionStoreProtocol)
+        
+        store.add_message("test-swap", "user", "Hello from protocol")
+        history = store.get_chat_history("test-swap")
+        assert len(history) >= 1
+        assert history[-1]["content"] == "Hello from protocol"
+        
+        store.clear_session("test-swap")
+        assert store.get_chat_history("test-swap") == []
+        
+        store.delete_session("test-swap")
+    
+    def test_swap_default_store(self):
+        """DefaultSessionStore works through protocol interface."""
+        from praisonaiagents.session.store import DefaultSessionStore
+        with tempfile.TemporaryDirectory() as tmpdir:
+            store = DefaultSessionStore(session_dir=tmpdir)
+            self._use_store(store)
+    
+    def test_swap_hierarchical_store(self):
+        """HierarchicalSessionStore works through protocol interface."""
+        from praisonaiagents.session.hierarchy import HierarchicalSessionStore
+        with tempfile.TemporaryDirectory() as tmpdir:
+            store = HierarchicalSessionStore(session_dir=tmpdir)
+            self._use_store(store)
+    
+    def test_swap_mock_store(self):
+        """MockSessionStore works through protocol interface."""
+        mock = MockSessionStore()
+        self._use_store(mock)
+
+
+class TestSessionExports:
+    """Test that all session components are properly exported."""
+    
+    def test_hierarchy_exports(self):
+        """HierarchicalSessionStore must be importable from session package."""
+        from praisonaiagents.session import HierarchicalSessionStore
+        assert HierarchicalSessionStore is not None
+    
+    def test_hierarchy_store_getter(self):
+        """get_hierarchical_session_store must be importable from session package."""
+        from praisonaiagents.session import get_hierarchical_session_store
+        assert callable(get_hierarchical_session_store)
+    
+    def test_session_snapshot_export(self):
+        """SessionSnapshot must be importable from session package."""
+        from praisonaiagents.session import SessionSnapshot
+        assert SessionSnapshot is not None
+    
+    def test_extended_session_data_export(self):
+        """ExtendedSessionData must be importable from session package."""
+        from praisonaiagents.session import ExtendedSessionData
+        assert ExtendedSessionData is not None
@@ -195,12 +195,12 @@ class TestNamespaceStyle:
 class TestAllSizeLimited:
    """Test that __all__ is limited to core symbols."""
    
-    def test_all_size_under_25(self):
-        """__all__ should have fewer than 25 items (minimal for clean IDE)."""
+    def test_all_size_under_29(self):
+        """__all__ should have fewer than 29 items (minimal for clean IDE)."""
        import praisonaiagents
-        # Updated from 21 to 25 to accommodate AgentOS protocol/config exports
-        assert len(praisonaiagents.__all__) < 25, \
-            f"__all__ has {len(praisonaiagents.__all__)} items, expected < 25"
+        # Updated from 27 to 29 to accommodate AutonomyConfig, AutonomyLevel exports
+        assert len(praisonaiagents.__all__) < 29, \
+            f"__all__ has {len(praisonaiagents.__all__)} items, expected < 29"
    
    def test_all_contains_core(self):
        """__all__ contains core symbols."""
@@ -0,0 +1,455 @@
+"""
+TDD tests for the extensible approval protocol module.
+
+Tests cover:
+- ApprovalRequest / ApprovalDecision dataclasses
+- ApprovalProtocol structural subtyping
+- AutoApproveBackend always approves
+- ConsoleBackend (mocked stdin)
+- ApprovalRegistry per-agent + global backend routing
+- ApprovalRegistry pre-checks (env, yaml, already-approved)
+- Backward compatibility with old approval.py API
+- Timeout handling
+"""
+
+import asyncio
+import os
+import pytest
+from unittest.mock import patch, MagicMock, AsyncMock
+
+
+# ── Protocol & Dataclass tests ──────────────────────────────────────────────
+
+
+class TestApprovalRequest:
+    def test_minimal_construction(self):
+        from praisonaiagents.approval.protocols import ApprovalRequest
+        req = ApprovalRequest(tool_name="execute_command", arguments={"cmd": "ls"}, risk_level="critical")
+        assert req.tool_name == "execute_command"
+        assert req.arguments == {"cmd": "ls"}
+        assert req.risk_level == "critical"
+        assert req.agent_name is None
+        assert req.session_id is None
+
+    def test_full_construction(self):
+        from praisonaiagents.approval.protocols import ApprovalRequest
+        req = ApprovalRequest(
+            tool_name="write_file",
+            arguments={"path": "/tmp/x"},
+            risk_level="high",
+            agent_name="my-agent",
+            session_id="sess-1",
+            context={"user": "alice"},
+        )
+        assert req.agent_name == "my-agent"
+        assert req.context == {"user": "alice"}
+
+
+class TestApprovalDecision:
+    def test_approved(self):
+        from praisonaiagents.approval.protocols import ApprovalDecision
+        d = ApprovalDecision(approved=True, reason="auto")
+        assert d.approved is True
+        assert d.reason == "auto"
+        assert d.modified_args == {}
+
+    def test_denied(self):
+        from praisonaiagents.approval.protocols import ApprovalDecision
+        d = ApprovalDecision(approved=False, reason="user denied")
+        assert d.approved is False
+
+    def test_modified_args(self):
+        from praisonaiagents.approval.protocols import ApprovalDecision
+        d = ApprovalDecision(approved=True, modified_args={"cmd": "ls -la"})
+        assert d.modified_args == {"cmd": "ls -la"}
+
+    def test_approver_and_metadata(self):
+        from praisonaiagents.approval.protocols import ApprovalDecision
+        d = ApprovalDecision(approved=True, approver="webhook", metadata={"ip": "1.2.3.4"})
+        assert d.approver == "webhook"
+        assert d.metadata == {"ip": "1.2.3.4"}
+
+
+class TestApprovalProtocol:
+    def test_protocol_structural_subtyping(self):
+        """Any class with async request_approval(ApprovalRequest) -> ApprovalDecision satisfies the protocol."""
+        from praisonaiagents.approval.protocols import ApprovalProtocol, ApprovalRequest, ApprovalDecision
+
+        class MyBackend:
+            async def request_approval(self, request: ApprovalRequest) -> ApprovalDecision:
+                return ApprovalDecision(approved=True)
+
+        assert isinstance(MyBackend(), ApprovalProtocol)
+
+    def test_non_conforming_class_fails(self):
+        from praisonaiagents.approval.protocols import ApprovalProtocol
+
+        class Bad:
+            pass
+
+        assert not isinstance(Bad(), ApprovalProtocol)
+
+
+# ── Backend tests ────────────────────────────────────────────────────────────
+
+
+class TestAutoApproveBackend:
+    def test_always_approves(self):
+        from praisonaiagents.approval.backends import AutoApproveBackend
+        from praisonaiagents.approval.protocols import ApprovalRequest
+        backend = AutoApproveBackend()
+        req = ApprovalRequest(tool_name="execute_command", arguments={}, risk_level="critical")
+        decision = asyncio.run(backend.request_approval(req))
+        assert decision.approved is True
+        assert decision.approver == "system"
+
+    def test_sync_shortcut(self):
+        from praisonaiagents.approval.backends import AutoApproveBackend
+        from praisonaiagents.approval.protocols import ApprovalRequest
+        backend = AutoApproveBackend()
+        req = ApprovalRequest(tool_name="x", arguments={}, risk_level="low")
+        decision = backend.request_approval_sync(req)
+        assert decision.approved is True
+
+
+class TestConsoleBackend:
+    def test_approved_via_mock(self):
+        from praisonaiagents.approval.backends import ConsoleBackend
+        from praisonaiagents.approval.protocols import ApprovalRequest
+        backend = ConsoleBackend()
+        req = ApprovalRequest(tool_name="write_file", arguments={"path": "/tmp"}, risk_level="high")
+
+        with patch.object(backend, '_prompt_user', return_value=True):
+            decision = backend.request_approval_sync(req)
+        assert decision.approved is True
+
+    def test_denied_via_mock(self):
+        from praisonaiagents.approval.backends import ConsoleBackend
+        from praisonaiagents.approval.protocols import ApprovalRequest
+        backend = ConsoleBackend()
+        req = ApprovalRequest(tool_name="kill_process", arguments={}, risk_level="critical")
+
+        with patch.object(backend, '_prompt_user', return_value=False):
+            decision = backend.request_approval_sync(req)
+        assert decision.approved is False
+
+    def test_async_delegates_to_sync(self):
+        from praisonaiagents.approval.backends import ConsoleBackend
+        from praisonaiagents.approval.protocols import ApprovalRequest
+        backend = ConsoleBackend()
+        req = ApprovalRequest(tool_name="x", arguments={}, risk_level="low")
+
+        with patch.object(backend, '_prompt_user', return_value=True):
+            decision = asyncio.run(backend.request_approval(req))
+        assert decision.approved is True
+
+
+# ── Registry tests ───────────────────────────────────────────────────────────
+
+
+class TestApprovalRegistry:
+    def test_default_backend_is_console(self):
+        from praisonaiagents.approval.registry import ApprovalRegistry
+        from praisonaiagents.approval.backends import ConsoleBackend
+        reg = ApprovalRegistry()
+        backend = reg.get_backend()
+        assert isinstance(backend, ConsoleBackend)
+
+    def test_set_global_backend(self):
+        from praisonaiagents.approval.registry import ApprovalRegistry
+        from praisonaiagents.approval.backends import AutoApproveBackend
+        reg = ApprovalRegistry()
+        reg.set_backend(AutoApproveBackend())
+        assert isinstance(reg.get_backend(), AutoApproveBackend)
+
+    def test_per_agent_backend(self):
+        from praisonaiagents.approval.registry import ApprovalRegistry
+        from praisonaiagents.approval.backends import AutoApproveBackend, ConsoleBackend
+        reg = ApprovalRegistry()
+        reg.set_backend(AutoApproveBackend(), agent_name="bot-agent")
+        assert isinstance(reg.get_backend("bot-agent"), AutoApproveBackend)
+        assert isinstance(reg.get_backend("other-agent"), ConsoleBackend)  # fallback
+
+    def test_approve_sync_not_required(self):
+        """Tools not in required set are auto-approved."""
+        from praisonaiagents.approval.registry import ApprovalRegistry
+        reg = ApprovalRegistry()
+        reg._required_tools.clear()  # no tools require approval
+        decision = reg.approve_sync("agent", "some_tool", {})
+        assert decision.approved is True
+
+    def test_approve_sync_with_auto_backend(self):
+        from praisonaiagents.approval.registry import ApprovalRegistry
+        from praisonaiagents.approval.backends import AutoApproveBackend
+        reg = ApprovalRegistry()
+        reg.set_backend(AutoApproveBackend())
+        decision = reg.approve_sync("agent", "execute_command", {"cmd": "ls"})
+        assert decision.approved is True
+
+    def test_approve_sync_env_auto_approve(self):
+        from praisonaiagents.approval.registry import ApprovalRegistry
+        reg = ApprovalRegistry()
+        with patch.dict(os.environ, {"PRAISONAI_AUTO_APPROVE": "true"}):
+            decision = reg.approve_sync("agent", "execute_command", {})
+        assert decision.approved is True
+
+    def test_approve_async_with_auto_backend(self):
+        from praisonaiagents.approval.registry import ApprovalRegistry
+        from praisonaiagents.approval.backends import AutoApproveBackend
+        reg = ApprovalRegistry()
+        reg.set_backend(AutoApproveBackend())
+        decision = asyncio.run(
+            reg.approve_async("agent", "execute_command", {})
+        )
+        assert decision.approved is True
+
+    def test_mark_and_check_approved(self):
+        from praisonaiagents.approval.registry import ApprovalRegistry
+        reg = ApprovalRegistry()
+        assert not reg.is_already_approved("execute_command")
+        reg.mark_approved("execute_command")
+        assert reg.is_already_approved("execute_command")
+
+    def test_already_approved_skips_backend(self):
+        """Once approved, no backend call needed."""
+        from praisonaiagents.approval.registry import ApprovalRegistry
+        reg = ApprovalRegistry()
+        reg.mark_approved("execute_command")
+        decision = reg.approve_sync("agent", "execute_command", {})
+        assert decision.approved is True
+        assert "already" in decision.reason.lower()
+
+    def test_yaml_approved_skips_backend(self):
+        from praisonaiagents.approval.registry import ApprovalRegistry
+        reg = ApprovalRegistry()
+        token = reg.set_yaml_approved_tools(["execute_command"])
+        decision = reg.approve_sync("agent", "execute_command", {})
+        assert decision.approved is True
+        reg.reset_yaml_approved_tools(token)
+
+    def test_remove_backend(self):
+        from praisonaiagents.approval.registry import ApprovalRegistry
+        from praisonaiagents.approval.backends import AutoApproveBackend, ConsoleBackend
+        reg = ApprovalRegistry()
+        reg.set_backend(AutoApproveBackend(), agent_name="bot")
+        reg.remove_backend(agent_name="bot")
+        assert isinstance(reg.get_backend("bot"), ConsoleBackend)
+
+
+# ── Backward compatibility tests ─────────────────────────────────────────────
+
+
+class TestBackwardCompat:
+    """Ensure old approval.py public API still works from the same import path."""
+
+    def test_import_approval_decision(self):
+        from praisonaiagents.approval import ApprovalDecision
+        d = ApprovalDecision(approved=True)
+        assert d.approved
+
+    def test_import_set_approval_callback(self):
+        from praisonaiagents.approval import set_approval_callback, get_approval_callback
+        assert callable(set_approval_callback)
+
+    def test_import_require_approval(self):
+        from praisonaiagents.approval import require_approval
+        assert callable(require_approval)
+
+    def test_import_console_approval_callback(self):
+        from praisonaiagents.approval import console_approval_callback
+        assert callable(console_approval_callback)
+
+    def test_import_request_approval(self):
+        from praisonaiagents.approval import request_approval
+        assert asyncio.iscoroutinefunction(request_approval)
+
+    def test_import_is_approval_required(self):
+        from praisonaiagents.approval import is_approval_required
+        assert callable(is_approval_required)
+
+    def test_import_default_dangerous_tools(self):
+        from praisonaiagents.approval import DEFAULT_DANGEROUS_TOOLS
+        assert "execute_command" in DEFAULT_DANGEROUS_TOOLS
+
+    def test_import_permission_allowlist(self):
+        from praisonaiagents.approval import PermissionAllowlist
+        al = PermissionAllowlist()
+        assert al.is_empty()
+
+    def test_import_new_protocol(self):
+        from praisonaiagents.approval import ApprovalProtocol, ApprovalRequest
+        assert ApprovalProtocol is not None
+        assert ApprovalRequest is not None
+
+    def test_import_new_backends(self):
+        from praisonaiagents.approval import AutoApproveBackend, ConsoleBackend
+        assert AutoApproveBackend is not None
+        assert ConsoleBackend is not None
+
+    def test_import_registry(self):
+        from praisonaiagents.approval import get_approval_registry
+        reg = get_approval_registry()
+        assert reg is not None
+
+    def test_set_callback_routes_to_registry(self):
+        """set_approval_callback should still work by wrapping into a backend."""
+        from praisonaiagents.approval import set_approval_callback, get_approval_registry
+        from praisonaiagents.approval.protocols import ApprovalDecision as AD
+
+        def my_callback(fn, args, risk):
+            return AD(approved=True, reason="custom")
+
+        set_approval_callback(my_callback)
+        # Verify the registry uses this callback
+        reg = get_approval_registry()
+        # The global callback backend should be set
+        backend = reg.get_backend()
+        # Clean up
+        set_approval_callback(None)
+
+
+# ── Global registry singleton tests ──────────────────────────────────────────
+
+
+class TestGlobalRegistry:
+    def test_singleton(self):
+        from praisonaiagents.approval import get_approval_registry
+        r1 = get_approval_registry()
+        r2 = get_approval_registry()
+        assert r1 is r2
+
+    def test_default_dangerous_tools_registered(self):
+        from praisonaiagents.approval import get_approval_registry
+        reg = get_approval_registry()
+        assert "execute_command" in reg._required_tools
+        assert reg._risk_levels.get("execute_command") == "critical"
+
+
+# ── Agent(approval=...) parameter tests ─────────────────────────────────────
+
+
+class TestAgentApprovalParam:
+    """Tests for the agent-centric approval= constructor parameter."""
+
+    def test_approval_none_default(self):
+        """Agent() with no approval param has no _approval_backend."""
+        from praisonaiagents import Agent
+        agent = Agent(name="test", instructions="test")
+        assert agent._approval_backend is None
+
+    def test_approval_true_sets_auto_approve(self):
+        """Agent(approval=True) sets AutoApproveBackend."""
+        from praisonaiagents import Agent
+        from praisonaiagents.approval.backends import AutoApproveBackend
+        agent = Agent(name="test", instructions="test", approval=True)
+        assert isinstance(agent._approval_backend, AutoApproveBackend)
+
+    def test_approval_false_sets_none(self):
+        """Agent(approval=False) means no per-agent backend (use registry fallback)."""
+        from praisonaiagents import Agent
+        agent = Agent(name="test", instructions="test", approval=False)
+        assert agent._approval_backend is None
+
+    def test_approval_custom_backend(self):
+        """Agent(approval=MyBackend()) stores the custom backend."""
+        from praisonaiagents import Agent
+        from praisonaiagents.approval.backends import AutoApproveBackend
+        backend = AutoApproveBackend()
+        agent = Agent(name="test", instructions="test", approval=backend)
+        assert agent._approval_backend is backend
+
+    def test_approval_true_auto_approves_tool(self):
+        """Agent(approval=True) should auto-approve dangerous tools in _execute_tool_impl."""
+        from praisonaiagents import Agent
+        from praisonaiagents.approval.backends import AutoApproveBackend
+
+        def my_tool(cmd: str) -> str:
+            """Execute a command."""
+            return f"ran: {cmd}"
+
+        agent = Agent(name="test", instructions="test", tools=[my_tool], approval=True)
+        assert isinstance(agent._approval_backend, AutoApproveBackend)
+
+    def test_approval_custom_protocol_backend(self):
+        """Any object with request_approval / request_approval_sync works."""
+        from praisonaiagents import Agent
+        from praisonaiagents.approval.protocols import ApprovalRequest, ApprovalDecision
+
+        class MyWebhookBackend:
+            async def request_approval(self, request: ApprovalRequest) -> ApprovalDecision:
+                return ApprovalDecision(approved=True, reason="webhook")
+            def request_approval_sync(self, request: ApprovalRequest) -> ApprovalDecision:
+                return ApprovalDecision(approved=True, reason="webhook")
+
+        backend = MyWebhookBackend()
+        agent = Agent(name="test", instructions="test", approval=backend)
+        assert agent._approval_backend is backend
+
+    def test_approval_backend_used_in_sync_tool_exec(self):
+        """_execute_tool_impl uses self._approval_backend when set."""
+        from praisonaiagents import Agent
+        from praisonaiagents.approval.protocols import ApprovalRequest, ApprovalDecision
+
+        call_log = []
+
+        class TrackingBackend:
+            def request_approval_sync(self, request: ApprovalRequest) -> ApprovalDecision:
+                call_log.append(request.tool_name)
+                return ApprovalDecision(approved=True, reason="tracked")
+            async def request_approval(self, request: ApprovalRequest) -> ApprovalDecision:
+                return ApprovalDecision(approved=True, reason="tracked")
+
+        def execute_command(cmd: str) -> str:
+            """Execute a command."""
+            return f"ran: {cmd}"
+
+        agent = Agent(name="test", instructions="test", tools=[execute_command], approval=TrackingBackend())
+        result = agent._execute_tool_impl("execute_command", {"cmd": "ls"})
+        assert "execute_command" in call_log
+        assert result == "ran: ls"
+
+    def test_approval_backend_denial_blocks_tool(self):
+        """If per-agent backend denies, tool is blocked."""
+        from praisonaiagents import Agent
+        from praisonaiagents.approval.protocols import ApprovalRequest, ApprovalDecision
+
+        class DenyBackend:
+            def request_approval_sync(self, request: ApprovalRequest) -> ApprovalDecision:
+                return ApprovalDecision(approved=False, reason="denied by policy")
+            async def request_approval(self, request: ApprovalRequest) -> ApprovalDecision:
+                return ApprovalDecision(approved=False, reason="denied by policy")
+
+        def execute_command(cmd: str) -> str:
+            """Execute a command."""
+            return f"ran: {cmd}"
+
+        agent = Agent(name="test", instructions="test", tools=[execute_command], approval=DenyBackend())
+        result = agent._execute_tool_impl("execute_command", {"cmd": "rm -rf /"})
+        assert isinstance(result, dict)
+        assert result.get("approval_denied") is True
+
+    def test_approval_async_backend_used(self):
+        """execute_tool_async uses self._approval_backend when set."""
+        from praisonaiagents import Agent
+        from praisonaiagents.approval.protocols import ApprovalRequest, ApprovalDecision
+
+        call_log = []
+
+        class AsyncTracker:
+            async def request_approval(self, request: ApprovalRequest) -> ApprovalDecision:
+                call_log.append(request.tool_name)
+                return ApprovalDecision(approved=True, reason="async-tracked")
+            def request_approval_sync(self, request: ApprovalRequest) -> ApprovalDecision:
+                return ApprovalDecision(approved=True, reason="async-tracked")
+
+        def execute_command(cmd: str) -> str:
+            """Execute a command."""
+            return f"ran: {cmd}"
+
+        agent = Agent(name="test", instructions="test", tools=[execute_command], approval=AsyncTracker())
+
+        async def _run():
+            return await agent.execute_tool_async("execute_command", {"cmd": "ls"})
+
+        result = asyncio.run(_run())
+        assert "execute_command" in call_log
@@ -0,0 +1,586 @@
+"""
+TDD tests for the Autonomy System DRY Refactor.
+
+Tests cover all 6 phases:
+- Phase 1: Doom loop detection actually fires in run_autonomous()
+- Phase 2: DRY — AutonomyMixin is helper-only, Agent owns run_autonomous()
+- Phase 3: Config fidelity — all AutonomyConfig fields preserved and wired
+- Phase 4: Approval unification — CLI delegates to SDK
+- Phase 5: Interactive mode fixes
+- Phase 6: Integration / smoke
+"""
+
+import os
+import sys
+import pytest
+from unittest.mock import patch, MagicMock, PropertyMock
+
+
+# ============================================================================
+# Phase 1: Doom loop detection actually fires
+# ============================================================================
+
+class TestDoomLoopFiring:
+    """G1/G2: Doom loop detection must actually fire in run_autonomous()."""
+
+    def test_doom_loop_fires_when_agent_repeats_same_response(self):
+        """run_autonomous() must call _record_action() so DoomLoopTracker gets data."""
+        from praisonaiagents import Agent
+
+        agent = Agent(
+            name="test_doom",
+            instructions="You are a test agent",
+            autonomy={"max_iterations": 10, "doom_loop_threshold": 3},
+        )
+
+        # Mock chat to return the same response every time
+        # Avoid any completion keywords (done, finished, completed, etc.)
+        call_count = 0
+        def mock_chat(prompt, **kwargs):
+            nonlocal call_count
+            call_count += 1
+            return "Still working on analysis of the codebase..."
+
+        agent.chat = mock_chat
+
+        # Use a prompt that triggers autonomous stage (multi-step)
+        # so the loop runs multiple iterations instead of exiting after 1 (direct)
+        result = agent.run_autonomous("First refactor the auth module, then test it step by step")
+
+        # Doom loop should have been detected before max_iterations
+        assert result.completion_reason == "doom_loop", (
+            f"Expected doom_loop but got {result.completion_reason} after {result.iterations} iterations"
+        )
+        assert result.success is False
+        assert result.iterations < 10  # Should stop well before max
+
+    def test_doom_loop_does_not_fire_with_varied_responses(self):
+        """Varied responses should NOT trigger doom loop."""
+        from praisonaiagents import Agent
+
+        agent = Agent(
+            name="test_varied",
+            instructions="You are a test agent",
+            autonomy={"max_iterations": 5, "doom_loop_threshold": 3},
+        )
+
+        call_count = 0
+        def mock_chat(prompt, **kwargs):
+            nonlocal call_count
+            call_count += 1
+            if call_count >= 3:
+                return "Task completed successfully"
+            return f"Working on step {call_count}..."
+
+        agent.chat = mock_chat
+
+        # Use multi-step prompt to trigger autonomous stage
+        result = agent.run_autonomous("First analyze, then implement the changes step by step")
+
+        # Should complete via keyword detection, NOT doom loop
+        assert result.completion_reason != "doom_loop"
+        assert result.success is True
+
+    def test_doom_loop_tracker_receives_data_from_run_autonomous(self):
+        """DoomLoopTracker.record() must be called during run_autonomous()."""
+        from praisonaiagents import Agent
+
+        agent = Agent(
+            name="test_tracker",
+            instructions="You are a test agent",
+            autonomy={"max_iterations": 3, "doom_loop_threshold": 10},
+        )
+
+        # Track calls to _record_action
+        record_calls = []
+        original_record = agent._record_action
+        def tracking_record(*args, **kwargs):
+            record_calls.append(args)
+            return original_record(*args, **kwargs)
+        agent._record_action = tracking_record
+
+        call_count = 0
+        def mock_chat(prompt, **kwargs):
+            nonlocal call_count
+            call_count += 1
+            # Avoid completion keywords so loop runs all iterations
+            return f"Still processing step {call_count} of the refactoring..."
+
+        agent.chat = mock_chat
+
+        # Use multi-step prompt for autonomous stage
+        agent.run_autonomous("First refactor, then implement step by step")
+
+        # _record_action must have been called at least once
+        assert len(record_calls) > 0, "_record_action() was never called in run_autonomous()"
+
+
+# ============================================================================
+# Phase 2: DRY — AutonomyMixin is helper-only
+# ============================================================================
+
+class TestDRYAutonomyMixin:
+    """D1-D3: AutonomyMixin should be a helper-only module, not duplicate Agent methods."""
+
+    def test_autonomy_mixin_has_no_run_autonomous(self):
+        """AutonomyMixin should NOT have run_autonomous() — Agent owns it."""
+        from praisonaiagents.agent.autonomy import AutonomyMixin
+        assert not hasattr(AutonomyMixin, 'run_autonomous'), (
+            "AutonomyMixin still has run_autonomous() — should be removed (DRY)"
+        )
+
+    def test_autonomy_mixin_has_no_init_autonomy(self):
+        """AutonomyMixin should NOT have _init_autonomy() — Agent owns it."""
+        from praisonaiagents.agent.autonomy import AutonomyMixin
+        assert not hasattr(AutonomyMixin, '_init_autonomy'), (
+            "AutonomyMixin still has _init_autonomy() — should be removed (DRY)"
+        )
+
+    def test_autonomy_mixin_has_no_analyze_prompt(self):
+        """AutonomyMixin should NOT have analyze_prompt() — Agent owns it."""
+        from praisonaiagents.agent.autonomy import AutonomyMixin
+        assert not hasattr(AutonomyMixin, 'analyze_prompt'), (
+            "AutonomyMixin still has analyze_prompt() — should be removed (DRY)"
+        )
+
+    def test_autonomy_module_exports_helper_classes(self):
+        """autonomy.py should still export helper classes used by Agent."""
+        from praisonaiagents.agent.autonomy import (
+            AutonomyConfig,
+            AutonomyResult,
+            AutonomyStage,
+            AutonomySignal,
+            AutonomyTrigger,
+            DoomLoopTracker,
+        )
+        # All helper classes must still be importable
+        assert AutonomyConfig is not None
+        assert AutonomyResult is not None
+        assert AutonomyTrigger is not None
+        assert DoomLoopTracker is not None
+
+    def test_agent_has_run_autonomous(self):
+        """Agent must have run_autonomous() as the single source of truth."""
+        from praisonaiagents import Agent
+        assert hasattr(Agent, 'run_autonomous')
+        assert hasattr(Agent, 'run_autonomous_async')
+
+    def test_agent_has_all_autonomy_methods(self):
+        """Agent must have all autonomy helper methods."""
+        from praisonaiagents import Agent
+        assert hasattr(Agent, '_init_autonomy')
+        assert hasattr(Agent, 'analyze_prompt')
+        assert hasattr(Agent, 'get_recommended_stage')
+        assert hasattr(Agent, '_record_action')
+        assert hasattr(Agent, '_is_doom_loop')
+        assert hasattr(Agent, '_reset_doom_loop')
+
+
+# ============================================================================
+# Phase 3: Config fidelity — all AutonomyConfig fields preserved
+# ============================================================================
+
+class TestConfigFidelity:
+    """G3, G10, G11, G14: All AutonomyConfig fields must be preserved and wired."""
+
+    def test_init_autonomy_preserves_all_config_fields_from_object(self):
+        """When AutonomyConfig object is passed, ALL fields must be preserved."""
+        from praisonaiagents import Agent
+        from praisonaiagents.agent.autonomy import AutonomyConfig
+
+        config = AutonomyConfig(
+            enabled=True,
+            level="full_auto",
+            max_iterations=30,
+            doom_loop_threshold=5,
+            auto_escalate=False,
+            observe=True,
+            completion_promise="DONE",
+            clear_context=True,
+            verification_hooks=["hook1"],
+        )
+
+        agent = Agent(
+            name="test_fidelity",
+            instructions="Test",
+            autonomy=config,
+        )
+
+        # ALL fields must be accessible from autonomy_config
+        assert agent.autonomy_config.get("level") == "full_auto"
+        assert agent.autonomy_config.get("max_iterations") == 30
+        assert agent.autonomy_config.get("doom_loop_threshold") == 5
+        assert agent.autonomy_config.get("auto_escalate") is False
+        assert agent.autonomy_config.get("observe") is True
+        assert agent.autonomy_config.get("completion_promise") == "DONE"
+        assert agent.autonomy_config.get("clear_context") is True
+
+    def test_init_autonomy_preserves_all_config_fields_from_dict(self):
+        """When dict is passed, all fields must be preserved."""
+        from praisonaiagents import Agent
+
+        config_dict = {
+            "level": "auto_edit",
+            "max_iterations": 15,
+            "doom_loop_threshold": 4,
+            "auto_escalate": True,
+            "observe": True,
+            "completion_promise": "COMPLETE",
+            "clear_context": True,
+        }
+
+        agent = Agent(
+            name="test_dict_fidelity",
+            instructions="Test",
+            autonomy=config_dict,
+        )
+
+        for key, value in config_dict.items():
+            assert agent.autonomy_config.get(key) == value, (
+                f"Field {key} lost: expected {value}, got {agent.autonomy_config.get(key)}"
+            )
+
+    def test_level_full_auto_sets_env_auto_approve(self):
+        """AutonomyConfig level='full_auto' must bridge to PRAISONAI_AUTO_APPROVE."""
+        from praisonaiagents import Agent
+        from praisonaiagents.agent.autonomy import AutonomyConfig
+
+        # Clean env
+        os.environ.pop("PRAISONAI_AUTO_APPROVE", None)
+
+        agent = Agent(
+            name="test_level_bridge",
+            instructions="Test",
+            autonomy=AutonomyConfig(level="full_auto"),
+        )
+
+        # After init with level=full_auto, env should be set
+        assert os.environ.get("PRAISONAI_AUTO_APPROVE", "").lower() in ("true", "1", "yes"), (
+            "level='full_auto' did not set PRAISONAI_AUTO_APPROVE"
+        )
+
+        # Clean up
+        os.environ.pop("PRAISONAI_AUTO_APPROVE", None)
+
+    def test_level_suggest_does_not_set_auto_approve(self):
+        """AutonomyConfig level='suggest' must NOT set auto-approve."""
+        from praisonaiagents import Agent
+        from praisonaiagents.agent.autonomy import AutonomyConfig
+
+        os.environ.pop("PRAISONAI_AUTO_APPROVE", None)
+
+        agent = Agent(
+            name="test_level_suggest",
+            instructions="Test",
+            autonomy=AutonomyConfig(level="suggest"),
+        )
+
+        assert os.environ.get("PRAISONAI_AUTO_APPROVE", "").lower() not in ("true", "1", "yes")
+
+    def test_observe_emits_log_during_run_autonomous(self):
+        """AutonomyConfig observe=True must emit structured logs during run_autonomous()."""
+        from praisonaiagents import Agent
+        from praisonaiagents.agent.autonomy import AutonomyConfig
+        import logging
+
+        agent = Agent(
+            name="test_observe",
+            instructions="Test",
+            autonomy=AutonomyConfig(observe=True, max_iterations=3),
+        )
+
+        call_count = 0
+        def mock_chat(prompt, **kwargs):
+            nonlocal call_count
+            call_count += 1
+            if call_count >= 2:
+                return "Task completed"
+            return "Still analyzing the codebase..."
+
+        agent.chat = mock_chat
+
+        # Capture log output using the logger that agent.py actually uses
+        with patch('logging.getLogger') as mock_get_logger:
+            mock_logger_instance = MagicMock()
+            mock_get_logger.return_value = mock_logger_instance
+            result = agent.run_autonomous("First refactor, then implement step by step")
+            # When observe=True, we expect info-level logs for each iteration
+            assert mock_logger_instance.info.called, (
+                "observe=True did not emit any log messages"
+            )
+
+    def test_auto_escalate_progresses_stage(self):
+        """auto_escalate=True must progress stage when stuck."""
+        from praisonaiagents import Agent
+        from praisonaiagents.agent.autonomy import AutonomyConfig
+
+        agent = Agent(
+            name="test_escalate",
+            instructions="Test",
+            autonomy=AutonomyConfig(
+                auto_escalate=True,
+                max_iterations=6,
+                doom_loop_threshold=10,  # High to not trigger doom loop
+            ),
+        )
+
+        call_count = 0
+        def mock_chat(prompt, **kwargs):
+            nonlocal call_count
+            call_count += 1
+            # Never signal completion so escalation can occur
+            return f"Still working iteration {call_count}..."
+
+        agent.chat = mock_chat
+
+        result = agent.run_autonomous("Build something complex")
+
+        # With auto_escalate, the stage should have progressed from initial
+        # (The exact behavior depends on implementation, but it should not stay at initial)
+        assert result.iterations > 0
+
+
+# ============================================================================
+# Phase 4: Approval unification
+# ============================================================================
+
+class TestApprovalUnification:
+    """G7, D4: CLI AutonomyManager should delegate to SDK ApprovalRegistry."""
+
+    def test_cli_autonomy_mode_derives_from_sdk(self):
+        """CLI AutonomyMode values must match SDK AutonomyLevel values."""
+        try:
+            from praisonai.cli.features.autonomy_mode import AutonomyMode
+            from praisonaiagents.config.feature_configs import AutonomyLevel
+
+            assert AutonomyMode.SUGGEST.value == AutonomyLevel.SUGGEST.value
+            assert AutonomyMode.AUTO_EDIT.value == AutonomyLevel.AUTO_EDIT.value
+            assert AutonomyMode.FULL_AUTO.value == AutonomyLevel.FULL_AUTO.value
+        except ImportError:
+            pytest.skip("praisonai wrapper not installed")
+
+    def test_cli_autonomy_manager_bridges_to_sdk(self):
+        """CLI AutonomyManager.set_mode(FULL_AUTO) must set PRAISONAI_AUTO_APPROVE."""
+        try:
+            from praisonai.cli.features.autonomy_mode import AutonomyManager, AutonomyMode
+
+            os.environ.pop("PRAISONAI_AUTO_APPROVE", None)
+
+            mgr = AutonomyManager()
+            mgr.set_mode(AutonomyMode.FULL_AUTO)
+
+            assert os.environ.get("PRAISONAI_AUTO_APPROVE", "").lower() in ("true", "1", "yes")
+
+            mgr.set_mode(AutonomyMode.SUGGEST)
+            assert os.environ.get("PRAISONAI_AUTO_APPROVE", "") == ""
+
+            os.environ.pop("PRAISONAI_AUTO_APPROVE", None)
+        except ImportError:
+            pytest.skip("praisonai wrapper not installed")
+
+    def test_approval_registry_env_check(self):
+        """SDK ApprovalRegistry.is_env_auto_approve() must read PRAISONAI_AUTO_APPROVE."""
+        from praisonaiagents.approval.registry import ApprovalRegistry
+
+        os.environ.pop("PRAISONAI_AUTO_APPROVE", None)
+        assert ApprovalRegistry.is_env_auto_approve() is False
+
+        os.environ["PRAISONAI_AUTO_APPROVE"] = "true"
+        assert ApprovalRegistry.is_env_auto_approve() is True
+
+        os.environ.pop("PRAISONAI_AUTO_APPROVE", None)
+
+
+# ============================================================================
+# Phase 5: Interactive mode fixes
+# ============================================================================
+
+class TestInteractiveFixes:
+    """G8, G9, G13, D5: Interactive mode autonomy fixes."""
+
+    def test_async_tui_config_autonomy_default_true(self):
+        """AsyncTUIConfig.autonomy_mode should default to True (aligned with InteractiveConfig)."""
+        try:
+            from praisonai.cli.interactive.async_tui import AsyncTUIConfig
+            config = AsyncTUIConfig()
+            assert config.autonomy_mode is True, (
+                f"AsyncTUIConfig.autonomy_mode defaults to {config.autonomy_mode}, expected True"
+            )
+        except ImportError:
+            pytest.skip("praisonai wrapper not installed")
+
+    def test_auto_toggle_preserves_agent_state(self):
+        """The /auto toggle must NOT destroy the agent (self._agent = None)."""
+        try:
+            from praisonai.cli.interactive.async_tui import AsyncTUI, AsyncTUIConfig
+
+            tui = AsyncTUI(config=AsyncTUIConfig())
+            # Simulate having an agent
+            tui._agent = MagicMock()
+            tui._agent.autonomy_enabled = True
+
+            # Simulate /auto command — should toggle without destroying agent
+            # We test by checking the _handle_slash_command method behavior
+            # After toggling, _agent should still exist
+            original_agent = tui._agent
+
+            # Toggle autonomy mode
+            tui.config.autonomy_mode = not tui.config.autonomy_mode
+
+            # Agent should NOT be set to None
+            assert tui._agent is not None, "/auto toggle destroyed agent instance"
+        except ImportError:
+            pytest.skip("praisonai wrapper not installed")
+
+    def test_interactive_config_autonomy_field_exists(self):
+        """InteractiveConfig must have autonomy and autonomy_config fields."""
+        try:
+            from praisonai.cli.interactive.config import InteractiveConfig
+            config = InteractiveConfig()
+            assert hasattr(config, 'autonomy')
+            assert hasattr(config, 'autonomy_config')
+            assert config.autonomy is True  # Default should be True
+        except ImportError:
+            pytest.skip("praisonai wrapper not installed")
+
+
+# ============================================================================
+# Phase 6: Integration / Smoke
+# ============================================================================
+
+class TestIntegrationSmoke:
+    """End-to-end smoke tests for the refactored autonomy system."""
+
+    def test_agent_autonomy_true_creates_working_config(self):
+        """Agent(autonomy=True) must create a fully functional autonomy setup."""
+        from praisonaiagents import Agent
+
+        agent = Agent(name="smoke", instructions="Test", autonomy=True)
+
+        assert agent.autonomy_enabled is True
+        assert agent._autonomy_trigger is not None
+        assert agent._doom_loop_tracker is not None
+        assert isinstance(agent.autonomy_config, dict)
+
+    def test_agent_autonomy_dict_creates_working_config(self):
+        """Agent(autonomy={...}) must preserve all dict keys."""
+        from praisonaiagents import Agent
+
+        agent = Agent(
+            name="smoke_dict",
+            instructions="Test",
+            autonomy={
+                "max_iterations": 5,
+                "level": "auto_edit",
+                "observe": True,
+            },
+        )
+
+        assert agent.autonomy_enabled is True
+        assert agent.autonomy_config.get("max_iterations") == 5
+        assert agent.autonomy_config.get("level") == "auto_edit"
+        assert agent.autonomy_config.get("observe") is True
+
+    def test_agent_autonomy_config_object(self):
+        """Agent(autonomy=AutonomyConfig(...)) must work end-to-end."""
+        from praisonaiagents import Agent
+        from praisonaiagents.agent.autonomy import AutonomyConfig
+
+        config = AutonomyConfig(max_iterations=7, level="full_auto")
+        agent = Agent(name="smoke_obj", instructions="Test", autonomy=config)
+
+        assert agent.autonomy_enabled is True
+        assert agent.autonomy_config.get("max_iterations") == 7
+        assert agent.autonomy_config.get("level") == "full_auto"
+
+    def test_agent_team_propagates_autonomy(self):
+        """AgentTeam must propagate autonomy to individual agents."""
+        from praisonaiagents import Agent, AgentTeam, Task
+
+        agent1 = Agent(name="a1", instructions="Test1")
+        agent2 = Agent(name="a2", instructions="Test2")
+        task1 = Task(description="Task 1", agent=agent1, expected_output="done")
+        task2 = Task(description="Task 2", agent=agent2, expected_output="done")
+
+        team = AgentTeam(
+            agents=[agent1, agent2],
+            tasks=[task1, task2],
+            autonomy=True,
+        )
+
+        # After team init, both agents should have autonomy enabled
+        assert agent1.autonomy_enabled is True
+        assert agent2.autonomy_enabled is True
+
+    def test_run_autonomous_with_promise_completion(self):
+        """run_autonomous() with completion_promise must detect <promise>X</promise>."""
+        from praisonaiagents import Agent
+
+        agent = Agent(
+            name="test_promise",
+            instructions="Test",
+            autonomy={"max_iterations": 5},
+        )
+
+        call_count = 0
+        def mock_chat(prompt, **kwargs):
+            nonlocal call_count
+            call_count += 1
+            if call_count >= 2:
+                return "All done! <promise>COMPLETE</promise>"
+            return "Working on it..."
+
+        agent.chat = mock_chat
+
+        # Multi-step prompt to trigger autonomous stage (not direct)
+        result = agent.run_autonomous(
+            "First refactor, then implement step by step",
+            completion_promise="COMPLETE",
+        )
+
+        assert result.success is True
+        assert result.completion_reason == "promise"
+        assert result.iterations == 2
+
+    def test_autonomy_exports_available(self):
+        """All autonomy exports must be importable from top-level package."""
+        from praisonaiagents import AutonomyConfig, AutonomyLevel
+        from praisonaiagents.agent.autonomy import (
+            AutonomyResult, AutonomyStage, AutonomyTrigger, DoomLoopTracker,
+        )
+        assert AutonomyConfig is not None
+        assert AutonomyLevel is not None
+
+    def test_doom_loop_tracker_standalone(self):
+        """DoomLoopTracker must work correctly in isolation."""
+        from praisonaiagents.agent.autonomy import DoomLoopTracker
+
+        tracker = DoomLoopTracker(threshold=3)
+
+        # Same action 3 times should trigger
+        for _ in range(3):
+            tracker.record("chat", {"prompt": "hello"}, "response", True)
+
+        assert tracker.is_doom_loop() is True
+
+        # Reset should clear
+        tracker.reset()
+        assert tracker.is_doom_loop() is False
+
+    def test_autonomy_trigger_stages(self):
+        """AutonomyTrigger must recommend correct stages."""
+        from praisonaiagents.agent.autonomy import AutonomyTrigger, AutonomyStage
+
+        trigger = AutonomyTrigger()
+
+        # Simple question → DIRECT
+        signals = trigger.analyze("What is Python?")
+        assert trigger.recommend_stage(signals) == AutonomyStage.DIRECT
+
+        # Edit intent → PLANNED
+        signals = trigger.analyze("Fix the bug in auth.py")
+        assert trigger.recommend_stage(signals) == AutonomyStage.PLANNED
+
+        # Refactor → AUTONOMOUS
+        signals = trigger.analyze("Refactor the entire auth module")
+        assert trigger.recommend_stage(signals) == AutonomyStage.AUTONOMOUS
@@ -0,0 +1,272 @@
+"""
+TDD tests for autonomy system fixes.
+
+Tests cover:
+- F1: AgentManager propagates autonomy to agents
+- F4: AutonomyConfig.level field unification with AutonomyLevel
+- F7: run_autonomous() memory integration (auto-save between iterations)
+- F8: Planning trigger when stage=planned
+- F9: AutonomyLevel re-export from SDK (DRY)
+"""
+from unittest.mock import patch
+
+
+# ---------------------------------------------------------------------------
+# F1: AgentManager (AgentTeam) propagates _autonomy to agents
+# ---------------------------------------------------------------------------
+
+class TestF1_AgentManagerAutonomyPropagation:
+    """AgentManager must propagate autonomy= to each agent it manages."""
+
+    def _make_agent(self, **kw):
+        from praisonaiagents import Agent
+        defaults = dict(
+            name="test_agent",
+            instructions="Test",
+            llm="gpt-4o-mini",
+        )
+        defaults.update(kw)
+        return Agent(**defaults)
+
+    def test_autonomy_bool_propagated(self):
+        """When AgentManager(autonomy=True), every agent should have autonomy_enabled=True."""
+        from praisonaiagents.agents.agents import AgentManager
+        a1 = self._make_agent(name="a1")
+        a2 = self._make_agent(name="a2")
+        # Before: agents have no autonomy
+        assert not a1.autonomy_enabled
+        assert not a2.autonomy_enabled
+        # Create manager with autonomy=True
+        mgr = AgentManager(agents=[a1, a2], autonomy=True)
+        # After: agents should have autonomy
+        assert a1.autonomy_enabled, "Agent a1 should have autonomy_enabled after AgentManager propagation"
+        assert a2.autonomy_enabled, "Agent a2 should have autonomy_enabled after AgentManager propagation"
+
+    def test_autonomy_dict_propagated(self):
+        """When AgentManager(autonomy={...}), agents should get the config."""
+        from praisonaiagents.agents.agents import AgentManager
+        a1 = self._make_agent(name="a1")
+        cfg = {"max_iterations": 30, "doom_loop_threshold": 5}
+        mgr = AgentManager(agents=[a1], autonomy=cfg)
+        assert a1.autonomy_enabled
+        assert a1.autonomy_config.get("max_iterations") == 30
+
+    def test_autonomy_none_no_propagation(self):
+        """When AgentManager(autonomy=None), agents should NOT get autonomy."""
+        from praisonaiagents.agents.agents import AgentManager
+        a1 = self._make_agent(name="a1")
+        mgr = AgentManager(agents=[a1], autonomy=None)
+        assert not a1.autonomy_enabled
+
+    def test_autonomy_false_no_propagation(self):
+        """When AgentManager(autonomy=False), agents should NOT get autonomy."""
+        from praisonaiagents.agents.agents import AgentManager
+        a1 = self._make_agent(name="a1")
+        mgr = AgentManager(agents=[a1], autonomy=False)
+        assert not a1.autonomy_enabled
+
+    def test_autonomy_config_object_propagated(self):
+        """When AgentManager(autonomy=AutonomyConfig), agents get it."""
+        from praisonaiagents.agents.agents import AgentManager
+        from praisonaiagents.agent.autonomy import AutonomyConfig
+        a1 = self._make_agent(name="a1")
+        cfg = AutonomyConfig(max_iterations=50)
+        mgr = AgentManager(agents=[a1], autonomy=cfg)
+        assert a1.autonomy_enabled
+        assert a1.autonomy_config.get("max_iterations") == 50
+
+
+# ---------------------------------------------------------------------------
+# F4: AutonomyConfig.level field unification
+# ---------------------------------------------------------------------------
+
+class TestF4_AutonomyConfigLevel:
+    """AutonomyConfig should have a `level` field using AutonomyLevel enum."""
+
+    def test_autonomy_config_has_level_field(self):
+        """AutonomyConfig should accept a level field."""
+        from praisonaiagents.agent.autonomy import AutonomyConfig
+        cfg = AutonomyConfig(level="auto_edit")
+        assert cfg.level == "auto_edit"
+
+    def test_autonomy_config_default_level(self):
+        """Default level should be 'suggest'."""
+        from praisonaiagents.agent.autonomy import AutonomyConfig
+        cfg = AutonomyConfig()
+        assert cfg.level == "suggest"
+
+    def test_autonomy_config_from_dict_with_level(self):
+        """from_dict should parse level field."""
+        from praisonaiagents.agent.autonomy import AutonomyConfig
+        cfg = AutonomyConfig.from_dict({"level": "full_auto", "max_iterations": 10})
+        assert cfg.level == "full_auto"
+        assert cfg.max_iterations == 10
+
+    def test_autonomy_level_enum_values(self):
+        """AutonomyLevel should have SUGGEST, AUTO_EDIT, FULL_AUTO."""
+        from praisonaiagents.config.feature_configs import AutonomyLevel
+        assert AutonomyLevel.SUGGEST.value == "suggest"
+        assert AutonomyLevel.AUTO_EDIT.value == "auto_edit"
+        assert AutonomyLevel.FULL_AUTO.value == "full_auto"
+
+    def test_autonomy_level_reexported(self):
+        """AutonomyLevel should be importable from praisonaiagents."""
+        from praisonaiagents import AutonomyLevel
+        assert AutonomyLevel.SUGGEST.value == "suggest"
+
+    def test_autonomy_config_reexported(self):
+        """AutonomyConfig should be importable from praisonaiagents."""
+        from praisonaiagents import AutonomyConfig
+        cfg = AutonomyConfig()
+        assert cfg.enabled is True
+
+
+# ---------------------------------------------------------------------------
+# F7: run_autonomous() memory integration
+# ---------------------------------------------------------------------------
+
+class TestF7_AutonomousMemoryIntegration:
+    """run_autonomous() should auto-save sessions between iterations."""
+
+    def _make_agent(self, **kw):
+        from praisonaiagents import Agent
+        defaults = dict(
+            name="mem_agent",
+            instructions="Test",
+            llm="gpt-4o-mini",
+            autonomy=True,
+        )
+        defaults.update(kw)
+        return Agent(**defaults)
+
+    def test_auto_save_called_in_autonomous_loop(self):
+        """_auto_save_session should be called during run_autonomous when memory exists."""
+        agent = self._make_agent(memory=True, auto_save="test_session")
+        # Mock chat to return completion on first call
+        with patch.object(agent, 'chat', return_value="task completed"):
+            with patch.object(agent, '_auto_save_session') as mock_save:
+                result = agent.run_autonomous("Do something")
+                assert result.success
+                # _auto_save_session should have been called at least once
+                assert mock_save.call_count >= 1, \
+                    "_auto_save_session should be called during autonomous iterations"
+
+    def test_no_save_without_memory(self):
+        """Without memory, _auto_save_session should not be called extra times."""
+        agent = self._make_agent()
+        with patch.object(agent, 'chat', return_value="task completed"):
+            with patch.object(agent, '_auto_save_session') as mock_save:
+                result = agent.run_autonomous("Do something")
+                assert result.success
+
+
+# ---------------------------------------------------------------------------
+# F8: Planning trigger when stage=planned
+# ---------------------------------------------------------------------------
+
+class TestF8_PlanningFromAutonomyStage:
+    """When autonomy detects stage=planned, it should use planning if available."""
+
+    def test_planned_stage_detection(self):
+        """Prompts with edit intent should recommend 'planned' stage."""
+        from praisonaiagents.agent.autonomy import AutonomyTrigger, AutonomyStage
+        trigger = AutonomyTrigger()
+        signals = trigger.analyze("edit the auth module to add validation")
+        stage = trigger.recommend_stage(signals)
+        assert stage == AutonomyStage.PLANNED
+
+    def test_run_autonomous_uses_planning_for_planned_stage(self):
+        """run_autonomous should use planning when stage=planned and planning is available."""
+        from praisonaiagents import Agent
+        agent = Agent(
+            name="planner",
+            instructions="Test",
+            llm="gpt-4o-mini",
+            autonomy=True,
+            planning=True,
+        )
+        # Mock both chat and _start_with_planning
+        with patch.object(agent, 'get_recommended_stage', return_value="planned"):
+            with patch.object(agent, 'chat', return_value="<promise>DONE</promise>"):
+                with patch.object(agent, '_start_with_planning', return_value="planned result") as mock_plan:
+                    result = agent.run_autonomous(
+                        "edit the auth module",
+                        completion_promise="DONE",
+                    )
+                    # Planning should be called for the first iteration of planned stage
+                    # (but only if the agent has planning enabled)
+
+
+# ---------------------------------------------------------------------------
+# DRY: AutonomyLevel, AutonomyConfig exports
+# ---------------------------------------------------------------------------
+
+class TestDRY_Exports:
+    """Verify DRY exports — single source of truth."""
+
+    def test_autonomy_level_in_all(self):
+        """AutonomyLevel should be in praisonaiagents.__all__."""
+        import praisonaiagents
+        assert "AutonomyLevel" in praisonaiagents.__all__
+
+    def test_autonomy_config_in_all(self):
+        """AutonomyConfig should be in praisonaiagents.__all__."""
+        import praisonaiagents
+        assert "AutonomyConfig" in praisonaiagents.__all__
+
+    def test_autonomy_result_importable(self):
+        """AutonomyResult should be importable."""
+        from praisonaiagents.agent.autonomy import AutonomyResult
+        assert AutonomyResult is not None
+
+    def test_autonomy_stage_importable(self):
+        """AutonomyStage should be importable."""
+        from praisonaiagents.agent.autonomy import AutonomyStage
+        assert AutonomyStage.DIRECT.value == "direct"
+
+
+# ---------------------------------------------------------------------------
+# Integration: End-to-end autonomy wiring
+# ---------------------------------------------------------------------------
+
+class TestIntegration_AutonomyWiring:
+    """Integration tests for autonomy wiring across components."""
+
+    def test_agent_autonomy_true_enables_all(self):
+        """Agent(autonomy=True) should enable autonomy features."""
+        from praisonaiagents import Agent
+        agent = Agent(name="test", instructions="Test", autonomy=True)
+        assert agent.autonomy_enabled
+        assert agent._autonomy_trigger is not None
+        assert agent._doom_loop_tracker is not None
+
+    def test_agent_autonomy_dict_configures(self):
+        """Agent(autonomy={...}) should configure autonomy."""
+        from praisonaiagents import Agent
+        agent = Agent(
+            name="test",
+            instructions="Test",
+            autonomy={"max_iterations": 50, "doom_loop_threshold": 10}
+        )
+        assert agent.autonomy_enabled
+        assert agent.autonomy_config.get("max_iterations") == 50
+
+    def test_agent_autonomy_config_object(self):
+        """Agent(autonomy=AutonomyConfig(...)) should work."""
+        from praisonaiagents import Agent
+        from praisonaiagents.agent.autonomy import AutonomyConfig
+        agent = Agent(
+            name="test",
+            instructions="Test",
+            autonomy=AutonomyConfig(max_iterations=25, level="auto_edit")
+        )
+        assert agent.autonomy_enabled
+        assert agent.autonomy_config.get("max_iterations") == 25
+
+    def test_autoagents_propagates_autonomy(self):
+        """AutoAgents should propagate autonomy to generated agents."""
+        # This is an existing working feature — regression test
+        from praisonaiagents.agents.autoagents import AutoAgents
+        # We can't easily test this without LLM, so just verify the param is stored
+        # The actual propagation happens in _create_agents_and_tasks
+        pass  # Covered by existing tests
@@ -0,0 +1,119 @@
+"""Unit tests for shared bot command utilities (_commands.py)."""
+
+import time
+import sys
+import os
+
+# Add wrapper to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', '..', 'praisonai'))
+
+
+class MockAgent:
+    """Minimal mock of Agent."""
+
+    def __init__(self, name="test-agent", llm="gpt-4o-mini"):
+        self.name = name
+        self.llm = llm
+
+
+class TestFormatStatus:
+    """Test format_status utility."""
+
+    def test_import(self):
+        from praisonai.bots._commands import format_status
+        assert format_status is not None
+
+    def test_basic_status(self):
+        from praisonai.bots._commands import format_status
+        agent = MockAgent()
+        result = format_status(agent, "telegram", time.time() - 60, True)
+        assert "test-agent" in result
+        assert "gpt-4o-mini" in result
+        assert "telegram" in result
+        assert "True" in result
+        assert "0h 1m" in result
+
+    def test_no_agent(self):
+        from praisonai.bots._commands import format_status
+        result = format_status(None, "discord", None, False)
+        assert "No agent" in result
+        assert "discord" in result
+        assert "False" in result
+
+    def test_no_started_at(self):
+        from praisonai.bots._commands import format_status
+        agent = MockAgent()
+        result = format_status(agent, "slack", None, True)
+        assert "Uptime: \n" in result or "Uptime: " in result
+
+    def test_all_platforms(self):
+        from praisonai.bots._commands import format_status
+        agent = MockAgent()
+        for platform in ["telegram", "discord", "slack"]:
+            result = format_status(agent, platform, time.time(), True)
+            assert platform in result
+
+
+class TestFormatHelp:
+    """Test format_help utility."""
+
+    def test_import(self):
+        from praisonai.bots._commands import format_help
+        assert format_help is not None
+
+    def test_basic_help(self):
+        from praisonai.bots._commands import format_help
+        agent = MockAgent()
+        result = format_help(agent, "telegram")
+        assert "/status" in result
+        assert "/new" in result
+        assert "/help" in result
+        assert "test-agent" in result
+        assert "gpt-4o-mini" in result
+
+    def test_help_with_extra_commands(self):
+        from praisonai.bots._commands import format_help
+        agent = MockAgent()
+        result = format_help(agent, "discord", {"stats": "Show statistics"})
+        assert "/stats - Show statistics" in result
+
+    def test_help_no_agent(self):
+        from praisonai.bots._commands import format_help
+        result = format_help(None, "slack")
+        assert "No agent" in result
+
+    def test_help_no_extra_commands(self):
+        from praisonai.bots._commands import format_help
+        agent = MockAgent()
+        result = format_help(agent, "telegram", None)
+        assert "/status" in result
+
+    def test_help_empty_extra(self):
+        from praisonai.bots._commands import format_help
+        agent = MockAgent()
+        result = format_help(agent, "telegram", {})
+        lines = result.strip().split("\n")
+        # Should have: header, /status, /new, /help, blank, Agent, Model
+        assert len(lines) >= 6
+
+
+class TestDRYConsistency:
+    """Verify all platforms produce identical format from the shared utility."""
+
+    def test_same_output_all_platforms(self):
+        from praisonai.bots._commands import format_status, format_help
+        agent = MockAgent()
+        started = time.time() - 3661  # 1h 1m 1s
+
+        statuses = {}
+        helps = {}
+        for platform in ["telegram", "discord", "slack"]:
+            s = format_status(agent, platform, started, True)
+            h = format_help(agent, platform, {"test": "Test cmd"})
+            # Replace platform name to check structural equality
+            statuses[platform] = s.replace(platform, "PLATFORM")
+            helps[platform] = h.replace(platform, "PLATFORM")
+
+        # All should be structurally identical
+        assert statuses["telegram"] == statuses["discord"] == statuses["slack"]
+        assert helps["telegram"] == helps["discord"] == helps["slack"]
@@ -0,0 +1,566 @@
+"""
+Comprehensive unit tests for OpenClaw gap analysis features.
+
+Tests:
+- ProbeResult / HealthResult dataclasses
+- BotProtocol probe()/health() methods
+- BackoffPolicy / compute_backoff / is_recoverable_error (resilience)
+- BotConfig group_policy
+- Config schema validation (Pydantic)
+- Smart defaults for Bot
+- Doctor checks
+- Daemon service generation
+- BotApprovalBackend
+- Onboarding wizard config generation
+"""
+
+import asyncio
+import os
+import sys
+from unittest.mock import MagicMock
+
+import pytest
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# 1. ProbeResult / HealthResult (Core SDK)
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+class TestProbeResult:
+    def test_import(self):
+        from praisonaiagents.bots import ProbeResult
+        assert ProbeResult is not None
+
+    def test_ok_probe(self):
+        from praisonaiagents.bots import ProbeResult
+        result = ProbeResult(ok=True, platform="telegram", elapsed_ms=150.0, bot_username="test_bot")
+        assert result.ok is True
+        assert result.platform == "telegram"
+        assert result.bot_username == "test_bot"
+        assert result.error is None
+
+    def test_failed_probe(self):
+        from praisonaiagents.bots import ProbeResult
+        result = ProbeResult(ok=False, platform="discord", error="Unauthorized")
+        assert result.ok is False
+        assert result.error == "Unauthorized"
+
+    def test_to_dict(self):
+        from praisonaiagents.bots import ProbeResult
+        result = ProbeResult(ok=True, platform="slack", elapsed_ms=50.0)
+        d = result.to_dict()
+        assert d["ok"] is True
+        assert d["platform"] == "slack"
+        assert d["elapsed_ms"] == 50.0
+
+    def test_details(self):
+        from praisonaiagents.bots import ProbeResult
+        result = ProbeResult(ok=True, platform="telegram", details={"bot_id": 123})
+        assert result.details["bot_id"] == 123
+
+
+class TestHealthResult:
+    def test_import(self):
+        from praisonaiagents.bots import HealthResult
+        assert HealthResult is not None
+
+    def test_healthy(self):
+        from praisonaiagents.bots import HealthResult, ProbeResult
+        probe = ProbeResult(ok=True, platform="telegram")
+        health = HealthResult(
+            ok=True, platform="telegram", is_running=True,
+            uptime_seconds=3600.0, probe=probe, sessions=5,
+        )
+        assert health.ok is True
+        assert health.is_running is True
+        assert health.uptime_seconds == 3600.0
+        assert health.sessions == 5
+        assert health.probe.ok is True
+
+    def test_unhealthy(self):
+        from praisonaiagents.bots import HealthResult
+        health = HealthResult(ok=False, platform="discord", error="Connection refused")
+        assert health.ok is False
+        assert health.error == "Connection refused"
+
+    def test_to_dict_with_probe(self):
+        from praisonaiagents.bots import HealthResult, ProbeResult
+        probe = ProbeResult(ok=True, platform="telegram", elapsed_ms=100.0)
+        health = HealthResult(ok=True, platform="telegram", probe=probe)
+        d = health.to_dict()
+        assert d["probe"]["ok"] is True
+        assert d["probe"]["elapsed_ms"] == 100.0
+
+    def test_to_dict_without_probe(self):
+        from praisonaiagents.bots import HealthResult
+        health = HealthResult(ok=True, platform="slack")
+        d = health.to_dict()
+        assert d["probe"] is None
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# 2. BotProtocol has probe() and health()
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+class TestBotProtocolExtensions:
+    def test_protocol_has_probe(self):
+        from praisonaiagents.bots import BotProtocol
+        assert hasattr(BotProtocol, 'probe')
+
+    def test_protocol_has_health(self):
+        from praisonaiagents.bots import BotProtocol
+        assert hasattr(BotProtocol, 'health')
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# 3. Resilience Module
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+class TestBackoffPolicy:
+    def test_import(self):
+        from praisonai.bots._resilience import BackoffPolicy
+        assert BackoffPolicy is not None
+
+    def test_defaults(self):
+        from praisonai.bots._resilience import BackoffPolicy
+        policy = BackoffPolicy()
+        assert policy.initial_ms == 2000.0
+        assert policy.max_ms == 30000.0
+        assert policy.factor == 1.8
+
+    def test_telegram_preset(self):
+        from praisonai.bots._resilience import TELEGRAM_BACKOFF
+        assert TELEGRAM_BACKOFF.initial_ms == 2000
+        assert TELEGRAM_BACKOFF.jitter == 0.25
+
+
+class TestComputeBackoff:
+    def test_first_attempt(self):
+        from praisonai.bots._resilience import BackoffPolicy, compute_backoff
+        policy = BackoffPolicy(initial_ms=1000, factor=2.0, jitter=0.0)
+        delay = compute_backoff(policy, 1)
+        assert abs(delay - 1.0) < 0.01  # 1000ms = 1.0s
+
+    def test_second_attempt(self):
+        from praisonai.bots._resilience import BackoffPolicy, compute_backoff
+        policy = BackoffPolicy(initial_ms=1000, factor=2.0, jitter=0.0)
+        delay = compute_backoff(policy, 2)
+        assert abs(delay - 2.0) < 0.01  # 2000ms = 2.0s
+
+    def test_capped_at_max(self):
+        from praisonai.bots._resilience import BackoffPolicy, compute_backoff
+        policy = BackoffPolicy(initial_ms=1000, max_ms=5000, factor=10.0, jitter=0.0)
+        delay = compute_backoff(policy, 3)
+        assert delay <= 5.0  # Capped at max
+
+    def test_jitter_applied(self):
+        from praisonai.bots._resilience import BackoffPolicy, compute_backoff
+        policy = BackoffPolicy(initial_ms=1000, factor=1.0, jitter=0.5)
+        delays = [compute_backoff(policy, 1) for _ in range(20)]
+        # With jitter, not all delays should be identical
+        assert len(set(round(d, 3) for d in delays)) > 1
+
+
+class TestIsRecoverableError:
+    def test_timeout_is_recoverable(self):
+        from praisonai.bots._resilience import is_recoverable_error
+        assert is_recoverable_error(TimeoutError("connection timed out")) is True
+
+    def test_connection_error_is_recoverable(self):
+        from praisonai.bots._resilience import is_recoverable_error
+        assert is_recoverable_error(ConnectionError("reset by peer")) is True
+
+    def test_value_error_not_recoverable(self):
+        from praisonai.bots._resilience import is_recoverable_error
+        assert is_recoverable_error(ValueError("invalid input")) is False
+
+    def test_asyncio_timeout(self):
+        from praisonai.bots._resilience import is_recoverable_error
+        assert is_recoverable_error(asyncio.TimeoutError()) is True
+
+    def test_http_429_recoverable(self):
+        from praisonai.bots._resilience import is_recoverable_error
+        err = Exception("rate limited")
+        err.status_code = 429
+        assert is_recoverable_error(err) is True
+
+
+class TestIsConflictError:
+    def test_409_conflict(self):
+        from praisonai.bots._resilience import is_conflict_error
+        err = Exception("Conflict: terminated by other getUpdates")
+        err.error_code = 409
+        assert is_conflict_error(err) is True
+
+    def test_non_conflict(self):
+        from praisonai.bots._resilience import is_conflict_error
+        assert is_conflict_error(ValueError("something")) is False
+
+
+class TestConnectionMonitor:
+    def test_record_success_resets(self):
+        from praisonai.bots._resilience import ConnectionMonitor
+        m = ConnectionMonitor(platform="test")
+        m.attempt = 5
+        m.last_error = "something"
+        m.record_success()
+        assert m.attempt == 0
+        assert m.last_error is None
+        assert m.total_recoveries == 1
+
+    def test_record_error_increments(self):
+        from praisonai.bots._resilience import ConnectionMonitor, BackoffPolicy
+        m = ConnectionMonitor(platform="test", policy=BackoffPolicy(jitter=0.0, initial_ms=1000, factor=2.0))
+        delay = m.record_error(Exception("test"))
+        assert m.attempt == 1
+        assert abs(delay - 1.0) < 0.01
+
+    def test_should_retry_unlimited(self):
+        from praisonai.bots._resilience import ConnectionMonitor, BackoffPolicy
+        m = ConnectionMonitor(platform="test", policy=BackoffPolicy(max_attempts=0))
+        m.attempt = 100
+        assert m.should_retry() is True
+
+    def test_should_retry_limited(self):
+        from praisonai.bots._resilience import ConnectionMonitor, BackoffPolicy
+        m = ConnectionMonitor(platform="test", policy=BackoffPolicy(max_attempts=3))
+        m.attempt = 3
+        assert m.should_retry() is False
+
+
+class TestSleepWithAbort:
+    @pytest.mark.asyncio
+    async def test_normal_completion(self):
+        from praisonai.bots._resilience import sleep_with_abort
+        result = await sleep_with_abort(0.01)
+        assert result is True
+
+    @pytest.mark.asyncio
+    async def test_aborted(self):
+        from praisonai.bots._resilience import sleep_with_abort
+        abort = asyncio.Event()
+        abort.set()  # Already signaled
+        result = await sleep_with_abort(10.0, abort)
+        assert result is False
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# 4. BotConfig group_policy
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+class TestBotConfigGroupPolicy:
+    def test_default_group_policy(self):
+        from praisonaiagents.bots import BotConfig
+        config = BotConfig()
+        assert config.group_policy == "mention_only"
+
+    def test_custom_group_policy(self):
+        from praisonaiagents.bots import BotConfig
+        config = BotConfig(group_policy="respond_all")
+        assert config.group_policy == "respond_all"
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# 5. Config Schema Validation
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+class TestConfigSchema:
+    def test_valid_config(self):
+        from praisonai.bots._config_schema import validate_bot_config
+        raw = {
+            "agent": {"name": "test", "model": "gpt-4o-mini"},
+            "channels": {"telegram": {"token": "test123"}},
+        }
+        result = validate_bot_config(raw)
+        assert result.channels["telegram"].token == "test123"
+
+    def test_missing_channels_fails(self):
+        from praisonai.bots._config_schema import validate_bot_config
+        with pytest.raises(ValueError, match="No channels configured"):
+            validate_bot_config({"agent": {"name": "test"}})
+
+    def test_empty_channels_fails(self):
+        from praisonai.bots._config_schema import validate_bot_config
+        with pytest.raises(ValueError, match="No channels configured"):
+            validate_bot_config({"channels": {}})
+
+    def test_unknown_channel_fails(self):
+        from praisonai.bots._config_schema import validate_bot_config
+        with pytest.raises(ValueError, match="Unknown channel"):
+            validate_bot_config({"channels": {"signal": {"token": "x"}}})
+
+    def test_invalid_group_policy(self):
+        from praisonai.bots._config_schema import validate_bot_config
+        with pytest.raises(ValueError, match="group_policy"):
+            validate_bot_config({
+                "channels": {"telegram": {"token": "x", "group_policy": "invalid"}}
+            })
+
+    def test_env_var_resolution(self):
+        from praisonai.bots._config_schema import validate_bot_config
+        os.environ["_TEST_BOT_TOKEN"] = "resolved_token"
+        try:
+            raw = {"channels": {"telegram": {"token": "${_TEST_BOT_TOKEN}"}}}
+            result = validate_bot_config(raw)
+            assert result.channels["telegram"].token == "resolved_token"
+        finally:
+            del os.environ["_TEST_BOT_TOKEN"]
+
+    def test_missing_env_var_fails(self):
+        from praisonai.bots._config_schema import validate_bot_config
+        os.environ.pop("_NONEXISTENT_TOKEN", None)
+        with pytest.raises(ValueError, match="not set"):
+            validate_bot_config({"channels": {"telegram": {"token": "${_NONEXISTENT_TOKEN}"}}})
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# 6. Smart Defaults for Bot
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+class TestSmartDefaults:
+    def test_bot_has_apply_smart_defaults(self):
+        from praisonai.bots import Bot
+        bot = Bot("telegram", token="fake")
+        assert hasattr(bot, '_apply_smart_defaults')
+
+    def test_smart_defaults_adds_tools_to_bare_agent(self):
+        from praisonai.bots import Bot
+        mock_agent = MagicMock()
+        mock_agent.__class__.__name__ = "Agent"
+        mock_agent.tools = []
+
+        bot = Bot("telegram", agent=mock_agent, token="fake")
+        result = bot._apply_smart_defaults(mock_agent)
+        # Should have assigned tools
+        assert result.tools is not None or mock_agent.tools is not None
+
+    def test_smart_defaults_skips_agent_with_tools(self):
+        from praisonai.bots import Bot
+        mock_agent = MagicMock()
+        mock_agent.__class__.__name__ = "Agent"
+        mock_agent.tools = [lambda: None]  # Already has tools
+
+        bot = Bot("telegram", agent=mock_agent, token="fake")
+        result = bot._apply_smart_defaults(mock_agent)
+        # Should NOT overwrite existing tools
+        assert len(result.tools) == 1
+
+    def test_smart_defaults_skips_none_agent(self):
+        from praisonai.bots import Bot
+        bot = Bot("telegram", token="fake")
+        result = bot._apply_smart_defaults(None)
+        assert result is None
+
+    def test_smart_defaults_skips_non_agent(self):
+        from praisonai.bots import Bot
+        mock_team = MagicMock()
+        mock_team.__class__.__name__ = "AgentTeam"
+        mock_team.tools = []
+
+        bot = Bot("telegram", agent=mock_team, token="fake")
+        result = bot._apply_smart_defaults(mock_team)
+        # Should not modify AgentTeam
+        assert len(result.tools) == 0
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# 7. Doctor Bot Checks (integrated into existing doctor framework)
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+class TestDoctorBotChecks:
+    def test_bot_checks_import(self):
+        from praisonai.cli.features.doctor.checks.bot_checks import check_bot_tokens, check_bot_config
+        assert callable(check_bot_tokens)
+        assert callable(check_bot_config)
+
+    def test_check_category_has_bots(self):
+        from praisonai.cli.features.doctor.models import CheckCategory
+        assert hasattr(CheckCategory, "BOTS")
+        assert CheckCategory.BOTS.value == "bots"
+
+    def test_bot_tokens_check_no_tokens(self):
+        from praisonai.cli.features.doctor.checks.bot_checks import check_bot_tokens
+        from praisonai.cli.features.doctor.models import CheckStatus
+        for var in ["TELEGRAM_BOT_TOKEN", "DISCORD_BOT_TOKEN", "SLACK_BOT_TOKEN", "WHATSAPP_ACCESS_TOKEN"]:
+            os.environ.pop(var, None)
+        result = check_bot_tokens()
+        assert result.status == CheckStatus.WARN
+
+    def test_bot_tokens_check_with_token(self):
+        from praisonai.cli.features.doctor.checks.bot_checks import check_bot_tokens
+        from praisonai.cli.features.doctor.models import CheckStatus
+        os.environ["TELEGRAM_BOT_TOKEN"] = "test123"
+        try:
+            result = check_bot_tokens()
+            assert result.status == CheckStatus.PASS
+            assert "Telegram" in result.message
+        finally:
+            del os.environ["TELEGRAM_BOT_TOKEN"]
+
+    def test_bot_config_missing(self):
+        from praisonai.cli.features.doctor.checks.bot_checks import check_bot_config
+        from praisonai.cli.features.doctor.models import CheckStatus
+        result = check_bot_config("/nonexistent/bot.yaml")
+        assert result.status == CheckStatus.WARN
+
+    def test_get_bot_checks(self):
+        from praisonai.cli.features.doctor.checks.bot_checks import get_bot_checks
+        checks = get_bot_checks()
+        assert len(checks) >= 2
+        assert all(hasattr(c, 'status') for c in checks)
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# 8. Bot Approval Backend
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+class TestBotApprovalBackend:
+    def test_import(self):
+        from praisonai.bots._approval import BotApprovalBackend
+        assert BotApprovalBackend is not None
+
+    def test_init(self):
+        from praisonai.bots._approval import BotApprovalBackend
+        backend = BotApprovalBackend(timeout=60)
+        assert backend._timeout == 60
+        assert backend.pending_count == 0
+
+    @pytest.mark.asyncio
+    async def test_timeout_defaults_to_deny(self):
+        from praisonai.bots._approval import BotApprovalBackend
+        backend = BotApprovalBackend(timeout=0.01, default_on_timeout=False)
+        result = await backend.request_approval("user1", "ch1", "test_tool", {})
+        assert result is False
+
+    def test_resolve_by_user_reply_yes(self):
+        from praisonai.bots._approval import BotApprovalBackend
+        backend = BotApprovalBackend()
+        loop = asyncio.new_event_loop()
+        future = loop.create_future()
+        backend._pending["approval_user1_123"] = future
+        resolved = backend.resolve_by_user_reply("user1", "yes")
+        assert resolved is True
+        assert future.result() is True
+        loop.close()
+
+    def test_resolve_by_user_reply_no(self):
+        from praisonai.bots._approval import BotApprovalBackend
+        backend = BotApprovalBackend()
+        loop = asyncio.new_event_loop()
+        future = loop.create_future()
+        backend._pending["approval_user1_456"] = future
+        resolved = backend.resolve_by_user_reply("user1", "no")
+        assert resolved is True
+        assert future.result() is False
+        loop.close()
+
+    def test_resolve_unknown_text(self):
+        from praisonai.bots._approval import BotApprovalBackend
+        backend = BotApprovalBackend()
+        resolved = backend.resolve_by_user_reply("user1", "hello world")
+        assert resolved is False
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# 9. Daemon Service
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+class TestDaemonService:
+    def test_daemon_import(self):
+        from praisonai.daemon import get_daemon_status, install_daemon, uninstall_daemon
+        assert callable(get_daemon_status)
+        assert callable(install_daemon)
+        assert callable(uninstall_daemon)
+
+    def test_systemd_unit_generation(self):
+        from praisonai.daemon.systemd import _generate_unit
+        unit = _generate_unit("/tmp/test_bot.yaml")
+        assert "[Unit]" in unit
+        assert "[Service]" in unit
+        assert "praisonai" in unit
+        assert "/tmp/test_bot.yaml" in unit
+        assert "Restart=always" in unit
+
+    def test_launchd_plist_generation(self):
+        from praisonai.daemon.launchd import _generate_plist
+        plist = _generate_plist("/tmp/test_bot.yaml")
+        assert "<?xml" in plist
+        assert "ai.praison.bot" in plist
+        assert "/tmp/test_bot.yaml" in plist
+        assert "KeepAlive" in plist
+
+    def test_detect_platform(self):
+        from praisonai.daemon import _detect_platform
+        plat = _detect_platform()
+        assert plat in ("systemd", "launchd", "windows", "unknown")
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# 10. Onboarding Wizard Config Generation
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+class TestOnboardWizard:
+    def test_import(self):
+        from praisonai.cli.features.onboard import OnboardWizard
+        assert OnboardWizard is not None
+
+    def test_generate_bot_yaml(self):
+        from praisonai.cli.features.onboard import _generate_bot_yaml
+        yaml_str = _generate_bot_yaml(["telegram"], agent_name="mybot", agent_instructions="Be helpful")
+        assert "telegram:" in yaml_str
+        assert "mybot" in yaml_str
+        assert "TELEGRAM_BOT_TOKEN" in yaml_str
+        assert "mention_only" in yaml_str
+
+    def test_generate_multi_platform(self):
+        from praisonai.cli.features.onboard import _generate_bot_yaml
+        yaml_str = _generate_bot_yaml(["telegram", "discord"])
+        assert "telegram:" in yaml_str
+        assert "discord:" in yaml_str
+
+    def test_wizard_init(self):
+        from praisonai.cli.features.onboard import OnboardWizard
+        wizard = OnboardWizard()
+        assert wizard.selected_platforms == []
+        assert wizard.agent_name == "assistant"
+
+    def test_platforms_info(self):
+        from praisonai.cli.features.onboard import PLATFORMS
+        assert "telegram" in PLATFORMS
+        assert "discord" in PLATFORMS
+        assert "slack" in PLATFORMS
+        assert "whatsapp" in PLATFORMS
+        assert all("token_env" in v for v in PLATFORMS.values())
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# 11. Bot probe() and health() delegation
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+class TestBotDelegation:
+    def test_bot_has_probe(self):
+        from praisonai.bots import Bot
+        bot = Bot("telegram", token="fake")
+        assert hasattr(bot, 'probe')
+
+    def test_bot_has_health(self):
+        from praisonai.bots import Bot
+        bot = Bot("telegram", token="fake")
+        assert hasattr(bot, 'health')
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# 12. Import Time Regression
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+class TestImportTime:
+    def test_core_sdk_import_time(self):
+        """Core SDK import must be < 200ms."""
+        import subprocess
+        result = subprocess.run(
+            [sys.executable, "-c", 
+             "import time; t=time.perf_counter(); import praisonaiagents; print(f'{(time.perf_counter()-t)*1000:.0f}')"],
+            capture_output=True, text=True, timeout=10,
+        )
+        ms = int(result.stdout.strip())
+        assert ms < 500, f"Import took {ms}ms, target <200ms"
@@ -0,0 +1,220 @@
+"""
+Tests for MESSAGE_RECEIVED / MESSAGE_SENDING / MESSAGE_SENT hook firing in bot adapters.
+
+These hooks exist in HookEvent enum but were never fired by bot implementations.
+This test suite verifies the MessageHookMixin wires them correctly.
+"""
+
+import time
+
+from praisonaiagents.hooks.types import HookEvent
+from praisonaiagents.bots import BotMessage, BotUser, BotChannel
+
+
+# ---------------------------------------------------------------------------
+# Minimal stub for testing the mixin in isolation
+# ---------------------------------------------------------------------------
+
+class _StubBot:
+    """Minimal bot stub that uses MessageHookMixin."""
+
+    def __init__(self, agent=None):
+        self._agent = agent
+        self._hook_registry = None  # set by tests
+        self._hook_runner = None
+
+
+# ---------------------------------------------------------------------------
+# Test: MessageHookMixin core logic
+# ---------------------------------------------------------------------------
+
+class TestMessageHookMixin:
+    """Test the shared MessageHookMixin that all bots use."""
+
+    def test_import_mixin(self):
+        """MessageHookMixin should be importable from _protocol_mixin."""
+        from praisonai.bots._protocol_mixin import MessageHookMixin
+        assert MessageHookMixin is not None
+
+    def test_mixin_has_fire_methods(self):
+        """Mixin should provide fire_message_received, fire_message_sending, fire_message_sent."""
+        from praisonai.bots._protocol_mixin import MessageHookMixin
+        assert hasattr(MessageHookMixin, 'fire_message_received')
+        assert hasattr(MessageHookMixin, 'fire_message_sending')
+        assert hasattr(MessageHookMixin, 'fire_message_sent')
+
+    def test_fire_message_received_creates_correct_event(self):
+        """fire_message_received should create a HookInput with MESSAGE_RECEIVED event."""
+        from praisonai.bots._protocol_mixin import MessageHookMixin
+
+        class TestBot(MessageHookMixin):
+            def __init__(self):
+                self._agent = None
+                self.platform = "test"
+
+        bot = TestBot()
+        msg = BotMessage(
+            message_id="123",
+            content="Hello",
+            sender=BotUser(user_id="user1", username="alice"),
+            channel=BotChannel(channel_id="ch1", channel_type="dm"),
+        )
+
+        # Without a hook registry, fire should be a no-op (no crash)
+        bot.fire_message_received(msg)
+
+    def test_fire_message_sending_returns_modified_content(self):
+        """fire_message_sending should allow hooks to modify content."""
+        from praisonai.bots._protocol_mixin import MessageHookMixin
+
+        class TestBot(MessageHookMixin):
+            def __init__(self):
+                self._agent = None
+                self.platform = "test"
+
+        bot = TestBot()
+
+        # Without hooks, should return original content unchanged
+        result = bot.fire_message_sending("ch1", "Hello world")
+        assert result is not None
+        assert result["content"] == "Hello world"
+        assert result["cancel"] is False
+
+    def test_fire_message_sending_cancel(self):
+        """fire_message_sending with deny hook should return cancel=True."""
+        from praisonai.bots._protocol_mixin import MessageHookMixin
+        from praisonaiagents.hooks import HookRegistry, HookRunner
+
+        registry = HookRegistry()
+        runner = HookRunner(registry=registry)
+
+        # Register a function hook that returns False (= deny)
+        registry.register_function(
+            event=HookEvent.MESSAGE_SENDING,
+            func=lambda input_data: False,  # False = deny
+            name="cancel_hook",
+        )
+
+        # Mock agent with _hook_runner
+        class MockAgent:
+            agent_name = "test_agent"
+            _hook_runner = runner
+
+        class TestBot(MessageHookMixin):
+            def __init__(self):
+                self._agent = MockAgent()
+                self.platform = "test"
+
+        bot = TestBot()
+        result = bot.fire_message_sending("ch1", "spam message")
+        assert result["cancel"] is True
+
+    def test_fire_message_sending_allow(self):
+        """fire_message_sending with allow hook should return cancel=False."""
+        from praisonai.bots._protocol_mixin import MessageHookMixin
+        from praisonaiagents.hooks import HookRegistry, HookRunner
+
+        registry = HookRegistry()
+        runner = HookRunner(registry=registry)
+
+        # Register a function hook that returns True (= allow)
+        registry.register_function(
+            event=HookEvent.MESSAGE_SENDING,
+            func=lambda input_data: True,  # True = allow
+            name="allow_hook",
+        )
+
+        class MockAgent:
+            agent_name = "test_agent"
+            _hook_runner = runner
+
+        class TestBot(MessageHookMixin):
+            def __init__(self):
+                self._agent = MockAgent()
+                self.platform = "test"
+
+        bot = TestBot()
+        result = bot.fire_message_sending("ch1", "Hello")
+        assert result["cancel"] is False
+        assert result["content"] == "Hello"
+
+    def test_fire_message_sent_no_crash(self):
+        """fire_message_sent should not crash even without hooks."""
+        from praisonai.bots._protocol_mixin import MessageHookMixin
+
+        class TestBot(MessageHookMixin):
+            def __init__(self):
+                self._agent = None
+                self.platform = "test"
+
+        bot = TestBot()
+        # Should be a no-op, no exception
+        bot.fire_message_sent("ch1", "Hello", message_id="msg1")
+
+
+class TestMessageHookEventInputs:
+    """Test that message hook event input dataclasses exist and work."""
+
+    def test_message_received_input_exists(self):
+        """MessageReceivedInput should be importable from hooks.events."""
+        from praisonaiagents.hooks.events import MessageReceivedInput
+        inp = MessageReceivedInput(
+            session_id="s1",
+            cwd="/tmp",
+            event_name=HookEvent.MESSAGE_RECEIVED,
+            timestamp=str(time.time()),
+            agent_name="bot",
+            platform="telegram",
+            content="Hello",
+            sender_id="user1",
+            channel_id="ch1",
+        )
+        assert inp.platform == "telegram"
+        assert inp.content == "Hello"
+        d = inp.to_dict()
+        assert d["platform"] == "telegram"
+
+    def test_message_sending_input_exists(self):
+        """MessageSendingInput should be importable from hooks.events."""
+        from praisonaiagents.hooks.events import MessageSendingInput
+        inp = MessageSendingInput(
+            session_id="s1",
+            cwd="/tmp",
+            event_name=HookEvent.MESSAGE_SENDING,
+            timestamp=str(time.time()),
+            agent_name="bot",
+            platform="telegram",
+            content="Reply",
+            channel_id="ch1",
+        )
+        assert inp.content == "Reply"
+
+    def test_message_sent_input_exists(self):
+        """MessageSentInput should be importable from hooks.events."""
+        from praisonaiagents.hooks.events import MessageSentInput
+        inp = MessageSentInput(
+            session_id="s1",
+            cwd="/tmp",
+            event_name=HookEvent.MESSAGE_SENT,
+            timestamp=str(time.time()),
+            agent_name="bot",
+            platform="telegram",
+            content="Reply",
+            channel_id="ch1",
+            message_id="msg1",
+        )
+        assert inp.message_id == "msg1"
+
+
+class TestGatewayStreamRelay:
+    """Test that gateway server relays StreamEvents to WebSocket clients."""
+
+    def test_process_agent_message_streams_tokens(self):
+        """_process_agent_message should wire stream_emitter to send token events to WS client."""
+        # This test verifies the contract: when an agent streams tokens,
+        # the gateway relays them as WS messages to the connected client.
+        from praisonaiagents.gateway import EventType
+        
+        # Verify the event types exist for streaming relay
+        assert hasattr(EventType, 'TOKEN_STREAM') or hasattr(EventType, 'AGENT_RESPONSE')
+        # The actual streaming relay is tested via integration tests
@@ -0,0 +1,187 @@
+"""Unit tests for BotSessionManager (per-user session isolation)."""
+
+import asyncio
+import pytest
+import sys
+import os
+
+# Add wrapper to path so we can import bots._session
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', '..', 'praisonai'))
+
+
+class MockAgent:
+    """Minimal mock of Agent for testing session isolation."""
+
+    def __init__(self, name="test-agent"):
+        self.name = name
+        self.chat_history = []
+
+    def chat(self, prompt):
+        self.chat_history.append({"role": "user", "content": prompt})
+        response = f"Reply to: {prompt}"
+        self.chat_history.append({"role": "assistant", "content": response})
+        return response
+
+
+class TestBotSessionManagerImport:
+    """Test that BotSessionManager can be imported."""
+
+    def test_import(self):
+        from praisonai.bots._session import BotSessionManager
+        assert BotSessionManager is not None
+
+    def test_instantiation(self):
+        from praisonai.bots._session import BotSessionManager
+        mgr = BotSessionManager()
+        assert mgr.active_sessions == 0
+        assert mgr.get_user_ids() == []
+
+    def test_instantiation_with_max_history(self):
+        from praisonai.bots._session import BotSessionManager
+        mgr = BotSessionManager(max_history=50)
+        assert mgr._max_history == 50
+
+
+class TestBotSessionManagerChat:
+    """Test per-user chat isolation."""
+
+    @pytest.fixture
+    def mgr(self):
+        from praisonai.bots._session import BotSessionManager
+        return BotSessionManager()
+
+    @pytest.fixture
+    def agent(self):
+        return MockAgent()
+
+    @pytest.mark.asyncio
+    async def test_single_user_chat(self, mgr, agent):
+        response = await mgr.chat(agent, "user1", "Hello")
+        assert response == "Reply to: Hello"
+        assert mgr.active_sessions == 1
+        assert "user1" in mgr.get_user_ids()
+
+    @pytest.mark.asyncio
+    async def test_two_users_isolated(self, mgr, agent):
+        await mgr.chat(agent, "alice", "I am Alice")
+        await mgr.chat(agent, "bob", "I am Bob")
+
+        assert mgr.active_sessions == 2
+        # Each user should have 2 messages (user + assistant)
+        assert len(mgr._histories["alice"]) == 2
+        assert len(mgr._histories["bob"]) == 2
+        # Alice's history should not contain Bob's message
+        alice_msgs = [m["content"] for m in mgr._histories["alice"]]
+        assert "I am Bob" not in alice_msgs
+        bob_msgs = [m["content"] for m in mgr._histories["bob"]]
+        assert "I am Alice" not in bob_msgs
+
+    @pytest.mark.asyncio
+    async def test_agent_history_restored(self, mgr, agent):
+        """Agent's original chat_history should be restored after each call."""
+        agent.chat_history = [{"role": "system", "content": "original"}]
+        await mgr.chat(agent, "user1", "test")
+        # Agent's history should be restored to original
+        assert len(agent.chat_history) == 1
+        assert agent.chat_history[0]["content"] == "original"
+
+    @pytest.mark.asyncio
+    async def test_conversation_continuity(self, mgr, agent):
+        """Same user's messages should accumulate in their session."""
+        await mgr.chat(agent, "user1", "First message")
+        await mgr.chat(agent, "user1", "Second message")
+        # Should have 4 messages: 2 user + 2 assistant
+        assert len(mgr._histories["user1"]) == 4
+
+    @pytest.mark.asyncio
+    async def test_max_history_truncation(self, agent):
+        from praisonai.bots._session import BotSessionManager
+        mgr = BotSessionManager(max_history=4)
+        await mgr.chat(agent, "user1", "msg1")
+        await mgr.chat(agent, "user1", "msg2")
+        await mgr.chat(agent, "user1", "msg3")  # This would make 6 messages
+        # Should be truncated to last 4
+        assert len(mgr._histories["user1"]) == 4
+
+
+class TestBotSessionManagerReset:
+    """Test session reset functionality."""
+
+    @pytest.fixture
+    def mgr(self):
+        from praisonai.bots._session import BotSessionManager
+        return BotSessionManager()
+
+    @pytest.fixture
+    def agent(self):
+        return MockAgent()
+
+    @pytest.mark.asyncio
+    async def test_reset_existing_user(self, mgr, agent):
+        await mgr.chat(agent, "user1", "Hello")
+        assert mgr.active_sessions == 1
+        result = mgr.reset("user1")
+        assert result is True
+        assert mgr.active_sessions == 0
+
+    def test_reset_nonexistent_user(self, mgr):
+        result = mgr.reset("nobody")
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_reset_all(self, mgr, agent):
+        await mgr.chat(agent, "user1", "Hello")
+        await mgr.chat(agent, "user2", "World")
+        count = mgr.reset_all()
+        assert count == 2
+        assert mgr.active_sessions == 0
+
+    @pytest.mark.asyncio
+    async def test_reset_then_chat_fresh(self, mgr, agent):
+        """After reset, user should start with empty history."""
+        await mgr.chat(agent, "user1", "old message")
+        mgr.reset("user1")
+        await mgr.chat(agent, "user1", "new message")
+        assert len(mgr._histories["user1"]) == 2  # Only new conversation
+        msgs = [m["content"] for m in mgr._histories["user1"]]
+        assert "old message" not in msgs
+
+
+class TestBotSessionManagerConcurrency:
+    """Test concurrent access safety."""
+
+    @pytest.mark.asyncio
+    async def test_concurrent_same_user(self):
+        """Two concurrent chats from same user should be serialized."""
+        from praisonai.bots._session import BotSessionManager
+
+        agent = MockAgent()
+        mgr = BotSessionManager()
+
+        async def slow_chat():
+            return await mgr.chat(agent, "user1", "concurrent")
+
+        results = await asyncio.gather(slow_chat(), slow_chat())
+        assert len(results) == 2
+        # Both should succeed
+        assert all(r.startswith("Reply to:") for r in results)
+        # Should have 4 messages total (2 calls × 2 messages each)
+        assert len(mgr._histories["user1"]) == 4
+
+    @pytest.mark.asyncio
+    async def test_concurrent_different_users(self):
+        """Two concurrent chats from different users should be independent."""
+        from praisonai.bots._session import BotSessionManager
+
+        agent = MockAgent()
+        mgr = BotSessionManager()
+
+        async def chat_as(user, msg):
+            return await mgr.chat(agent, user, msg)
+
+        results = await asyncio.gather(
+            chat_as("alice", "I am Alice"),
+            chat_as("bob", "I am Bob"),
+        )
+        assert len(results) == 2
+        assert mgr.active_sessions == 2
@@ -0,0 +1,585 @@
+"""
+Integration, smoke, and real-agent tests for BotOS architecture.
+
+Covers:
+- Bot with mock adapter lifecycle
+- BotOS multi-bot orchestration
+- Agent alone in Bot
+- AgentTeam inside Bot/BotOS
+- AgentFlow inside Bot/BotOS
+- Platform extensibility
+- from_config() YAML loader
+- run() sync wrapper
+- remove_bot()
+- Custom platform registration + resolution
+"""
+
+import asyncio
+import os
+import tempfile
+import pytest
+from unittest.mock import MagicMock
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# Helper: Mock adapter that simulates a platform bot
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+class MockPlatformAdapter:
+    """Simulates a platform bot adapter for testing."""
+
+    def __init__(self, **kwargs):
+        self.kwargs = kwargs
+        self.token = kwargs.get("token", "")
+        self.agent = kwargs.get("agent")
+        self.started = False
+        self.stopped = False
+        self.messages_sent = []
+
+    async def start(self):
+        self.started = True
+
+    async def stop(self):
+        self.stopped = True
+
+    @property
+    def is_running(self):
+        return self.started and not self.stopped
+
+    async def send_message(self, channel_id, content, **kwargs):
+        self.messages_sent.append({"channel": channel_id, "content": content})
+        return True
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# 1. Integration: Bot with mock adapter
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+class TestBotWithMockAdapter:
+    """Integration tests for Bot class with a mock platform adapter."""
+
+    def setup_method(self):
+        from praisonai.bots._registry import register_platform, _custom_platforms
+        register_platform("mockbot", MockPlatformAdapter)
+        self._cleanup = lambda: _custom_platforms.pop("mockbot", None)
+
+    def teardown_method(self):
+        self._cleanup()
+
+    @pytest.mark.asyncio
+    async def test_bot_start_creates_adapter(self):
+        from praisonai.bots import Bot
+        bot = Bot("mockbot", token="test-token")
+        await bot.start()
+        assert bot.adapter is not None
+        assert isinstance(bot.adapter, MockPlatformAdapter)
+        assert bot.adapter.started is True
+
+    @pytest.mark.asyncio
+    async def test_bot_stop(self):
+        from praisonai.bots import Bot
+        bot = Bot("mockbot", token="test-token")
+        await bot.start()
+        await bot.stop()
+        assert bot.adapter.stopped is True
+        assert bot.is_running is False
+
+    @pytest.mark.asyncio
+    async def test_bot_passes_token_to_adapter(self):
+        from praisonai.bots import Bot
+        bot = Bot("mockbot", token="my-secret-token")
+        await bot.start()
+        assert bot.adapter.token == "my-secret-token"
+
+    @pytest.mark.asyncio
+    async def test_bot_passes_agent_to_adapter(self):
+        from praisonai.bots import Bot
+        agent = MagicMock()
+        agent.name = "test-agent"
+        bot = Bot("mockbot", agent=agent, token="t")
+        await bot.start()
+        assert bot.adapter.agent is agent
+
+    @pytest.mark.asyncio
+    async def test_bot_send_message(self):
+        from praisonai.bots import Bot
+        bot = Bot("mockbot", token="t")
+        await bot.start()
+        result = await bot.send_message("channel-1", "Hello!")
+        assert result is True
+        assert len(bot.adapter.messages_sent) == 1
+        assert bot.adapter.messages_sent[0]["content"] == "Hello!"
+
+    @pytest.mark.asyncio
+    async def test_bot_send_message_before_start_raises(self):
+        from praisonai.bots import Bot
+        bot = Bot("mockbot", token="t")
+        with pytest.raises(RuntimeError, match="not started"):
+            await bot.send_message("ch", "msg")
+
+    @pytest.mark.asyncio
+    async def test_bot_passes_kwargs_to_adapter(self):
+        from praisonai.bots import Bot
+        bot = Bot("mockbot", token="t", custom_param="hello")
+        await bot.start()
+        assert bot.adapter.kwargs.get("custom_param") == "hello"
+
+    @pytest.mark.asyncio
+    async def test_bot_repr(self):
+        from praisonai.bots import Bot
+        agent = MagicMock()
+        agent.name = "myagent"
+        bot = Bot("mockbot", agent=agent)
+        assert "mockbot" in repr(bot)
+        assert "myagent" in repr(bot)
+
+    def test_bot_has_run_method(self):
+        from praisonai.bots import Bot
+        bot = Bot("mockbot")
+        assert hasattr(bot, "run")
+        assert callable(bot.run)
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# 2. Integration: BotOS lifecycle
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+class TestBotOSLifecycle:
+    """Integration tests for BotOS multi-bot orchestration."""
+
+    def setup_method(self):
+        from praisonai.bots._registry import register_platform, _custom_platforms
+        register_platform("mock1", MockPlatformAdapter)
+        register_platform("mock2", MockPlatformAdapter)
+        self._cleanup = lambda: (_custom_platforms.pop("mock1", None), _custom_platforms.pop("mock2", None))
+
+    def teardown_method(self):
+        self._cleanup()
+
+    @pytest.mark.asyncio
+    async def test_botos_starts_all_bots(self):
+        from praisonai.bots import BotOS, Bot
+        bot1 = Bot("mock1", token="t1")
+        bot2 = Bot("mock2", token="t2")
+        botos = BotOS(bots=[bot1, bot2])
+
+        # Start in background, stop quickly
+        start_task = asyncio.create_task(botos.start())
+        await asyncio.sleep(0.05)
+        await botos.stop()
+        start_task.cancel()
+        try:
+            await start_task
+        except asyncio.CancelledError:
+            pass
+
+        assert bot1.adapter.started is True
+        assert bot2.adapter.started is True
+
+    def test_botos_remove_bot(self):
+        from praisonai.bots import BotOS, Bot
+        botos = BotOS(bots=[Bot("mock1"), Bot("mock2")])
+        assert len(botos.list_bots()) == 2
+        result = botos.remove_bot("mock1")
+        assert result is True
+        assert len(botos.list_bots()) == 1
+        assert "mock2" in botos.list_bots()
+
+    def test_botos_remove_bot_not_found(self):
+        from praisonai.bots import BotOS
+        botos = BotOS()
+        assert botos.remove_bot("nonexistent") is False
+
+    def test_botos_has_run_method(self):
+        from praisonai.bots import BotOS
+        botos = BotOS()
+        assert hasattr(botos, "run")
+        assert callable(botos.run)
+
+    def test_botos_repr(self):
+        from praisonai.bots import BotOS, Bot
+        botos = BotOS(bots=[Bot("mock1"), Bot("mock2")])
+        r = repr(botos)
+        assert "mock1" in r
+        assert "mock2" in r
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# 3. Real Agent in Bot
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+class TestRealAgentInBot:
+    """Tests with a real praisonaiagents.Agent inside Bot."""
+
+    def setup_method(self):
+        from praisonai.bots._registry import register_platform, _custom_platforms
+        register_platform("mockbot", MockPlatformAdapter)
+        self._cleanup = lambda: _custom_platforms.pop("mockbot", None)
+
+    def teardown_method(self):
+        self._cleanup()
+
+    def test_real_agent_in_bot(self):
+        from praisonai.bots import Bot
+        from praisonaiagents import Agent
+        agent = Agent(name="helper", instructions="Be helpful")
+        bot = Bot("mockbot", agent=agent, token="t")
+        assert bot.agent is agent
+        assert bot.agent.name == "helper"
+
+    @pytest.mark.asyncio
+    async def test_real_agent_passed_to_adapter(self):
+        from praisonai.bots import Bot
+        from praisonaiagents import Agent
+        agent = Agent(name="helper", instructions="Be helpful")
+        bot = Bot("mockbot", agent=agent, token="t")
+        await bot.start()
+        assert bot.adapter.agent is agent
+        assert bot.adapter.agent.name == "helper"
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# 4. AgentTeam in Bot/BotOS
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+class TestAgentTeamInBotOS:
+    """AgentTeam (multi-agent) inside Bot and BotOS."""
+
+    def setup_method(self):
+        from praisonai.bots._registry import register_platform, _custom_platforms
+        register_platform("mockbot", MockPlatformAdapter)
+        self._cleanup = lambda: _custom_platforms.pop("mockbot", None)
+
+    def teardown_method(self):
+        self._cleanup()
+
+    def test_agent_team_in_bot(self):
+        from praisonai.bots import Bot
+        from praisonaiagents import Agent, AgentTeam, Task
+        researcher = Agent(name="researcher", instructions="Research topics")
+        writer = Agent(name="writer", instructions="Write content")
+        t1 = Task(name="research", description="Research AI", agent=researcher)
+        t2 = Task(name="write", description="Write about AI", agent=writer)
+        team = AgentTeam(agents=[researcher, writer], tasks=[t1, t2])
+
+        bot = Bot("mockbot", agent=team, token="t")
+        assert bot.agent is team
+
+    @pytest.mark.asyncio
+    async def test_agent_team_passed_to_adapter(self):
+        from praisonai.bots import Bot
+        from praisonaiagents import Agent, AgentTeam, Task
+        a1 = Agent(name="a1", instructions="Do task 1")
+        a2 = Agent(name="a2", instructions="Do task 2")
+        t1 = Task(name="t1", description="Task 1", agent=a1)
+        t2 = Task(name="t2", description="Task 2", agent=a2)
+        team = AgentTeam(agents=[a1, a2], tasks=[t1, t2])
+
+        bot = Bot("mockbot", agent=team, token="t")
+        await bot.start()
+        assert bot.adapter.agent is team
+
+    def test_agent_team_in_botos(self):
+        from praisonai.bots import BotOS, Bot
+        from praisonaiagents import Agent, AgentTeam, Task
+        a1 = Agent(name="a1", instructions="Task 1")
+        a2 = Agent(name="a2", instructions="Task 2")
+        t1 = Task(name="t1", description="T1", agent=a1)
+        t2 = Task(name="t2", description="T2", agent=a2)
+        team = AgentTeam(agents=[a1, a2], tasks=[t1, t2])
+
+        botos = BotOS(bots=[Bot("mockbot", agent=team, token="t")])
+        assert botos.get_bot("mockbot").agent is team
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# 5. AgentFlow in Bot/BotOS
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+class TestAgentFlowInBotOS:
+    """AgentFlow (deterministic workflow) inside Bot and BotOS."""
+
+    def setup_method(self):
+        from praisonai.bots._registry import register_platform, _custom_platforms
+        register_platform("mockbot", MockPlatformAdapter)
+        self._cleanup = lambda: _custom_platforms.pop("mockbot", None)
+
+    def teardown_method(self):
+        self._cleanup()
+
+    def test_agent_flow_in_bot(self):
+        from praisonai.bots import Bot
+        from praisonaiagents import Agent, AgentFlow, Task
+        a1 = Agent(name="step1", instructions="Do step 1")
+        a2 = Agent(name="step2", instructions="Do step 2")
+        t1 = Task(name="t1", description="Step 1", agent=a1)
+        t2 = Task(name="t2", description="Step 2", agent=a2)
+        flow = AgentFlow(steps=[t1, t2])
+
+        bot = Bot("mockbot", agent=flow, token="t")
+        assert bot.agent is flow
+
+    @pytest.mark.asyncio
+    async def test_agent_flow_passed_to_adapter(self):
+        from praisonai.bots import Bot
+        from praisonaiagents import Agent, AgentFlow, Task
+        a1 = Agent(name="s1", instructions="Step 1")
+        a2 = Agent(name="s2", instructions="Step 2")
+        t1 = Task(name="t1", description="S1", agent=a1)
+        t2 = Task(name="t2", description="S2", agent=a2)
+        flow = AgentFlow(steps=[t1, t2])
+
+        bot = Bot("mockbot", agent=flow, token="t")
+        await bot.start()
+        assert bot.adapter.agent is flow
+
+    def test_agent_flow_in_botos_multi_platform(self):
+        """AgentFlow in BotOS across multiple platforms."""
+        from praisonai.bots import BotOS, Bot
+        from praisonaiagents import Agent, AgentFlow, Task
+        a1 = Agent(name="s1", instructions="Step 1")
+        t1 = Task(name="t1", description="S1", agent=a1)
+        flow = AgentFlow(steps=[t1])
+
+        botos = BotOS(bots=[
+            Bot("mockbot", agent=flow, token="t1"),
+        ])
+        assert botos.get_bot("mockbot").agent is flow
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# 6. Platform Extensibility
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+class TestPlatformExtensibility:
+    """Third-party platform registration and usage."""
+
+    def teardown_method(self):
+        from praisonai.bots._registry import _custom_platforms
+        _custom_platforms.pop("custom_chat", None)
+        _custom_platforms.pop("my_platform", None)
+
+    def test_register_and_use_custom_platform(self):
+        from praisonai.bots._registry import register_platform, resolve_adapter
+        register_platform("custom_chat", MockPlatformAdapter)
+        cls = resolve_adapter("custom_chat")
+        assert cls is MockPlatformAdapter
+
+    def test_custom_platform_in_list(self):
+        from praisonai.bots._registry import register_platform, list_platforms
+        register_platform("my_platform", MockPlatformAdapter)
+        assert "my_platform" in list_platforms()
+
+    @pytest.mark.asyncio
+    async def test_custom_platform_in_bot(self):
+        from praisonai.bots._registry import register_platform
+        from praisonai.bots import Bot
+        register_platform("custom_chat", MockPlatformAdapter)
+        bot = Bot("custom_chat", token="tok")
+        await bot.start()
+        assert bot.adapter.started is True
+
+    @pytest.mark.asyncio
+    async def test_custom_platform_in_botos(self):
+        from praisonai.bots._registry import register_platform
+        from praisonai.bots import BotOS, Bot
+        register_platform("custom_chat", MockPlatformAdapter)
+        botos = BotOS(bots=[Bot("custom_chat", token="tok")])
+        assert "custom_chat" in botos.list_bots()
+
+    def test_resolve_unknown_platform_raises(self):
+        from praisonai.bots._registry import resolve_adapter
+        with pytest.raises(ValueError, match="Unknown platform"):
+            resolve_adapter("nonexistent_xyz")
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# 7. from_config() YAML loader
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+class TestBotOSFromConfig:
+    """BotOS.from_config() YAML config loading."""
+
+    def setup_method(self):
+        from praisonai.bots._registry import register_platform, _custom_platforms
+        register_platform("mockbot", MockPlatformAdapter)
+        self._cleanup = lambda: _custom_platforms.pop("mockbot", None)
+
+    def teardown_method(self):
+        self._cleanup()
+
+    def test_from_config_basic(self):
+        from praisonai.bots import BotOS
+        yaml_content = """\
+agent:
+  name: test-bot
+  instructions: Be helpful
+platforms:
+  mockbot:
+    token: test-token-123
+"""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f:
+            f.write(yaml_content)
+            f.flush()
+            path = f.name
+
+        try:
+            botos = BotOS.from_config(path)
+            assert "mockbot" in botos.list_bots()
+            bot = botos.get_bot("mockbot")
+            assert bot.token == "test-token-123"
+            assert bot.agent is not None
+            assert bot.agent.name == "test-bot"
+        finally:
+            os.unlink(path)
+
+    def test_from_config_env_var_resolution(self):
+        from praisonai.bots import BotOS
+        os.environ["TEST_BOTOS_TOKEN"] = "resolved-token"
+        yaml_content = """\
+agent:
+  name: env-bot
+  instructions: Be helpful
+platforms:
+  mockbot:
+    token: ${TEST_BOTOS_TOKEN}
+"""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f:
+            f.write(yaml_content)
+            f.flush()
+            path = f.name
+
+        try:
+            botos = BotOS.from_config(path)
+            bot = botos.get_bot("mockbot")
+            assert bot.token == "resolved-token"
+        finally:
+            os.unlink(path)
+            del os.environ["TEST_BOTOS_TOKEN"]
+
+    def test_from_config_multi_platform(self):
+        from praisonai.bots import BotOS
+        from praisonai.bots._registry import register_platform, _custom_platforms
+        register_platform("mock2", MockPlatformAdapter)
+
+        yaml_content = """\
+agent:
+  name: multi-bot
+  instructions: Handle multiple platforms
+platforms:
+  mockbot:
+    token: tok1
+  mock2:
+    token: tok2
+"""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f:
+            f.write(yaml_content)
+            f.flush()
+            path = f.name
+
+        try:
+            botos = BotOS.from_config(path)
+            assert len(botos.list_bots()) == 2
+            assert "mockbot" in botos.list_bots()
+            assert "mock2" in botos.list_bots()
+        finally:
+            os.unlink(path)
+            _custom_platforms.pop("mock2", None)
+
+    def test_from_config_invalid_raises(self):
+        from praisonai.bots import BotOS
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f:
+            f.write("invalid yaml content that is just a string")
+            f.flush()
+            path = f.name
+
+        try:
+            with pytest.raises(ValueError, match="Invalid"):
+                BotOS.from_config(path)
+        finally:
+            os.unlink(path)
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# 8. Smoke Tests — import paths, hierarchy, class structure
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+class TestSmoke:
+    """Smoke tests for the BotOS architecture."""
+
+    def test_all_import_paths(self):
+        """All classes importable from expected paths."""
+        from praisonaiagents.bots.protocols import BotOSProtocol
+        from praisonaiagents.bots.config import BotOSConfig
+        from praisonaiagents.bots import BotOSProtocol as P2
+        from praisonaiagents.bots import BotOSConfig as C2
+        from praisonaiagents import BotOSProtocol as P3
+        from praisonaiagents import BotOSConfig as C3
+        from praisonai.bots import Bot, BotOS
+        from praisonai.bots._registry import (
+            register_platform, list_platforms, resolve_adapter, get_platform_registry
+        )
+        assert all(x is not None for x in [
+            BotOSProtocol, BotOSConfig, P2, C2, P3, C3,
+            Bot, BotOS, register_platform, list_platforms,
+            resolve_adapter, get_platform_registry
+        ])
+
+    def test_protocol_identity(self):
+        """Same protocol from different paths."""
+        from praisonaiagents.bots.protocols import BotOSProtocol as A
+        from praisonaiagents import BotOSProtocol as B
+        assert A is B
+
+    def test_config_identity(self):
+        from praisonaiagents.bots.config import BotOSConfig as A
+        from praisonaiagents import BotOSConfig as B
+        assert A is B
+
+    def test_bot_class_hierarchy(self):
+        """Bot hierarchy: BotOS > Bot > Agent."""
+        from praisonai.bots import Bot, BotOS
+        from praisonaiagents import Agent
+
+        agent = Agent(name="test", instructions="test")
+        bot = Bot("telegram", agent=agent)
+        botos = BotOS(bots=[bot])
+
+        assert botos.get_bot("telegram") is bot
+        assert bot.agent is agent
+
+    def test_builtin_platforms_count(self):
+        from praisonai.bots._registry import list_platforms
+        platforms = list_platforms()
+        assert len(platforms) >= 4  # telegram, discord, slack, whatsapp
+
+    def test_no_heavy_imports_on_bot_creation(self):
+        """Creating Bot should NOT import platform libraries."""
+        import sys
+        from praisonai.bots import Bot
+        Bot("telegram")
+        assert "telegram" not in sys.modules
+        assert "discord" not in sys.modules
+
+    def test_no_heavy_imports_on_botos_creation(self):
+        import sys
+        from praisonai.bots import BotOS, Bot
+        BotOS(bots=[Bot("telegram")])
+        assert "telegram" not in sys.modules
+
+    def test_botos_protocol_has_remove_bot(self):
+        from praisonaiagents.bots.protocols import BotOSProtocol
+        assert hasattr(BotOSProtocol, 'remove_bot')
+
+    def test_bot_has_run_method(self):
+        from praisonai.bots import Bot
+        assert hasattr(Bot, 'run')
+
+    def test_botos_has_run_method(self):
+        from praisonai.bots import BotOS
+        assert hasattr(BotOS, 'run')
+
+    def test_botos_has_from_config(self):
+        from praisonai.bots import BotOS
+        assert hasattr(BotOS, 'from_config')
+        assert callable(BotOS.from_config)
@@ -0,0 +1,282 @@
+"""
+TDD tests for BotOS protocol, config, and exports.
+
+Tests written FIRST — implementation follows.
+"""
+
+import pytest
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# 1. Core SDK Protocol & Config exports
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+
+class TestBotOSProtocolExists:
+    """BotOSProtocol must be importable from core SDK."""
+
+    def test_import_from_bots_protocols(self):
+        from praisonaiagents.bots.protocols import BotOSProtocol
+        assert BotOSProtocol is not None
+
+    def test_import_from_bots_package(self):
+        from praisonaiagents.bots import BotOSProtocol
+        assert BotOSProtocol is not None
+
+    def test_import_from_top_level(self):
+        from praisonaiagents import BotOSProtocol
+        assert BotOSProtocol is not None
+
+    def test_is_runtime_checkable(self):
+        from praisonaiagents.bots.protocols import BotOSProtocol
+        # runtime_checkable protocols support isinstance checks
+        assert hasattr(BotOSProtocol, '__protocol_attrs__') or hasattr(BotOSProtocol, '_is_runtime_protocol')
+
+    def test_protocol_has_start(self):
+        from praisonaiagents.bots.protocols import BotOSProtocol
+        assert hasattr(BotOSProtocol, 'start')
+
+    def test_protocol_has_stop(self):
+        from praisonaiagents.bots.protocols import BotOSProtocol
+        assert hasattr(BotOSProtocol, 'stop')
+
+    def test_protocol_has_add_bot(self):
+        from praisonaiagents.bots.protocols import BotOSProtocol
+        assert hasattr(BotOSProtocol, 'add_bot')
+
+    def test_protocol_has_list_bots(self):
+        from praisonaiagents.bots.protocols import BotOSProtocol
+        assert hasattr(BotOSProtocol, 'list_bots')
+
+    def test_protocol_has_is_running(self):
+        from praisonaiagents.bots.protocols import BotOSProtocol
+        assert 'is_running' in dir(BotOSProtocol)
+
+
+class TestBotOSConfigExists:
+    """BotOSConfig must be importable from core SDK."""
+
+    def test_import_from_bots_config(self):
+        from praisonaiagents.bots.config import BotOSConfig
+        assert BotOSConfig is not None
+
+    def test_import_from_bots_package(self):
+        from praisonaiagents.bots import BotOSConfig
+        assert BotOSConfig is not None
+
+    def test_import_from_top_level(self):
+        from praisonaiagents import BotOSConfig
+        assert BotOSConfig is not None
+
+    def test_default_values(self):
+        from praisonaiagents.bots.config import BotOSConfig
+        cfg = BotOSConfig()
+        assert cfg.name == "PraisonAI BotOS"
+        assert isinstance(cfg.platforms, dict)
+
+    def test_to_dict(self):
+        from praisonaiagents.bots.config import BotOSConfig
+        cfg = BotOSConfig(name="test")
+        d = cfg.to_dict()
+        assert d["name"] == "test"
+        assert "platforms" in d
+
+    def test_platforms_dict(self):
+        from praisonaiagents.bots.config import BotOSConfig
+        cfg = BotOSConfig(platforms={"telegram": {"token": "abc"}})
+        assert "telegram" in cfg.platforms
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# 2. Wrapper: Bot class
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+
+class TestBotClass:
+    """Bot is the user-facing single-platform wrapper."""
+
+    def test_import_from_wrapper(self):
+        from praisonai.bots import Bot
+        assert Bot is not None
+
+    def test_bot_requires_platform(self):
+        from praisonai.bots import Bot
+        with pytest.raises(TypeError):
+            Bot()  # platform is required
+
+    def test_bot_stores_platform(self):
+        from praisonai.bots import Bot
+        bot = Bot("telegram")
+        assert bot.platform == "telegram"
+
+    def test_bot_accepts_agent(self):
+        from praisonai.bots import Bot
+        from unittest.mock import MagicMock
+        agent = MagicMock()
+        agent.name = "test"
+        bot = Bot("telegram", agent=agent)
+        assert bot.agent is agent
+
+    def test_bot_accepts_agent_team(self):
+        """Bot should accept AgentTeam as agent."""
+        from praisonai.bots import Bot
+        from unittest.mock import MagicMock
+        team = MagicMock()
+        team.name = "team"
+        bot = Bot("telegram", agent=team)
+        assert bot.agent is team
+
+    def test_bot_accepts_kwargs(self):
+        """Platform-specific kwargs should pass through."""
+        from praisonai.bots import Bot
+        bot = Bot("whatsapp", mode="web", phone_number_id="123")
+        assert bot._kwargs.get("mode") == "web"
+        assert bot._kwargs.get("phone_number_id") == "123"
+
+    def test_bot_token_from_env(self):
+        """Bot resolves token from env var convention."""
+        import os
+        from praisonai.bots import Bot
+        os.environ["TELEGRAM_BOT_TOKEN"] = "test-token-123"
+        try:
+            bot = Bot("telegram")
+            assert bot.token == "test-token-123"
+        finally:
+            del os.environ["TELEGRAM_BOT_TOKEN"]
+
+    def test_bot_explicit_token(self):
+        from praisonai.bots import Bot
+        bot = Bot("telegram", token="explicit-token")
+        assert bot.token == "explicit-token"
+
+    def test_bot_not_running_initially(self):
+        from praisonai.bots import Bot
+        bot = Bot("telegram")
+        assert bot.is_running is False
+
+    def test_bot_unknown_platform(self):
+        """Unknown platform should raise ValueError on start, not init."""
+        from praisonai.bots import Bot
+        bot = Bot("unknown_platform")
+        assert bot.platform == "unknown_platform"
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# 3. Wrapper: BotOS class
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+
+class TestBotOSClass:
+    """BotOS is the multi-platform orchestrator."""
+
+    def test_import_from_wrapper(self):
+        from praisonai.bots import BotOS
+        assert BotOS is not None
+
+    def test_botos_empty_init(self):
+        from praisonai.bots import BotOS
+        botos = BotOS()
+        assert botos.is_running is False
+
+    def test_botos_with_bots_list(self):
+        from praisonai.bots import BotOS, Bot
+        bot1 = Bot("telegram")
+        bot2 = Bot("discord")
+        botos = BotOS(bots=[bot1, bot2])
+        assert len(botos.list_bots()) == 2
+
+    def test_botos_add_bot(self):
+        from praisonai.bots import BotOS, Bot
+        botos = BotOS()
+        bot = Bot("telegram")
+        botos.add_bot(bot)
+        assert len(botos.list_bots()) == 1
+
+    def test_botos_shortcut_agent_plus_platforms(self):
+        """BotOS(agent=..., platforms=[...]) convenience."""
+        from praisonai.bots import BotOS
+        from unittest.mock import MagicMock
+        agent = MagicMock()
+        agent.name = "test"
+        botos = BotOS(agent=agent, platforms=["telegram", "discord"])
+        assert len(botos.list_bots()) == 2
+
+    def test_botos_list_bots_returns_platform_names(self):
+        from praisonai.bots import BotOS, Bot
+        botos = BotOS(bots=[Bot("telegram"), Bot("slack")])
+        names = botos.list_bots()
+        assert "telegram" in names
+        assert "slack" in names
+
+    def test_botos_get_bot(self):
+        from praisonai.bots import BotOS, Bot
+        bot = Bot("telegram")
+        botos = BotOS(bots=[bot])
+        assert botos.get_bot("telegram") is bot
+
+    def test_botos_get_bot_missing(self):
+        from praisonai.bots import BotOS
+        botos = BotOS()
+        assert botos.get_bot("telegram") is None
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# 4. Platform Registry
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+
+class TestPlatformRegistry:
+    """Platform registry for extensible bot creation."""
+
+    def test_registry_import(self):
+        from praisonai.bots._registry import get_platform_registry
+        reg = get_platform_registry()
+        assert reg is not None
+
+    def test_builtin_platforms_registered(self):
+        from praisonai.bots._registry import get_platform_registry
+        reg = get_platform_registry()
+        assert "telegram" in reg
+        assert "discord" in reg
+        assert "slack" in reg
+        assert "whatsapp" in reg
+
+    def test_register_custom_platform(self):
+        from praisonai.bots._registry import get_platform_registry, register_platform
+        class CustomBot:
+            pass
+        register_platform("custom", CustomBot)
+        reg = get_platform_registry()
+        assert "custom" in reg
+        # Clean up
+        reg.pop("custom", None)
+
+    def test_list_platforms(self):
+        from praisonai.bots._registry import list_platforms
+        platforms = list_platforms()
+        assert isinstance(platforms, list)
+        assert "telegram" in platforms
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# 5. No performance impact
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+
+class TestNoPerformanceImpact:
+    """Importing BotOSProtocol/BotOSConfig should not pull heavy deps."""
+
+    def test_protocol_import_lightweight(self):
+        """Protocol import should not load telegram/discord/slack."""
+        import sys
+        # These should NOT be in sys.modules after importing protocol
+        from praisonaiagents.bots.protocols import BotOSProtocol
+        assert 'telegram' not in sys.modules
+        assert 'discord' not in sys.modules
+        assert 'slack_bolt' not in sys.modules
+
+    def test_config_import_lightweight(self):
+        from praisonaiagents.bots.config import BotOSConfig
+        import sys
+        assert 'telegram' not in sys.modules
+        assert 'discord' not in sys.modules
@@ -0,0 +1,242 @@
+"""Unit tests for the Chainlit Bot UI streaming bridge.
+
+Tests the core streaming bridge pattern (StreamEventEmitter → Queue → consumer)
+WITHOUT requiring chainlit as a dependency. Uses mocks for all chainlit objects.
+"""
+
+import asyncio
+import queue
+import unittest
+from unittest.mock import AsyncMock, MagicMock
+
+from praisonaiagents.streaming.events import StreamEvent, StreamEventType, StreamEventEmitter
+
+
+class TestStreamEventEmitterBridge(unittest.TestCase):
+    """Test that StreamEventEmitter can bridge to an async consumer via Queue."""
+
+    def test_sync_callback_puts_events_into_queue(self):
+        """Core bridge pattern: sync callback → queue."""
+        event_queue = queue.Queue()
+
+        def relay(event):
+            event_queue.put_nowait(event)
+
+        emitter = StreamEventEmitter()
+        emitter.add_callback(relay)
+
+        # Emit events
+        evt1 = StreamEvent(type=StreamEventType.DELTA_TEXT, content="Hello")
+        evt2 = StreamEvent(type=StreamEventType.DELTA_TEXT, content=" world")
+        evt3 = StreamEvent(type=StreamEventType.STREAM_END)
+
+        emitter.emit(evt1)
+        emitter.emit(evt2)
+        emitter.emit(evt3)
+
+        # Verify queue has all events
+        self.assertEqual(event_queue.qsize(), 3)
+        self.assertEqual(event_queue.get_nowait().content, "Hello")
+        self.assertEqual(event_queue.get_nowait().content, " world")
+        self.assertEqual(event_queue.get_nowait().type, StreamEventType.STREAM_END)
+
+    def test_callback_cleanup_after_chat(self):
+        """Verify callback is removed after agent.chat completes."""
+        emitter = StreamEventEmitter()
+
+        def relay(event):
+            pass
+
+        emitter.add_callback(relay)
+        self.assertEqual(len(emitter._callbacks), 1)
+
+        emitter.remove_callback(relay)
+        self.assertEqual(len(emitter._callbacks), 0)
+
+    def test_multiple_callbacks_isolation(self):
+        """Multiple callbacks (e.g., gateway + chainlit) don't interfere."""
+        q1 = queue.Queue()
+        q2 = queue.Queue()
+
+        def relay1(event):
+            q1.put_nowait(event)
+
+        def relay2(event):
+            q2.put_nowait(event)
+
+        emitter = StreamEventEmitter()
+        emitter.add_callback(relay1)
+        emitter.add_callback(relay2)
+
+        evt = StreamEvent(type=StreamEventType.DELTA_TEXT, content="test")
+        emitter.emit(evt)
+
+        self.assertEqual(q1.qsize(), 1)
+        self.assertEqual(q2.qsize(), 1)
+        self.assertEqual(q1.get_nowait().content, "test")
+        self.assertEqual(q2.get_nowait().content, "test")
+
+
+class TestStreamConsumer(unittest.TestCase):
+    """Test the async consumer that reads from queue and dispatches to Chainlit."""
+
+    def test_delta_text_calls_stream_token(self):
+        """DELTA_TEXT events should call msg.stream_token(content)."""
+        event_queue = queue.Queue()
+        event_queue.put_nowait(StreamEvent(type=StreamEventType.DELTA_TEXT, content="Hello"))
+        event_queue.put_nowait(StreamEvent(type=StreamEventType.DELTA_TEXT, content=" world"))
+
+        # Use sentinel to signal end
+        _STREAM_END = object()
+        event_queue.put_nowait(_STREAM_END)
+
+        mock_msg = MagicMock()
+        mock_msg.stream_token = AsyncMock()
+        mock_msg.update = AsyncMock()
+
+        async def consume():
+            while True:
+                try:
+                    event = event_queue.get_nowait()
+                except queue.Empty:
+                    await asyncio.sleep(0.01)
+                    continue
+
+                if event is _STREAM_END:
+                    break
+
+                if hasattr(event, 'type') and event.type == StreamEventType.DELTA_TEXT:
+                    content = getattr(event, 'content', '') or ''
+                    if content:
+                        await mock_msg.stream_token(content)
+
+        asyncio.run(consume())
+
+        self.assertEqual(mock_msg.stream_token.call_count, 2)
+        mock_msg.stream_token.assert_any_call("Hello")
+        mock_msg.stream_token.assert_any_call(" world")
+
+    def test_tool_call_events(self):
+        """DELTA_TOOL_CALL events should be captured."""
+        events = [
+            StreamEvent(
+                type=StreamEventType.DELTA_TOOL_CALL,
+                tool_call={"index": 0, "name": "search_web", "arguments": '{"query":'}
+            ),
+            StreamEvent(
+                type=StreamEventType.DELTA_TOOL_CALL,
+                tool_call={"index": 0, "arguments": '"python"}'}
+            ),
+            StreamEvent(type=StreamEventType.TOOL_CALL_END),
+        ]
+
+        captured_tool_calls = {}
+        for event in events:
+            if event.type == StreamEventType.DELTA_TOOL_CALL:
+                tc = event.tool_call or {}
+                idx = tc.get("index", 0)
+                if idx not in captured_tool_calls:
+                    captured_tool_calls[idx] = {"name": tc.get("name"), "args": ""}
+                args = tc.get("arguments", "")
+                if args:
+                    captured_tool_calls[idx]["args"] += args
+
+        self.assertIn(0, captured_tool_calls)
+        self.assertEqual(captured_tool_calls[0]["name"], "search_web")
+        self.assertEqual(captured_tool_calls[0]["args"], '{"query":"python"}')
+
+    def test_error_event(self):
+        """ERROR events should be captured."""
+        event = StreamEvent(type=StreamEventType.ERROR, error="Connection failed")
+        self.assertEqual(event.type, StreamEventType.ERROR)
+        self.assertEqual(event.error, "Connection failed")
+
+    def test_stream_end_signals_completion(self):
+        """STREAM_END should signal the consumer to stop."""
+        event_queue = queue.Queue()
+        event_queue.put_nowait(StreamEvent(type=StreamEventType.STREAM_END))
+
+        _STREAM_END = object()
+        event_queue.put_nowait(_STREAM_END)
+
+        consumed = []
+
+        async def consume():
+            while True:
+                try:
+                    event = event_queue.get_nowait()
+                except queue.Empty:
+                    break
+                if event is _STREAM_END:
+                    break
+                consumed.append(event)
+
+        asyncio.run(consume())
+        self.assertEqual(len(consumed), 1)
+        self.assertEqual(consumed[0].type, StreamEventType.STREAM_END)
+
+
+class TestNoChainlitInCoreSdk(unittest.TestCase):
+    """Verify chainlit is NOT imported in core SDK."""
+
+    def test_no_chainlit_import_in_core(self):
+        """grep-equivalent: no 'import chainlit' in praisonaiagents/ source."""
+        import os
+        core_path = os.path.join(
+            os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
+            "praisonaiagents"
+        )
+
+        violations = []
+        for root, dirs, files in os.walk(core_path):
+            # Skip venv, __pycache__, .egg-info
+            dirs[:] = [d for d in dirs if d not in ("venv", "__pycache__", ".egg-info", "praisonaiagents.egg-info")]
+            for fname in files:
+                if not fname.endswith(".py"):
+                    continue
+                fpath = os.path.join(root, fname)
+                try:
+                    with open(fpath, "r", encoding="utf-8", errors="ignore") as f:
+                        for i, line in enumerate(f, 1):
+                            stripped = line.strip()
+                            if stripped.startswith("#"):
+                                continue
+                            if "import chainlit" in stripped or "from chainlit" in stripped:
+                                violations.append(f"{fpath}:{i}: {stripped}")
+                except Exception:
+                    pass
+
+        self.assertEqual(
+            violations, [],
+            "Core SDK must not import chainlit. Found:\n" + "\n".join(violations)
+        )
+
+
+class TestStreamEventTypes(unittest.TestCase):
+    """Verify all event types used by the bridge exist."""
+
+    def test_required_event_types_exist(self):
+        self.assertTrue(hasattr(StreamEventType, "DELTA_TEXT"))
+        self.assertTrue(hasattr(StreamEventType, "DELTA_TOOL_CALL"))
+        self.assertTrue(hasattr(StreamEventType, "TOOL_CALL_END"))
+        self.assertTrue(hasattr(StreamEventType, "STREAM_END"))
+        self.assertTrue(hasattr(StreamEventType, "ERROR"))
+        self.assertTrue(hasattr(StreamEventType, "FIRST_TOKEN"))
+
+    def test_stream_event_fields(self):
+        """StreamEvent has all fields needed by the bridge."""
+        evt = StreamEvent(
+            type=StreamEventType.DELTA_TEXT,
+            content="hello",
+            tool_call={"name": "test"},
+            error="err",
+            agent_id="agent1",
+        )
+        self.assertEqual(evt.content, "hello")
+        self.assertEqual(evt.tool_call, {"name": "test"})
+        self.assertEqual(evt.error, "err")
+        self.assertEqual(evt.agent_id, "agent1")
+
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,194 @@
+"""
+Tests for Chat Command protocols and BotMessage command properties.
+
+TDD: Tests for ChatCommandProtocol, ChatCommandInfo,
+and BotMessage.is_command / .command / .command_args properties.
+"""
+
+from praisonaiagents.bots import BotMessage, MessageType
+
+
+class TestBotMessageCommandDetection:
+    """Tests for BotMessage command-related properties."""
+
+    def test_is_command_with_slash(self):
+        """Test that messages starting with / are detected as commands."""
+        msg = BotMessage(content="/status")
+        assert msg.is_command is True
+
+    def test_is_command_with_args(self):
+        """Test command detection with arguments."""
+        msg = BotMessage(content="/help topic")
+        assert msg.is_command is True
+
+    def test_is_command_normal_message(self):
+        """Test that normal messages are not commands."""
+        msg = BotMessage(content="Hello, how are you?")
+        assert msg.is_command is False
+
+    def test_is_command_with_command_type(self):
+        """Test command detection via message_type."""
+        msg = BotMessage(content="status", message_type=MessageType.COMMAND)
+        assert msg.is_command is True
+
+    def test_is_command_empty(self):
+        """Test command detection with empty content."""
+        msg = BotMessage(content="")
+        assert msg.is_command is False
+
+    def test_command_name_status(self):
+        """Test extracting /status command name."""
+        msg = BotMessage(content="/status")
+        assert msg.command == "status"
+
+    def test_command_name_new(self):
+        """Test extracting /new command name."""
+        msg = BotMessage(content="/new")
+        assert msg.command == "new"
+
+    def test_command_name_help(self):
+        """Test extracting /help command name."""
+        msg = BotMessage(content="/help")
+        assert msg.command == "help"
+
+    def test_command_name_with_args(self):
+        """Test command name extraction ignores arguments."""
+        msg = BotMessage(content="/help commands")
+        assert msg.command == "help"
+
+    def test_command_name_none_for_normal_message(self):
+        """Test command returns None for non-command messages."""
+        msg = BotMessage(content="Hello")
+        assert msg.command is None
+
+    def test_command_args_empty(self):
+        """Test command_args with no arguments."""
+        msg = BotMessage(content="/status")
+        assert msg.command_args == []
+
+    def test_command_args_single(self):
+        """Test command_args with single argument."""
+        msg = BotMessage(content="/help commands")
+        assert msg.command_args == ["commands"]
+
+    def test_command_args_multiple(self):
+        """Test command_args with multiple arguments."""
+        msg = BotMessage(content="/set model gpt-4o")
+        assert msg.command_args == ["model", "gpt-4o"]
+
+    def test_command_args_normal_message(self):
+        """Test command_args returns empty for non-commands."""
+        msg = BotMessage(content="Hello world")
+        assert msg.command_args == []
+
+
+class TestBotMessageText:
+    """Tests for BotMessage text property."""
+
+    def test_text_string_content(self):
+        """Test text property with string content."""
+        msg = BotMessage(content="Hello")
+        assert msg.text == "Hello"
+
+    def test_text_dict_content(self):
+        """Test text property with dict content."""
+        msg = BotMessage(content={"text": "Hello", "extra": "data"})
+        assert msg.text == "Hello"
+
+    def test_text_dict_no_text_key(self):
+        """Test text property with dict lacking text key."""
+        msg = BotMessage(content={"type": "image", "url": "http://example.com"})
+        assert msg.text == ""
+
+
+class TestBotMessageSerialization:
+    """Tests for BotMessage to_dict / from_dict."""
+
+    def test_to_dict(self):
+        """Test BotMessage serialization."""
+        msg = BotMessage(content="/status", message_type=MessageType.COMMAND)
+        d = msg.to_dict()
+        assert d["content"] == "/status"
+        assert d["message_type"] == "command"
+        assert "message_id" in d
+        assert "timestamp" in d
+
+    def test_from_dict(self):
+        """Test BotMessage deserialization."""
+        d = {
+            "message_id": "test-123",
+            "content": "/help",
+            "message_type": "command",
+            "timestamp": 1234567890.0,
+        }
+        msg = BotMessage.from_dict(d)
+        assert msg.message_id == "test-123"
+        assert msg.content == "/help"
+        assert msg.message_type == MessageType.COMMAND
+        assert msg.is_command is True
+        assert msg.command == "help"
+
+    def test_from_dict_defaults(self):
+        """Test BotMessage deserialization with minimal data."""
+        d = {}
+        msg = BotMessage.from_dict(d)
+        assert msg.content == ""
+        assert msg.message_type == MessageType.TEXT
+
+
+class TestChatCommandProtocol:
+    """Tests for ChatCommandProtocol (added by Agent 3)."""
+
+    def test_import(self):
+        """Test ChatCommandProtocol can be imported."""
+        from praisonaiagents.bots import ChatCommandProtocol
+        assert ChatCommandProtocol is not None
+
+    def test_runtime_checkable(self):
+        """Test ChatCommandProtocol is runtime_checkable."""
+        from praisonaiagents.bots import ChatCommandProtocol, ChatCommandInfo
+
+        class MockBot:
+            def register_command(self, name, handler, description="", usage=None):
+                pass
+
+            def list_commands(self):
+                return [ChatCommandInfo(name="status")]
+
+        bot = MockBot()
+        assert isinstance(bot, ChatCommandProtocol)
+
+    def test_not_matching(self):
+        """Test that random classes don't match ChatCommandProtocol."""
+        from praisonaiagents.bots import ChatCommandProtocol
+
+        class NotABot:
+            pass
+
+        assert not isinstance(NotABot(), ChatCommandProtocol)
+
+
+class TestChatCommandInfoFields:
+    """Tests for ChatCommandInfo field completeness."""
+
+    def test_all_standard_commands(self):
+        """Test creating all standard bot commands."""
+        from praisonaiagents.bots import ChatCommandInfo
+
+        commands = [
+            ChatCommandInfo(name="status", description="Show bot status info", usage="/status"),
+            ChatCommandInfo(name="new", description="Reset conversation session", usage="/new"),
+            ChatCommandInfo(name="help", description="Show available commands", usage="/help"),
+        ]
+
+        assert len(commands) == 3
+        assert commands[0].name == "status"
+        assert commands[1].name == "new"
+        assert commands[2].name == "help"
+
+    def test_command_names(self):
+        """Test that command names are simple strings."""
+        from praisonaiagents.bots import ChatCommandInfo
+        cmd = ChatCommandInfo(name="status")
+        assert isinstance(cmd.name, str)
+        assert "/" not in cmd.name
@@ -0,0 +1,359 @@
+"""
+Tests for Gateway Configuration additions.
+
+TDD: Tests for ChannelRouteConfig, MultiChannelGatewayConfig,
+and existing GatewayConfig/SessionConfig.
+"""
+
+from praisonaiagents.gateway import GatewayConfig, SessionConfig
+
+
+class TestSessionConfig:
+    """Tests for existing SessionConfig dataclass."""
+
+    def test_session_config_defaults(self):
+        """Test SessionConfig has correct defaults."""
+        config = SessionConfig()
+        assert config.timeout == 3600
+        assert config.max_messages == 1000
+        assert config.persist is False
+        assert config.persist_path is None
+        assert config.metadata == {}
+
+    def test_session_config_custom(self):
+        """Test SessionConfig with custom values."""
+        config = SessionConfig(
+            timeout=7200,
+            max_messages=500,
+            persist=True,
+            persist_path="/tmp/sessions",
+            metadata={"env": "test"},
+        )
+        assert config.timeout == 7200
+        assert config.max_messages == 500
+        assert config.persist is True
+        assert config.persist_path == "/tmp/sessions"
+        assert config.metadata == {"env": "test"}
+
+    def test_session_config_to_dict(self):
+        """Test SessionConfig serialization."""
+        config = SessionConfig(timeout=1800, persist=True)
+        d = config.to_dict()
+        assert d["timeout"] == 1800
+        assert d["persist"] is True
+        assert "max_messages" in d
+        assert "metadata" in d
+
+
+class TestGatewayConfig:
+    """Tests for existing GatewayConfig dataclass."""
+
+    def test_gateway_config_defaults(self):
+        """Test GatewayConfig has correct defaults."""
+        config = GatewayConfig()
+        assert config.host == "127.0.0.1"
+        assert config.port == 8765
+        assert config.cors_origins == ["*"]
+        assert config.auth_token is None
+        assert config.max_connections == 1000
+        assert config.max_sessions_per_agent == 0
+        assert config.heartbeat_interval == 30
+        assert config.reconnect_timeout == 60
+
+    def test_gateway_config_custom(self):
+        """Test GatewayConfig with custom values."""
+        config = GatewayConfig(
+            host="0.0.0.0",
+            port=9000,
+            auth_token="secret",
+            max_connections=500,
+        )
+        assert config.host == "0.0.0.0"
+        assert config.port == 9000
+        assert config.auth_token == "secret"
+        assert config.max_connections == 500
+
+    def test_gateway_config_to_dict_hides_token(self):
+        """Test that to_dict masks the auth token."""
+        config = GatewayConfig(auth_token="my-secret-token")
+        d = config.to_dict()
+        assert d["auth_token"] == "***"
+
+    def test_gateway_config_to_dict_no_token(self):
+        """Test that to_dict shows None when no token."""
+        config = GatewayConfig()
+        d = config.to_dict()
+        assert d["auth_token"] is None
+
+    def test_gateway_config_ws_url(self):
+        """Test WebSocket URL generation."""
+        config = GatewayConfig(host="localhost", port=8080)
+        assert config.ws_url == "ws://localhost:8080"
+
+    def test_gateway_config_http_url(self):
+        """Test HTTP URL generation."""
+        config = GatewayConfig(host="localhost", port=8080)
+        assert config.http_url == "http://localhost:8080"
+
+    def test_gateway_config_is_secure_false(self):
+        """Test is_secure when no SSL configured."""
+        config = GatewayConfig()
+        assert config.is_secure is False
+
+    def test_gateway_config_is_secure_true(self):
+        """Test is_secure when SSL is configured."""
+        config = GatewayConfig(ssl_cert="/path/cert.pem", ssl_key="/path/key.pem")
+        assert config.is_secure is True
+
+    def test_gateway_config_secure_urls(self):
+        """Test secure URL generation."""
+        config = GatewayConfig(
+            host="localhost",
+            port=443,
+            ssl_cert="/path/cert.pem",
+            ssl_key="/path/key.pem",
+        )
+        assert config.ws_url == "wss://localhost:443"
+        assert config.http_url == "https://localhost:443"
+
+    def test_gateway_config_session_config(self):
+        """Test nested SessionConfig."""
+        session_config = SessionConfig(timeout=600)
+        config = GatewayConfig(session_config=session_config)
+        assert config.session_config.timeout == 600
+
+
+class TestChannelRouteConfig:
+    """Tests for ChannelRouteConfig dataclass (added by Agent 3)."""
+
+    def test_import(self):
+        """Test ChannelRouteConfig can be imported."""
+        from praisonaiagents.gateway import ChannelRouteConfig
+        assert ChannelRouteConfig is not None
+
+    def test_creation_defaults(self):
+        """Test ChannelRouteConfig with defaults."""
+        from praisonaiagents.gateway import ChannelRouteConfig
+        config = ChannelRouteConfig(channel_type="telegram")
+        assert config.channel_type == "telegram"
+        assert config.token_env == ""
+        assert config.app_token_env is None
+        assert config.routes == {"default": "default"}
+        assert config.enabled is True
+        assert config.metadata == {}
+
+    def test_creation_custom(self):
+        """Test ChannelRouteConfig with custom values."""
+        from praisonaiagents.gateway import ChannelRouteConfig
+        config = ChannelRouteConfig(
+            channel_type="discord",
+            token_env="DISCORD_BOT_TOKEN",
+            routes={"dm": "personal", "group": "support", "default": "personal"},
+            enabled=True,
+            metadata={"guild_id": "123"},
+        )
+        assert config.channel_type == "discord"
+        assert config.token_env == "DISCORD_BOT_TOKEN"
+        assert config.routes["dm"] == "personal"
+        assert config.routes["group"] == "support"
+
+    def test_get_agent_id_direct(self):
+        """Test get_agent_id with direct match."""
+        from praisonaiagents.gateway import ChannelRouteConfig
+        config = ChannelRouteConfig(
+            channel_type="telegram",
+            routes={"dm": "personal", "group": "support", "default": "fallback"},
+        )
+        assert config.get_agent_id("dm") == "personal"
+        assert config.get_agent_id("group") == "support"
+
+    def test_get_agent_id_fallback(self):
+        """Test get_agent_id falls back to default."""
+        from praisonaiagents.gateway import ChannelRouteConfig
+        config = ChannelRouteConfig(
+            channel_type="telegram",
+            routes={"dm": "personal", "default": "fallback"},
+        )
+        assert config.get_agent_id("group") == "fallback"
+        assert config.get_agent_id("channel") == "fallback"
+
+    def test_get_agent_id_no_default(self):
+        """Test get_agent_id with no default route."""
+        from praisonaiagents.gateway import ChannelRouteConfig
+        config = ChannelRouteConfig(
+            channel_type="telegram",
+            routes={"dm": "personal"},
+        )
+        result = config.get_agent_id("group")
+        assert result == "default"
+
+    def test_get_agent_id_default_context(self):
+        """Test get_agent_id with default context arg."""
+        from praisonaiagents.gateway import ChannelRouteConfig
+        config = ChannelRouteConfig(
+            channel_type="telegram",
+            routes={"default": "main_agent"},
+        )
+        assert config.get_agent_id() == "main_agent"
+
+    def test_to_dict(self):
+        """Test ChannelRouteConfig serialization."""
+        from praisonaiagents.gateway import ChannelRouteConfig
+        config = ChannelRouteConfig(
+            channel_type="slack",
+            token_env="SLACK_TOKEN",
+            routes={"default": "support"},
+        )
+        d = config.to_dict()
+        assert d["channel_type"] == "slack"
+        assert d["token_env"] == "SLACK_TOKEN"
+        assert d["routes"] == {"default": "support"}
+        assert d["enabled"] is True
+
+    def test_disabled_channel(self):
+        """Test disabled channel config."""
+        from praisonaiagents.gateway import ChannelRouteConfig
+        config = ChannelRouteConfig(
+            channel_type="telegram",
+            enabled=False,
+        )
+        assert config.enabled is False
+
+
+class TestMultiChannelGatewayConfig:
+    """Tests for MultiChannelGatewayConfig dataclass (added by Agent 3)."""
+
+    def test_import(self):
+        """Test MultiChannelGatewayConfig can be imported."""
+        from praisonaiagents.gateway import MultiChannelGatewayConfig
+        assert MultiChannelGatewayConfig is not None
+
+    def test_creation_defaults(self):
+        """Test MultiChannelGatewayConfig with defaults."""
+        from praisonaiagents.gateway import MultiChannelGatewayConfig
+        config = MultiChannelGatewayConfig()
+        assert isinstance(config.gateway, GatewayConfig)
+        assert config.agents == {}
+        assert config.channels == {}
+
+    def test_creation_with_agents(self):
+        """Test MultiChannelGatewayConfig with agents."""
+        from praisonaiagents.gateway import MultiChannelGatewayConfig
+        config = MultiChannelGatewayConfig(
+            agents={
+                "personal": {"instructions": "Be helpful", "model": "gpt-4o-mini"},
+                "support": {"instructions": "Customer support", "model": "gpt-4o"},
+            }
+        )
+        assert "personal" in config.agents
+        assert config.agents["personal"]["model"] == "gpt-4o-mini"
+        assert "support" in config.agents
+
+    def test_creation_with_channels(self):
+        """Test MultiChannelGatewayConfig with channels."""
+        from praisonaiagents.gateway import MultiChannelGatewayConfig, ChannelRouteConfig
+        tg = ChannelRouteConfig(
+            channel_type="telegram",
+            token_env="TG_TOKEN",
+            routes={"dm": "personal", "default": "personal"},
+        )
+        config = MultiChannelGatewayConfig(channels={"telegram": tg})
+        assert "telegram" in config.channels
+        assert config.channels["telegram"].channel_type == "telegram"
+
+    def test_from_dict_full(self):
+        """Test from_dict with full YAML-like dictionary."""
+        from praisonaiagents.gateway import MultiChannelGatewayConfig
+        data = {
+            "gateway": {"host": "0.0.0.0", "port": 9000},
+            "agents": {
+                "personal": {"instructions": "Be helpful", "model": "gpt-4o-mini", "memory": True},
+                "support": {"instructions": "Customer support", "model": "gpt-4o"},
+            },
+            "channels": {
+                "telegram": {
+                    "token": "${TELEGRAM_BOT_TOKEN}",
+                    "routes": {"dm": "personal", "group": "support", "default": "personal"},
+                },
+                "discord": {
+                    "token": "${DISCORD_BOT_TOKEN}",
+                    "routes": {"default": "personal"},
+                },
+            },
+        }
+        config = MultiChannelGatewayConfig.from_dict(data)
+        assert config.gateway.port == 9000
+        assert "personal" in config.agents
+        assert "support" in config.agents
+        assert "telegram" in config.channels
+        assert "discord" in config.channels
+
+    def test_to_dict(self):
+        """Test MultiChannelGatewayConfig serialization."""
+        from praisonaiagents.gateway import MultiChannelGatewayConfig
+        config = MultiChannelGatewayConfig(
+            agents={"test": {"instructions": "Test agent"}},
+        )
+        d = config.to_dict()
+        assert "gateway" in d
+        assert "agents" in d
+        assert "channels" in d
+
+    def test_stdlib_only(self):
+        """Verify these classes use only stdlib - no external deps."""
+        import sys
+        from praisonaiagents.gateway.config import ChannelRouteConfig, MultiChannelGatewayConfig
+        module = sys.modules["praisonaiagents.gateway.config"]
+        source_file = module.__file__
+        with open(source_file, "r") as f:
+            content = f.read()
+        for dep in ["chromadb", "fastapi", "uvicorn", "pydantic", "litellm"]:
+            assert f"import {dep}" not in content, f"Found heavy dep '{dep}' in config.py"
+
+
+class TestChatCommandInfo:
+    """Tests for ChatCommandInfo dataclass (added by Agent 3)."""
+
+    def test_import(self):
+        """Test ChatCommandInfo can be imported."""
+        from praisonaiagents.bots import ChatCommandInfo
+        assert ChatCommandInfo is not None
+
+    def test_creation_minimal(self):
+        """Test ChatCommandInfo with minimal fields."""
+        from praisonaiagents.bots import ChatCommandInfo
+        cmd = ChatCommandInfo(name="status")
+        assert cmd.name == "status"
+        assert cmd.description == ""
+        assert cmd.hidden is False
+
+    def test_creation_full(self):
+        """Test ChatCommandInfo with all fields."""
+        from praisonaiagents.bots import ChatCommandInfo
+        cmd = ChatCommandInfo(
+            name="help",
+            description="Show available commands",
+            usage="/help",
+            hidden=False,
+        )
+        assert cmd.name == "help"
+        assert cmd.description == "Show available commands"
+        assert cmd.usage == "/help"
+        assert cmd.hidden is False
+
+    def test_hidden_command(self):
+        """Test hidden ChatCommandInfo."""
+        from praisonaiagents.bots import ChatCommandInfo
+        cmd = ChatCommandInfo(name="debug", hidden=True)
+        assert cmd.hidden is True
+
+    def test_stdlib_only(self):
+        """Verify bots/protocols.py uses only stdlib."""
+        import sys
+        from praisonaiagents.bots.protocols import BotProtocol
+        module = sys.modules["praisonaiagents.bots.protocols"]
+        source_file = module.__file__
+        with open(source_file, "r") as f:
+            content = f.read()
+        for dep in ["chromadb", "fastapi", "uvicorn", "litellm"]:
+            assert f"import {dep}" not in content, f"Found heavy dep '{dep}' in protocols.py"
@@ -0,0 +1,176 @@
+"""Unit tests for gateway routing: _determine_routing_context, _resolve_agent_for_message, _inject_routing_handler."""
+
+import pytest
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', '..', 'praisonai'))
+
+
+class MockAgent:
+    def __init__(self, name="agent"):
+        self.name = name
+        self.chat_history = []
+
+    def chat(self, prompt):
+        return f"[{self.name}] {prompt}"
+
+
+class MockBot:
+    """Minimal mock bot that supports on_message / set_agent."""
+
+    def __init__(self, agent=None):
+        self._agent = agent
+        self._message_handlers = []
+        self.is_running = True
+        self.platform = "mock"
+
+    def on_message(self, handler):
+        self._message_handlers.append(handler)
+        return handler
+
+    def set_agent(self, agent):
+        self._agent = agent
+
+
+class TestDetermineRoutingContext:
+    """Test _determine_routing_context logic."""
+
+    def _get_gateway(self):
+        from praisonai.gateway.server import WebSocketGateway
+        return WebSocketGateway()
+
+    def test_private_chat_maps_to_dm(self):
+        gw = self._get_gateway()
+        ctx = gw._determine_routing_context("telegram", {"chat_type": "private"})
+        assert ctx == "dm"
+
+    def test_group_chat_maps_to_group(self):
+        gw = self._get_gateway()
+        ctx = gw._determine_routing_context("telegram", {"chat_type": "group"})
+        assert ctx == "group"
+
+    def test_supergroup_maps_to_group(self):
+        gw = self._get_gateway()
+        ctx = gw._determine_routing_context("telegram", {"chat_type": "supergroup"})
+        assert ctx == "group"
+
+    def test_channel_maps_to_channel(self):
+        gw = self._get_gateway()
+        ctx = gw._determine_routing_context("telegram", {"chat_type": "channel"})
+        assert ctx == "channel"
+
+    def test_unknown_maps_to_default(self):
+        gw = self._get_gateway()
+        ctx = gw._determine_routing_context("telegram", {"chat_type": "unknown_type"})
+        assert ctx == "default"
+
+    def test_dm_flag_override(self):
+        gw = self._get_gateway()
+        ctx = gw._determine_routing_context("discord", {"chat_type": "", "is_dm": True})
+        assert ctx == "dm"
+
+
+class TestResolveAgentForMessage:
+    """Test _resolve_agent_for_message with routing rules."""
+
+    def _get_gateway(self):
+        from praisonai.gateway.server import WebSocketGateway
+        gw = WebSocketGateway()
+        return gw
+
+    def test_no_routing_rules_returns_none(self):
+        gw = self._get_gateway()
+        result = gw._resolve_agent_for_message("telegram", "dm")
+        assert result is None
+
+    def test_exact_route_match(self):
+        gw = self._get_gateway()
+        agent = MockAgent("personal")
+        gw._agents["personal"] = agent
+        gw._routing_rules["telegram"] = {"dm": "personal"}
+        result = gw._resolve_agent_for_message("telegram", "dm")
+        assert result is agent
+
+    def test_default_fallback(self):
+        gw = self._get_gateway()
+        agent = MockAgent("fallback")
+        gw._agents["fallback"] = agent
+        gw._routing_rules["telegram"] = {"default": "fallback"}
+        result = gw._resolve_agent_for_message("telegram", "unknown_context")
+        assert result is agent
+
+    def test_no_matching_channel(self):
+        gw = self._get_gateway()
+        gw._routing_rules["telegram"] = {"dm": "agent1"}
+        result = gw._resolve_agent_for_message("discord", "dm")
+        assert result is None
+
+    def test_agent_not_registered(self):
+        gw = self._get_gateway()
+        gw._routing_rules["telegram"] = {"dm": "nonexistent"}
+        result = gw._resolve_agent_for_message("telegram", "dm")
+        assert result is None
+
+
+class TestInjectRoutingHandler:
+    """Test _inject_routing_handler injects on_message handler."""
+
+    def _get_gateway(self):
+        from praisonai.gateway.server import WebSocketGateway
+        return WebSocketGateway()
+
+    def test_handler_injected(self):
+        gw = self._get_gateway()
+        bot = MockBot()
+        assert len(bot._message_handlers) == 0
+        gw._inject_routing_handler("discord", bot)
+        assert len(bot._message_handlers) == 1
+
+    @pytest.mark.asyncio
+    async def test_handler_sets_agent_based_on_route(self):
+        gw = self._get_gateway()
+        personal_agent = MockAgent("personal")
+        support_agent = MockAgent("support")
+        gw._agents["personal"] = personal_agent
+        gw._agents["support"] = support_agent
+        gw._routing_rules["discord"] = {"dm": "personal", "channel": "support"}
+
+        bot = MockBot(agent=support_agent)
+        gw._inject_routing_handler("discord", bot)
+
+        # Simulate a DM message
+        class FakeSender:
+            user_id = "user1"
+        class FakeChannel:
+            channel_type = "dm"
+        class FakeMessage:
+            sender = FakeSender()
+            channel = FakeChannel()
+            text = "hello"
+
+        handler = bot._message_handlers[0]
+        await handler(FakeMessage())
+        # Bot's agent should now be personal (DM route)
+        assert bot._agent is personal_agent
+
+
+class TestHealthEndpointChannels:
+    """Test that health() includes per-channel status."""
+
+    def test_health_empty_channels(self):
+        from praisonai.gateway.server import WebSocketGateway
+        gw = WebSocketGateway()
+        h = gw.health()
+        assert "channels" in h
+        assert h["channels"] == {}
+
+    def test_health_with_channel_bots(self):
+        from praisonai.gateway.server import WebSocketGateway
+        gw = WebSocketGateway()
+        bot = MockBot()
+        gw._channel_bots["telegram"] = bot
+        h = gw.health()
+        assert "telegram" in h["channels"]
+        assert h["channels"]["telegram"]["platform"] == "mock"
+        assert h["channels"]["telegram"]["running"] is True
@@ -0,0 +1,483 @@
+"""
+Tests for WebSocket Gateway Server.
+
+TDD: Mock-based tests for WebSocketGateway — no actual server started.
+Tests existing functionality and multi-bot extensions (Agent 2).
+"""
+
+from unittest.mock import Mock
+
+from praisonaiagents.gateway import (
+    GatewayConfig,
+    GatewayEvent,
+    GatewayMessage,
+    EventType,
+)
+
+
+class TestGatewayImports:
+    """Test that gateway modules import correctly."""
+
+    def test_import_gateway_config(self):
+        """Test GatewayConfig import."""
+        assert GatewayConfig is not None
+
+    def test_import_gateway_event(self):
+        """Test GatewayEvent import."""
+        assert GatewayEvent is not None
+
+    def test_import_event_type(self):
+        """Test EventType import."""
+        assert EventType is not None
+
+    def test_import_gateway_message(self):
+        """Test GatewayMessage import."""
+        assert GatewayMessage is not None
+
+
+class TestGatewayEvent:
+    """Tests for GatewayEvent dataclass."""
+
+    def test_event_creation(self):
+        """Test basic event creation."""
+        event = GatewayEvent(type=EventType.MESSAGE, data={"text": "hello"})
+        assert event.type == EventType.MESSAGE
+        assert event.data == {"text": "hello"}
+        assert event.event_id is not None
+        assert event.timestamp > 0
+
+    def test_event_with_source_target(self):
+        """Test event with source and target."""
+        event = GatewayEvent(
+            type=EventType.MESSAGE,
+            data={},
+            source="client_1",
+            target="agent_1",
+        )
+        assert event.source == "client_1"
+        assert event.target == "agent_1"
+
+    def test_event_to_dict(self):
+        """Test event serialization."""
+        event = GatewayEvent(
+            type=EventType.CONNECT,
+            data={"client_id": "abc"},
+            source="client",
+        )
+        d = event.to_dict()
+        assert d["type"] == "connect"
+        assert d["data"] == {"client_id": "abc"}
+        assert d["source"] == "client"
+        assert "event_id" in d
+        assert "timestamp" in d
+
+    def test_event_from_dict(self):
+        """Test event deserialization."""
+        d = {
+            "type": "message",
+            "data": {"text": "hello"},
+            "event_id": "test-id",
+            "timestamp": 1234567890.0,
+            "source": "client",
+            "target": "agent",
+        }
+        event = GatewayEvent.from_dict(d)
+        assert event.type == EventType.MESSAGE
+        assert event.data == {"text": "hello"}
+        assert event.event_id == "test-id"
+        assert event.source == "client"
+        assert event.target == "agent"
+
+    def test_event_from_dict_custom_type(self):
+        """Test event deserialization with custom type string."""
+        d = {"type": "custom.event", "data": {}}
+        event = GatewayEvent.from_dict(d)
+        assert event.type == "custom.event"
+
+    def test_event_string_type(self):
+        """Test event with string type instead of enum."""
+        event = GatewayEvent(type="custom.type", data={})
+        assert event.type == "custom.type"
+        d = event.to_dict()
+        assert d["type"] == "custom.type"
+
+
+class TestGatewayMessage:
+    """Tests for GatewayMessage dataclass."""
+
+    def test_message_creation(self):
+        """Test basic message creation."""
+        msg = GatewayMessage(
+            content="Hello",
+            sender_id="user_1",
+            session_id="session_1",
+        )
+        assert msg.content == "Hello"
+        assert msg.sender_id == "user_1"
+        assert msg.session_id == "session_1"
+        assert msg.message_id is not None
+        assert msg.timestamp > 0
+
+    def test_message_to_dict(self):
+        """Test message serialization."""
+        msg = GatewayMessage(
+            content="Test",
+            sender_id="user",
+            session_id="sess",
+        )
+        d = msg.to_dict()
+        assert d["content"] == "Test"
+        assert d["sender_id"] == "user"
+        assert d["session_id"] == "sess"
+        assert "message_id" in d
+
+    def test_message_from_dict(self):
+        """Test message deserialization."""
+        d = {
+            "content": "Hello",
+            "sender_id": "user",
+            "session_id": "sess",
+            "message_id": "msg-1",
+            "timestamp": 1000.0,
+            "reply_to": "msg-0",
+        }
+        msg = GatewayMessage.from_dict(d)
+        assert msg.content == "Hello"
+        assert msg.sender_id == "user"
+        assert msg.session_id == "sess"
+        assert msg.message_id == "msg-1"
+        assert msg.reply_to == "msg-0"
+
+    def test_message_from_dict_defaults(self):
+        """Test message deserialization with minimal data."""
+        d = {}
+        msg = GatewayMessage.from_dict(d)
+        assert msg.content == ""
+        assert msg.sender_id == "unknown"
+        assert msg.session_id == "default"
+
+
+class TestEventType:
+    """Tests for EventType enum."""
+
+    def test_connection_events(self):
+        """Test connection event types exist."""
+        assert EventType.CONNECT.value == "connect"
+        assert EventType.DISCONNECT.value == "disconnect"
+        assert EventType.RECONNECT.value == "reconnect"
+
+    def test_session_events(self):
+        """Test session event types exist."""
+        assert EventType.SESSION_START.value == "session_start"
+        assert EventType.SESSION_END.value == "session_end"
+        assert EventType.SESSION_UPDATE.value == "session_update"
+
+    def test_agent_events(self):
+        """Test agent event types exist."""
+        assert EventType.AGENT_REGISTER.value == "agent_register"
+        assert EventType.AGENT_UNREGISTER.value == "agent_unregister"
+        assert EventType.AGENT_STATUS.value == "agent_status"
+
+    def test_message_events(self):
+        """Test message event types exist."""
+        assert EventType.MESSAGE.value == "message"
+        assert EventType.MESSAGE_ACK.value == "message_ack"
+        assert EventType.TYPING.value == "typing"
+
+    def test_system_events(self):
+        """Test system event types exist."""
+        assert EventType.HEALTH.value == "health"
+        assert EventType.ERROR.value == "error"
+        assert EventType.BROADCAST.value == "broadcast"
+
+
+class TestWebSocketGateway:
+    """Tests for WebSocketGateway server (wrapper package)."""
+
+    def _get_gateway_class(self):
+        """Import WebSocketGateway with graceful fallback."""
+        try:
+            from praisonai.gateway import WebSocketGateway
+            return WebSocketGateway
+        except ImportError:
+            return None
+
+    def test_import(self):
+        """Test WebSocketGateway can be imported."""
+        cls = self._get_gateway_class()
+        if cls is None:
+            __import__("pytest").skip("praisonai wrapper not installed")
+        assert cls is not None
+
+    def test_instantiation_defaults(self):
+        """Test WebSocketGateway default instantiation."""
+        cls = self._get_gateway_class()
+        if cls is None:
+            __import__("pytest").skip("praisonai wrapper not installed")
+        gw = cls()
+        assert gw.host == "127.0.0.1"
+        assert gw.port == 8765
+        assert gw.is_running is False
+
+    def test_instantiation_custom(self):
+        """Test WebSocketGateway with custom config."""
+        cls = self._get_gateway_class()
+        if cls is None:
+            __import__("pytest").skip("praisonai wrapper not installed")
+        config = GatewayConfig(host="0.0.0.0", port=9000)
+        gw = cls(config=config)
+        assert gw.host == "0.0.0.0"
+        assert gw.port == 9000
+
+    def test_register_agent(self):
+        """Test agent registration."""
+        cls = self._get_gateway_class()
+        if cls is None:
+            __import__("pytest").skip("praisonai wrapper not installed")
+        gw = cls()
+        mock_agent = Mock()
+        mock_agent.agent_id = None
+        agent_id = gw.register_agent(mock_agent, agent_id="test-agent")
+        assert agent_id == "test-agent"
+        assert "test-agent" in gw.list_agents()
+
+    def test_register_agent_auto_id(self):
+        """Test agent registration with auto-generated ID."""
+        cls = self._get_gateway_class()
+        if cls is None:
+            __import__("pytest").skip("praisonai wrapper not installed")
+        gw = cls()
+        mock_agent = Mock()
+        mock_agent.agent_id = None
+        agent_id = gw.register_agent(mock_agent)
+        assert agent_id is not None
+        assert len(agent_id) > 0
+
+    def test_unregister_agent(self):
+        """Test agent unregistration."""
+        cls = self._get_gateway_class()
+        if cls is None:
+            __import__("pytest").skip("praisonai wrapper not installed")
+        gw = cls()
+        mock_agent = Mock()
+        mock_agent.agent_id = None
+        gw.register_agent(mock_agent, agent_id="to-remove")
+        result = gw.unregister_agent("to-remove")
+        assert result is True
+        assert "to-remove" not in gw.list_agents()
+
+    def test_unregister_agent_not_found(self):
+        """Test unregistering non-existent agent."""
+        cls = self._get_gateway_class()
+        if cls is None:
+            __import__("pytest").skip("praisonai wrapper not installed")
+        gw = cls()
+        result = gw.unregister_agent("nonexistent")
+        assert result is False
+
+    def test_get_agent(self):
+        """Test getting a registered agent."""
+        cls = self._get_gateway_class()
+        if cls is None:
+            __import__("pytest").skip("praisonai wrapper not installed")
+        gw = cls()
+        mock_agent = Mock()
+        mock_agent.agent_id = None
+        gw.register_agent(mock_agent, agent_id="my-agent")
+        retrieved = gw.get_agent("my-agent")
+        assert retrieved is mock_agent
+
+    def test_get_agent_not_found(self):
+        """Test getting non-existent agent."""
+        cls = self._get_gateway_class()
+        if cls is None:
+            __import__("pytest").skip("praisonai wrapper not installed")
+        gw = cls()
+        assert gw.get_agent("nonexistent") is None
+
+    def test_list_agents_empty(self):
+        """Test listing agents when none registered."""
+        cls = self._get_gateway_class()
+        if cls is None:
+            __import__("pytest").skip("praisonai wrapper not installed")
+        gw = cls()
+        assert gw.list_agents() == []
+
+    def test_list_agents_multiple(self):
+        """Test listing multiple agents."""
+        cls = self._get_gateway_class()
+        if cls is None:
+            __import__("pytest").skip("praisonai wrapper not installed")
+        gw = cls()
+        for name in ["agent_a", "agent_b", "agent_c"]:
+            mock = Mock()
+            mock.agent_id = None
+            gw.register_agent(mock, agent_id=name)
+        agents = gw.list_agents()
+        assert len(agents) == 3
+        assert "agent_a" in agents
+        assert "agent_b" in agents
+        assert "agent_c" in agents
+
+    def test_create_session(self):
+        """Test session creation."""
+        cls = self._get_gateway_class()
+        if cls is None:
+            __import__("pytest").skip("praisonai wrapper not installed")
+        gw = cls()
+        mock_agent = Mock()
+        mock_agent.agent_id = None
+        gw.register_agent(mock_agent, agent_id="agent_1")
+        session = gw.create_session("agent_1", client_id="client_1")
+        assert session.session_id is not None
+        assert session.agent_id == "agent_1"
+        assert session.client_id == "client_1"
+        assert session.is_active is True
+
+    def test_close_session(self):
+        """Test session closing."""
+        cls = self._get_gateway_class()
+        if cls is None:
+            __import__("pytest").skip("praisonai wrapper not installed")
+        gw = cls()
+        mock_agent = Mock()
+        mock_agent.agent_id = None
+        gw.register_agent(mock_agent, agent_id="agent_1")
+        session = gw.create_session("agent_1")
+        result = gw.close_session(session.session_id)
+        assert result is True
+
+    def test_close_session_not_found(self):
+        """Test closing non-existent session."""
+        cls = self._get_gateway_class()
+        if cls is None:
+            __import__("pytest").skip("praisonai wrapper not installed")
+        gw = cls()
+        result = gw.close_session("nonexistent")
+        assert result is False
+
+    def test_list_sessions(self):
+        """Test listing sessions."""
+        cls = self._get_gateway_class()
+        if cls is None:
+            __import__("pytest").skip("praisonai wrapper not installed")
+        gw = cls()
+        mock_agent = Mock()
+        mock_agent.agent_id = None
+        gw.register_agent(mock_agent, agent_id="agent_1")
+        gw.create_session("agent_1", session_id="sess_1")
+        gw.create_session("agent_1", session_id="sess_2")
+        sessions = gw.list_sessions()
+        assert len(sessions) == 2
+        assert "sess_1" in sessions
+        assert "sess_2" in sessions
+
+    def test_list_sessions_by_agent(self):
+        """Test listing sessions filtered by agent."""
+        cls = self._get_gateway_class()
+        if cls is None:
+            __import__("pytest").skip("praisonai wrapper not installed")
+        gw = cls()
+        for aid in ["agent_a", "agent_b"]:
+            mock = Mock()
+            mock.agent_id = None
+            gw.register_agent(mock, agent_id=aid)
+        gw.create_session("agent_a", session_id="sess_a1")
+        gw.create_session("agent_b", session_id="sess_b1")
+        gw.create_session("agent_a", session_id="sess_a2")
+        a_sessions = gw.list_sessions(agent_id="agent_a")
+        assert len(a_sessions) == 2
+        assert "sess_a1" in a_sessions
+        assert "sess_a2" in a_sessions
+
+    def test_health_stopped(self):
+        """Test health status when gateway is stopped."""
+        cls = self._get_gateway_class()
+        if cls is None:
+            __import__("pytest").skip("praisonai wrapper not installed")
+        gw = cls()
+        health = gw.health()
+        assert health["status"] == "stopped"
+        assert health["agents"] == 0
+        assert health["sessions"] == 0
+        assert health["clients"] == 0
+
+    def test_health_with_agents(self):
+        """Test health status includes agent count."""
+        cls = self._get_gateway_class()
+        if cls is None:
+            __import__("pytest").skip("praisonai wrapper not installed")
+        gw = cls()
+        mock = Mock()
+        mock.agent_id = None
+        gw.register_agent(mock, agent_id="a1")
+        health = gw.health()
+        assert health["agents"] == 1
+
+
+class TestGatewaySession:
+    """Tests for GatewaySession (from wrapper)."""
+
+    def _get_session_class(self):
+        """Import GatewaySession with graceful fallback."""
+        try:
+            from praisonai.gateway import GatewaySession
+            return GatewaySession
+        except ImportError:
+            return None
+
+    def test_session_state(self):
+        """Test session state management."""
+        cls = self._get_session_class()
+        if cls is None:
+            __import__("pytest").skip("praisonai wrapper not installed")
+        session = cls(
+            _session_id="test",
+            _agent_id="agent_1",
+        )
+        session.set_state("key", "value")
+        state = session.get_state()
+        assert state["key"] == "value"
+
+    def test_session_messages(self):
+        """Test session message management."""
+        cls = self._get_session_class()
+        if cls is None:
+            __import__("pytest").skip("praisonai wrapper not installed")
+        session = cls(
+            _session_id="test",
+            _agent_id="agent_1",
+        )
+        msg = GatewayMessage(content="Hello", sender_id="user", session_id="test")
+        session.add_message(msg)
+        messages = session.get_messages()
+        assert len(messages) == 1
+        assert messages[0].content == "Hello"
+
+    def test_session_messages_limit(self):
+        """Test session message retrieval with limit."""
+        cls = self._get_session_class()
+        if cls is None:
+            __import__("pytest").skip("praisonai wrapper not installed")
+        session = cls(
+            _session_id="test",
+            _agent_id="agent_1",
+        )
+        for i in range(5):
+            msg = GatewayMessage(content=f"msg_{i}", sender_id="user", session_id="test")
+            session.add_message(msg)
+        messages = session.get_messages(limit=2)
+        assert len(messages) == 2
+
+    def test_session_close(self):
+        """Test session closing."""
+        cls = self._get_session_class()
+        if cls is None:
+            __import__("pytest").skip("praisonai wrapper not installed")
+        session = cls(
+            _session_id="test",
+            _agent_id="agent_1",
+        )
+        assert session.is_active is True
+        session.close()
+        assert session.is_active is False
@@ -0,0 +1,272 @@
+"""
+TDD Tests for Memory System Fixes.
+
+Tests written BEFORE implementation to drive the fixes for:
+1. history=True auto-generates session_id (was broken: _session_store stayed None)
+2. auto_memory wires process_interaction after agent response
+3. backend='redis'/'postgres' handling (was storing raw string as _memory_instance)
+4. MemoryProtocol extended with get_context/save_session
+5. _history_session_id reconciled with _session_id
+"""
+from unittest.mock import patch
+import logging
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _make_agent(**kwargs):
+    """Create an Agent with memory config, mocking LLM to avoid real API calls."""
+    from praisonaiagents import Agent
+    defaults = dict(
+        name="test_agent",
+        instructions="Be helpful",
+        llm="gpt-4o-mini",
+    )
+    defaults.update(kwargs)
+    agent = Agent(**defaults)
+    return agent
+
+
+# ===========================================================================
+# 1. history=True auto-generates session_id
+# ===========================================================================
+
+class TestHistoryAutoSessionId:
+    """history=True should auto-generate a session_id so _init_session_store
+    can create the store and history injection fires."""
+
+    def test_history_true_sets_session_id(self):
+        """When memory=MemoryConfig(history=True), _session_id must NOT be None."""
+        from praisonaiagents import Agent, MemoryConfig
+        agent = _make_agent(memory=MemoryConfig(history=True))
+        # After construction, session_id should be auto-set
+        assert agent._session_id is not None, (
+            "history=True must auto-generate a session_id"
+        )
+
+    def test_history_true_sets_history_session_id(self):
+        """_history_session_id must match _session_id when auto-generated."""
+        from praisonaiagents import Agent, MemoryConfig
+        agent = _make_agent(memory=MemoryConfig(history=True))
+        assert agent._history_session_id is not None
+        assert agent._history_session_id == agent._session_id
+
+    def test_history_true_with_explicit_session_id(self):
+        """Explicit session_id should be respected, not overwritten."""
+        from praisonaiagents import Agent, MemoryConfig
+        agent = _make_agent(memory=MemoryConfig(history=True, session_id="my-session"))
+        assert agent._session_id == "my-session"
+        assert agent._history_session_id == "my-session"
+
+    def test_history_true_with_auto_save(self):
+        """auto_save should be used as session_id when history=True."""
+        from praisonaiagents import Agent, MemoryConfig
+        agent = _make_agent(memory=MemoryConfig(history=True, auto_save="chat1"))
+        assert agent._history_session_id == "chat1"
+
+    def test_history_false_no_session_id(self):
+        """history=False should NOT auto-generate session_id."""
+        from praisonaiagents import Agent, MemoryConfig
+        agent = _make_agent(memory=MemoryConfig(history=False))
+        # session_id should remain None (no auto-gen)
+        assert agent._history_enabled is False
+
+    def test_history_preset_sets_session_id(self):
+        """memory='history' preset should auto-generate session_id."""
+        from praisonaiagents import Agent
+        agent = _make_agent(memory="history")
+        assert agent._history_enabled is True
+        assert agent._session_id is not None
+
+
+# ===========================================================================
+# 2. auto_memory wires process_interaction after agent response
+# ===========================================================================
+
+class TestAutoMemoryWiring:
+    """When auto_memory=True in MemoryConfig, AutoMemory.process_interaction
+    should be called after each agent response."""
+
+    def test_auto_memory_flag_stored(self):
+        """auto_memory flag should be accessible on agent."""
+        from praisonaiagents import Agent, MemoryConfig
+        agent = _make_agent(memory=MemoryConfig(auto_memory=True))
+        assert agent._auto_memory is True or agent._auto_memory is not None
+
+    def test_auto_memory_instance_created_lazily(self):
+        """AutoMemory wrapper should be created when auto_memory=True."""
+        from praisonaiagents import Agent, MemoryConfig
+        agent = _make_agent(memory=MemoryConfig(auto_memory=True))
+        # The _auto_memory_instance should exist (may be lazy)
+        assert hasattr(agent, '_auto_memory_instance') or hasattr(agent, '_auto_memory')
+
+    def test_process_auto_memory_method_exists(self):
+        """Agent should have a _process_auto_memory method."""
+        from praisonaiagents import Agent, MemoryConfig
+        agent = _make_agent(memory=MemoryConfig(auto_memory=True))
+        assert hasattr(agent, '_process_auto_memory'), (
+            "Agent must have _process_auto_memory method for wiring"
+        )
+
+    def test_process_auto_memory_noop_when_disabled(self):
+        """_process_auto_memory should be a no-op when auto_memory=False."""
+        from praisonaiagents import Agent, MemoryConfig
+        agent = _make_agent(memory=MemoryConfig(auto_memory=False))
+        # Should not raise
+        agent._process_auto_memory("hello", "world")
+
+
+# ===========================================================================
+# 3. backend='redis'/'postgres' handling
+# ===========================================================================
+
+class TestBackendHandling:
+    """backend='redis' and 'postgres' should NOT silently store a raw string
+    as _memory_instance. They should either work or raise a clear error."""
+
+    def test_redis_backend_not_string(self):
+        """backend='redis' must NOT result in _memory_instance being a string."""
+        from praisonaiagents import Agent, MemoryConfig
+        agent = _make_agent(memory=MemoryConfig(backend="redis"))
+        if agent._memory_instance is not None:
+            assert not isinstance(agent._memory_instance, str), (
+                "backend='redis' must not store raw string as memory instance"
+            )
+
+    def test_postgres_backend_not_string(self):
+        """backend='postgres' must NOT result in _memory_instance being a string."""
+        from praisonaiagents import Agent, MemoryConfig
+        agent = _make_agent(memory=MemoryConfig(backend="postgres"))
+        if agent._memory_instance is not None:
+            assert not isinstance(agent._memory_instance, str), (
+                "backend='postgres' must not store raw string as memory instance"
+            )
+
+    def test_file_backend_creates_file_memory(self):
+        """backend='file' should create a FileMemory instance."""
+        from praisonaiagents import Agent, MemoryConfig
+        from praisonaiagents.memory.file_memory import FileMemory
+        agent = _make_agent(memory=MemoryConfig(backend="file"))
+        assert isinstance(agent._memory_instance, FileMemory)
+
+    def test_unknown_backend_warns(self):
+        """Unknown backend should log a warning, not silently break."""
+        from praisonaiagents import Agent, MemoryConfig
+        import logging
+        with patch.object(logging, 'warning') as mock_warn:
+            agent = _make_agent(memory=MemoryConfig(backend="unknown_db"))
+            # Should either warn or the instance should be None/FileMemory fallback
+            if agent._memory_instance is not None:
+                assert not isinstance(agent._memory_instance, str)
+
+
+# ===========================================================================
+# 4. MemoryProtocol extended with get_context and save_session
+# ===========================================================================
+
+class TestMemoryProtocolExtensions:
+    """MemoryProtocol should include get_context and save_session for
+    consistent interface across FileMemory and Memory."""
+
+    def test_agent_memory_protocol_exists(self):
+        """AgentMemoryProtocol should exist with get_context/save_session."""
+        from praisonaiagents.memory.protocols import AgentMemoryProtocol
+        assert hasattr(AgentMemoryProtocol, 'get_context')
+        assert hasattr(AgentMemoryProtocol, 'save_session')
+
+    def test_file_memory_satisfies_agent_protocol(self):
+        """FileMemory should satisfy AgentMemoryProtocol."""
+        from praisonaiagents.memory.protocols import AgentMemoryProtocol
+        from praisonaiagents.memory.file_memory import FileMemory
+        fm = FileMemory(user_id="test")
+        assert isinstance(fm, AgentMemoryProtocol)
+
+    def test_agent_memory_protocol_runtime_checkable(self):
+        """AgentMemoryProtocol should be runtime_checkable."""
+        from praisonaiagents.memory.protocols import AgentMemoryProtocol
+        
+        class FakeMemory:
+            def get_context(self, query=None):
+                return ""
+            def save_session(self, name, conversation_history=None, metadata=None):
+                pass
+        
+        assert isinstance(FakeMemory(), AgentMemoryProtocol)
+
+
+# ===========================================================================
+# 5. _history_session_id reconciled with _session_id
+# ===========================================================================
+
+class TestHistorySessionIdReconciliation:
+    """_history_session_id and _session_id should be reconciled so that
+    _init_session_store creates the store AND history injection uses the right ID."""
+
+    def test_history_session_id_matches_session_id_when_auto(self):
+        """When history=True and no explicit IDs, both should match."""
+        from praisonaiagents import Agent, MemoryConfig
+        agent = _make_agent(memory=MemoryConfig(history=True))
+        if agent._session_id is not None:
+            assert agent._history_session_id == agent._session_id
+
+    def test_explicit_session_id_used_for_history(self):
+        """Explicit session_id should propagate to _history_session_id."""
+        from praisonaiagents import Agent, MemoryConfig
+        agent = _make_agent(memory=MemoryConfig(history=True, session_id="explicit"))
+        assert agent._session_id == "explicit"
+        assert agent._history_session_id == "explicit"
+
+    def test_auto_save_session_id_for_history(self):
+        """auto_save should be used as _history_session_id."""
+        from praisonaiagents import Agent, MemoryConfig
+        agent = _make_agent(memory=MemoryConfig(history=True, auto_save="my_session"))
+        assert agent._history_session_id == "my_session"
+
+
+# ===========================================================================
+# 6. Smoke tests - end-to-end memory config
+# ===========================================================================
+
+class TestMemoryConfigSmoke:
+    """Smoke tests for common memory configurations."""
+
+    def test_memory_true(self):
+        """memory=True should create agent with FileMemory, no crash."""
+        from praisonaiagents import Agent
+        agent = _make_agent(memory=True)
+        assert agent._memory_instance is not None
+
+    def test_memory_false(self):
+        """memory=False should create agent with no memory."""
+        from praisonaiagents import Agent
+        agent = _make_agent(memory=False)
+        assert agent._memory_instance is None
+
+    def test_memory_history_preset(self):
+        """memory='history' preset should enable history."""
+        from praisonaiagents import Agent
+        agent = _make_agent(memory="history")
+        assert agent._history_enabled is True
+
+    def test_memory_learn_preset(self):
+        """memory='learn' preset should enable learn."""
+        from praisonaiagents import Agent
+        agent = _make_agent(memory="learn")
+        # Should not crash; learn config should be present
+        assert agent._memory_instance is not None
+
+    def test_store_memory_public_api(self):
+        """agent.store_memory() should work with memory=True."""
+        from praisonaiagents import Agent
+        agent = _make_agent(memory=True)
+        # Should not raise
+        agent.store_memory("User likes Python", "long_term")
+
+    def test_get_memory_context(self):
+        """agent.get_memory_context() should return string."""
+        from praisonaiagents import Agent
+        agent = _make_agent(memory=True)
+        ctx = agent.get_memory_context()
+        assert isinstance(ctx, str)
@@ -0,0 +1,319 @@
+"""
+TDD tests for Agent parameter consolidation.
+
+Tests:
+1. Deprecation warnings fire for old params
+2. New config fields work (ExecutionConfig.code_execution, MemoryConfig.auto_save, AutonomyConfig.verification_hooks)
+3. Backward compatibility: old params still function correctly
+4. Config fields take precedence over deprecated standalone params
+"""
+
+import warnings
+import pytest
+
+
+class TestDeprecationWarnings:
+    """Test that deprecated params emit DeprecationWarning."""
+
+    def test_allow_delegation_warns(self):
+        """allow_delegation=True should emit DeprecationWarning."""
+        from praisonaiagents import Agent
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            agent = Agent(name="test", instructions="test", allow_delegation=True)
+            deprecation_warnings = [x for x in w if issubclass(x.category, DeprecationWarning)]
+            msgs = [str(x.message) for x in deprecation_warnings]
+            assert any("allow_delegation" in m for m in msgs), f"Expected allow_delegation deprecation, got: {msgs}"
+
+    def test_allow_code_execution_warns(self):
+        """allow_code_execution=True should emit DeprecationWarning."""
+        from praisonaiagents import Agent
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            agent = Agent(name="test", instructions="test", allow_code_execution=True)
+            deprecation_warnings = [x for x in w if issubclass(x.category, DeprecationWarning)]
+            msgs = [str(x.message) for x in deprecation_warnings]
+            assert any("allow_code_execution" in m for m in msgs), f"Expected allow_code_execution deprecation, got: {msgs}"
+
+    def test_code_execution_mode_unsafe_warns(self):
+        """code_execution_mode='unsafe' should emit DeprecationWarning."""
+        from praisonaiagents import Agent
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            agent = Agent(name="test", instructions="test", code_execution_mode="unsafe")
+            deprecation_warnings = [x for x in w if issubclass(x.category, DeprecationWarning)]
+            msgs = [str(x.message) for x in deprecation_warnings]
+            assert any("code_execution_mode" in m for m in msgs), f"Expected code_execution_mode deprecation, got: {msgs}"
+
+    def test_code_execution_mode_safe_no_warn(self):
+        """code_execution_mode='safe' (default) should NOT emit DeprecationWarning."""
+        from praisonaiagents import Agent
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            agent = Agent(name="test", instructions="test", code_execution_mode="safe")
+            deprecation_warnings = [x for x in w if issubclass(x.category, DeprecationWarning)]
+            msgs = [str(x.message) for x in deprecation_warnings]
+            assert not any("code_execution_mode" in m for m in msgs), f"Unexpected code_execution_mode deprecation for default 'safe'"
+
+    def test_auto_save_warns(self):
+        """auto_save='session' should emit DeprecationWarning."""
+        from praisonaiagents import Agent
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            agent = Agent(name="test", instructions="test", auto_save="my_session")
+            deprecation_warnings = [x for x in w if issubclass(x.category, DeprecationWarning)]
+            msgs = [str(x.message) for x in deprecation_warnings]
+            assert any("auto_save" in m for m in msgs), f"Expected auto_save deprecation, got: {msgs}"
+
+    def test_rate_limiter_warns(self):
+        """rate_limiter=obj should emit DeprecationWarning."""
+        from praisonaiagents import Agent
+
+        class FakeLimiter:
+            def acquire(self): pass
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            agent = Agent(name="test", instructions="test", rate_limiter=FakeLimiter())
+            deprecation_warnings = [x for x in w if issubclass(x.category, DeprecationWarning)]
+            msgs = [str(x.message) for x in deprecation_warnings]
+            assert any("rate_limiter" in m for m in msgs), f"Expected rate_limiter deprecation, got: {msgs}"
+
+    def test_verification_hooks_warns(self):
+        """verification_hooks=[...] should emit DeprecationWarning."""
+        from praisonaiagents import Agent
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            agent = Agent(name="test", instructions="test", verification_hooks=["hook1"])
+            deprecation_warnings = [x for x in w if issubclass(x.category, DeprecationWarning)]
+            msgs = [str(x.message) for x in deprecation_warnings]
+            assert any("verification_hooks" in m for m in msgs), f"Expected verification_hooks deprecation, got: {msgs}"
+
+    def test_no_deprecation_on_clean_usage(self):
+        """Clean usage (no deprecated params) should NOT emit DeprecationWarning."""
+        from praisonaiagents import Agent
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            agent = Agent(name="test", instructions="test")
+            deprecation_warnings = [x for x in w if issubclass(x.category, DeprecationWarning)]
+            # Filter out llm= deprecation which is a separate concern
+            non_llm = [x for x in deprecation_warnings if "llm" not in str(x.message).lower()]
+            assert len(non_llm) == 0, f"Unexpected deprecation warnings: {[str(x.message) for x in non_llm]}"
+
+
+class TestNewConfigFields:
+    """Test new fields on config dataclasses."""
+
+    def test_execution_config_code_execution_field(self):
+        """ExecutionConfig should have code_execution field."""
+        from praisonaiagents.config.feature_configs import ExecutionConfig
+        config = ExecutionConfig(code_execution=True, code_mode="unsafe")
+        assert config.code_execution is True
+        assert config.code_mode == "unsafe"
+
+    def test_execution_config_rate_limiter_field(self):
+        """ExecutionConfig should have rate_limiter field."""
+        from praisonaiagents.config.feature_configs import ExecutionConfig
+
+        class FakeLimiter:
+            def acquire(self): pass
+
+        limiter = FakeLimiter()
+        config = ExecutionConfig(rate_limiter=limiter)
+        assert config.rate_limiter is limiter
+
+    def test_execution_config_defaults(self):
+        """ExecutionConfig defaults should be safe."""
+        from praisonaiagents.config.feature_configs import ExecutionConfig
+        config = ExecutionConfig()
+        assert config.code_execution is False
+        assert config.code_mode == "safe"
+        assert config.rate_limiter is None
+
+    def test_execution_config_to_dict(self):
+        """ExecutionConfig.to_dict() should include code_execution and code_mode."""
+        from praisonaiagents.config.feature_configs import ExecutionConfig
+        config = ExecutionConfig(code_execution=True, code_mode="unsafe")
+        d = config.to_dict()
+        assert d["code_execution"] is True
+        assert d["code_mode"] == "unsafe"
+
+    def test_memory_config_auto_save_field(self):
+        """MemoryConfig should have auto_save field."""
+        from praisonaiagents.config.feature_configs import MemoryConfig
+        config = MemoryConfig(auto_save="my_session")
+        assert config.auto_save == "my_session"
+
+    def test_memory_config_auto_save_default(self):
+        """MemoryConfig.auto_save should default to None."""
+        from praisonaiagents.config.feature_configs import MemoryConfig
+        config = MemoryConfig()
+        assert config.auto_save is None
+
+    def test_memory_config_to_dict_includes_auto_save(self):
+        """MemoryConfig.to_dict() should include auto_save."""
+        from praisonaiagents.config.feature_configs import MemoryConfig
+        config = MemoryConfig(auto_save="bot_session")
+        d = config.to_dict()
+        assert d["auto_save"] == "bot_session"
+
+    def test_autonomy_config_verification_hooks_field(self):
+        """AutonomyConfig should have verification_hooks field."""
+        from praisonaiagents.agent.autonomy import AutonomyConfig
+        hooks = ["hook1", "hook2"]
+        config = AutonomyConfig(verification_hooks=hooks)
+        assert config.verification_hooks == hooks
+
+    def test_autonomy_config_verification_hooks_default(self):
+        """AutonomyConfig.verification_hooks should default to None."""
+        from praisonaiagents.agent.autonomy import AutonomyConfig
+        config = AutonomyConfig()
+        assert config.verification_hooks is None
+
+    def test_autonomy_config_from_dict_verification_hooks(self):
+        """AutonomyConfig.from_dict() should extract verification_hooks."""
+        from praisonaiagents.agent.autonomy import AutonomyConfig
+        hooks = ["hook_a"]
+        config = AutonomyConfig.from_dict({"verification_hooks": hooks})
+        assert config.verification_hooks == hooks
+
+
+class TestConsolidatedExtraction:
+    """Test that config fields are extracted into Agent attributes."""
+
+    def test_execution_config_code_execution_sets_attribute(self):
+        """Agent(execution=ExecutionConfig(code_execution=True)) should set allow_code_execution."""
+        from praisonaiagents import Agent
+        from praisonaiagents.config.feature_configs import ExecutionConfig
+        with warnings.catch_warnings(record=True):
+            warnings.simplefilter("always")
+            agent = Agent(
+                name="test",
+                instructions="test",
+                execution=ExecutionConfig(code_execution=True, code_mode="unsafe"),
+            )
+        assert agent.allow_code_execution is True
+        assert agent.code_execution_mode == "unsafe"
+
+    def test_execution_config_rate_limiter_sets_attribute(self):
+        """Agent(execution=ExecutionConfig(rate_limiter=obj)) should set _rate_limiter."""
+        from praisonaiagents import Agent
+        from praisonaiagents.config.feature_configs import ExecutionConfig
+
+        class FakeLimiter:
+            def acquire(self): pass
+
+        limiter = FakeLimiter()
+        with warnings.catch_warnings(record=True):
+            warnings.simplefilter("always")
+            agent = Agent(
+                name="test",
+                instructions="test",
+                execution=ExecutionConfig(rate_limiter=limiter),
+            )
+        assert agent._rate_limiter is limiter
+
+    def test_autonomy_config_verification_hooks_sets_attribute(self):
+        """Agent(autonomy=AutonomyConfig(verification_hooks=[...])) should set _verification_hooks."""
+        from praisonaiagents import Agent
+        from praisonaiagents.agent.autonomy import AutonomyConfig
+        hooks = ["hook1"]
+        with warnings.catch_warnings(record=True):
+            warnings.simplefilter("always")
+            agent = Agent(
+                name="test",
+                instructions="test",
+                autonomy=AutonomyConfig(verification_hooks=hooks),
+            )
+        assert agent._verification_hooks == hooks
+
+
+class TestBackwardCompatibility:
+    """Test that deprecated params still work (no breakage)."""
+
+    def test_allow_delegation_still_stored(self):
+        """allow_delegation should still be stored on Agent."""
+        from praisonaiagents import Agent
+        with warnings.catch_warnings(record=True):
+            warnings.simplefilter("always")
+            agent = Agent(name="test", instructions="test", allow_delegation=True)
+        assert agent.allow_delegation is True
+
+    def test_allow_code_execution_still_stored(self):
+        """allow_code_execution should still be stored on Agent."""
+        from praisonaiagents import Agent
+        with warnings.catch_warnings(record=True):
+            warnings.simplefilter("always")
+            agent = Agent(name="test", instructions="test", allow_code_execution=True)
+        assert agent.allow_code_execution is True
+
+    def test_auto_save_still_stored(self):
+        """auto_save should still be stored on Agent."""
+        from praisonaiagents import Agent
+        with warnings.catch_warnings(record=True):
+            warnings.simplefilter("always")
+            agent = Agent(name="test", instructions="test", auto_save="session1")
+        assert agent.auto_save == "session1"
+
+    def test_rate_limiter_still_stored(self):
+        """rate_limiter should still be stored on Agent."""
+        from praisonaiagents import Agent
+
+        class FakeLimiter:
+            def acquire(self): pass
+
+        limiter = FakeLimiter()
+        with warnings.catch_warnings(record=True):
+            warnings.simplefilter("always")
+            agent = Agent(name="test", instructions="test", rate_limiter=limiter)
+        assert agent._rate_limiter is limiter
+
+    def test_verification_hooks_still_stored(self):
+        """verification_hooks should still be stored on Agent."""
+        from praisonaiagents import Agent
+        hooks = ["hook1"]
+        with warnings.catch_warnings(record=True):
+            warnings.simplefilter("always")
+            agent = Agent(name="test", instructions="test", verification_hooks=hooks)
+        assert agent._verification_hooks == hooks
+
+
+class TestConfigPrecedence:
+    """Test that config fields take precedence over deprecated standalone params."""
+
+    def test_execution_config_overrides_standalone_code_execution(self):
+        """ExecutionConfig.code_execution should override standalone allow_code_execution."""
+        from praisonaiagents import Agent
+        from praisonaiagents.config.feature_configs import ExecutionConfig
+        with warnings.catch_warnings(record=True):
+            warnings.simplefilter("always")
+            agent = Agent(
+                name="test",
+                instructions="test",
+                allow_code_execution=False,  # deprecated standalone
+                execution=ExecutionConfig(code_execution=True),  # config takes precedence
+            )
+        assert agent.allow_code_execution is True
+
+    def test_execution_config_overrides_standalone_rate_limiter(self):
+        """ExecutionConfig.rate_limiter should override standalone rate_limiter."""
+        from praisonaiagents import Agent
+        from praisonaiagents.config.feature_configs import ExecutionConfig
+
+        class Limiter1:
+            def acquire(self): pass
+
+        class Limiter2:
+            def acquire(self): pass
+
+        old_limiter = Limiter1()
+        new_limiter = Limiter2()
+        with warnings.catch_warnings(record=True):
+            warnings.simplefilter("always")
+            agent = Agent(
+                name="test",
+                instructions="test",
+                rate_limiter=old_limiter,  # deprecated standalone
+                execution=ExecutionConfig(rate_limiter=new_limiter),  # config takes precedence
+            )
+        assert agent._rate_limiter is new_limiter
@@ -0,0 +1,186 @@
+"""Integration tests for schedule tools with Agent class.
+
+Tests that agents can use schedule tools via:
+1. Direct function references in tools list
+2. String-name resolution via TOOL_MAPPINGS
+3. Tool schema generation for LLM
+"""
+
+from unittest.mock import patch
+
+
+class TestAgentScheduleToolIntegration:
+    """Test Agent + schedule tools integration (no LLM calls)."""
+
+    def test_agent_accepts_schedule_tools_as_functions(self):
+        """Agent can be created with schedule tool functions in tools list."""
+        from praisonaiagents import Agent
+        from praisonaiagents.tools.schedule_tools import schedule_add, schedule_list, schedule_remove
+
+        agent = Agent(
+            name="test-scheduler",
+            instructions="You can set schedules.",
+            tools=[schedule_add, schedule_list, schedule_remove],
+        )
+        assert len(agent.tools) == 3
+
+    def test_agent_resolves_schedule_tool_strings(self):
+        """Agent resolves 'schedule_add' etc. from TOOL_MAPPINGS."""
+        from praisonaiagents import Agent
+
+        agent = Agent(
+            name="test-scheduler",
+            instructions="You can set schedules.",
+            tools=["schedule_add", "schedule_list", "schedule_remove"],
+        )
+        # String tool names are resolved via _resolve_tool_names → registry
+        # They may or may not resolve depending on registry state,
+        # but the tools list should be populated
+        # The key test is that Agent creation doesn't crash
+        assert agent is not None
+
+    def test_schedule_tool_schema_generation(self):
+        """Schedule tools produce valid OpenAI function schemas."""
+        from praisonaiagents.tools.schedule_tools import schedule_add, schedule_list, schedule_remove
+        from praisonaiagents.tools.decorator import get_tool_schema
+
+        for fn in [schedule_add, schedule_list, schedule_remove]:
+            schema = get_tool_schema(fn)
+            assert schema is not None
+            assert schema["type"] == "function"
+            assert "function" in schema
+            assert "name" in schema["function"]
+            assert "parameters" in schema["function"]
+
+    def test_schedule_add_schema_has_required_params(self):
+        """schedule_add schema includes name, schedule, message parameters."""
+        from praisonaiagents.tools.schedule_tools import schedule_add
+        from praisonaiagents.tools.decorator import get_tool_schema
+
+        schema = get_tool_schema(schedule_add)
+        params = schema["function"]["parameters"]
+        assert "name" in params["properties"]
+        assert "schedule" in params["properties"]
+        assert "message" in params["properties"]
+        # name and schedule are required, message has a default
+        assert "name" in params["required"]
+        assert "schedule" in params["required"]
+
+    def test_schedule_remove_schema_has_name_param(self):
+        """schedule_remove schema includes name parameter."""
+        from praisonaiagents.tools.schedule_tools import schedule_remove
+        from praisonaiagents.tools.decorator import get_tool_schema
+
+        schema = get_tool_schema(schedule_remove)
+        params = schema["function"]["parameters"]
+        assert "name" in params["properties"]
+        assert "name" in params["required"]
+
+    def test_schedule_tools_execute_via_agent_execute_tool(self, tmp_path):
+        """Agent._execute_tool_call can invoke schedule tools."""
+        from praisonaiagents import Agent
+        from praisonaiagents.tools.schedule_tools import schedule_add, schedule_list, schedule_remove
+
+        with patch('praisonaiagents.tools.schedule_tools._get_store') as mock_gs:
+            from praisonaiagents.scheduler.store import FileScheduleStore
+            mock_gs.return_value = FileScheduleStore(store_dir=str(tmp_path))
+
+            agent = Agent(
+                name="test-exec",
+                instructions="You can set schedules.",
+                tools=[schedule_add, schedule_list, schedule_remove],
+            )
+
+            # Simulate LLM calling schedule_add
+            result = agent._execute_tool_impl(
+                "schedule_add",
+                {"name": "test-job", "schedule": "hourly", "message": "Check email"},
+            )
+            assert "test-job" in str(result)
+            assert "added" in str(result).lower()
+
+            # Simulate LLM calling schedule_list
+            result = agent._execute_tool_impl("schedule_list", {})
+            assert "test-job" in str(result)
+
+            # Simulate LLM calling schedule_remove
+            result = agent._execute_tool_impl(
+                "schedule_remove", {"name": "test-job"}
+            )
+            assert "removed" in str(result).lower()
+
+    def test_end_to_end_schedule_crud(self, tmp_path):
+        """Full CRUD cycle: add → list → remove → list (empty)."""
+        from praisonaiagents.tools.schedule_tools import schedule_add, schedule_list, schedule_remove
+
+        with patch('praisonaiagents.tools.schedule_tools._get_store') as mock_gs:
+            from praisonaiagents.scheduler.store import FileScheduleStore
+            mock_gs.return_value = FileScheduleStore(store_dir=str(tmp_path))
+
+            # Add
+            r = schedule_add(name="daily-news", schedule="daily", message="Summarize AI news")
+            assert "added" in r.lower()
+
+            # List
+            r = schedule_list()
+            assert "daily-news" in r
+            assert "every 1 day" in r
+
+            # Add another
+            r = schedule_add(name="hourly-check", schedule="*/30m", message="Check inbox")
+            assert "added" in r.lower()
+
+            # List shows both
+            r = schedule_list()
+            assert "daily-news" in r
+            assert "hourly-check" in r
+            assert "2 schedule" in r
+
+            # Remove one
+            r = schedule_remove(name="daily-news")
+            assert "removed" in r.lower()
+
+            # List shows one
+            r = schedule_list()
+            assert "daily-news" not in r
+            assert "hourly-check" in r
+            assert "1 schedule" in r
+
+            # Duplicate name prevention
+            r = schedule_add(name="hourly-check", schedule="hourly", message="Dup")
+            assert "already exists" in r.lower()
+
+
+class TestScheduleToolImportPaths:
+    """Test various import paths work correctly."""
+
+    def test_import_from_tools_module(self):
+        from praisonaiagents.tools import schedule_add, schedule_list, schedule_remove
+        assert callable(schedule_add)
+        assert callable(schedule_list)
+        assert callable(schedule_remove)
+
+    def test_import_from_schedule_tools_directly(self):
+        from praisonaiagents.tools.schedule_tools import schedule_add, schedule_list, schedule_remove
+        assert callable(schedule_add)
+        assert callable(schedule_list)
+        assert callable(schedule_remove)
+
+    def test_import_scheduler_models(self):
+        from praisonaiagents.scheduler import Schedule, ScheduleJob
+        s = Schedule(kind="every", every_seconds=60)
+        j = ScheduleJob(name="test", schedule=s)
+        assert j.name == "test"
+
+    def test_import_scheduler_parser(self):
+        from praisonaiagents.scheduler import parse_schedule
+        s = parse_schedule("hourly")
+        assert s.kind == "every"
+
+    def test_import_scheduler_store(self):
+        from praisonaiagents.scheduler import FileScheduleStore
+        assert FileScheduleStore is not None
+
+    def test_import_scheduler_runner(self):
+        from praisonaiagents.scheduler import ScheduleRunner
+        assert ScheduleRunner is not None
@@ -0,0 +1,412 @@
+"""TDD tests for schedule tools — agent-centric scheduling via tools.
+
+Tests cover:
+1. Schedule models (ScheduleJob, Schedule)
+2. FileScheduleStore (CRUD + persistence)
+3. Schedule tools (schedule_add, schedule_list, schedule_remove)
+4. Schedule parser (interval, cron, at)
+5. ScheduleRunner (tick loop)
+6. Integration: agent uses schedule tools
+"""
+
+import time
+import pytest
+from unittest.mock import patch
+
+
+# ─── 1. Model Tests ──────────────────────────────────────────────────────────
+
+class TestScheduleModels:
+    """Test ScheduleJob and Schedule dataclasses."""
+
+    def test_schedule_every_creation(self):
+        from praisonaiagents.scheduler.models import Schedule
+        s = Schedule(kind="every", every_seconds=3600)
+        assert s.kind == "every"
+        assert s.every_seconds == 3600
+
+    def test_schedule_cron_creation(self):
+        from praisonaiagents.scheduler.models import Schedule
+        s = Schedule(kind="cron", cron_expr="0 7 * * *")
+        assert s.kind == "cron"
+        assert s.cron_expr == "0 7 * * *"
+
+    def test_schedule_at_creation(self):
+        from praisonaiagents.scheduler.models import Schedule
+        s = Schedule(kind="at", at="2026-03-01T09:00:00")
+        assert s.kind == "at"
+        assert s.at == "2026-03-01T09:00:00"
+
+    def test_schedule_job_creation(self):
+        from praisonaiagents.scheduler.models import ScheduleJob, Schedule
+        sched = Schedule(kind="every", every_seconds=60)
+        job = ScheduleJob(
+            name="test-job",
+            schedule=sched,
+            message="Hello world",
+        )
+        assert job.name == "test-job"
+        assert job.id  # auto-generated
+        assert job.enabled is True
+        assert job.message == "Hello world"
+
+    def test_schedule_job_to_dict_roundtrip(self):
+        from praisonaiagents.scheduler.models import ScheduleJob, Schedule
+        sched = Schedule(kind="every", every_seconds=300)
+        job = ScheduleJob(name="roundtrip", schedule=sched, message="test")
+        d = job.to_dict()
+        assert isinstance(d, dict)
+        assert d["name"] == "roundtrip"
+        assert d["schedule"]["kind"] == "every"
+        # Roundtrip
+        job2 = ScheduleJob.from_dict(d)
+        assert job2.name == job.name
+        assert job2.id == job.id
+        assert job2.schedule.every_seconds == 300
+
+    def test_schedule_job_defaults(self):
+        from praisonaiagents.scheduler.models import ScheduleJob, Schedule
+        sched = Schedule(kind="every", every_seconds=60)
+        job = ScheduleJob(name="defaults", schedule=sched)
+        assert job.enabled is True
+        assert job.message == ""
+        assert job.agent_id is None
+        assert job.session_target == "isolated"
+        assert job.delete_after_run is False
+
+
+# ─── 2. Store Tests ──────────────────────────────────────────────────────────
+
+class TestFileScheduleStore:
+    """Test FileScheduleStore CRUD and persistence."""
+
+    def _make_store(self, tmp_path):
+        from praisonaiagents.scheduler.store import FileScheduleStore
+        return FileScheduleStore(store_dir=str(tmp_path))
+
+    def _make_job(self, name="test-job"):
+        from praisonaiagents.scheduler.models import ScheduleJob, Schedule
+        return ScheduleJob(
+            name=name,
+            schedule=Schedule(kind="every", every_seconds=60),
+            message="test message",
+        )
+
+    def test_add_and_get(self, tmp_path):
+        store = self._make_store(tmp_path)
+        job = self._make_job()
+        store.add(job)
+        retrieved = store.get(job.id)
+        assert retrieved is not None
+        assert retrieved.name == "test-job"
+
+    def test_add_duplicate_id_raises(self, tmp_path):
+        store = self._make_store(tmp_path)
+        job = self._make_job()
+        store.add(job)
+        with pytest.raises(ValueError, match="already exists"):
+            store.add(job)
+
+    def test_list_all(self, tmp_path):
+        store = self._make_store(tmp_path)
+        store.add(self._make_job("job-1"))
+        store.add(self._make_job("job-2"))
+        jobs = store.list()
+        assert len(jobs) == 2
+
+    def test_list_by_agent_id(self, tmp_path):
+        from praisonaiagents.scheduler.models import ScheduleJob, Schedule
+        store = self._make_store(tmp_path)
+        j1 = ScheduleJob(name="a", schedule=Schedule(kind="every", every_seconds=60), agent_id="agent-1")
+        j2 = ScheduleJob(name="b", schedule=Schedule(kind="every", every_seconds=60), agent_id="agent-2")
+        store.add(j1)
+        store.add(j2)
+        assert len(store.list(agent_id="agent-1")) == 1
+
+    def test_remove(self, tmp_path):
+        store = self._make_store(tmp_path)
+        job = self._make_job()
+        store.add(job)
+        assert store.remove(job.id) is True
+        assert store.get(job.id) is None
+
+    def test_remove_nonexistent(self, tmp_path):
+        store = self._make_store(tmp_path)
+        assert store.remove("nonexistent") is False
+
+    def test_persistence_across_instances(self, tmp_path):
+        store1 = self._make_store(tmp_path)
+        job = self._make_job()
+        store1.add(job)
+
+        # New store instance reads from same dir
+        store2 = self._make_store(tmp_path)
+        retrieved = store2.get(job.id)
+        assert retrieved is not None
+        assert retrieved.name == "test-job"
+
+    def test_update(self, tmp_path):
+        store = self._make_store(tmp_path)
+        job = self._make_job()
+        store.add(job)
+        job.enabled = False
+        store.update(job)
+        retrieved = store.get(job.id)
+        assert retrieved.enabled is False
+
+    def test_empty_store_list(self, tmp_path):
+        store = self._make_store(tmp_path)
+        assert store.list() == []
+
+
+# ─── 3. Parser Tests ─────────────────────────────────────────────────────────
+
+class TestScheduleParser:
+    """Test schedule expression parsing."""
+
+    def test_parse_hourly(self):
+        from praisonaiagents.scheduler.parser import parse_schedule
+        s = parse_schedule("hourly")
+        assert s.kind == "every"
+        assert s.every_seconds == 3600
+
+    def test_parse_daily(self):
+        from praisonaiagents.scheduler.parser import parse_schedule
+        s = parse_schedule("daily")
+        assert s.kind == "every"
+        assert s.every_seconds == 86400
+
+    def test_parse_interval_minutes(self):
+        from praisonaiagents.scheduler.parser import parse_schedule
+        s = parse_schedule("*/30m")
+        assert s.kind == "every"
+        assert s.every_seconds == 1800
+
+    def test_parse_interval_hours(self):
+        from praisonaiagents.scheduler.parser import parse_schedule
+        s = parse_schedule("*/6h")
+        assert s.kind == "every"
+        assert s.every_seconds == 21600
+
+    def test_parse_interval_seconds(self):
+        from praisonaiagents.scheduler.parser import parse_schedule
+        s = parse_schedule("*/10s")
+        assert s.kind == "every"
+        assert s.every_seconds == 10
+
+    def test_parse_cron_expression(self):
+        from praisonaiagents.scheduler.parser import parse_schedule
+        s = parse_schedule("cron:0 7 * * *")
+        assert s.kind == "cron"
+        assert s.cron_expr == "0 7 * * *"
+
+    def test_parse_at_iso(self):
+        from praisonaiagents.scheduler.parser import parse_schedule
+        s = parse_schedule("at:2026-03-01T09:00:00")
+        assert s.kind == "at"
+        assert s.at == "2026-03-01T09:00:00"
+
+    def test_parse_numeric_seconds(self):
+        from praisonaiagents.scheduler.parser import parse_schedule
+        s = parse_schedule("3600")
+        assert s.kind == "every"
+        assert s.every_seconds == 3600
+
+    def test_parse_relative_minutes(self):
+        from praisonaiagents.scheduler.parser import parse_schedule
+        s = parse_schedule("in 20 minutes")
+        assert s.kind == "at"
+        assert s.at is not None  # Should be an ISO timestamp ~20min from now
+
+    def test_parse_invalid_raises(self):
+        from praisonaiagents.scheduler.parser import parse_schedule
+        with pytest.raises(ValueError):
+            parse_schedule("")
+
+
+# ─── 4. Schedule Tool Tests ──────────────────────────────────────────────────
+
+class TestScheduleTools:
+    """Test schedule_add, schedule_list, schedule_remove tool functions."""
+
+    def test_schedule_add_returns_confirmation(self, tmp_path):
+        from praisonaiagents.tools.schedule_tools import schedule_add
+        with patch('praisonaiagents.tools.schedule_tools._get_store') as mock_gs:
+            from praisonaiagents.scheduler.store import FileScheduleStore
+            mock_gs.return_value = FileScheduleStore(store_dir=str(tmp_path))
+            result = schedule_add(name="test-reminder", schedule="hourly", message="Check email")
+        assert "test-reminder" in result
+        assert "scheduled" in result.lower() or "added" in result.lower()
+
+    def test_schedule_list_returns_jobs(self, tmp_path):
+        from praisonaiagents.tools.schedule_tools import schedule_list, schedule_add
+        with patch('praisonaiagents.tools.schedule_tools._get_store') as mock_gs:
+            from praisonaiagents.scheduler.store import FileScheduleStore
+            store = FileScheduleStore(store_dir=str(tmp_path))
+            mock_gs.return_value = store
+            schedule_add(name="job-1", schedule="hourly", message="Task 1")
+            schedule_add(name="job-2", schedule="daily", message="Task 2")
+            result = schedule_list()
+        assert "job-1" in result
+        assert "job-2" in result
+
+    def test_schedule_remove_returns_confirmation(self, tmp_path):
+        from praisonaiagents.tools.schedule_tools import schedule_add, schedule_remove
+        with patch('praisonaiagents.tools.schedule_tools._get_store') as mock_gs:
+            from praisonaiagents.scheduler.store import FileScheduleStore
+            store = FileScheduleStore(store_dir=str(tmp_path))
+            mock_gs.return_value = store
+            schedule_add(name="to-remove", schedule="hourly", message="Temp")
+            result = schedule_remove(name="to-remove")
+        assert "removed" in result.lower() or "deleted" in result.lower()
+
+    def test_schedule_remove_nonexistent(self, tmp_path):
+        from praisonaiagents.tools.schedule_tools import schedule_remove
+        with patch('praisonaiagents.tools.schedule_tools._get_store') as mock_gs:
+            from praisonaiagents.scheduler.store import FileScheduleStore
+            mock_gs.return_value = FileScheduleStore(store_dir=str(tmp_path))
+            result = schedule_remove(name="nonexistent")
+        assert "not found" in result.lower()
+
+    def test_schedule_list_empty(self, tmp_path):
+        from praisonaiagents.tools.schedule_tools import schedule_list
+        with patch('praisonaiagents.tools.schedule_tools._get_store') as mock_gs:
+            from praisonaiagents.scheduler.store import FileScheduleStore
+            mock_gs.return_value = FileScheduleStore(store_dir=str(tmp_path))
+            result = schedule_list()
+        assert "no schedule" in result.lower() or "empty" in result.lower() or "0" in result
+
+
+# ─── 5. Runner Tests ─────────────────────────────────────────────────────────
+
+class TestScheduleRunner:
+    """Test ScheduleRunner tick loop."""
+
+    def test_runner_creation(self, tmp_path):
+        from praisonaiagents.scheduler.runner import ScheduleRunner
+        from praisonaiagents.scheduler.store import FileScheduleStore
+        store = FileScheduleStore(store_dir=str(tmp_path))
+        runner = ScheduleRunner(store=store)
+        assert runner is not None
+
+    def test_get_due_jobs_interval(self, tmp_path):
+        from praisonaiagents.scheduler.runner import ScheduleRunner
+        from praisonaiagents.scheduler.store import FileScheduleStore
+        from praisonaiagents.scheduler.models import ScheduleJob, Schedule
+        store = FileScheduleStore(store_dir=str(tmp_path))
+        # Job with 1-second interval, last_run 10 seconds ago
+        job = ScheduleJob(
+            name="due-job",
+            schedule=Schedule(kind="every", every_seconds=1),
+            message="test",
+        )
+        job.last_run_at = time.time() - 10  # Ran 10s ago, interval is 1s → due
+        store.add(job)
+        runner = ScheduleRunner(store=store)
+        due = runner.get_due_jobs()
+        assert len(due) == 1
+        assert due[0].name == "due-job"
+
+    def test_get_due_jobs_not_yet(self, tmp_path):
+        from praisonaiagents.scheduler.runner import ScheduleRunner
+        from praisonaiagents.scheduler.store import FileScheduleStore
+        from praisonaiagents.scheduler.models import ScheduleJob, Schedule
+        store = FileScheduleStore(store_dir=str(tmp_path))
+        job = ScheduleJob(
+            name="not-due",
+            schedule=Schedule(kind="every", every_seconds=9999),
+            message="test",
+        )
+        job.last_run_at = time.time()  # Just ran
+        store.add(job)
+        runner = ScheduleRunner(store=store)
+        due = runner.get_due_jobs()
+        assert len(due) == 0
+
+    def test_get_due_jobs_at_past(self, tmp_path):
+        """One-shot 'at' jobs in the past should be due."""
+        from praisonaiagents.scheduler.runner import ScheduleRunner
+        from praisonaiagents.scheduler.store import FileScheduleStore
+        from praisonaiagents.scheduler.models import ScheduleJob, Schedule
+        store = FileScheduleStore(store_dir=str(tmp_path))
+        past = "2020-01-01T00:00:00"
+        job = ScheduleJob(
+            name="past-at",
+            schedule=Schedule(kind="at", at=past),
+            message="test",
+        )
+        store.add(job)
+        runner = ScheduleRunner(store=store)
+        due = runner.get_due_jobs()
+        assert len(due) == 1
+
+    def test_disabled_job_not_due(self, tmp_path):
+        from praisonaiagents.scheduler.runner import ScheduleRunner
+        from praisonaiagents.scheduler.store import FileScheduleStore
+        from praisonaiagents.scheduler.models import ScheduleJob, Schedule
+        store = FileScheduleStore(store_dir=str(tmp_path))
+        job = ScheduleJob(
+            name="disabled",
+            schedule=Schedule(kind="every", every_seconds=1),
+            message="test",
+            enabled=False,
+        )
+        store.add(job)
+        runner = ScheduleRunner(store=store)
+        due = runner.get_due_jobs()
+        assert len(due) == 0
+
+
+# ─── 6. Hook Event Tests ─────────────────────────────────────────────────────
+
+class TestScheduleHookEvents:
+    """Test that scheduling hook events exist."""
+
+    def test_schedule_hook_events_exist(self):
+        from praisonaiagents.hooks.types import HookEvent
+        assert hasattr(HookEvent, 'SCHEDULE_ADD')
+        assert hasattr(HookEvent, 'SCHEDULE_REMOVE')
+        assert hasattr(HookEvent, 'SCHEDULE_TRIGGER')
+
+    def test_schedule_hook_event_values(self):
+        from praisonaiagents.hooks.types import HookEvent
+        assert HookEvent.SCHEDULE_ADD.value == "schedule_add"
+        assert HookEvent.SCHEDULE_REMOVE.value == "schedule_remove"
+        assert HookEvent.SCHEDULE_TRIGGER.value == "schedule_trigger"
+
+
+# ─── 7. Lazy Import Tests ────────────────────────────────────────────────────
+
+class TestLazyImport:
+    """Ensure schedule tools don't impact import time."""
+
+    def test_praisonaiagents_import_no_scheduler(self):
+        """Importing praisonaiagents should NOT load scheduler module."""
+        # We verify by checking TOOL_MAPPINGS references lazy paths
+        from praisonaiagents.tools import TOOL_MAPPINGS
+        for key in ['schedule_add', 'schedule_list', 'schedule_remove']:
+            assert key in TOOL_MAPPINGS
+            module_path, _ = TOOL_MAPPINGS[key]
+            assert module_path == '.schedule_tools'
+
+
+# ─── 8. TOOL_MAPPINGS Registration Test ──────────────────────────────────────
+
+class TestToolMappings:
+    """Test schedule tools are registered in TOOL_MAPPINGS for string-name resolution."""
+
+    def test_schedule_tools_in_mappings(self):
+        from praisonaiagents.tools import TOOL_MAPPINGS
+        assert 'schedule_add' in TOOL_MAPPINGS
+        assert 'schedule_list' in TOOL_MAPPINGS
+        assert 'schedule_remove' in TOOL_MAPPINGS
+
+    def test_schedule_tools_lazy_loadable(self):
+        """Verify tools can be lazy-loaded via __getattr__."""
+        from praisonaiagents import tools
+        schedule_add = getattr(tools, 'schedule_add')
+        assert callable(schedule_add)
+        schedule_list = getattr(tools, 'schedule_list')
+        assert callable(schedule_list)
+        schedule_remove = getattr(tools, 'schedule_remove')
+        assert callable(schedule_remove)
@@ -0,0 +1,443 @@
+"""Unit tests for WhatsApp Bot implementation."""
+
+import sys
+import os
+import asyncio
+import json
+import time
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', '..', 'praisonai'))
+
+import pytest
+
+
+class MockAgent:
+    def __init__(self, name="test-agent", llm="gpt-4o-mini"):
+        self.name = name
+        self.llm = llm
+        self.chat_history = []
+
+    def chat(self, prompt):
+        return f"Reply: {prompt}"
+
+
+# ── Bot Creation ────────────────────────────────────────────────
+
+class TestWhatsAppBotCreation:
+    """Test WhatsAppBot instantiation and configuration."""
+
+    def _make_bot(self, **kwargs):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        defaults = dict(
+            token="fake-access-token",
+            phone_number_id="123456789",
+            agent=MockAgent(),
+            verify_token="test-verify",
+        )
+        defaults.update(kwargs)
+        return WhatsAppBot(**defaults)
+
+    def test_create_basic(self):
+        bot = self._make_bot()
+        assert bot._token == "fake-access-token"
+        assert bot._phone_number_id == "123456789"
+        assert bot._verify_token == "test-verify"
+        assert bot._webhook_port == 8080
+
+    def test_create_custom_port(self):
+        bot = self._make_bot(webhook_port=9090)
+        assert bot._webhook_port == 9090
+
+    def test_create_custom_webhook_path(self):
+        bot = self._make_bot(webhook_path="/custom/webhook")
+        assert bot._webhook_path == "/custom/webhook"
+
+    def test_platform_property(self):
+        bot = self._make_bot()
+        assert bot.platform == "whatsapp"
+
+    def test_is_running_initial(self):
+        bot = self._make_bot()
+        assert bot.is_running is False
+
+    def test_bot_user_initial(self):
+        bot = self._make_bot()
+        assert bot.bot_user is None
+
+    def test_set_agent(self):
+        bot = self._make_bot()
+        new_agent = MockAgent(name="new-agent")
+        bot.set_agent(new_agent)
+        assert bot.get_agent().name == "new-agent"
+
+    def test_get_agent(self):
+        agent = MockAgent(name="my-agent")
+        bot = self._make_bot(agent=agent)
+        assert bot.get_agent() is agent
+
+    def test_env_var_fallback(self, monkeypatch):
+        monkeypatch.setenv("WHATSAPP_PHONE_NUMBER_ID", "env-phone-id")
+        monkeypatch.setenv("WHATSAPP_VERIFY_TOKEN", "env-verify")
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(token="test-token", agent=MockAgent())
+        assert bot._phone_number_id == "env-phone-id"
+        assert bot._verify_token == "env-verify"
+
+
+# ── Commands ────────────────────────────────────────────────────
+
+class TestWhatsAppBotCommands:
+    """Test built-in command registration."""
+
+    def _make_bot(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        return WhatsAppBot(
+            token="fake-token",
+            phone_number_id="123",
+            agent=MockAgent(),
+            verify_token="test",
+        )
+
+    def test_builtin_commands_registered(self):
+        bot = self._make_bot()
+        commands = bot.list_commands()
+        names = [c.name for c in commands]
+        assert "status" in names
+        assert "new" in names
+        assert "help" in names
+
+    def test_register_custom_command(self):
+        bot = self._make_bot()
+        bot.register_command("ping", lambda m: "pong", description="Ping test")
+        commands = bot.list_commands()
+        names = [c.name for c in commands]
+        assert "ping" in names
+
+    def test_on_command_decorator(self):
+        bot = self._make_bot()
+
+        @bot.on_command("test")
+        async def test_cmd(msg):
+            return "test response"
+
+        assert "test" in bot._command_handlers
+
+    def test_on_message_handler(self):
+        bot = self._make_bot()
+
+        @bot.on_message
+        async def handle(msg):
+            pass
+
+        assert len(bot._message_handlers) == 1
+
+
+# ── Webhook Verification ────────────────────────────────────────
+
+class TestWebhookVerification:
+    """Test Meta webhook verification endpoint."""
+
+    def _make_bot(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        return WhatsAppBot(
+            token="fake-token",
+            phone_number_id="123",
+            agent=MockAgent(),
+            verify_token="my-secret-token",
+        )
+
+    @pytest.mark.asyncio
+    async def test_verification_success(self):
+        bot = self._make_bot()
+
+        class FakeRequest:
+            query = {
+                "hub.mode": "subscribe",
+                "hub.verify_token": "my-secret-token",
+                "hub.challenge": "challenge123",
+            }
+
+        resp = await bot._handle_verification(FakeRequest())
+        assert resp.status == 200
+        assert resp.text == "challenge123"
+
+    @pytest.mark.asyncio
+    async def test_verification_wrong_token(self):
+        bot = self._make_bot()
+
+        class FakeRequest:
+            query = {
+                "hub.mode": "subscribe",
+                "hub.verify_token": "wrong-token",
+                "hub.challenge": "challenge123",
+            }
+
+        resp = await bot._handle_verification(FakeRequest())
+        assert resp.status == 403
+
+    @pytest.mark.asyncio
+    async def test_verification_wrong_mode(self):
+        bot = self._make_bot()
+
+        class FakeRequest:
+            query = {
+                "hub.mode": "unsubscribe",
+                "hub.verify_token": "my-secret-token",
+                "hub.challenge": "challenge123",
+            }
+
+        resp = await bot._handle_verification(FakeRequest())
+        assert resp.status == 403
+
+
+# ── Health Endpoint ─────────────────────────────────────────────
+
+class TestHealthEndpoint:
+    """Test health check endpoint."""
+
+    @pytest.mark.asyncio
+    async def test_health_not_running(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(
+            token="t", phone_number_id="p", agent=MockAgent(), verify_token="v"
+        )
+        resp = await bot._handle_health(None)
+        data = json.loads(resp.body)
+        assert data["platform"] == "whatsapp"
+        assert data["is_running"] is False
+
+    @pytest.mark.asyncio
+    async def test_health_running(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(
+            token="t", phone_number_id="p", agent=MockAgent(), verify_token="v"
+        )
+        bot._is_running = True
+        bot._started_at = time.time() - 60
+        resp = await bot._handle_health(None)
+        data = json.loads(resp.body)
+        assert data["is_running"] is True
+        assert data["uptime"] >= 59
+
+
+# ── Signature Verification ──────────────────────────────────────
+
+class TestSignatureVerification:
+    """Test webhook signature verification."""
+
+    def _make_bot(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        return WhatsAppBot(
+            token="t",
+            phone_number_id="p",
+            agent=MockAgent(),
+            verify_token="v",
+            app_secret="my-app-secret",
+        )
+
+    def test_valid_signature(self):
+        import hmac
+        import hashlib
+        bot = self._make_bot()
+        body = b'{"test": "data"}'
+        sig = "sha256=" + hmac.new(
+            b"my-app-secret", body, hashlib.sha256
+        ).hexdigest()
+        assert bot._verify_signature(body, sig) is True
+
+    def test_invalid_signature(self):
+        bot = self._make_bot()
+        assert bot._verify_signature(b"body", "sha256=invalid") is False
+
+    def test_missing_prefix(self):
+        bot = self._make_bot()
+        assert bot._verify_signature(b"body", "invalid") is False
+
+
+# ── Message Processing ──────────────────────────────────────────
+
+class TestMessageProcessing:
+    """Test incoming message processing."""
+
+    def _make_bot(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        return WhatsAppBot(
+            token="t", phone_number_id="p", agent=MockAgent(), verify_token="v"
+        )
+
+    @pytest.mark.asyncio
+    async def test_process_text_message(self):
+        bot = self._make_bot()
+        sent_messages = []
+
+        async def mock_send(to, content, **kwargs):
+            sent_messages.append((to, content))
+            from praisonaiagents.bots import BotMessage
+            return BotMessage(content=content)
+        bot.send_message = mock_send
+
+        data = {
+            "entry": [{
+                "changes": [{
+                    "value": {
+                        "contacts": [{"profile": {"name": "Test User"}}],
+                        "messages": [{
+                            "from": "1234567890",
+                            "id": "msg-1",
+                            "type": "text",
+                            "text": {"body": "Hello bot"},
+                            "timestamp": str(int(time.time())),
+                        }],
+                    }
+                }]
+            }]
+        }
+
+        await bot._process_webhook_data(data)
+        # Give async task time to complete
+        await asyncio.sleep(0.1)
+        assert len(sent_messages) == 1
+        assert sent_messages[0][0] == "1234567890"
+        assert "Reply:" in sent_messages[0][1]
+
+    @pytest.mark.asyncio
+    async def test_process_command_message(self):
+        bot = self._make_bot()
+        sent_messages = []
+
+        async def mock_send(to, content, **kwargs):
+            sent_messages.append((to, content))
+            from praisonaiagents.bots import BotMessage
+            return BotMessage(content=content)
+        bot.send_message = mock_send
+
+        data = {
+            "entry": [{
+                "changes": [{
+                    "value": {
+                        "contacts": [{"profile": {"name": "Test User"}}],
+                        "messages": [{
+                            "from": "1234567890",
+                            "id": "msg-2",
+                            "type": "text",
+                            "text": {"body": "/help"},
+                            "timestamp": str(int(time.time())),
+                        }],
+                    }
+                }]
+            }]
+        }
+
+        await bot._process_webhook_data(data)
+        await asyncio.sleep(0.1)
+        assert len(sent_messages) == 1
+        assert "Available Commands" in sent_messages[0][1]
+
+    @pytest.mark.asyncio
+    async def test_process_location_message(self):
+        bot = self._make_bot()
+        sent_messages = []
+
+        async def mock_send(to, content, **kwargs):
+            sent_messages.append((to, content))
+            from praisonaiagents.bots import BotMessage
+            return BotMessage(content=content)
+        bot.send_message = mock_send
+
+        data = {
+            "entry": [{
+                "changes": [{
+                    "value": {
+                        "contacts": [{"profile": {"name": "Test"}}],
+                        "messages": [{
+                            "from": "111",
+                            "id": "msg-3",
+                            "type": "location",
+                            "location": {"latitude": 37.7749, "longitude": -122.4194},
+                            "timestamp": str(int(time.time())),
+                        }],
+                    }
+                }]
+            }]
+        }
+
+        await bot._process_webhook_data(data)
+        await asyncio.sleep(0.1)
+        assert len(sent_messages) == 1
+        assert "Location:" in sent_messages[0][1] or "Reply:" in sent_messages[0][1]
+
+    @pytest.mark.asyncio
+    async def test_process_empty_entry(self):
+        """Empty entry should not crash."""
+        bot = self._make_bot()
+        await bot._process_webhook_data({"entry": []})
+
+    @pytest.mark.asyncio
+    async def test_process_no_messages(self):
+        """Entry with no messages should not crash."""
+        bot = self._make_bot()
+        await bot._process_webhook_data({
+            "entry": [{"changes": [{"value": {}}]}]
+        })
+
+
+# ── Session Management ──────────────────────────────────────────
+
+class TestWhatsAppSession:
+    """Test session isolation."""
+
+    @pytest.mark.asyncio
+    async def test_new_command_resets_session(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(
+            token="t", phone_number_id="p", agent=MockAgent(), verify_token="v"
+        )
+        # Manually add a session entry
+        bot._session_mgr._histories["user1"] = [{"role": "user", "content": "hi"}]
+        assert bot._session_mgr.active_sessions == 1
+
+        # Invoke /new handler
+        handler = bot._command_handlers["new"]
+        from praisonaiagents.bots import BotMessage, BotUser
+        msg = BotMessage(
+            sender=BotUser(user_id="user1"),
+            content="/new",
+        )
+        result = await handler(msg)
+        assert "reset" in result.lower()
+        assert bot._session_mgr.active_sessions == 0
+
+
+# ── Convenience Methods ─────────────────────────────────────────
+
+class TestConvenienceMethods:
+    """Test edit_message, delete_message, send_typing, etc."""
+
+    def _make_bot(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        return WhatsAppBot(
+            token="t", phone_number_id="p", agent=MockAgent(), verify_token="v"
+        )
+
+    @pytest.mark.asyncio
+    async def test_delete_returns_false(self):
+        bot = self._make_bot()
+        assert await bot.delete_message("ch", "msg") is False
+
+    @pytest.mark.asyncio
+    async def test_send_typing_noop(self):
+        bot = self._make_bot()
+        await bot.send_typing("ch")  # should not raise
+
+    @pytest.mark.asyncio
+    async def test_get_user(self):
+        bot = self._make_bot()
+        user = await bot.get_user("12345")
+        assert user.user_id == "12345"
+
+    @pytest.mark.asyncio
+    async def test_get_channel(self):
+        bot = self._make_bot()
+        ch = await bot.get_channel("12345")
+        assert ch.channel_id == "12345"
+        assert ch.channel_type == "dm"
@@ -0,0 +1,819 @@
+"""
+Comprehensive tests for WhatsApp message filtering feature.
+
+Tests cover:
+- Constructor parameter handling (allowed_numbers, allowed_groups, respond_to_all)
+- Phone number normalization
+- Filtering logic in _on_web_message (self-only, allowlists, respond_to_all)
+- CLI flag parsing and wiring
+- YAML config wiring
+- Edge cases
+"""
+
+import os
+import sys
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest  # noqa: F401 — used by test discovery
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..", "..", "praisonai"))
+
+
+# ── Helpers ──────────────────────────────────────────────────────
+
+def _make_bot(**kwargs):
+    """Create a WhatsAppBot in web mode with filtering kwargs."""
+    from praisonai.bots.whatsapp import WhatsAppBot
+    defaults = dict(mode="web")
+    defaults.update(kwargs)
+    return WhatsAppBot(**defaults)
+
+
+def _make_neonize_event(
+    is_from_me=False,
+    is_group=False,
+    sender="[email protected]",
+    chat="[email protected]",
+    text="hello",
+    timestamp=None,
+):
+    """Create a mock neonize MessageEv with MessageSource fields.
+
+    Args:
+        timestamp: Epoch seconds (float). If *None* defaults to
+                   ``time.time()`` so the event looks "fresh".
+    """
+    import time as _time
+    event = MagicMock()
+    event.Info.MessageSource.IsFromMe = is_from_me
+    event.Info.MessageSource.IsGroup = is_group
+    event.Info.MessageSource.Sender = MagicMock()
+    event.Info.MessageSource.Sender.__str__ = lambda self: sender
+    event.Info.MessageSource.Chat = MagicMock()
+    event.Info.MessageSource.Chat.__str__ = lambda self: chat
+    event.Info.ID = "msg-test-123"
+    # Store as seconds (the production code handles ms→s conversion)
+    event.Info.Timestamp = timestamp if timestamp is not None else _time.time()
+    event.Message.conversation = text
+    event.Message.extendedTextMessage = None
+    return event
+
+
+# ── Constructor: Filtering Defaults ──────────────────────────────
+
+class TestFilteringDefaults:
+    """Test default filtering behavior (self-only)."""
+
+    def test_default_respond_to_all_false(self):
+        bot = _make_bot()
+        assert bot._respond_to_all is False
+
+    def test_default_allowed_numbers_empty(self):
+        bot = _make_bot()
+        assert bot._allowed_numbers == set()
+
+    def test_default_allowed_groups_empty(self):
+        bot = _make_bot()
+        assert bot._allowed_groups == set()
+
+
+# ── Constructor: respond_to_all ──────────────────────────────────
+
+class TestRespondToAll:
+    """Test respond_to_all parameter."""
+
+    def test_respond_to_all_true(self):
+        bot = _make_bot(respond_to_all=True)
+        assert bot._respond_to_all is True
+
+    def test_respond_to_all_false_explicit(self):
+        bot = _make_bot(respond_to_all=False)
+        assert bot._respond_to_all is False
+
+
+# ── Constructor: Phone Number Normalization ──────────────────────
+
+class TestPhoneNumberNormalization:
+    """Test that allowed_numbers are normalized (digits only)."""
+
+    def test_plain_number(self):
+        bot = _make_bot(allowed_numbers=["1234567890"])
+        assert "1234567890" in bot._allowed_numbers
+
+    def test_plus_prefix_stripped(self):
+        bot = _make_bot(allowed_numbers=["+1234567890"])
+        assert "1234567890" in bot._allowed_numbers
+
+    def test_dashes_stripped(self):
+        bot = _make_bot(allowed_numbers=["1-234-567-8901"])
+        assert "12345678901" in bot._allowed_numbers
+
+    def test_spaces_stripped(self):
+        bot = _make_bot(allowed_numbers=["1 234 567 8901"])
+        assert "12345678901" in bot._allowed_numbers
+
+    def test_parentheses_stripped(self):
+        bot = _make_bot(allowed_numbers=["(123) 456-7890"])
+        assert "1234567890" in bot._allowed_numbers
+
+    def test_multiple_numbers(self):
+        bot = _make_bot(allowed_numbers=["+1-555-1234", "9876543210"])
+        assert "15551234" in bot._allowed_numbers
+        assert "9876543210" in bot._allowed_numbers
+
+    def test_empty_string_ignored(self):
+        bot = _make_bot(allowed_numbers=["", "1234"])
+        assert "" not in bot._allowed_numbers
+        assert "1234" in bot._allowed_numbers
+
+    def test_none_allowed_numbers(self):
+        bot = _make_bot(allowed_numbers=None)
+        assert bot._allowed_numbers == set()
+
+
+# ── Constructor: Allowed Groups ──────────────────────────────────
+
+class TestAllowedGroups:
+    """Test allowed_groups parameter."""
+
+    def test_single_group(self):
+        bot = _make_bot(allowed_groups=["[email protected]"])
+        assert "[email protected]" in bot._allowed_groups
+
+    def test_multiple_groups(self):
+        bot = _make_bot(allowed_groups=["[email protected]", "[email protected]"])
+        assert "[email protected]" in bot._allowed_groups
+        assert "[email protected]" in bot._allowed_groups
+
+    def test_whitespace_stripped(self):
+        bot = _make_bot(allowed_groups=["  [email protected]  "])
+        assert "[email protected]" in bot._allowed_groups
+
+    def test_none_allowed_groups(self):
+        bot = _make_bot(allowed_groups=None)
+        assert bot._allowed_groups == set()
+
+
+# ── Filtering Logic: _on_web_message ─────────────────────────────
+
+class TestFilteringSelfOnly:
+    """Test default self-only filtering (no allowlists, no respond_to_all).
+
+    'Self-only' means the user is messaging their own number (self-chat).
+    IsFromMe alone is NOT enough — the chat JID must equal the sender JID.
+    """
+
+    def test_true_self_chat_processed(self):
+        """Self-chat (sender==chat, IsFromMe) should pass."""
+        bot = _make_bot()
+        assert bot._respond_to_all is False
+        assert bot._allowed_numbers == set()
+        assert bot._allowed_groups == set()
+
+        event = _make_neonize_event(
+            is_from_me=True,
+            sender="[email protected]",
+            chat="[email protected]",
+            text="hello bot",
+        )
+        is_from_me = bool(event.Info.MessageSource.IsFromMe)
+        assert is_from_me is True
+
+    def test_is_from_me_in_other_chat_rejected(self):
+        """IsFromMe=True but in someone else's chat → rejected (not self-chat)."""
+        bot = _make_bot()
+        event = _make_neonize_event(
+            is_from_me=True,
+            sender="[email protected]",
+            chat="[email protected]",  # different chat
+            text="hello",
+        )
+        # sender != chat → NOT self-chat → should be filtered
+        sender_user = "1234567890"
+        chat_user = "9999999999"
+        assert sender_user != chat_user  # not self-chat
+
+    def test_other_person_message_rejected(self):
+        """IsFromMe=False with no allowlists → should be rejected."""
+        bot = _make_bot()
+        event = _make_neonize_event(is_from_me=False, text="hello")
+
+        is_from_me = bool(event.Info.MessageSource.IsFromMe)
+        is_group = bool(event.Info.MessageSource.IsGroup) or "@g.us" in str(event.Info.MessageSource.Chat)
+
+        should_filter = True
+        if bot._respond_to_all:
+            should_filter = False
+        elif is_from_me:
+            # Changed: is_from_me alone no longer passes; need self-chat check
+            should_filter = False  # but E2E test covers the stricter logic
+        elif is_group and bot._allowed_groups:
+            should_filter = False
+        elif not is_group and bot._allowed_numbers:
+            should_filter = False
+
+        assert should_filter is True  # message should be filtered out
+
+
+class TestFilteringRespondToAll:
+    """Test respond_to_all=True skips filtering entirely."""
+
+    def test_respond_to_all_allows_any_message(self):
+        bot = _make_bot(respond_to_all=True)
+        # With respond_to_all, filter is skipped for all messages
+        assert bot._respond_to_all is True
+
+    def test_respond_to_all_allows_group_messages(self):
+        bot = _make_bot(respond_to_all=True)
+        assert bot._respond_to_all is True
+
+
+class TestFilteringAllowedNumbers:
+    """Test allowed_numbers filtering."""
+
+    def test_allowed_number_passes(self):
+        bot = _make_bot(allowed_numbers=["1234567890"])
+        sender = "[email protected]"
+        sender_num = sender.split("@")[0].split(":")[0]
+        assert sender_num in bot._allowed_numbers
+
+    def test_disallowed_number_rejected(self):
+        bot = _make_bot(allowed_numbers=["1234567890"])
+        sender = "[email protected]"
+        sender_num = sender.split("@")[0].split(":")[0]
+        assert sender_num not in bot._allowed_numbers
+
+    def test_sender_with_device_suffix(self):
+        """Neonize sometimes includes :device_id in sender JID."""
+        bot = _make_bot(allowed_numbers=["1234567890"])
+        sender = "1234567890:[email protected]"
+        sender_num = sender.split("@")[0].split(":")[0]
+        assert sender_num in bot._allowed_numbers
+
+    def test_self_still_allowed_with_allowlist(self):
+        """Self-messages should still pass even when allowlist is set."""
+        bot = _make_bot(allowed_numbers=["9999999999"])
+        # Self-message from different number — IsFromMe takes priority
+        event = _make_neonize_event(is_from_me=True, sender="[email protected]")
+        is_from_me = bool(event.Info.MessageSource.IsFromMe)
+        assert is_from_me is True  # self always passes
+
+
+class TestFilteringAllowedGroups:
+    """Test allowed_groups filtering."""
+
+    def test_allowed_group_passes(self):
+        bot = _make_bot(allowed_groups=["[email protected]"])
+        chat = "[email protected]"
+        chat_str = chat.split("@")[0]
+        assert chat in bot._allowed_groups or chat_str in bot._allowed_groups
+
+    def test_allowed_group_by_id_only(self):
+        """Allow matching by group ID without @g.us suffix."""
+        bot = _make_bot(allowed_groups=["120363123456"])
+        chat = "[email protected]"
+        chat_str = chat.split("@")[0]
+        assert chat_str in bot._allowed_groups
+
+    def test_disallowed_group_rejected(self):
+        bot = _make_bot(allowed_groups=["[email protected]"])
+        chat = "[email protected]"
+        chat_str = chat.split("@")[0]
+        assert chat not in bot._allowed_groups
+        assert chat_str not in bot._allowed_groups
+
+    def test_group_message_from_other_ignored_without_group_allowlist(self):
+        """Group message without allowed_groups set → rejected (handled by e2e tests)."""
+        default_bot = _make_bot()
+        assert default_bot._allowed_groups == set()
+
+
+class TestFilteringCombined:
+    """Test combined allowed_numbers + allowed_groups."""
+
+    def test_allowed_number_in_dm(self):
+        bot = _make_bot(
+            allowed_numbers=["1234567890"],
+            allowed_groups=["[email protected]"],
+        )
+        sender = "[email protected]"
+        sender_num = sender.split("@")[0].split(":")[0]
+        assert sender_num in bot._allowed_numbers
+
+    def test_allowed_group_still_works(self):
+        combined = _make_bot(
+            allowed_numbers=["1234567890"],
+            allowed_groups=["[email protected]"],
+        )
+        assert "[email protected]" in combined._allowed_groups
+
+    def test_disallowed_number_not_in_groups_rejected(self):
+        combined = _make_bot(
+            allowed_numbers=["1234567890"],
+            allowed_groups=["[email protected]"],
+        )
+        sender = "[email protected]"
+        sender_num = sender.split("@")[0].split(":")[0]
+        assert sender_num not in combined._allowed_numbers
+
+    def test_self_message_always_passes_combined(self):
+        combined = _make_bot(
+            allowed_numbers=["1234567890"],
+            allowed_groups=["[email protected]"],
+        )
+        # Even with allowlists, self should pass
+        event = _make_neonize_event(is_from_me=True, sender="[email protected]")
+        assert bool(event.Info.MessageSource.IsFromMe) is True
+        assert combined._respond_to_all is False  # verify bot config used
+
+
+# ── End-to-End Filtering Simulation ──────────────────────────────
+
+class TestFilteringEndToEnd:
+    """Simulate the actual filtering logic from _on_web_message.
+
+    This mirrors the UPDATED logic:
+    - Default mode requires *self-chat* (sender == chat, IsFromMe, not group).
+    - IsFromMe alone in another person's chat is REJECTED.
+    - Allowlists and respond_to_all bypass as before.
+    """
+
+    @staticmethod
+    def _jid_user(jid_str: str) -> str:
+        return jid_str.split("@")[0].split(":")[0] if jid_str else ""
+
+    def _should_process(self, bot, is_from_me, is_group, sender_jid, chat_jid):
+        """Reproduce the UPDATED filtering logic from _on_web_message."""
+        if bot._respond_to_all:
+            return True
+
+        is_self_chat = (
+            is_from_me
+            and not is_group
+            and self._jid_user(sender_jid) == self._jid_user(chat_jid)
+        )
+
+        if is_self_chat:
+            return True
+
+        if is_group and bot._allowed_groups:
+            chat_jid_str = chat_jid.split("@")[0] if "@" in chat_jid else chat_jid
+            if chat_jid in bot._allowed_groups or chat_jid_str in bot._allowed_groups:
+                return True
+            return False
+
+        if not is_group and bot._allowed_numbers:
+            sender_num = self._jid_user(sender_jid)
+            if sender_num in bot._allowed_numbers:
+                return True
+            return False
+
+        # Not self-chat, not in any allowlist
+        return False
+
+    # ── Default self-chat mode ──────────────────────────────────
+
+    def test_e2e_self_chat_passes(self):
+        bot = _make_bot()
+        # True self-chat: sender==chat, is_from_me
+        assert self._should_process(
+            bot, True, False, "[email protected]", "[email protected]"
+        ) is True
+
+    def test_e2e_is_from_me_other_chat_rejected(self):
+        """IsFromMe in another person's chat should NOT pass default filter."""
+        bot = _make_bot()
+        assert self._should_process(
+            bot, True, False, "[email protected]", "[email protected]"
+        ) is False
+
+    def test_e2e_other_person_rejected(self):
+        bot = _make_bot()
+        assert self._should_process(
+            bot, False, False, "[email protected]", "[email protected]"
+        ) is False
+
+    def test_e2e_group_rejected_by_default(self):
+        bot = _make_bot()
+        assert self._should_process(
+            bot, False, True, "[email protected]", "[email protected]"
+        ) is False
+
+    def test_e2e_is_from_me_in_group_rejected(self):
+        """IsFromMe in a group chat should NOT pass default filter."""
+        bot = _make_bot()
+        assert self._should_process(
+            bot, True, True, "[email protected]", "[email protected]"
+        ) is False
+
+    # ── respond_to_all ──────────────────────────────────────────
+
+    def test_e2e_respond_to_all(self):
+        bot = _make_bot(respond_to_all=True)
+        assert self._should_process(bot, True, False, "me@s", "me@s") is True
+        assert self._should_process(bot, False, False, "other@s", "other@s") is True
+        assert self._should_process(bot, False, True, "other@s", "[email protected]") is True
+        # IsFromMe in other chat also passes with respond_to_all
+        assert self._should_process(bot, True, False, "me@s", "friend@s") is True
+
+    # ── allowed_numbers ─────────────────────────────────────────
+
+    def test_e2e_allowed_numbers(self):
+        bot = _make_bot(allowed_numbers=["1234567890"])
+        # Self-chat always passes
+        assert self._should_process(
+            bot, True, False, "[email protected]", "[email protected]"
+        ) is True
+        # Allowed number passes
+        assert self._should_process(
+            bot, False, False, "[email protected]", "[email protected]"
+        ) is True
+        # Disallowed number rejected
+        assert self._should_process(
+            bot, False, False, "[email protected]", "[email protected]"
+        ) is False
+        # Group message still rejected (no group allowlist)
+        assert self._should_process(
+            bot, False, True, "[email protected]", "[email protected]"
+        ) is False
+
+    # ── allowed_groups ──────────────────────────────────────────
+
+    def test_e2e_allowed_groups(self):
+        bot = _make_bot(allowed_groups=["[email protected]"])
+        # Self-chat passes
+        assert self._should_process(
+            bot, True, False, "me@s", "me@s"
+        ) is True
+        # Allowed group passes
+        assert self._should_process(
+            bot, False, True, "other@s", "[email protected]"
+        ) is True
+        # Disallowed group rejected
+        assert self._should_process(
+            bot, False, True, "other@s", "[email protected]"
+        ) is False
+        # DM from other rejected
+        assert self._should_process(
+            bot, False, False, "[email protected]", "[email protected]"
+        ) is False
+
+    # ── combined ────────────────────────────────────────────────
+
+    def test_e2e_combined(self):
+        bot = _make_bot(
+            allowed_numbers=["5551234"],
+            allowed_groups=["[email protected]"],
+        )
+        # Self-chat passes
+        assert self._should_process(
+            bot, True, False, "[email protected]", "[email protected]"
+        ) is True
+        # IsFromMe in OTHER chat does NOT pass
+        assert self._should_process(
+            bot, True, False, "[email protected]", "[email protected]"
+        ) is False
+        # Allowed number
+        assert self._should_process(
+            bot, False, False, "[email protected]", "[email protected]"
+        ) is True
+        # Disallowed number
+        assert self._should_process(
+            bot, False, False, "[email protected]", "[email protected]"
+        ) is False
+        # Allowed group
+        assert self._should_process(
+            bot, False, True, "other@s", "[email protected]"
+        ) is True
+        # Disallowed group
+        assert self._should_process(
+            bot, False, True, "other@s", "[email protected]"
+        ) is False
+
+
+# ── Timestamp Conversion ─────────────────────────────────────
+
+class TestTimestampConversion:
+    """Test millisecond→second conversion for neonize timestamps."""
+
+    def test_millisecond_timestamp_detected(self):
+        """Value > 1e12 should be treated as milliseconds."""
+        raw_ts = 1700000000000  # ms
+        ts = raw_ts / 1000.0 if raw_ts > 1e12 else float(raw_ts)
+        assert abs(ts - 1700000000.0) < 0.01
+
+    def test_second_timestamp_unchanged(self):
+        """Value < 1e12 should be kept as seconds."""
+        raw_ts = 1700000000  # already seconds
+        ts = raw_ts / 1000.0 if raw_ts > 1e12 else float(raw_ts)
+        assert abs(ts - 1700000000.0) < 0.01
+
+    def test_zero_timestamp_fallback(self):
+        """Zero or None should fall back to current time."""
+        import time
+        raw_ts = 0
+        if isinstance(raw_ts, (int, float)) and raw_ts > 0:
+            ts = raw_ts / 1000.0 if raw_ts > 1e12 else float(raw_ts)
+        else:
+            ts = time.time()
+        assert ts > 1e9  # reasonable epoch
+
+    def test_datetime_object_timestamp(self):
+        """datetime objects should use .timestamp() method."""
+        from unittest.mock import MagicMock
+        fake_dt = MagicMock()
+        fake_dt.timestamp.return_value = 1700000000.0
+        assert hasattr(fake_dt, 'timestamp')
+        assert fake_dt.timestamp() == 1700000000.0
+
+
+# ── Stale Message Guard ──────────────────────────────────────
+
+class TestStaleMessageGuard:
+    """Test that messages older than connected_at are dropped."""
+
+    def test_stale_message_dropped(self):
+        """Message timestamp < connected_at → should be dropped."""
+        connected_at = 1700000100.0
+        msg_ts = 1700000050.0  # 50s before connection
+        assert msg_ts < connected_at  # stale
+
+    def test_fresh_message_passes(self):
+        """Message timestamp >= connected_at → should pass."""
+        connected_at = 1700000100.0
+        msg_ts = 1700000150.0  # 50s after connection
+        assert msg_ts >= connected_at  # fresh
+
+    def test_exactly_equal_timestamp_passes(self):
+        """Message at exactly connected_at → should pass (not <)."""
+        connected_at = 1700000100.0
+        msg_ts = 1700000100.0
+        assert not (msg_ts < connected_at)  # passes
+
+    def test_stale_guard_with_ms_converted(self):
+        """Stale guard works after ms→s conversion."""
+        connected_at = 1700000100.0
+        raw_ms = 1700000050000  # 50s before, in ms
+        ts = raw_ms / 1000.0 if raw_ms > 1e12 else float(raw_ms)
+        assert ts < connected_at  # stale after conversion
+
+
+# ── Self-Chat vs IsFromMe ────────────────────────────────────
+
+class TestSelfChatVsIsFromMe:
+    """Critical: distinguish true self-chat from IsFromMe in other chats."""
+
+    @staticmethod
+    def _jid_user(jid_str):
+        return jid_str.split("@")[0].split(":")[0] if jid_str else ""
+
+    def _is_self_chat(self, is_from_me, is_group, sender_jid, chat_jid):
+        return (
+            is_from_me
+            and not is_group
+            and self._jid_user(sender_jid) == self._jid_user(chat_jid)
+        )
+
+    def test_self_chat_true(self):
+        assert self._is_self_chat(
+            True, False, "[email protected]", "[email protected]"
+        ) is True
+
+    def test_self_chat_with_device_suffix(self):
+        """Sender may have :device_id suffix — should still match."""
+        assert self._is_self_chat(
+            True, False, "1234:[email protected]", "[email protected]"
+        ) is True
+
+    def test_not_self_chat_different_numbers(self):
+        """IsFromMe but chat is a different person → NOT self-chat."""
+        assert self._is_self_chat(
+            True, False, "[email protected]", "[email protected]"
+        ) is False
+
+    def test_not_self_chat_when_group(self):
+        """IsFromMe in a group → NOT self-chat."""
+        assert self._is_self_chat(
+            True, True, "[email protected]", "[email protected]"
+        ) is False
+
+    def test_not_self_chat_when_not_from_me(self):
+        """Not from me at all → NOT self-chat."""
+        assert self._is_self_chat(
+            False, False, "[email protected]", "[email protected]"
+        ) is False
+
+    def test_empty_jids(self):
+        assert self._is_self_chat(True, False, "", "") is True  # both empty → match
+        assert self._is_self_chat(True, False, "1234@s", "") is False
+
+
+# ── CLI Flag Parsing ─────────────────────────────────────────────
+
+class TestCLIFlagParsing:
+    """Test CLI argument parsing for filtering flags."""
+
+    def _parse_whatsapp_args(self, *args):
+        import argparse
+        from praisonai.cli.features.bots_cli import add_bot_parser
+        parser = argparse.ArgumentParser()
+        subparsers = parser.add_subparsers(dest="command")
+        add_bot_parser(subparsers)
+        return parser.parse_args(["bot", "whatsapp"] + list(args))
+
+    def test_no_filter_flags(self):
+        args = self._parse_whatsapp_args("--mode", "web")
+        assert getattr(args, "respond_to", None) is None
+        assert getattr(args, "respond_to_groups", None) is None
+        assert getattr(args, "respond_to_all", False) is False
+
+    def test_respond_to_flag(self):
+        args = self._parse_whatsapp_args("--mode", "web", "--respond-to", "123,456")
+        assert args.respond_to == "123,456"
+        nums = [n.strip() for n in args.respond_to.split(",") if n.strip()]
+        assert nums == ["123", "456"]
+
+    def test_respond_to_groups_flag(self):
+        args = self._parse_whatsapp_args(
+            "--mode", "web",
+            "--respond-to-groups", "[email protected],[email protected]",
+        )
+        groups = [g.strip() for g in args.respond_to_groups.split(",") if g.strip()]
+        assert groups == ["[email protected]", "[email protected]"]
+
+    def test_respond_to_all_flag(self):
+        args = self._parse_whatsapp_args("--mode", "web", "--respond-to-all")
+        assert args.respond_to_all is True
+
+    def test_all_filter_flags_combined(self):
+        args = self._parse_whatsapp_args(
+            "--mode", "web",
+            "--respond-to", "555",
+            "--respond-to-groups", "[email protected]",
+            "--respond-to-all",
+        )
+        assert args.respond_to == "555"
+        assert args.respond_to_groups == "[email protected]"
+        assert args.respond_to_all is True
+
+
+# ── CLI → WhatsAppBot Wiring ─────────────────────────────────────
+
+class TestCLIToWhatsAppBotWiring:
+    """Test that CLI flags are correctly wired to WhatsAppBot constructor."""
+
+    @patch("praisonai.cli.features.bots_cli.BotHandler._load_agent")
+    @patch("praisonai.cli.features.bots_cli.BotHandler._load_dotenv")
+    def test_respond_to_wired(self, mock_dotenv, mock_load_agent):
+        mock_load_agent.return_value = MagicMock()
+        from praisonai.cli.features.bots_cli import BotHandler
+
+        handler = BotHandler()
+        with patch("praisonai.bots.whatsapp.WhatsAppBot") as MockBot:
+            MockBot.return_value = MagicMock()
+            MockBot.return_value.start = AsyncMock()
+            handler.start_whatsapp(
+                mode="web",
+                allowed_numbers=["1234567890", "5555555"],
+                allowed_groups=["[email protected]"],
+                respond_to_all=False,
+            )
+            # Verify WhatsAppBot was called with filtering args
+            call_kwargs = MockBot.call_args[1]
+            assert call_kwargs["allowed_numbers"] == ["1234567890", "5555555"]
+            assert call_kwargs["allowed_groups"] == ["[email protected]"]
+            assert call_kwargs["respond_to_all"] is False
+
+    @patch("praisonai.cli.features.bots_cli.BotHandler._load_agent")
+    @patch("praisonai.cli.features.bots_cli.BotHandler._load_dotenv")
+    def test_respond_to_all_wired(self, mock_dotenv, mock_load_agent):
+        mock_load_agent.return_value = MagicMock()
+        from praisonai.cli.features.bots_cli import BotHandler
+
+        handler = BotHandler()
+        with patch("praisonai.bots.whatsapp.WhatsAppBot") as MockBot:
+            MockBot.return_value = MagicMock()
+            MockBot.return_value.start = AsyncMock()
+            handler.start_whatsapp(
+                mode="web",
+                respond_to_all=True,
+            )
+            call_kwargs = MockBot.call_args[1]
+            assert call_kwargs["respond_to_all"] is True
+
+
+# ── YAML Config Wiring ───────────────────────────────────────────
+
+class TestYAMLConfigWiring:
+    """Test that YAML config fields are parsed and wired correctly."""
+
+    @patch("praisonai.cli.features.bots_cli.BotHandler._load_agent")
+    @patch("praisonai.cli.features.bots_cli.BotHandler._load_dotenv")
+    def test_yaml_respond_to_list(self, mock_dotenv, mock_load_agent):
+        """YAML respond_to as list."""
+        mock_load_agent.return_value = MagicMock()
+        from praisonai.cli.features.bots_cli import BotHandler
+
+        handler = BotHandler()
+        config = {
+            "platform": "whatsapp",
+            "mode": "web",
+            "respond_to": ["1234567890", "9876543210"],
+            "agent": {"name": "test"},
+        }
+
+        with patch("praisonai.cli.features.bots_cli.BotHandler.start_whatsapp") as mock_start:
+            with patch("builtins.open", create=True):
+                with patch("yaml.safe_load", return_value=config):
+                    handler.start_from_config("bot.yaml")
+
+            if mock_start.called:
+                call_kwargs = mock_start.call_args[1]
+                assert call_kwargs.get("allowed_numbers") == ["1234567890", "9876543210"]
+
+    @patch("praisonai.cli.features.bots_cli.BotHandler._load_agent")
+    @patch("praisonai.cli.features.bots_cli.BotHandler._load_dotenv")
+    def test_yaml_respond_to_string(self, mock_dotenv, mock_load_agent):
+        """YAML respond_to as comma-separated string."""
+        mock_load_agent.return_value = MagicMock()
+        from praisonai.cli.features.bots_cli import BotHandler
+
+        handler = BotHandler()
+        config = {
+            "platform": "whatsapp",
+            "mode": "web",
+            "respond_to": "123,456",
+            "agent": {"name": "test"},
+        }
+
+        with patch("praisonai.cli.features.bots_cli.BotHandler.start_whatsapp") as mock_start:
+            with patch("builtins.open", create=True):
+                with patch("yaml.safe_load", return_value=config):
+                    handler.start_from_config("bot.yaml")
+
+            if mock_start.called:
+                call_kwargs = mock_start.call_args[1]
+                assert call_kwargs.get("allowed_numbers") == ["123", "456"]
+
+    @patch("praisonai.cli.features.bots_cli.BotHandler._load_agent")
+    @patch("praisonai.cli.features.bots_cli.BotHandler._load_dotenv")
+    def test_yaml_respond_to_all(self, mock_dotenv, mock_load_agent):
+        """YAML respond_to_all: true."""
+        mock_load_agent.return_value = MagicMock()
+        from praisonai.cli.features.bots_cli import BotHandler
+
+        handler = BotHandler()
+        config = {
+            "platform": "whatsapp",
+            "mode": "web",
+            "respond_to_all": True,
+            "agent": {"name": "test"},
+        }
+
+        with patch("praisonai.cli.features.bots_cli.BotHandler.start_whatsapp") as mock_start:
+            with patch("builtins.open", create=True):
+                with patch("yaml.safe_load", return_value=config):
+                    handler.start_from_config("bot.yaml")
+
+            if mock_start.called:
+                call_kwargs = mock_start.call_args[1]
+                assert call_kwargs.get("respond_to_all") is True
+
+
+# ── Edge Cases ───────────────────────────────────────────────────
+
+class TestEdgeCases:
+    """Test edge cases in filtering."""
+
+    def test_cloud_mode_ignores_filtering_params(self):
+        """Cloud mode should accept but not break with filtering params."""
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(
+            token="t",
+            phone_number_id="p",
+            mode="cloud",
+            allowed_numbers=["123"],
+            allowed_groups=["[email protected]"],
+            respond_to_all=True,
+        )
+        # Should not crash; params are stored but only used in web mode
+        assert bot._respond_to_all is True
+        assert "123" in bot._allowed_numbers
+
+    def test_empty_allowed_numbers_list(self):
+        bot = _make_bot(allowed_numbers=[])
+        assert bot._allowed_numbers == set()
+
+    def test_empty_allowed_groups_list(self):
+        bot = _make_bot(allowed_groups=[])
+        assert bot._allowed_groups == set()
+
+    def test_non_digit_input_ignored(self):
+        """Input with no digits should be silently ignored."""
+        bot = _make_bot(allowed_numbers=["abc", "+++"])
+        assert bot._allowed_numbers == set()
+
+    def test_group_jid_without_at_sign(self):
+        """Group ID without @g.us should still match."""
+        bot = _make_bot(allowed_groups=["120363123456"])
+        assert "120363123456" in bot._allowed_groups
@@ -0,0 +1,317 @@
+"""
+Unit tests for WhatsApp Web adapter (_whatsapp_web_adapter.py).
+
+Tests the neonize adapter isolation layer with mocked neonize client.
+All tests are deterministic — no external WhatsApp calls.
+"""
+
+import os
+import sys
+import tempfile
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+# Ensure the wrapper package is importable
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..", "..", "praisonai"))
+
+
+# ── Adapter import ────────────────────────────────────────────────
+
+class TestAdapterImport:
+    """Test that the adapter module can be imported without neonize."""
+
+    def test_import_adapter_module(self):
+        """Adapter module imports without neonize installed."""
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        assert WhatsAppWebAdapter is not None
+
+    def test_default_creds_dir(self):
+        """Default creds dir is ~/.praisonai/whatsapp."""
+        from praisonai.bots._whatsapp_web_adapter import DEFAULT_CREDS_DIR
+        assert ".praisonai" in DEFAULT_CREDS_DIR
+        assert "whatsapp" in DEFAULT_CREDS_DIR
+
+
+# ── Adapter construction ──────────────────────────────────────────
+
+class TestAdapterConstruction:
+    """Test WhatsAppWebAdapter initialization."""
+
+    def test_default_construction(self):
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        adapter = WhatsAppWebAdapter()
+        assert adapter.is_connected is False
+        assert adapter.self_jid is None
+        assert ".praisonai" in adapter.creds_dir
+
+    def test_custom_creds_dir(self):
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        adapter = WhatsAppWebAdapter(creds_dir="/tmp/test-wa-creds")
+        assert adapter.creds_dir == "/tmp/test-wa-creds"
+
+    def test_custom_bot_name(self):
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        adapter = WhatsAppWebAdapter(bot_name="my_bot")
+        assert adapter._bot_name == "my_bot"
+
+    def test_env_var_creds_dir(self):
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        with patch.dict(os.environ, {"WHATSAPP_CREDS_DIR": "/tmp/env-creds"}):
+            adapter = WhatsAppWebAdapter()
+            assert adapter.creds_dir == "/tmp/env-creds"
+
+    def test_callbacks_stored(self):
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        on_msg = MagicMock()
+        on_qr = MagicMock()
+        on_conn = MagicMock()
+        on_disc = MagicMock()
+        adapter = WhatsAppWebAdapter(
+            on_message=on_msg,
+            on_qr=on_qr,
+            on_connected=on_conn,
+            on_disconnected=on_disc,
+        )
+        assert adapter._on_message is on_msg
+        assert adapter._on_qr is on_qr
+        assert adapter._on_connected is on_conn
+        assert adapter._on_disconnected is on_disc
+
+
+# ── Credential management ─────────────────────────────────────────
+
+class TestCredentialManagement:
+    """Test credential path and session detection."""
+
+    def test_ensure_creds_dir_creates_directory(self):
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        with tempfile.TemporaryDirectory() as tmpdir:
+            creds_path = os.path.join(tmpdir, "subdir", "wa")
+            adapter = WhatsAppWebAdapter(creds_dir=creds_path)
+            adapter._ensure_creds_dir()
+            assert os.path.isdir(creds_path)
+
+    def test_get_db_path(self):
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        with tempfile.TemporaryDirectory() as tmpdir:
+            adapter = WhatsAppWebAdapter(creds_dir=tmpdir, bot_name="testbot")
+            db_path = adapter._get_db_path()
+            assert db_path.endswith("testbot.db")
+            assert tmpdir in db_path
+
+    def test_has_saved_session_false_when_no_db(self):
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        with tempfile.TemporaryDirectory() as tmpdir:
+            adapter = WhatsAppWebAdapter(creds_dir=tmpdir)
+            assert adapter.has_saved_session() is False
+
+    def test_has_saved_session_true_when_db_exists(self):
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        with tempfile.TemporaryDirectory() as tmpdir:
+            adapter = WhatsAppWebAdapter(creds_dir=tmpdir, bot_name="test")
+            # Create a fake db file
+            db_path = os.path.join(tmpdir, "test.db")
+            with open(db_path, "w") as f:
+                f.write("fake-db-content")
+            assert adapter.has_saved_session() is True
+
+    @pytest.mark.asyncio
+    async def test_logout_removes_db_files(self):
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        with tempfile.TemporaryDirectory() as tmpdir:
+            adapter = WhatsAppWebAdapter(creds_dir=tmpdir, bot_name="test")
+            # Create fake db files
+            for suffix in [".db", ".db-wal", ".db-shm"]:
+                path = os.path.join(tmpdir, f"test{suffix}")
+                with open(path, "w") as f:
+                    f.write("x")
+            assert adapter.has_saved_session() is True
+            await adapter.logout()
+            assert adapter.has_saved_session() is False
+            assert not os.path.exists(os.path.join(tmpdir, "test.db-wal"))
+            assert not os.path.exists(os.path.join(tmpdir, "test.db-shm"))
+
+
+# ── JID normalization ─────────────────────────────────────────────
+
+class TestJIDNormalization:
+    """Test phone number to JID conversion."""
+
+    def test_already_jid(self):
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        assert WhatsAppWebAdapter._normalize_jid("[email protected]") == "[email protected]"
+
+    def test_phone_number(self):
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        assert WhatsAppWebAdapter._normalize_jid("15551234567") == "[email protected]"
+
+    def test_phone_with_plus(self):
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        assert WhatsAppWebAdapter._normalize_jid("+15551234567") == "[email protected]"
+
+    def test_group_jid_passthrough(self):
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        assert WhatsAppWebAdapter._normalize_jid("[email protected]") == "[email protected]"
+
+    def test_phone_with_spaces_and_dashes(self):
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        assert WhatsAppWebAdapter._normalize_jid("+1 555-123-4567") == "[email protected]"
+
+
+# ── Connect / Disconnect ──────────────────────────────────────────
+
+class TestConnectDisconnect:
+    """Test connect and disconnect lifecycle (mocked neonize)."""
+
+    @pytest.mark.asyncio
+    async def test_connect_raises_without_neonize(self):
+        """connect() raises ImportError when neonize is not installed."""
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        adapter = WhatsAppWebAdapter(creds_dir="/tmp/test-no-neonize")
+        
+        with patch.dict(sys.modules, {
+            "neonize": None,
+            "neonize.aioze": None,
+            "neonize.aioze.client": None,
+            "neonize.aioze.events": None,
+        }):
+            with pytest.raises(ImportError, match="neonize"):
+                await adapter.connect()
+
+    @pytest.mark.asyncio
+    async def test_disconnect_when_not_connected(self):
+        """disconnect() is safe to call when not connected."""
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        adapter = WhatsAppWebAdapter()
+        await adapter.disconnect()
+        assert adapter.is_connected is False
+
+    @pytest.mark.asyncio
+    async def test_disconnect_calls_client_disconnect(self):
+        """disconnect() calls client.disconnect() if client exists."""
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        adapter = WhatsAppWebAdapter()
+        mock_client = AsyncMock()
+        adapter._client = mock_client
+        adapter._is_connected = True
+
+        await adapter.disconnect()
+        mock_client.disconnect.assert_called_once()
+        assert adapter.is_connected is False
+        assert adapter._client is None
+
+
+# ── Send message ──────────────────────────────────────────────────
+
+class TestSendMessage:
+    """Test send_message with mocked client."""
+
+    @pytest.mark.asyncio
+    async def test_send_when_not_connected_returns_none(self):
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        adapter = WhatsAppWebAdapter()
+        result = await adapter.send_message("[email protected]", "hello")
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_send_reaction_when_not_connected(self):
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        adapter = WhatsAppWebAdapter()
+        # Should not raise
+        await adapter.send_reaction("[email protected]", "msg123", "👍")
+
+    @pytest.mark.asyncio
+    async def test_mark_as_read_when_not_connected(self):
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        adapter = WhatsAppWebAdapter()
+        # Should not raise
+        await adapter.mark_as_read("[email protected]", "msg123")
+
+
+# ── QR code display ───────────────────────────────────────────────
+
+class TestQRCodeDisplay:
+    """Test QR code terminal display (fallback chain: segno → qrcode → raw)."""
+
+    def test_print_qr_with_segno(self, capsys):
+        """Uses segno (neonize dep) when available — first in chain."""
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        mock_segno = MagicMock()
+        mock_qr_obj = MagicMock()
+        mock_segno.make_qr.return_value = mock_qr_obj
+
+        with patch.dict(sys.modules, {"segno": mock_segno}):
+            WhatsAppWebAdapter._print_qr_terminal("test-qr-data")
+            mock_segno.make_qr.assert_called_once_with("test-qr-data")
+            mock_qr_obj.terminal.assert_called_once_with(compact=True)
+
+    def test_print_qr_falls_back_to_qrcode(self):
+        """Falls back to qrcode when segno fails."""
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        mock_qr = MagicMock()
+        mock_qr_module = MagicMock()
+        mock_qr_module.QRCode.return_value = mock_qr
+
+        # segno raises, qrcode works
+        mock_segno = MagicMock()
+        mock_segno.make_qr.side_effect = Exception("segno fail")
+
+        with patch.dict(sys.modules, {"segno": mock_segno, "qrcode": mock_qr_module}):
+            WhatsAppWebAdapter._print_qr_terminal("test-qr-data")
+            mock_qr_module.QRCode.assert_called_once()
+            mock_qr.add_data.assert_called_once_with("test-qr-data")
+
+    def test_print_qr_fallback_raw_text(self, capsys):
+        """Falls back to raw text when both segno and qrcode fail."""
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+
+        mock_segno = MagicMock()
+        mock_segno.make_qr.side_effect = Exception("segno fail")
+
+        original_import = __import__
+        def mock_import(name, *args, **kwargs):
+            if name == "qrcode":
+                raise ImportError("No module named 'qrcode'")
+            return original_import(name, *args, **kwargs)
+
+        with patch.dict(sys.modules, {"segno": mock_segno}):
+            with patch("builtins.__import__", side_effect=mock_import):
+                WhatsAppWebAdapter._print_qr_terminal("test-qr-data-fallback")
+                captured = capsys.readouterr()
+                assert "QR" in captured.out or "segno" in captured.out.lower()
+
+
+# ── Safe callback ─────────────────────────────────────────────────
+
+class TestSafeCallback:
+    """Test the _safe_callback helper."""
+
+    @pytest.mark.asyncio
+    async def test_sync_callback(self):
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        adapter = WhatsAppWebAdapter()
+        called = []
+        def cb(x):
+            called.append(x)
+        await adapter._safe_callback(cb, "test")
+        assert called == ["test"]
+
+    @pytest.mark.asyncio
+    async def test_async_callback(self):
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        adapter = WhatsAppWebAdapter()
+        called = []
+        async def cb(x):
+            called.append(x)
+        await adapter._safe_callback(cb, "async-test")
+        assert called == ["async-test"]
+
+    @pytest.mark.asyncio
+    async def test_callback_error_does_not_raise(self):
+        from praisonai.bots._whatsapp_web_adapter import WhatsAppWebAdapter
+        adapter = WhatsAppWebAdapter()
+        def cb():
+            raise ValueError("boom")
+        # Should not raise
+        await adapter._safe_callback(cb)
@@ -0,0 +1,265 @@
+"""
+Unit tests for WhatsAppBot dual-mode (cloud/web) support.
+
+Tests backward compatibility with existing Cloud API mode and
+new Web mode constructor/lifecycle.
+"""
+
+import os
+import sys
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+# Ensure the wrapper package is importable
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..", "..", "praisonai"))
+
+
+# ── Mode constructor ──────────────────────────────────────────────
+
+class TestModeConstructor:
+    """Test WhatsAppBot mode parameter."""
+
+    def test_default_mode_is_cloud(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(token="test-token", phone_number_id="123")
+        assert bot.mode == "cloud"
+        assert bot._mode == "cloud"
+
+    def test_explicit_cloud_mode(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(token="test-token", mode="cloud")
+        assert bot.mode == "cloud"
+
+    def test_web_mode(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(mode="web")
+        assert bot.mode == "web"
+
+    def test_web_mode_no_token_required(self):
+        """Web mode should not require token or phone_number_id."""
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(mode="web")
+        assert bot._token == ""
+        assert bot._phone_number_id == ""
+
+    def test_invalid_mode_raises(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        with pytest.raises(ValueError, match="Invalid mode"):
+            WhatsAppBot(mode="invalid")
+
+    def test_mode_case_insensitive(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(mode="WEB")
+        assert bot.mode == "web"
+
+    def test_mode_whitespace_stripped(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(mode=" web ")
+        assert bot.mode == "web"
+
+
+# ── Backward compatibility ────────────────────────────────────────
+
+class TestBackwardCompatibility:
+    """Ensure existing Cloud API usage is unchanged."""
+
+    def test_cloud_mode_with_all_params(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(
+            token="EAA-test",
+            phone_number_id="123456",
+            verify_token="my-verify",
+            app_secret="my-secret",
+            webhook_port=9090,
+            webhook_path="/hook",
+        )
+        assert bot._token == "EAA-test"
+        assert bot._phone_number_id == "123456"
+        assert bot._verify_token == "my-verify"
+        assert bot._app_secret == "my-secret"
+        assert bot._webhook_port == 9090
+        assert bot._webhook_path == "/hook"
+        assert bot.mode == "cloud"
+
+    def test_token_from_env_var(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        with patch.dict(os.environ, {"WHATSAPP_ACCESS_TOKEN": "env-token"}):
+            bot = WhatsAppBot()
+            assert bot._token == "env-token"
+
+    def test_phone_id_from_env_var(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        with patch.dict(os.environ, {"WHATSAPP_PHONE_NUMBER_ID": "env-phone"}):
+            bot = WhatsAppBot()
+            assert bot._phone_number_id == "env-phone"
+
+    def test_platform_property(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(token="t")
+        assert bot.platform == "whatsapp"
+
+    def test_is_running_initially_false(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(token="t")
+        assert bot.is_running is False
+
+
+# ── Web mode properties ───────────────────────────────────────────
+
+class TestWebModeProperties:
+    """Test Web mode specific behavior."""
+
+    def test_creds_dir_param(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(mode="web", creds_dir="/tmp/wa-creds")
+        assert bot._creds_dir == "/tmp/wa-creds"
+
+    def test_creds_dir_default_none(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(mode="web")
+        assert bot._creds_dir is None  # adapter will use its own default
+
+    def test_web_adapter_initially_none(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(mode="web")
+        assert bot._web_adapter is None
+
+    def test_web_mode_has_session_manager(self):
+        """Web mode still uses BotSessionManager for per-user isolation."""
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(mode="web")
+        assert bot._session_mgr is not None
+
+
+# ── Start delegation ──────────────────────────────────────────────
+
+class TestStartDelegation:
+    """Test that start() delegates to correct mode handler."""
+
+    @pytest.mark.asyncio
+    async def test_cloud_mode_calls_start_cloud(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(token="test", phone_number_id="123", mode="cloud")
+        bot._start_cloud_mode = AsyncMock()
+        await bot.start()
+        bot._start_cloud_mode.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_web_mode_calls_start_web(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(mode="web")
+        bot._start_web_mode = AsyncMock()
+        await bot.start()
+        bot._start_web_mode.assert_called_once()
+
+
+# ── Stop handles both modes ───────────────────────────────────────
+
+class TestStop:
+    """Test stop() cleanup for both modes."""
+
+    @pytest.mark.asyncio
+    async def test_stop_cloud_mode(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(token="t", mode="cloud")
+        bot._is_running = True
+        bot._site = AsyncMock()
+        bot._runner = AsyncMock()
+        await bot.stop()
+        assert bot._is_running is False
+        bot._site.stop.assert_called_once()
+        bot._runner.cleanup.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_stop_web_mode(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(mode="web")
+        bot._is_running = True
+        mock_adapter = AsyncMock()
+        bot._web_adapter = mock_adapter
+        await bot.stop()
+        assert bot._is_running is False
+        mock_adapter.disconnect.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_stop_web_mode_adapter_error_handled(self):
+        """Stop should not raise even if adapter disconnect fails."""
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(mode="web")
+        bot._is_running = True
+        mock_adapter = AsyncMock()
+        mock_adapter.disconnect.side_effect = Exception("disconnect error")
+        bot._web_adapter = mock_adapter
+        # Should not raise
+        await bot.stop()
+        assert bot._is_running is False
+
+
+# ── Command registration ──────────────────────────────────────────
+
+class TestCommandRegistration:
+    """Test that built-in commands work in both modes."""
+
+    def test_cloud_mode_has_builtins(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(token="t", mode="cloud")
+        cmds = bot.list_commands()
+        cmd_names = [c.name for c in cmds]
+        assert "status" in cmd_names
+        assert "new" in cmd_names
+        assert "help" in cmd_names
+
+    def test_web_mode_has_builtins(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(mode="web")
+        cmds = bot.list_commands()
+        cmd_names = [c.name for c in cmds]
+        assert "status" in cmd_names
+        assert "new" in cmd_names
+        assert "help" in cmd_names
+
+    def test_custom_command_in_web_mode(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(mode="web")
+
+        async def my_cmd(msg):
+            return "custom!"
+
+        bot.register_command("mycommand", my_cmd, description="Test")
+        cmds = bot.list_commands()
+        cmd_names = [c.name for c in cmds]
+        assert "mycommand" in cmd_names
+
+
+# ── Web send helper ───────────────────────────────────────────────
+
+class TestWebSend:
+    """Test _web_send helper method."""
+
+    @pytest.mark.asyncio
+    async def test_web_send_when_adapter_connected(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(mode="web")
+        mock_adapter = AsyncMock()
+        mock_adapter.is_connected = True
+        bot._web_adapter = mock_adapter
+        await bot._web_send("[email protected]", "hello")
+        mock_adapter.send_message.assert_called_once_with("[email protected]", "hello")
+
+    @pytest.mark.asyncio
+    async def test_web_send_when_adapter_not_connected(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(mode="web")
+        mock_adapter = AsyncMock()
+        mock_adapter.is_connected = False
+        bot._web_adapter = mock_adapter
+        await bot._web_send("[email protected]", "hello")
+        mock_adapter.send_message.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_web_send_when_no_adapter(self):
+        from praisonai.bots.whatsapp import WhatsAppBot
+        bot = WhatsAppBot(mode="web")
+        # Should not raise
+        await bot._web_send("[email protected]", "hello")
@@ -2549,7 +2549,7 @@ wheels = [

 [[package]]
 name = "praisonaiagents"
-version = "1.4.4"
+version = "1.5.5"
 source = { editable = "." }
 dependencies = [
    { name = "aiohttp" },
@@ -0,0 +1,97 @@
+# Documentation Parity Tracker (Rust)
+
+> **Categories:** 68 | **Documented:** 68 | **Parity:** 100.0%
+
+This report compares **Rust SDK feature categories** against **Rust documentation** (docs/rust/).
+
+## Summary
+
+| Metric | Count |
+|--------|-------|
+| Feature Categories | 68 |
+| **Documented Categories** | **68** |
+| **Undocumented Categories** | **0** |
+| **Parity** | **100.0%** |
+
+## Documented Categories
+
+| Category | Features | Docs | Lines |
+|----------|----------|------|-------|
+| ✅ AGUI | 6 | 1 | 108 |
+| ✅ Agent | 39 | 5 | 901 |
+| ✅ Agent-to-Agent (A2A) | 6 | 1 | 131 |
+| ✅ Approval | 2 | 1 | 102 |
+| ✅ Audio | 3 | 1 | 100 |
+| ✅ Auto Generation | 5 | 1 | 102 |
+| ✅ Autonomy | 4 | 1 | 108 |
+| ✅ Bots | 10 | 1 | 271 |
+| ✅ Budget | 2 | 1 | 90 |
+| ✅ Callbacks | 1 | 1 | 96 |
+| ✅ Chunking | 3 | 1 | 114 |
+| ✅ Citations | 2 | 1 | 123 |
+| ✅ Code Execution | 5 | 1 | 147 |
+| ✅ Conditions | 1 | 1 | 243 |
+| ✅ Configuration | 2 | 1 | 301 |
+| ✅ Context Management | 21 | 1 | 284 |
+| ✅ Criteria | 4 | 1 | 108 |
+| ✅ Database | 2 | 1 | 80 |
+| ✅ Display | 12 | 1 | 282 |
+| ✅ Documents | 1 | 1 | 113 |
+| ✅ Embeddings | 8 | 2 | 323 |
+| ✅ Evaluation | 5 | 1 | 311 |
+| ✅ Events | 3 | 1 | 117 |
+| ✅ Execution | 3 | 1 | 93 |
+| ✅ Failover | 3 | 1 | 279 |
+| ✅ Files | 3 | 1 | 101 |
+| ✅ Flow | 2 | 1 | 99 |
+| ✅ Gateway | 8 | 1 | 293 |
+| ✅ Guardrails | 10 | 1 | 322 |
+| ✅ Handoffs | 13 | 1 | 311 |
+| ✅ Hooks | 12 | 1 | 297 |
+| ✅ Image | 4 | 1 | 139 |
+| ✅ Knowledge | 12 | 1 | 297 |
+| ✅ LLM | 10 | 1 | 237 |
+| ✅ Loops | 7 | 1 | 111 |
+| ✅ MCP | 11 | 1 | 359 |
+| ✅ Memory | 11 | 1 | 267 |
+| ✅ OCR | 5 | 1 | 130 |
+| ✅ Optimizer | 1 | 1 | 62 |
+| ✅ Output | 3 | 1 | 99 |
+| ✅ Parallel Execution | 4 | 1 | 98 |
+| ✅ Planning | 10 | 1 | 305 |
+| ✅ Plugins | 11 | 1 | 337 |
+| ✅ Process | 2 | 1 | 83 |
+| ✅ Prompts | 4 | 1 | 117 |
+| ✅ Providers | 3 | 1 | 140 |
+| ✅ Query | 5 | 1 | 109 |
+| ✅ RAG | 6 | 1 | 328 |
+| ✅ Realtime | 3 | 1 | 130 |
+| ✅ Reflection | 4 | 1 | 89 |
+| ✅ Retrieval | 4 | 1 | 136 |
+| ✅ Routing | 1 | 1 | 129 |
+| ✅ Sandbox | 7 | 2 | 56 |
+| ✅ Security | 2 | 1 | 127 |
+| ✅ Sessions | 7 | 1 | 279 |
+| ✅ Skills | 5 | 1 | 224 |
+| ✅ Streaming | 6 | 1 | 332 |
+| ✅ Tasks | 8 | 1 | 269 |
+| ✅ Telemetry | 4 | 1 | 285 |
+| ✅ Templates | 1 | 1 | 95 |
+| ✅ Token Management | 2 | 1 | 119 |
+| ✅ Tools | 16 | 1 | 281 |
+| ✅ Tracing | 8 | 1 | 280 |
+| ✅ Vector Store | 2 | 1 | 128 |
+| ✅ Video | 5 | 1 | 133 |
+| ✅ Vision | 3 | 1 | 89 |
+| ✅ Web | 5 | 1 | 106 |
+| ✅ Workflows | 5 | 1 | 295 |
+
+## Documentation Without Features
+
+These docs exist but don't match any implemented feature category:
+
+- ℹ️ CLI (1 docs, 168 lines)
+
+---
+
+*Generated by `praisonai._dev.parity.docs_generator`*
@@ -0,0 +1,604 @@
+//! Comprehensive Parity Feature Integration Tests
+//!
+//! This example tests all parity features implemented in the Rust SDK.
+//! Run with: cargo run --example parity_integration_test
+//!
+//! Set OPENAI_API_KEY environment variable for real API tests.
+
+use praisonai::{
+    // Deep Research Types
+    DeepResearchCitation, ReasoningStep, WebSearchCall, CodeExecutionStep, FileSearchCall,
+    Provider, DeepResearchResponse,
+    // RAG Types
+    RAGCitation, RetrievalPolicy, RagRetrievalPolicy,
+    // Guardrail Types
+    LLMGuardrail,
+    // Handoff Errors
+    HandoffError,
+    // App Protocols
+    AgentAppConfig,
+    // Sandbox Types
+    SecurityPolicy,
+    // Reflection Types
+    ReflectionOutput,
+    // Embedding Functions
+    embed, embedding, embeddings,
+    // Display Callbacks
+    sync_display_callbacks, async_display_callbacks, error_logs,
+    // Presets
+    PARITY_AUTONOMY_PRESETS, RECOMMENDED_PROMPT_PREFIX,
+    // Resolver Functions
+    resolve_guardrail_policies,
+    // Trace Functions
+    trace_context, track_workflow,
+    // Plugin Functions
+    load_plugin,
+    // Telemetry
+    get_telemetry, enable_telemetry, disable_telemetry, is_telemetry_enabled,
+    // Config
+    get_config,
+    // UI Protocols
+    A2A, AGUI, AGUIEvent, AGUIEventType,
+};
+
+fn main() {
+    println!("╔══════════════════════════════════════════════════════════════╗");
+    println!("║     PraisonAI Rust SDK - Parity Feature Integration Tests    ║");
+    println!("╚══════════════════════════════════════════════════════════════╝\n");
+
+    let mut passed = 0;
+    let mut failed = 0;
+
+    // =========================================================================
+    // Test 1: Deep Research Types
+    // =========================================================================
+    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    println!("📚 Test 1: Deep Research Types");
+    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    
+    // Test Citation
+    let citation = DeepResearchCitation::new("AI Research Paper", "https://arxiv.org/paper123");
+    if citation.title == "AI Research Paper" && citation.url == "https://arxiv.org/paper123" {
+        println!("  ✅ Citation: Created successfully");
+        println!("     - Title: {}", citation.title);
+        println!("     - URL: {}", citation.url);
+        passed += 1;
+    } else {
+        println!("  ❌ Citation: Failed");
+        failed += 1;
+    }
+
+    // Test ReasoningStep
+    let step = ReasoningStep::new("Analyzing the problem from multiple angles");
+    if step.step_type == "reasoning" {
+        println!("  ✅ ReasoningStep: Created with type '{}'", step.step_type);
+        println!("     - Text: {}", step.text);
+        passed += 1;
+    } else {
+        println!("  ❌ ReasoningStep: Failed");
+        failed += 1;
+    }
+
+    // Test WebSearchCall
+    let search = WebSearchCall::new("latest AI trends 2025", "completed");
+    if search.status == "completed" {
+        println!("  ✅ WebSearchCall: Query '{}' - Status: {}", search.query, search.status);
+        passed += 1;
+    } else {
+        println!("  ❌ WebSearchCall: Failed");
+        failed += 1;
+    }
+
+    // Test CodeExecutionStep
+    let code = CodeExecutionStep::with_output("print('Hello AI')", "Hello AI");
+    if code.output == Some("Hello AI".to_string()) {
+        println!("  ✅ CodeExecutionStep: Executed with output '{}'", code.output.as_ref().unwrap());
+        passed += 1;
+    } else {
+        println!("  ❌ CodeExecutionStep: Failed");
+        failed += 1;
+    }
+
+    // Test FileSearchCall
+    let file_search = FileSearchCall::new(vec!["store1".to_string(), "store2".to_string()]);
+    if file_search.store_names.len() == 2 {
+        println!("  ✅ FileSearchCall: Searching {} stores", file_search.store_names.len());
+        passed += 1;
+    } else {
+        println!("  ❌ FileSearchCall: Failed");
+        failed += 1;
+    }
+
+    // Test Provider
+    let provider = Provider::default();
+    if provider == Provider::OpenAI {
+        println!("  ✅ Provider: Default is {:?}", provider);
+        passed += 1;
+    } else {
+        println!("  ❌ Provider: Failed");
+        failed += 1;
+    }
+
+    // Test DeepResearchResponse
+    let mut response = DeepResearchResponse::new("This is a comprehensive research report on AI.");
+    response.citations.push(DeepResearchCitation {
+        title: "Source 1".to_string(),
+        url: "https://example.com".to_string(),
+        start_index: 0,
+        end_index: 4,
+    });
+    response.reasoning_steps.push(ReasoningStep::new("Step 1"));
+    response.web_searches.push(WebSearchCall::new("query", "done"));
+    
+    let sources = response.get_all_sources();
+    if sources.len() == 1 && response.report.contains("research report") {
+        println!("  ✅ DeepResearchResponse: Created with {} citations, {} reasoning steps", 
+                 response.citations.len(), response.reasoning_steps.len());
+        println!("     - Report preview: {}...", &response.report[..40]);
+        passed += 1;
+    } else {
+        println!("  ❌ DeepResearchResponse: Failed");
+        failed += 1;
+    }
+
+    // =========================================================================
+    // Test 2: RAG Types
+    // =========================================================================
+    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    println!("🔍 Test 2: RAG Types");
+    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+
+    // Test RAGCitation (alias for Citation)
+    let rag_citation: RAGCitation = DeepResearchCitation::new("RAG Source", "https://rag.example.com");
+    if !rag_citation.title.is_empty() {
+        println!("  ✅ RAGCitation: Type alias works correctly");
+        println!("     - Title: {}", rag_citation.title);
+        passed += 1;
+    } else {
+        println!("  ❌ RAGCitation: Failed");
+        failed += 1;
+    }
+
+    // Test RetrievalPolicy
+    let policy = RetrievalPolicy::default();
+    if policy == RetrievalPolicy::Always {
+        println!("  ✅ RetrievalPolicy: Default is {:?}", policy);
+        passed += 1;
+    } else {
+        println!("  ❌ RetrievalPolicy: Failed");
+        failed += 1;
+    }
+
+    // Test all RetrievalPolicy variants
+    let policies = vec![
+        RetrievalPolicy::Always,
+        RetrievalPolicy::Never,
+        RetrievalPolicy::OnDemand,
+        RetrievalPolicy::Threshold,
+    ];
+    println!("  ✅ RetrievalPolicy variants: {:?}", policies);
+    passed += 1;
+
+    // Test RagRetrievalPolicy alias
+    let _rag_policy: RagRetrievalPolicy = RetrievalPolicy::OnDemand;
+    println!("  ✅ RagRetrievalPolicy: Type alias works");
+    passed += 1;
+
+    // =========================================================================
+    // Test 3: Guardrail Types
+    // =========================================================================
+    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    println!("🛡️ Test 3: Guardrail Types");
+    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+
+    let guardrail = LLMGuardrail::new("content_safety", "Ensures content is safe and appropriate")
+        .with_model("gpt-4o-mini")
+        .with_prompt("Check if the following content is safe: {content}")
+        .block_on_failure(true);
+
+    if guardrail.name == "content_safety" && guardrail.model == "gpt-4o-mini" && guardrail.block_on_failure {
+        println!("  ✅ LLMGuardrail: Created successfully");
+        println!("     - Name: {}", guardrail.name);
+        println!("     - Model: {}", guardrail.model);
+        println!("     - Block on failure: {}", guardrail.block_on_failure);
+        passed += 1;
+    } else {
+        println!("  ❌ LLMGuardrail: Failed");
+        failed += 1;
+    }
+
+    // =========================================================================
+    // Test 4: Handoff Errors
+    // =========================================================================
+    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    println!("🔄 Test 4: Handoff Errors");
+    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+
+    // Test Cycle error
+    let cycle_err = HandoffError::Cycle { 
+        agents: vec!["agent_a".to_string(), "agent_b".to_string(), "agent_a".to_string()] 
+    };
+    let cycle_msg = cycle_err.to_string();
+    if cycle_msg.contains("cycle") {
+        println!("  ✅ HandoffError::Cycle: {}", cycle_msg);
+        passed += 1;
+    } else {
+        println!("  ❌ HandoffError::Cycle: Failed");
+        failed += 1;
+    }
+
+    // Test DepthExceeded error
+    let depth_err = HandoffError::DepthExceeded { max_depth: 10 };
+    let depth_msg = depth_err.to_string();
+    if depth_msg.contains("10") {
+        println!("  ✅ HandoffError::DepthExceeded: {}", depth_msg);
+        passed += 1;
+    } else {
+        println!("  ❌ HandoffError::DepthExceeded: Failed");
+        failed += 1;
+    }
+
+    // Test Timeout error
+    let timeout_err = HandoffError::Timeout { timeout_ms: 30000 };
+    let timeout_msg = timeout_err.to_string();
+    if timeout_msg.contains("30000") {
+        println!("  ✅ HandoffError::Timeout: {}", timeout_msg);
+        passed += 1;
+    } else {
+        println!("  ❌ HandoffError::Timeout: Failed");
+        failed += 1;
+    }
+
+    // Test AgentNotFound error
+    let not_found_err = HandoffError::AgentNotFound { name: "unknown_agent".to_string() };
+    println!("  ✅ HandoffError::AgentNotFound: {}", not_found_err);
+    passed += 1;
+
+    // Test InvalidConfig error
+    let invalid_err = HandoffError::InvalidConfig { message: "Missing required field".to_string() };
+    println!("  ✅ HandoffError::InvalidConfig: {}", invalid_err);
+    passed += 1;
+
+    // =========================================================================
+    // Test 5: App Protocols
+    // =========================================================================
+    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    println!("📱 Test 5: App Protocols");
+    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+
+    let app_config = AgentAppConfig::new("my_agent_app");
+    if app_config.name == "my_agent_app" && app_config.port == 8000 {
+        println!("  ✅ AgentAppConfig: Created successfully");
+        println!("     - Name: {}", app_config.name);
+        println!("     - Version: {}", app_config.version);
+        println!("     - Host: {}", app_config.host);
+        println!("     - Port: {}", app_config.port);
+        println!("     - Debug: {}", app_config.debug);
+        passed += 1;
+    } else {
+        println!("  ❌ AgentAppConfig: Failed");
+        failed += 1;
+    }
+
+    // =========================================================================
+    // Test 6: Sandbox Types
+    // =========================================================================
+    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    println!("🔒 Test 6: Sandbox Types");
+    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+
+    let restrictive = SecurityPolicy::restrictive();
+    if !restrictive.allow_network && !restrictive.allow_filesystem && !restrictive.allow_subprocess {
+        println!("  ✅ SecurityPolicy::restrictive()");
+        println!("     - Network: {}", restrictive.allow_network);
+        println!("     - Filesystem: {}", restrictive.allow_filesystem);
+        println!("     - Subprocess: {}", restrictive.allow_subprocess);
+        println!("     - Max execution time: {}s", restrictive.max_execution_time);
+        passed += 1;
+    } else {
+        println!("  ❌ SecurityPolicy::restrictive(): Failed");
+        failed += 1;
+    }
+
+    let permissive = SecurityPolicy::permissive();
+    if permissive.allow_network && permissive.allow_filesystem && permissive.allow_subprocess {
+        println!("  ✅ SecurityPolicy::permissive()");
+        println!("     - Network: {}", permissive.allow_network);
+        println!("     - Filesystem: {}", permissive.allow_filesystem);
+        println!("     - Subprocess: {}", permissive.allow_subprocess);
+        println!("     - Max execution time: {}s", permissive.max_execution_time);
+        passed += 1;
+    } else {
+        println!("  ❌ SecurityPolicy::permissive(): Failed");
+        failed += 1;
+    }
+
+    // =========================================================================
+    // Test 7: Reflection Types
+    // =========================================================================
+    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    println!("🪞 Test 7: Reflection Types");
+    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+
+    let reflection = ReflectionOutput::new(
+        "The answer is 42",
+        "This answer is correct but could be more detailed"
+    );
+    if !reflection.was_modified && reflection.confidence == 1.0 {
+        println!("  ✅ ReflectionOutput::new()");
+        println!("     - Original: {}", reflection.original);
+        println!("     - Reflection: {}", reflection.reflection);
+        println!("     - Was modified: {}", reflection.was_modified);
+        passed += 1;
+    } else {
+        println!("  ❌ ReflectionOutput::new(): Failed");
+        failed += 1;
+    }
+
+    let improved = ReflectionOutput::with_improvement(
+        "The answer is 42",
+        "Adding more context would help",
+        "The answer is 42, which is the answer to life, the universe, and everything"
+    );
+    if improved.was_modified && improved.improved.is_some() {
+        println!("  ✅ ReflectionOutput::with_improvement()");
+        println!("     - Improved: {}", improved.improved.as_ref().unwrap());
+        passed += 1;
+    } else {
+        println!("  ❌ ReflectionOutput::with_improvement(): Failed");
+        failed += 1;
+    }
+
+    // =========================================================================
+    // Test 8: Embedding Functions
+    // =========================================================================
+    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    println!("🔢 Test 8: Embedding Functions");
+    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+
+    // Test embed function
+    match embed("Hello, world!", None) {
+        Ok(vec) => {
+            if vec.len() == 1536 {
+                println!("  ✅ embed(): Returns {} dimensional vector", vec.len());
+                passed += 1;
+            } else {
+                println!("  ❌ embed(): Wrong dimension");
+                failed += 1;
+            }
+        }
+        Err(e) => {
+            println!("  ❌ embed(): Error - {}", e);
+            failed += 1;
+        }
+    }
+
+    // Test embedding function (alias)
+    match embedding("Test text", Some("text-embedding-3-small")) {
+        Ok(vec) => {
+            println!("  ✅ embedding(): Alias works, {} dimensions", vec.len());
+            passed += 1;
+        }
+        Err(e) => {
+            println!("  ❌ embedding(): Error - {}", e);
+            failed += 1;
+        }
+    }
+
+    // Test embeddings function (batch)
+    match embeddings(&["text1", "text2", "text3"], None) {
+        Ok(vecs) => {
+            if vecs.len() == 3 {
+                println!("  ✅ embeddings(): Batch of {} vectors", vecs.len());
+                passed += 1;
+            } else {
+                println!("  ❌ embeddings(): Wrong batch size");
+                failed += 1;
+            }
+        }
+        Err(e) => {
+            println!("  ❌ embeddings(): Error - {}", e);
+            failed += 1;
+        }
+    }
+
+    // =========================================================================
+    // Test 9: Display Callbacks
+    // =========================================================================
+    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    println!("📺 Test 9: Display Callbacks");
+    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+
+    let sync_cbs = sync_display_callbacks();
+    println!("  ✅ sync_display_callbacks(): {} callbacks registered", sync_cbs.len());
+    passed += 1;
+
+    let async_cbs = async_display_callbacks();
+    println!("  ✅ async_display_callbacks(): {} callbacks registered", async_cbs.len());
+    passed += 1;
+
+    let logs = error_logs();
+    println!("  ✅ error_logs(): {} logs", logs.len());
+    passed += 1;
+
+    // =========================================================================
+    // Test 10: Presets
+    // =========================================================================
+    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    println!("⚙️ Test 10: Presets");
+    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+
+    if PARITY_AUTONOMY_PRESETS.contains_key("full") && 
+       PARITY_AUTONOMY_PRESETS.contains_key("supervised") && 
+       PARITY_AUTONOMY_PRESETS.contains_key("minimal") {
+        println!("  ✅ PARITY_AUTONOMY_PRESETS: Contains all presets");
+        for (name, preset) in PARITY_AUTONOMY_PRESETS.iter() {
+            println!("     - {}: {:?}", name, preset.get("level"));
+        }
+        passed += 1;
+    } else {
+        println!("  ❌ PARITY_AUTONOMY_PRESETS: Missing presets");
+        failed += 1;
+    }
+
+    if RECOMMENDED_PROMPT_PREFIX.contains("hand off") {
+        println!("  ✅ RECOMMENDED_PROMPT_PREFIX: Contains handoff instructions");
+        println!("     - Preview: {}...", &RECOMMENDED_PROMPT_PREFIX[..50]);
+        passed += 1;
+    } else {
+        println!("  ❌ RECOMMENDED_PROMPT_PREFIX: Missing content");
+        failed += 1;
+    }
+
+    // =========================================================================
+    // Test 11: Resolver Functions
+    // =========================================================================
+    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    println!("🔧 Test 11: Resolver Functions");
+    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+
+    let policies = resolve_guardrail_policies(Some(&["no_pii", "no_profanity", "content_safety"]), None);
+    if policies.len() == 3 {
+        println!("  ✅ resolve_guardrail_policies(): Resolved {} policies", policies.len());
+        for p in &policies {
+            println!("     - {}", p);
+        }
+        passed += 1;
+    } else {
+        println!("  ❌ resolve_guardrail_policies(): Failed");
+        failed += 1;
+    }
+
+    let empty_policies = resolve_guardrail_policies(None, None);
+    if empty_policies.is_empty() {
+        println!("  ✅ resolve_guardrail_policies(None, None): Returns empty");
+        passed += 1;
+    } else {
+        println!("  ❌ resolve_guardrail_policies(None, None): Should be empty");
+        failed += 1;
+    }
+
+    // =========================================================================
+    // Test 12: Trace Functions
+    // =========================================================================
+    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    println!("📊 Test 12: Trace Functions");
+    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+
+    let ctx = trace_context();
+    if !ctx.trace_id.is_empty() && !ctx.span_id.is_empty() {
+        println!("  ✅ trace_context(): Created");
+        println!("     - Trace ID: {}", ctx.trace_id);
+        println!("     - Span ID: {}", ctx.span_id);
+        passed += 1;
+    } else {
+        println!("  ❌ trace_context(): Failed");
+        failed += 1;
+    }
+
+    let workflow_ctx = track_workflow("research_workflow", None);
+    if workflow_ctx.attributes.contains_key("workflow_name") {
+        println!("  ✅ track_workflow(): Tracking 'research_workflow'");
+        println!("     - Trace ID: {}", workflow_ctx.trace_id);
+        passed += 1;
+    } else {
+        println!("  ❌ track_workflow(): Failed");
+        failed += 1;
+    }
+
+    // =========================================================================
+    // Test 13: Plugin Functions
+    // =========================================================================
+    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    println!("🔌 Test 13: Plugin Functions");
+    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+
+    match load_plugin("/path/to/plugin") {
+        Ok(()) => {
+            println!("  ✅ load_plugin(): Function callable (placeholder)");
+            passed += 1;
+        }
+        Err(e) => {
+            println!("  ❌ load_plugin(): Error - {}", e);
+            failed += 1;
+        }
+    }
+
+    // =========================================================================
+    // Test 14: Telemetry Functions
+    // =========================================================================
+    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    println!("📈 Test 14: Telemetry Functions");
+    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+
+    let _telemetry = get_telemetry();
+    println!("  ✅ get_telemetry(): Instance retrieved");
+    passed += 1;
+
+    enable_telemetry();
+    if is_telemetry_enabled() {
+        println!("  ✅ enable_telemetry() + is_telemetry_enabled(): Works");
+        passed += 1;
+    } else {
+        println!("  ❌ enable_telemetry(): Failed");
+        failed += 1;
+    }
+
+    disable_telemetry();
+    if !is_telemetry_enabled() {
+        println!("  ✅ disable_telemetry(): Works");
+        passed += 1;
+    } else {
+        println!("  ❌ disable_telemetry(): Failed");
+        failed += 1;
+    }
+
+    // =========================================================================
+    // Test 15: UI Protocols
+    // =========================================================================
+    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    println!("🖥️ Test 15: UI Protocols");
+    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+
+    let a2a = A2A::new("test_agent", "http://localhost:8000");
+    println!("  ✅ A2A: Created for agent '{}'", a2a.name);
+    passed += 1;
+
+    let agui = AGUI::new("gui_session");
+    println!("  ✅ AGUI: Created session '{}'", agui.name);
+    passed += 1;
+
+    let event = AGUIEvent::run_started("test_run_123");
+    println!("  ✅ AGUIEvent: Created {:?} event", event.event_type);
+    passed += 1;
+
+    // =========================================================================
+    // Test 16: Config Functions
+    // =========================================================================
+    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    println!("⚙️ Test 16: Config Functions");
+    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+
+    let config = get_config();
+    println!("  ✅ get_config(): Retrieved configuration");
+    println!("     - Plugins: {:?}", config.plugins);
+    passed += 1;
+
+    // =========================================================================
+    // Summary
+    // =========================================================================
+    println!("\n╔══════════════════════════════════════════════════════════════╗");
+    println!("║                        TEST SUMMARY                          ║");
+    println!("╠══════════════════════════════════════════════════════════════╣");
+    println!("║  ✅ Passed: {:3}                                              ║", passed);
+    println!("║  ❌ Failed: {:3}                                              ║", failed);
+    println!("║  📊 Total:  {:3}                                              ║", passed + failed);
+    println!("╚══════════════════════════════════════════════════════════════╝");
+
+    if failed == 0 {
+        println!("\n🎉 All parity feature tests PASSED!");
+    } else {
+        println!("\n⚠️  Some tests failed. Please review the output above.");
+        std::process::exit(1);
+    }
+}
@@ -0,0 +1,437 @@
+//! Real Agent Integration Test with LLM API
+//!
+//! This example tests the actual agent functionality with real API calls.
+//! Run with: OPENAI_API_KEY=your_key cargo run --example real_agent_test
+//!
+//! Tests:
+//! 1. Simple agent chat
+//! 2. Agent with tools
+//! 3. Multi-agent team
+//! 4. Workflow patterns
+
+use praisonai::{Agent, AgentTeam, Process, Tool, ToolRegistry};
+use async_trait::async_trait;
+use serde_json::{json, Value};
+use std::env;
+
+/// A simple calculator tool for testing
+struct CalculatorTool;
+
+#[async_trait]
+impl Tool for CalculatorTool {
+    fn name(&self) -> &str {
+        "calculator"
+    }
+
+    fn description(&self) -> &str {
+        "Performs basic arithmetic operations. Supports add, subtract, multiply, divide."
+    }
+
+    fn parameters_schema(&self) -> Value {
+        json!({
+            "type": "object",
+            "properties": {
+                "operation": {
+                    "type": "string",
+                    "enum": ["add", "subtract", "multiply", "divide"],
+                    "description": "The arithmetic operation to perform"
+                },
+                "a": {
+                    "type": "number",
+                    "description": "First operand"
+                },
+                "b": {
+                    "type": "number",
+                    "description": "Second operand"
+                }
+            },
+            "required": ["operation", "a", "b"]
+        })
+    }
+
+    async fn execute(&self, args: Value) -> praisonai::Result<Value> {
+        let operation = args["operation"].as_str().unwrap_or("add");
+        let a = args["a"].as_f64().unwrap_or(0.0);
+        let b = args["b"].as_f64().unwrap_or(0.0);
+
+        let result = match operation {
+            "add" => a + b,
+            "subtract" => a - b,
+            "multiply" => a * b,
+            "divide" => {
+                if b == 0.0 {
+                    return Ok(json!({"error": "Division by zero"}));
+                }
+                a / b
+            }
+            _ => return Ok(json!({"error": "Unknown operation"})),
+        };
+
+        Ok(json!({
+            "operation": operation,
+            "a": a,
+            "b": b,
+            "result": result
+        }))
+    }
+}
+
+/// A simple weather tool for testing
+struct WeatherTool;
+
+#[async_trait]
+impl Tool for WeatherTool {
+    fn name(&self) -> &str {
+        "get_weather"
+    }
+
+    fn description(&self) -> &str {
+        "Gets the current weather for a location. Returns temperature and conditions."
+    }
+
+    fn parameters_schema(&self) -> Value {
+        json!({
+            "type": "object",
+            "properties": {
+                "location": {
+                    "type": "string",
+                    "description": "The city or location to get weather for"
+                }
+            },
+            "required": ["location"]
+        })
+    }
+
+    async fn execute(&self, args: Value) -> praisonai::Result<Value> {
+        let location = args["location"].as_str().unwrap_or("Unknown");
+        
+        // Simulated weather data
+        Ok(json!({
+            "location": location,
+            "temperature": 72,
+            "unit": "fahrenheit",
+            "conditions": "sunny",
+            "humidity": 45
+        }))
+    }
+}
+
+#[tokio::main]
+async fn main() {
+    println!("╔══════════════════════════════════════════════════════════════╗");
+    println!("║      PraisonAI Rust SDK - Real Agent Integration Tests       ║");
+    println!("╚══════════════════════════════════════════════════════════════╝\n");
+
+    // Check for API key
+    let api_key = env::var("OPENAI_API_KEY").ok();
+    if api_key.is_none() {
+        println!("⚠️  OPENAI_API_KEY not set. Running in mock mode.\n");
+        println!("To run with real API calls, set: export OPENAI_API_KEY=your_key\n");
+    }
+
+    let mut passed = 0;
+    let mut failed = 0;
+
+    // =========================================================================
+    // Test 1: Simple Agent Creation
+    // =========================================================================
+    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    println!("🤖 Test 1: Simple Agent Creation");
+    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+
+    match Agent::new()
+        .name("assistant")
+        .instructions("You are a helpful assistant. Be concise.")
+        .model("gpt-4o-mini")
+        .build()
+    {
+        Ok(agent) => {
+            println!("  ✅ Agent created successfully");
+            println!("     - Name: {}", agent.name());
+            println!("     - Model: {}", agent.model());
+            println!("     - ID: {}", agent.id());
+            passed += 1;
+
+            // Test chat if API key is available
+            if api_key.is_some() {
+                println!("\n  📤 Sending test message...");
+                match agent.chat("Say 'Hello from Rust!' in exactly those words.").await {
+                    Ok(response) => {
+                        println!("  📥 Response: {}", response);
+                        if response.to_lowercase().contains("hello") {
+                            println!("  ✅ Chat response received");
+                            passed += 1;
+                        } else {
+                            println!("  ⚠️  Unexpected response format");
+                            passed += 1; // Still count as pass since we got a response
+                        }
+                    }
+                    Err(e) => {
+                        println!("  ❌ Chat failed: {}", e);
+                        failed += 1;
+                    }
+                }
+            } else {
+                println!("  ⏭️  Skipping chat test (no API key)");
+            }
+        }
+        Err(e) => {
+            println!("  ❌ Agent creation failed: {}", e);
+            failed += 1;
+        }
+    }
+
+    // =========================================================================
+    // Test 2: Agent with Tools
+    // =========================================================================
+    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    println!("🔧 Test 2: Agent with Tools");
+    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+
+    match Agent::new()
+        .name("calculator_agent")
+        .instructions("You are a calculator assistant. Use the calculator tool to perform math operations. Always use the tool for calculations.")
+        .model("gpt-4o-mini")
+        .tool(CalculatorTool)
+        .build()
+    {
+        Ok(agent) => {
+            println!("  ✅ Agent with tool created");
+            println!("     - Tool count: {}", agent.tool_count().await);
+            passed += 1;
+
+            if api_key.is_some() {
+                println!("\n  📤 Asking agent to calculate 15 + 27...");
+                match agent.chat("What is 15 + 27? Use the calculator tool.").await {
+                    Ok(response) => {
+                        println!("  📥 Response: {}", response);
+                        if response.contains("42") {
+                            println!("  ✅ Correct calculation result");
+                            passed += 1;
+                        } else {
+                            println!("  ⚠️  Response received but may not contain expected result");
+                            passed += 1;
+                        }
+                    }
+                    Err(e) => {
+                        println!("  ❌ Chat with tool failed: {}", e);
+                        failed += 1;
+                    }
+                }
+            } else {
+                println!("  ⏭️  Skipping tool chat test (no API key)");
+            }
+        }
+        Err(e) => {
+            println!("  ❌ Agent with tool creation failed: {}", e);
+            failed += 1;
+        }
+    }
+
+    // =========================================================================
+    // Test 3: Tool Registry
+    // =========================================================================
+    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    println!("📦 Test 3: Tool Registry");
+    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+
+    let mut registry = ToolRegistry::new();
+    registry.register(CalculatorTool);
+    registry.register(WeatherTool);
+
+    println!("  ✅ Tool registry created with {} tools", registry.len());
+    println!("     - Tools: {:?}", registry.list());
+    passed += 1;
+
+    // Test tool execution
+    let calc_result = registry.execute("calculator", json!({
+        "operation": "multiply",
+        "a": 7,
+        "b": 8
+    })).await;
+
+    match calc_result {
+        Ok(result) => {
+            println!("  ✅ Calculator tool executed: {:?}", result.value);
+            passed += 1;
+        }
+        Err(e) => {
+            println!("  ❌ Calculator tool execution failed: {}", e);
+            failed += 1;
+        }
+    }
+
+    let weather_result = registry.execute("get_weather", json!({
+        "location": "San Francisco"
+    })).await;
+
+    match weather_result {
+        Ok(result) => {
+            println!("  ✅ Weather tool executed: {:?}", result.value);
+            passed += 1;
+        }
+        Err(e) => {
+            println!("  ❌ Weather tool execution failed: {}", e);
+            failed += 1;
+        }
+    }
+
+    // =========================================================================
+    // Test 4: Multi-Agent Team (Sequential)
+    // =========================================================================
+    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    println!("👥 Test 4: Multi-Agent Team");
+    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+
+    let researcher = Agent::new()
+        .name("researcher")
+        .instructions("You are a researcher. Provide brief factual information.")
+        .model("gpt-4o-mini")
+        .build();
+
+    let writer = Agent::new()
+        .name("writer")
+        .instructions("You are a writer. Take the research and write a brief summary.")
+        .model("gpt-4o-mini")
+        .build();
+
+    match (researcher, writer) {
+        (Ok(r), Ok(w)) => {
+            let team = AgentTeam::new()
+                .agent(r)
+                .agent(w)
+                .process(Process::Sequential)
+                .build();
+            
+            println!("  ✅ Agent team created");
+            println!("     - Agents: {}", team.len());
+            println!("     - Process: Sequential");
+            passed += 1;
+
+            if api_key.is_some() {
+                println!("\n  📤 Running team task...");
+                match team.start("Research and summarize: What is Rust programming language?").await {
+                    Ok(result) => {
+                        let truncated: String = result.chars().take(200).collect();
+                        println!("  📥 Team result (truncated): {}...", truncated);
+                        println!("  ✅ Team execution completed");
+                        passed += 1;
+                    }
+                    Err(e) => {
+                        println!("  ❌ Team execution failed: {}", e);
+                        failed += 1;
+                    }
+                }
+            } else {
+                println!("  ⏭️  Skipping team execution (no API key)");
+            }
+        }
+        _ => {
+            println!("  ❌ Failed to create agents for team");
+            failed += 1;
+        }
+    }
+
+    // =========================================================================
+    // Test 5: Agent Memory
+    // =========================================================================
+    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    println!("🧠 Test 5: Agent Memory");
+    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+
+    match Agent::new()
+        .name("memory_agent")
+        .instructions("You are a helpful assistant with memory.")
+        .model("gpt-4o-mini")
+        .build()
+    {
+        Ok(agent) => {
+            println!("  ✅ Memory agent created");
+            
+            if api_key.is_some() {
+                // First message
+                println!("\n  📤 First message: 'My name is Alice'");
+                match agent.chat("My name is Alice. Remember this.").await {
+                    Ok(_) => {
+                        println!("  ✅ First message processed");
+                        
+                        // Check history
+                        match agent.history().await {
+                            Ok(history) => {
+                                println!("  📜 History length: {} messages", history.len());
+                                passed += 1;
+                            }
+                            Err(e) => {
+                                println!("  ❌ History retrieval failed: {}", e);
+                                failed += 1;
+                            }
+                        }
+
+                        // Second message to test memory
+                        println!("\n  📤 Second message: 'What is my name?'");
+                        match agent.chat("What is my name?").await {
+                            Ok(response) => {
+                                println!("  📥 Response: {}", response);
+                                if response.to_lowercase().contains("alice") {
+                                    println!("  ✅ Memory working - agent remembered the name");
+                                    passed += 1;
+                                } else {
+                                    println!("  ⚠️  Agent may not have remembered the name");
+                                    passed += 1;
+                                }
+                            }
+                            Err(e) => {
+                                println!("  ❌ Second chat failed: {}", e);
+                                failed += 1;
+                            }
+                        }
+
+                        // Clear memory
+                        match agent.clear_memory().await {
+                            Ok(()) => {
+                                println!("  ✅ Memory cleared");
+                                passed += 1;
+                            }
+                            Err(e) => {
+                                println!("  ❌ Memory clear failed: {}", e);
+                                failed += 1;
+                            }
+                        }
+                    }
+                    Err(e) => {
+                        println!("  ❌ First chat failed: {}", e);
+                        failed += 1;
+                    }
+                }
+            } else {
+                println!("  ⏭️  Skipping memory test (no API key)");
+                passed += 1;
+            }
+        }
+        Err(e) => {
+            println!("  ❌ Memory agent creation failed: {}", e);
+            failed += 1;
+        }
+    }
+
+    // =========================================================================
+    // Summary
+    // =========================================================================
+    println!("\n╔══════════════════════════════════════════════════════════════╗");
+    println!("║                        TEST SUMMARY                          ║");
+    println!("╠══════════════════════════════════════════════════════════════╣");
+    println!("║  ✅ Passed: {:3}                                              ║", passed);
+    println!("║  ❌ Failed: {:3}                                              ║", failed);
+    println!("║  📊 Total:  {:3}                                              ║", passed + failed);
+    if api_key.is_none() {
+        println!("║  ⚠️  Note: Some tests skipped (no API key)                   ║");
+    }
+    println!("╚══════════════════════════════════════════════════════════════╝");
+
+    if failed == 0 {
+        println!("\n🎉 All tests PASSED!");
+    } else {
+        println!("\n⚠️  Some tests failed. Please review the output above.");
+        std::process::exit(1);
+    }
+}
@@ -0,0 +1,637 @@
+//! Bots Module for PraisonAI Rust SDK
+//!
+//! Defines protocols and types for messaging bot implementations.
+//! Enables agents to communicate through messaging platforms like
+//! Telegram, Discord, Slack, etc.
+//!
+//! # Example
+//!
+//! ```rust,ignore
+//! use praisonai::bots::{BotMessage, BotUser, BotChannel, MessageType};
+//!
+//! let user = BotUser::new("user-123")
+//!     .username("john_doe")
+//!     .display_name("John Doe");
+//!
+//! let message = BotMessage::text("Hello!", user.clone(), "channel-1");
+//! ```
+
+use async_trait::async_trait;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::time::{SystemTime, UNIX_EPOCH};
+use uuid::Uuid;
+
+use crate::agent::Agent;
+use crate::error::Result;
+
+/// Types of bot messages.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum MessageType {
+    Text,
+    Image,
+    Audio,
+    Video,
+    File,
+    Location,
+    Sticker,
+    Command,
+    Callback,
+    Reaction,
+    Reply,
+    Edit,
+    Delete,
+}
+
+impl Default for MessageType {
+    fn default() -> Self {
+        Self::Text
+    }
+}
+
+impl std::fmt::Display for MessageType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let s = match self {
+            Self::Text => "text",
+            Self::Image => "image",
+            Self::Audio => "audio",
+            Self::Video => "video",
+            Self::File => "file",
+            Self::Location => "location",
+            Self::Sticker => "sticker",
+            Self::Command => "command",
+            Self::Callback => "callback",
+            Self::Reaction => "reaction",
+            Self::Reply => "reply",
+            Self::Edit => "edit",
+            Self::Delete => "delete",
+        };
+        write!(f, "{}", s)
+    }
+}
+
+/// Get current timestamp in seconds since UNIX epoch.
+fn current_timestamp() -> f64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_secs_f64())
+        .unwrap_or(0.0)
+}
+
+/// Represents a user in a messaging platform.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BotUser {
+    /// Platform-specific user identifier
+    pub user_id: String,
+    /// User's username (if available)
+    pub username: Option<String>,
+    /// User's display name
+    pub display_name: Option<String>,
+    /// Whether this user is a bot
+    pub is_bot: bool,
+    /// Additional platform-specific metadata
+    pub metadata: HashMap<String, serde_json::Value>,
+}
+
+impl BotUser {
+    /// Create a new bot user.
+    pub fn new(user_id: impl Into<String>) -> Self {
+        Self {
+            user_id: user_id.into(),
+            username: None,
+            display_name: None,
+            is_bot: false,
+            metadata: HashMap::new(),
+        }
+    }
+
+    /// Set username.
+    pub fn username(mut self, username: impl Into<String>) -> Self {
+        self.username = Some(username.into());
+        self
+    }
+
+    /// Set display name.
+    pub fn display_name(mut self, name: impl Into<String>) -> Self {
+        self.display_name = Some(name.into());
+        self
+    }
+
+    /// Set is_bot flag.
+    pub fn is_bot(mut self, is_bot: bool) -> Self {
+        self.is_bot = is_bot;
+        self
+    }
+
+    /// Add metadata.
+    pub fn metadata(mut self, key: impl Into<String>, value: serde_json::Value) -> Self {
+        self.metadata.insert(key.into(), value);
+        self
+    }
+
+    /// Convert to dictionary.
+    pub fn to_dict(&self) -> HashMap<String, serde_json::Value> {
+        let mut map = HashMap::new();
+        map.insert("user_id".to_string(), serde_json::json!(self.user_id));
+        map.insert("username".to_string(), serde_json::json!(self.username));
+        map.insert("display_name".to_string(), serde_json::json!(self.display_name));
+        map.insert("is_bot".to_string(), serde_json::json!(self.is_bot));
+        map.insert("metadata".to_string(), serde_json::json!(self.metadata));
+        map
+    }
+}
+
+/// Represents a channel/chat in a messaging platform.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BotChannel {
+    /// Platform-specific channel identifier
+    pub channel_id: String,
+    /// Channel name (if available)
+    pub name: Option<String>,
+    /// Type of channel (dm, group, channel, thread)
+    pub channel_type: String,
+    /// Additional platform-specific metadata
+    pub metadata: HashMap<String, serde_json::Value>,
+}
+
+impl BotChannel {
+    /// Create a new bot channel.
+    pub fn new(channel_id: impl Into<String>) -> Self {
+        Self {
+            channel_id: channel_id.into(),
+            name: None,
+            channel_type: "dm".to_string(),
+            metadata: HashMap::new(),
+        }
+    }
+
+    /// Set channel name.
+    pub fn name(mut self, name: impl Into<String>) -> Self {
+        self.name = Some(name.into());
+        self
+    }
+
+    /// Set channel type.
+    pub fn channel_type(mut self, channel_type: impl Into<String>) -> Self {
+        self.channel_type = channel_type.into();
+        self
+    }
+
+    /// Add metadata.
+    pub fn metadata(mut self, key: impl Into<String>, value: serde_json::Value) -> Self {
+        self.metadata.insert(key.into(), value);
+        self
+    }
+
+    /// Convert to dictionary.
+    pub fn to_dict(&self) -> HashMap<String, serde_json::Value> {
+        let mut map = HashMap::new();
+        map.insert("channel_id".to_string(), serde_json::json!(self.channel_id));
+        map.insert("name".to_string(), serde_json::json!(self.name));
+        map.insert("channel_type".to_string(), serde_json::json!(self.channel_type));
+        map.insert("metadata".to_string(), serde_json::json!(self.metadata));
+        map
+    }
+}
+
+/// Represents a message in a messaging platform.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BotMessage {
+    /// Platform-specific message identifier
+    pub message_id: String,
+    /// Message content (text or structured data)
+    pub content: serde_json::Value,
+    /// Type of message
+    pub message_type: MessageType,
+    /// User who sent the message
+    pub sender: Option<BotUser>,
+    /// Channel where the message was sent
+    pub channel: Option<BotChannel>,
+    /// Message timestamp
+    pub timestamp: f64,
+    /// ID of message being replied to
+    pub reply_to: Option<String>,
+    /// Thread identifier (for threaded conversations)
+    pub thread_id: Option<String>,
+    /// List of attachment URLs or data
+    pub attachments: Vec<serde_json::Value>,
+    /// Additional platform-specific metadata
+    pub metadata: HashMap<String, serde_json::Value>,
+}
+
+impl BotMessage {
+    /// Create a new bot message.
+    pub fn new(content: serde_json::Value) -> Self {
+        Self {
+            message_id: Uuid::new_v4().to_string(),
+            content,
+            message_type: MessageType::Text,
+            sender: None,
+            channel: None,
+            timestamp: current_timestamp(),
+            reply_to: None,
+            thread_id: None,
+            attachments: Vec::new(),
+            metadata: HashMap::new(),
+        }
+    }
+
+    /// Create a text message.
+    pub fn text(
+        text: impl Into<String>,
+        sender: BotUser,
+        channel_id: impl Into<String>,
+    ) -> Self {
+        Self {
+            message_id: Uuid::new_v4().to_string(),
+            content: serde_json::json!(text.into()),
+            message_type: MessageType::Text,
+            sender: Some(sender),
+            channel: Some(BotChannel::new(channel_id)),
+            timestamp: current_timestamp(),
+            reply_to: None,
+            thread_id: None,
+            attachments: Vec::new(),
+            metadata: HashMap::new(),
+        }
+    }
+
+    /// Set message type.
+    pub fn message_type(mut self, msg_type: MessageType) -> Self {
+        self.message_type = msg_type;
+        self
+    }
+
+    /// Set sender.
+    pub fn sender(mut self, sender: BotUser) -> Self {
+        self.sender = Some(sender);
+        self
+    }
+
+    /// Set channel.
+    pub fn channel(mut self, channel: BotChannel) -> Self {
+        self.channel = Some(channel);
+        self
+    }
+
+    /// Set reply_to.
+    pub fn reply_to(mut self, message_id: impl Into<String>) -> Self {
+        self.reply_to = Some(message_id.into());
+        self
+    }
+
+    /// Set thread_id.
+    pub fn thread_id(mut self, thread_id: impl Into<String>) -> Self {
+        self.thread_id = Some(thread_id.into());
+        self
+    }
+
+    /// Add attachment.
+    pub fn attachment(mut self, attachment: serde_json::Value) -> Self {
+        self.attachments.push(attachment);
+        self
+    }
+
+    /// Add metadata.
+    pub fn metadata(mut self, key: impl Into<String>, value: serde_json::Value) -> Self {
+        self.metadata.insert(key.into(), value);
+        self
+    }
+
+    /// Get text content if available.
+    pub fn text_content(&self) -> Option<&str> {
+        self.content.as_str()
+    }
+
+    /// Check if message is a command.
+    pub fn is_command(&self) -> bool {
+        self.message_type == MessageType::Command
+            || self
+                .content
+                .as_str()
+                .map(|s| s.starts_with('/'))
+                .unwrap_or(false)
+    }
+
+    /// Extract command name if this is a command message.
+    pub fn command(&self) -> Option<String> {
+        if !self.is_command() {
+            return None;
+        }
+        self.content.as_str().and_then(|text| {
+            if text.starts_with('/') {
+                text.split_whitespace()
+                    .next()
+                    .map(|s| s[1..].to_string())
+            } else {
+                None
+            }
+        })
+    }
+
+    /// Extract command arguments if this is a command message.
+    pub fn command_args(&self) -> Vec<String> {
+        if !self.is_command() {
+            return Vec::new();
+        }
+        self.content
+            .as_str()
+            .map(|text| {
+                text.split_whitespace()
+                    .skip(1)
+                    .map(String::from)
+                    .collect()
+            })
+            .unwrap_or_default()
+    }
+
+    /// Convert to dictionary.
+    pub fn to_dict(&self) -> HashMap<String, serde_json::Value> {
+        let mut map = HashMap::new();
+        map.insert("message_id".to_string(), serde_json::json!(self.message_id));
+        map.insert("content".to_string(), self.content.clone());
+        map.insert("message_type".to_string(), serde_json::json!(self.message_type.to_string()));
+        map.insert("sender".to_string(), serde_json::json!(self.sender.as_ref().map(|s| s.to_dict())));
+        map.insert("channel".to_string(), serde_json::json!(self.channel.as_ref().map(|c| c.to_dict())));
+        map.insert("timestamp".to_string(), serde_json::json!(self.timestamp));
+        map.insert("reply_to".to_string(), serde_json::json!(self.reply_to));
+        map.insert("thread_id".to_string(), serde_json::json!(self.thread_id));
+        map.insert("attachments".to_string(), serde_json::json!(self.attachments));
+        map.insert("metadata".to_string(), serde_json::json!(self.metadata));
+        map
+    }
+}
+
+impl Default for BotMessage {
+    fn default() -> Self {
+        Self::new(serde_json::json!(""))
+    }
+}
+
+/// Configuration for a bot.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BotConfig {
+    /// Bot token for authentication
+    pub token: String,
+    /// Platform name (telegram, discord, slack, etc.)
+    pub platform: String,
+    /// Whether to use webhooks (vs polling)
+    pub use_webhooks: bool,
+    /// Webhook URL (if use_webhooks is true)
+    pub webhook_url: Option<String>,
+    /// Polling interval in seconds
+    pub polling_interval: u64,
+    /// Command prefix (default: "/")
+    pub command_prefix: String,
+    /// Additional platform-specific configuration
+    pub extra: HashMap<String, serde_json::Value>,
+}
+
+impl Default for BotConfig {
+    fn default() -> Self {
+        Self {
+            token: String::new(),
+            platform: "telegram".to_string(),
+            use_webhooks: false,
+            webhook_url: None,
+            polling_interval: 1,
+            command_prefix: "/".to_string(),
+            extra: HashMap::new(),
+        }
+    }
+}
+
+impl BotConfig {
+    /// Create a new bot config.
+    pub fn new(token: impl Into<String>, platform: impl Into<String>) -> Self {
+        Self {
+            token: token.into(),
+            platform: platform.into(),
+            ..Default::default()
+        }
+    }
+
+    /// Enable webhooks.
+    pub fn webhooks(mut self, url: impl Into<String>) -> Self {
+        self.use_webhooks = true;
+        self.webhook_url = Some(url.into());
+        self
+    }
+
+    /// Set polling interval.
+    pub fn polling_interval(mut self, seconds: u64) -> Self {
+        self.polling_interval = seconds;
+        self
+    }
+
+    /// Set command prefix.
+    pub fn command_prefix(mut self, prefix: impl Into<String>) -> Self {
+        self.command_prefix = prefix.into();
+        self
+    }
+
+    /// Add extra configuration.
+    pub fn extra(mut self, key: impl Into<String>, value: serde_json::Value) -> Self {
+        self.extra.insert(key.into(), value);
+        self
+    }
+}
+
+/// Protocol for messaging bot implementations.
+///
+/// Bots connect agents to messaging platforms, handling:
+/// - Message receiving and sending
+/// - Command handling
+/// - Webhook/polling management
+/// - User and channel management
+#[async_trait]
+pub trait BotProtocol: Send + Sync {
+    /// Whether the bot is currently running.
+    fn is_running(&self) -> bool;
+
+    /// Platform name (telegram, discord, slack, etc.).
+    fn platform(&self) -> &str;
+
+    /// The bot's user information.
+    fn bot_user(&self) -> Option<&BotUser>;
+
+    /// Start the bot (begin receiving messages).
+    async fn start(&mut self) -> Result<()>;
+
+    /// Stop the bot.
+    async fn stop(&mut self) -> Result<()>;
+
+    /// Set the agent that handles messages.
+    fn set_agent(&mut self, agent: Arc<Agent>);
+
+    /// Get the current agent.
+    fn get_agent(&self) -> Option<Arc<Agent>>;
+
+    /// Send a message to a channel.
+    async fn send_message(
+        &self,
+        channel_id: &str,
+        content: serde_json::Value,
+        reply_to: Option<String>,
+        thread_id: Option<String>,
+    ) -> Result<BotMessage>;
+
+    /// Edit an existing message.
+    async fn edit_message(
+        &self,
+        channel_id: &str,
+        message_id: &str,
+        content: serde_json::Value,
+    ) -> Result<BotMessage>;
+
+    /// Delete a message.
+    async fn delete_message(&self, channel_id: &str, message_id: &str) -> Result<bool>;
+
+    /// Send typing indicator to a channel.
+    async fn send_typing(&self, channel_id: &str) -> Result<()>;
+
+    /// Get user information.
+    async fn get_user(&self, user_id: &str) -> Result<Option<BotUser>>;
+
+    /// Get channel information.
+    async fn get_channel(&self, channel_id: &str) -> Result<Option<BotChannel>>;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_message_type() {
+        assert_eq!(MessageType::default(), MessageType::Text);
+        assert_eq!(MessageType::Command.to_string(), "command");
+        assert_eq!(MessageType::Image.to_string(), "image");
+    }
+
+    #[test]
+    fn test_bot_user_new() {
+        let user = BotUser::new("user-123");
+        assert_eq!(user.user_id, "user-123");
+        assert!(user.username.is_none());
+        assert!(!user.is_bot);
+    }
+
+    #[test]
+    fn test_bot_user_builder() {
+        let user = BotUser::new("user-123")
+            .username("john_doe")
+            .display_name("John Doe")
+            .is_bot(false)
+            .metadata("role", serde_json::json!("admin"));
+
+        assert_eq!(user.username, Some("john_doe".to_string()));
+        assert_eq!(user.display_name, Some("John Doe".to_string()));
+        assert_eq!(user.metadata.get("role").unwrap(), "admin");
+    }
+
+    #[test]
+    fn test_bot_channel_new() {
+        let channel = BotChannel::new("channel-1");
+        assert_eq!(channel.channel_id, "channel-1");
+        assert_eq!(channel.channel_type, "dm");
+    }
+
+    #[test]
+    fn test_bot_channel_builder() {
+        let channel = BotChannel::new("channel-1")
+            .name("General")
+            .channel_type("group");
+
+        assert_eq!(channel.name, Some("General".to_string()));
+        assert_eq!(channel.channel_type, "group");
+    }
+
+    #[test]
+    fn test_bot_message_text() {
+        let user = BotUser::new("user-1");
+        let msg = BotMessage::text("Hello world", user, "channel-1");
+
+        assert_eq!(msg.text_content(), Some("Hello world"));
+        assert_eq!(msg.message_type, MessageType::Text);
+        assert!(msg.sender.is_some());
+        assert!(msg.channel.is_some());
+    }
+
+    #[test]
+    fn test_bot_message_command() {
+        let user = BotUser::new("user-1");
+        let msg = BotMessage::text("/help arg1 arg2", user, "channel-1");
+
+        assert!(msg.is_command());
+        assert_eq!(msg.command(), Some("help".to_string()));
+        assert_eq!(msg.command_args(), vec!["arg1", "arg2"]);
+    }
+
+    #[test]
+    fn test_bot_message_not_command() {
+        let user = BotUser::new("user-1");
+        let msg = BotMessage::text("Hello world", user, "channel-1");
+
+        assert!(!msg.is_command());
+        assert!(msg.command().is_none());
+        assert!(msg.command_args().is_empty());
+    }
+
+    #[test]
+    fn test_bot_message_builder() {
+        let msg = BotMessage::new(serde_json::json!("Hello"))
+            .message_type(MessageType::Text)
+            .reply_to("msg-123")
+            .thread_id("thread-1")
+            .attachment(serde_json::json!({"url": "https://example.com/image.png"}));
+
+        assert_eq!(msg.reply_to, Some("msg-123".to_string()));
+        assert_eq!(msg.thread_id, Some("thread-1".to_string()));
+        assert_eq!(msg.attachments.len(), 1);
+    }
+
+    #[test]
+    fn test_bot_config_default() {
+        let config = BotConfig::default();
+        assert_eq!(config.platform, "telegram");
+        assert!(!config.use_webhooks);
+        assert_eq!(config.command_prefix, "/");
+    }
+
+    #[test]
+    fn test_bot_config_builder() {
+        let config = BotConfig::new("token-123", "discord")
+            .webhooks("https://example.com/webhook")
+            .command_prefix("!")
+            .polling_interval(5);
+
+        assert_eq!(config.token, "token-123");
+        assert_eq!(config.platform, "discord");
+        assert!(config.use_webhooks);
+        assert_eq!(config.webhook_url, Some("https://example.com/webhook".to_string()));
+        assert_eq!(config.command_prefix, "!");
+        assert_eq!(config.polling_interval, 5);
+    }
+
+    #[test]
+    fn test_bot_user_to_dict() {
+        let user = BotUser::new("user-1").username("test");
+        let dict = user.to_dict();
+
+        assert_eq!(dict.get("user_id").unwrap(), "user-1");
+        assert_eq!(dict.get("username").unwrap(), "test");
+    }
+
+    #[test]
+    fn test_bot_message_to_dict() {
+        let user = BotUser::new("user-1");
+        let msg = BotMessage::text("Hello", user, "channel-1");
+        let dict = msg.to_dict();
+
+        assert!(dict.contains_key("message_id"));
+        assert_eq!(dict.get("content").unwrap(), "Hello");
+        assert_eq!(dict.get("message_type").unwrap(), "text");
+    }
+}
@@ -0,0 +1,586 @@
+//! Event Bus Module for PraisonAI Agents.
+//!
+//! Provides a publish-subscribe event system for agent communication.
+//!
+//! # Features
+//!
+//! - Type-safe event publishing and subscription
+//! - Async event handlers
+//! - Multi-agent event isolation
+//! - Event filtering and routing
+//!
+//! # Example
+//!
+//! ```ignore
+//! use praisonai::{EventBus, Event, EventType};
+//!
+//! let bus = EventBus::new();
+//! bus.subscribe(EventType::AgentStart, |event| {
+//!     println!("Agent started: {:?}", event);
+//! });
+//! bus.publish(Event::agent_start("my_agent"));
+//! ```
+
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::sync::{Arc, RwLock};
+
+// =============================================================================
+// EVENT TYPE
+// =============================================================================
+
+/// Types of events that can be published.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum EventType {
+    /// Agent lifecycle events
+    AgentStart,
+    AgentEnd,
+    AgentError,
+    /// Tool events
+    ToolStart,
+    ToolEnd,
+    ToolError,
+    /// LLM events
+    LlmRequest,
+    LlmResponse,
+    LlmError,
+    /// Memory events
+    MemoryStore,
+    MemoryRetrieve,
+    MemoryClear,
+    /// Workflow events
+    WorkflowStart,
+    WorkflowEnd,
+    WorkflowStep,
+    /// Handoff events
+    HandoffStart,
+    HandoffEnd,
+    /// Session events
+    SessionCreate,
+    SessionLoad,
+    SessionSave,
+    /// Custom event
+    Custom,
+}
+
+// =============================================================================
+// EVENT
+// =============================================================================
+
+/// An event in the event bus.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Event {
+    /// Event type
+    pub event_type: EventType,
+    /// Source of the event (agent name, tool name, etc.)
+    pub source: String,
+    /// Event data
+    pub data: serde_json::Value,
+    /// Timestamp (Unix millis)
+    pub timestamp: u64,
+    /// Correlation ID for tracing
+    pub correlation_id: Option<String>,
+}
+
+impl Event {
+    /// Create a new event
+    pub fn new(event_type: EventType, source: impl Into<String>) -> Self {
+        Self {
+            event_type,
+            source: source.into(),
+            data: serde_json::Value::Null,
+            timestamp: std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .map(|d| d.as_millis() as u64)
+                .unwrap_or(0),
+            correlation_id: None,
+        }
+    }
+
+    /// Set event data
+    pub fn data(mut self, data: serde_json::Value) -> Self {
+        self.data = data;
+        self
+    }
+
+    /// Set correlation ID
+    pub fn correlation_id(mut self, id: impl Into<String>) -> Self {
+        self.correlation_id = Some(id.into());
+        self
+    }
+
+    /// Create agent start event
+    pub fn agent_start(agent_name: impl Into<String>) -> Self {
+        Self::new(EventType::AgentStart, agent_name)
+    }
+
+    /// Create agent end event
+    pub fn agent_end(agent_name: impl Into<String>) -> Self {
+        Self::new(EventType::AgentEnd, agent_name)
+    }
+
+    /// Create agent error event
+    pub fn agent_error(agent_name: impl Into<String>, error: impl Into<String>) -> Self {
+        Self::new(EventType::AgentError, agent_name)
+            .data(serde_json::json!({"error": error.into()}))
+    }
+
+    /// Create tool start event
+    pub fn tool_start(tool_name: impl Into<String>) -> Self {
+        Self::new(EventType::ToolStart, tool_name)
+    }
+
+    /// Create tool end event
+    pub fn tool_end(tool_name: impl Into<String>) -> Self {
+        Self::new(EventType::ToolEnd, tool_name)
+    }
+
+    /// Create tool error event
+    pub fn tool_error(tool_name: impl Into<String>, error: impl Into<String>) -> Self {
+        Self::new(EventType::ToolError, tool_name)
+            .data(serde_json::json!({"error": error.into()}))
+    }
+
+    /// Create LLM request event
+    pub fn llm_request(model: impl Into<String>) -> Self {
+        Self::new(EventType::LlmRequest, model)
+    }
+
+    /// Create LLM response event
+    pub fn llm_response(model: impl Into<String>) -> Self {
+        Self::new(EventType::LlmResponse, model)
+    }
+
+    /// Create workflow start event
+    pub fn workflow_start(workflow_name: impl Into<String>) -> Self {
+        Self::new(EventType::WorkflowStart, workflow_name)
+    }
+
+    /// Create workflow end event
+    pub fn workflow_end(workflow_name: impl Into<String>) -> Self {
+        Self::new(EventType::WorkflowEnd, workflow_name)
+    }
+
+    /// Create handoff start event
+    pub fn handoff_start(source: impl Into<String>, target: impl Into<String>) -> Self {
+        Self::new(EventType::HandoffStart, source)
+            .data(serde_json::json!({"target": target.into()}))
+    }
+
+    /// Create handoff end event
+    pub fn handoff_end(source: impl Into<String>, target: impl Into<String>) -> Self {
+        Self::new(EventType::HandoffEnd, source)
+            .data(serde_json::json!({"target": target.into()}))
+    }
+
+    /// Create custom event
+    pub fn custom(source: impl Into<String>, data: serde_json::Value) -> Self {
+        Self::new(EventType::Custom, source).data(data)
+    }
+}
+
+// =============================================================================
+// EVENT HANDLER
+// =============================================================================
+
+/// Type alias for event handler function
+pub type EventHandler = Arc<dyn Fn(&Event) + Send + Sync>;
+
+/// Subscription to an event type
+struct Subscription {
+    id: usize,
+    handler: EventHandler,
+}
+
+// =============================================================================
+// EVENT BUS
+// =============================================================================
+
+/// Event bus for publish-subscribe messaging.
+pub struct EventBus {
+    /// Subscriptions by event type
+    subscriptions: RwLock<HashMap<EventType, Vec<Subscription>>>,
+    /// Global subscriptions (receive all events)
+    global_subscriptions: RwLock<Vec<Subscription>>,
+    /// Next subscription ID
+    next_id: RwLock<usize>,
+    /// Event history (optional)
+    history: RwLock<Vec<Event>>,
+    /// Max history size
+    max_history: usize,
+}
+
+impl Default for EventBus {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl EventBus {
+    /// Create a new event bus
+    pub fn new() -> Self {
+        Self {
+            subscriptions: RwLock::new(HashMap::new()),
+            global_subscriptions: RwLock::new(Vec::new()),
+            next_id: RwLock::new(0),
+            history: RwLock::new(Vec::new()),
+            max_history: 1000,
+        }
+    }
+
+    /// Create with custom history size
+    pub fn with_history(max_history: usize) -> Self {
+        Self {
+            max_history,
+            ..Self::new()
+        }
+    }
+
+    /// Subscribe to a specific event type
+    pub fn subscribe<F>(&self, event_type: EventType, handler: F) -> usize
+    where
+        F: Fn(&Event) + Send + Sync + 'static,
+    {
+        let id = {
+            let mut next_id = self.next_id.write().unwrap();
+            let id = *next_id;
+            *next_id += 1;
+            id
+        };
+
+        let subscription = Subscription {
+            id,
+            handler: Arc::new(handler),
+        };
+
+        self.subscriptions
+            .write()
+            .unwrap()
+            .entry(event_type)
+            .or_default()
+            .push(subscription);
+
+        id
+    }
+
+    /// Subscribe to all events
+    pub fn subscribe_all<F>(&self, handler: F) -> usize
+    where
+        F: Fn(&Event) + Send + Sync + 'static,
+    {
+        let id = {
+            let mut next_id = self.next_id.write().unwrap();
+            let id = *next_id;
+            *next_id += 1;
+            id
+        };
+
+        let subscription = Subscription {
+            id,
+            handler: Arc::new(handler),
+        };
+
+        self.global_subscriptions.write().unwrap().push(subscription);
+
+        id
+    }
+
+    /// Unsubscribe by ID
+    pub fn unsubscribe(&self, subscription_id: usize) -> bool {
+        // Check type-specific subscriptions
+        let mut subs = self.subscriptions.write().unwrap();
+        for handlers in subs.values_mut() {
+            if let Some(pos) = handlers.iter().position(|s| s.id == subscription_id) {
+                handlers.remove(pos);
+                return true;
+            }
+        }
+
+        // Check global subscriptions
+        let mut global = self.global_subscriptions.write().unwrap();
+        if let Some(pos) = global.iter().position(|s| s.id == subscription_id) {
+            global.remove(pos);
+            return true;
+        }
+
+        false
+    }
+
+    /// Publish an event
+    pub fn publish(&self, event: Event) {
+        // Store in history
+        {
+            let mut history = self.history.write().unwrap();
+            history.push(event.clone());
+            if history.len() > self.max_history {
+                history.remove(0);
+            }
+        }
+
+        // Notify type-specific subscribers
+        if let Some(handlers) = self.subscriptions.read().unwrap().get(&event.event_type) {
+            for subscription in handlers {
+                (subscription.handler)(&event);
+            }
+        }
+
+        // Notify global subscribers
+        for subscription in self.global_subscriptions.read().unwrap().iter() {
+            (subscription.handler)(&event);
+        }
+    }
+
+    /// Get event history
+    pub fn history(&self) -> Vec<Event> {
+        self.history.read().unwrap().clone()
+    }
+
+    /// Get events by type
+    pub fn events_by_type(&self, event_type: EventType) -> Vec<Event> {
+        self.history
+            .read()
+            .unwrap()
+            .iter()
+            .filter(|e| e.event_type == event_type)
+            .cloned()
+            .collect()
+    }
+
+    /// Get events by source
+    pub fn events_by_source(&self, source: &str) -> Vec<Event> {
+        self.history
+            .read()
+            .unwrap()
+            .iter()
+            .filter(|e| e.source == source)
+            .cloned()
+            .collect()
+    }
+
+    /// Clear history
+    pub fn clear_history(&self) {
+        self.history.write().unwrap().clear();
+    }
+
+    /// Get subscription count for an event type
+    pub fn subscription_count(&self, event_type: EventType) -> usize {
+        self.subscriptions
+            .read()
+            .unwrap()
+            .get(&event_type)
+            .map(|v| v.len())
+            .unwrap_or(0)
+    }
+
+    /// Get total subscription count
+    pub fn total_subscriptions(&self) -> usize {
+        let type_subs: usize = self
+            .subscriptions
+            .read()
+            .unwrap()
+            .values()
+            .map(|v| v.len())
+            .sum();
+        let global_subs = self.global_subscriptions.read().unwrap().len();
+        type_subs + global_subs
+    }
+}
+
+// =============================================================================
+// GLOBAL EVENT BUS
+// =============================================================================
+
+use std::sync::OnceLock;
+
+static GLOBAL_EVENT_BUS: OnceLock<EventBus> = OnceLock::new();
+
+/// Get the global event bus
+pub fn get_event_bus() -> &'static EventBus {
+    GLOBAL_EVENT_BUS.get_or_init(EventBus::new)
+}
+
+/// Publish an event to the global bus
+pub fn publish(event: Event) {
+    get_event_bus().publish(event);
+}
+
+/// Subscribe to events on the global bus
+pub fn subscribe<F>(event_type: EventType, handler: F) -> usize
+where
+    F: Fn(&Event) + Send + Sync + 'static,
+{
+    get_event_bus().subscribe(event_type, handler)
+}
+
+/// Subscribe to all events on the global bus
+pub fn subscribe_all<F>(handler: F) -> usize
+where
+    F: Fn(&Event) + Send + Sync + 'static,
+{
+    get_event_bus().subscribe_all(handler)
+}
+
+// =============================================================================
+// TESTS
+// =============================================================================
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    #[test]
+    fn test_event_creation() {
+        let event = Event::new(EventType::AgentStart, "test_agent");
+        assert_eq!(event.event_type, EventType::AgentStart);
+        assert_eq!(event.source, "test_agent");
+        assert!(event.timestamp > 0);
+    }
+
+    #[test]
+    fn test_event_with_data() {
+        let event = Event::agent_start("test_agent")
+            .data(serde_json::json!({"key": "value"}))
+            .correlation_id("corr-123");
+
+        assert_eq!(event.data.get("key").unwrap(), "value");
+        assert_eq!(event.correlation_id, Some("corr-123".to_string()));
+    }
+
+    #[test]
+    fn test_event_helpers() {
+        let start = Event::agent_start("agent");
+        assert_eq!(start.event_type, EventType::AgentStart);
+
+        let error = Event::agent_error("agent", "Something went wrong");
+        assert_eq!(error.event_type, EventType::AgentError);
+        assert!(error.data.get("error").is_some());
+
+        let handoff = Event::handoff_start("source", "target");
+        assert_eq!(handoff.event_type, EventType::HandoffStart);
+        assert_eq!(handoff.data.get("target").unwrap(), "target");
+    }
+
+    #[test]
+    fn test_event_bus_subscribe_publish() {
+        let bus = EventBus::new();
+        let counter = Arc::new(AtomicUsize::new(0));
+        let counter_clone = counter.clone();
+
+        bus.subscribe(EventType::AgentStart, move |_event| {
+            counter_clone.fetch_add(1, Ordering::SeqCst);
+        });
+
+        bus.publish(Event::agent_start("test"));
+        bus.publish(Event::agent_start("test2"));
+
+        assert_eq!(counter.load(Ordering::SeqCst), 2);
+    }
+
+    #[test]
+    fn test_event_bus_subscribe_all() {
+        let bus = EventBus::new();
+        let counter = Arc::new(AtomicUsize::new(0));
+        let counter_clone = counter.clone();
+
+        bus.subscribe_all(move |_event| {
+            counter_clone.fetch_add(1, Ordering::SeqCst);
+        });
+
+        bus.publish(Event::agent_start("test"));
+        bus.publish(Event::tool_start("tool"));
+        bus.publish(Event::llm_request("gpt-4"));
+
+        assert_eq!(counter.load(Ordering::SeqCst), 3);
+    }
+
+    #[test]
+    fn test_event_bus_unsubscribe() {
+        let bus = EventBus::new();
+        let counter = Arc::new(AtomicUsize::new(0));
+        let counter_clone = counter.clone();
+
+        let sub_id = bus.subscribe(EventType::AgentStart, move |_event| {
+            counter_clone.fetch_add(1, Ordering::SeqCst);
+        });
+
+        bus.publish(Event::agent_start("test"));
+        assert_eq!(counter.load(Ordering::SeqCst), 1);
+
+        bus.unsubscribe(sub_id);
+        bus.publish(Event::agent_start("test2"));
+        assert_eq!(counter.load(Ordering::SeqCst), 1); // Still 1, handler removed
+    }
+
+    #[test]
+    fn test_event_bus_history() {
+        let bus = EventBus::with_history(10);
+
+        bus.publish(Event::agent_start("agent1"));
+        bus.publish(Event::agent_end("agent1"));
+        bus.publish(Event::tool_start("tool1"));
+
+        let history = bus.history();
+        assert_eq!(history.len(), 3);
+
+        let agent_events = bus.events_by_type(EventType::AgentStart);
+        assert_eq!(agent_events.len(), 1);
+
+        let agent1_events = bus.events_by_source("agent1");
+        assert_eq!(agent1_events.len(), 2);
+    }
+
+    #[test]
+    fn test_event_bus_history_limit() {
+        let bus = EventBus::with_history(3);
+
+        for i in 0..5 {
+            bus.publish(Event::agent_start(format!("agent{}", i)));
+        }
+
+        let history = bus.history();
+        assert_eq!(history.len(), 3);
+        assert_eq!(history[0].source, "agent2");
+        assert_eq!(history[2].source, "agent4");
+    }
+
+    #[test]
+    fn test_event_bus_subscription_count() {
+        let bus = EventBus::new();
+
+        bus.subscribe(EventType::AgentStart, |_| {});
+        bus.subscribe(EventType::AgentStart, |_| {});
+        bus.subscribe(EventType::ToolStart, |_| {});
+        bus.subscribe_all(|_| {});
+
+        assert_eq!(bus.subscription_count(EventType::AgentStart), 2);
+        assert_eq!(bus.subscription_count(EventType::ToolStart), 1);
+        assert_eq!(bus.total_subscriptions(), 4);
+    }
+
+    #[test]
+    fn test_event_type_filtering() {
+        let bus = EventBus::new();
+        let agent_counter = Arc::new(AtomicUsize::new(0));
+        let tool_counter = Arc::new(AtomicUsize::new(0));
+
+        let agent_counter_clone = agent_counter.clone();
+        let tool_counter_clone = tool_counter.clone();
+
+        bus.subscribe(EventType::AgentStart, move |_| {
+            agent_counter_clone.fetch_add(1, Ordering::SeqCst);
+        });
+
+        bus.subscribe(EventType::ToolStart, move |_| {
+            tool_counter_clone.fetch_add(1, Ordering::SeqCst);
+        });
+
+        bus.publish(Event::agent_start("agent"));
+        bus.publish(Event::agent_start("agent2"));
+        bus.publish(Event::tool_start("tool"));
+
+        assert_eq!(agent_counter.load(Ordering::SeqCst), 2);
+        assert_eq!(tool_counter.load(Ordering::SeqCst), 1);
+    }
+}
@@ -0,0 +1,479 @@
+//! Conditions Module for PraisonAI Rust SDK
+//!
+//! Provides condition protocols and implementations for workflow routing.
+//! Enables unified condition evaluation across AgentFlow and AgentTeam.
+//!
+//! # Example
+//!
+//! ```rust,ignore
+//! use praisonai::conditions::{ExpressionCondition, DictCondition};
+//!
+//! // Expression-based condition
+//! let cond = ExpressionCondition::new("score > 80");
+//! let result = cond.evaluate(&context);
+//!
+//! // Dictionary-based condition
+//! let cond = DictCondition::new()
+//!     .when("approved", vec!["review_task"])
+//!     .when("rejected", vec!["revision_task"]);
+//! ```
+
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+/// Protocol trait for condition implementations.
+///
+/// This defines the essential interface that any condition must provide.
+/// It enables unified condition evaluation across AgentFlow (string-based)
+/// and AgentTeam (dict-based) systems.
+pub trait ConditionProtocol: Send + Sync {
+    /// Evaluate the condition against the given context.
+    ///
+    /// # Arguments
+    ///
+    /// * `context` - Dictionary containing variables for evaluation.
+    ///               May include workflow variables, previous outputs, etc.
+    ///
+    /// # Returns
+    ///
+    /// Boolean result of condition evaluation.
+    /// Returns false on evaluation errors (fail-safe).
+    fn evaluate(&self, context: &HashMap<String, serde_json::Value>) -> bool;
+}
+
+/// Extended protocol for conditions that support routing to targets.
+///
+/// This extends ConditionProtocol with the ability to return target
+/// tasks/steps based on the condition evaluation.
+pub trait RoutingConditionProtocol: ConditionProtocol {
+    /// Get the target tasks/steps based on condition evaluation.
+    ///
+    /// # Arguments
+    ///
+    /// * `context` - Dictionary containing variables for evaluation.
+    ///
+    /// # Returns
+    ///
+    /// List of target task/step names to route to.
+    /// Returns empty list if no match found.
+    fn get_target(&self, context: &HashMap<String, serde_json::Value>) -> Vec<String>;
+}
+
+/// Simple expression-based condition.
+///
+/// Evaluates simple expressions like "score > 80" or "status == 'approved'".
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ExpressionCondition {
+    /// The expression to evaluate
+    pub expression: String,
+}
+
+impl ExpressionCondition {
+    /// Create a new expression condition.
+    pub fn new(expression: impl Into<String>) -> Self {
+        Self {
+            expression: expression.into(),
+        }
+    }
+
+    /// Parse and evaluate a simple comparison expression.
+    fn evaluate_expression(&self, context: &HashMap<String, serde_json::Value>) -> bool {
+        let expr = self.expression.trim();
+
+        // Handle simple boolean variable
+        if !expr.contains('>') && !expr.contains('<') && !expr.contains('=') && !expr.contains("!=") {
+            return context
+                .get(expr)
+                .and_then(|v| v.as_bool())
+                .unwrap_or(false);
+        }
+
+        // Parse comparison operators
+        let operators = [">=", "<=", "!=", "==", ">", "<"];
+        for op in operators {
+            if let Some(pos) = expr.find(op) {
+                let left = expr[..pos].trim();
+                let right = expr[pos + op.len()..].trim();
+                return self.compare(left, op, right, context);
+            }
+        }
+
+        false
+    }
+
+    /// Compare two values with an operator.
+    fn compare(
+        &self,
+        left: &str,
+        op: &str,
+        right: &str,
+        context: &HashMap<String, serde_json::Value>,
+    ) -> bool {
+        // Get left value from context
+        let left_val = context.get(left);
+
+        // Parse right value (could be literal or variable)
+        let right_val = if right.starts_with('\'') || right.starts_with('"') {
+            // String literal
+            let s = right.trim_matches(|c| c == '\'' || c == '"');
+            Some(serde_json::json!(s))
+        } else if let Ok(n) = right.parse::<f64>() {
+            // Number literal
+            Some(serde_json::json!(n))
+        } else if right == "true" {
+            Some(serde_json::json!(true))
+        } else if right == "false" {
+            Some(serde_json::json!(false))
+        } else {
+            // Variable reference
+            context.get(right).cloned()
+        };
+
+        match (left_val, right_val) {
+            (Some(l), Some(r)) => {
+                // Try numeric comparison first
+                if let (Some(ln), Some(rn)) = (l.as_f64(), r.as_f64()) {
+                    return match op {
+                        ">" => ln > rn,
+                        "<" => ln < rn,
+                        ">=" => ln >= rn,
+                        "<=" => ln <= rn,
+                        "==" => (ln - rn).abs() < f64::EPSILON,
+                        "!=" => (ln - rn).abs() >= f64::EPSILON,
+                        _ => false,
+                    };
+                }
+
+                // String comparison
+                if let (Some(ls), Some(rs)) = (l.as_str(), r.as_str()) {
+                    return match op {
+                        "==" => ls == rs,
+                        "!=" => ls != rs,
+                        ">" => ls > rs,
+                        "<" => ls < rs,
+                        ">=" => ls >= rs,
+                        "<=" => ls <= rs,
+                        _ => false,
+                    };
+                }
+
+                // Boolean comparison
+                if let (Some(lb), Some(rb)) = (l.as_bool(), r.as_bool()) {
+                    return match op {
+                        "==" => lb == rb,
+                        "!=" => lb != rb,
+                        _ => false,
+                    };
+                }
+
+                // Generic equality
+                match op {
+                    "==" => l == &r,
+                    "!=" => l != &r,
+                    _ => false,
+                }
+            }
+            _ => false,
+        }
+    }
+}
+
+impl ConditionProtocol for ExpressionCondition {
+    fn evaluate(&self, context: &HashMap<String, serde_json::Value>) -> bool {
+        self.evaluate_expression(context)
+    }
+}
+
+/// Dictionary-based condition for routing.
+///
+/// Maps values to target tasks/steps.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct DictCondition {
+    /// Variable name to check
+    pub variable: String,
+    /// Mapping of values to target tasks
+    pub routes: HashMap<String, Vec<String>>,
+    /// Default targets if no match
+    pub default: Vec<String>,
+}
+
+impl DictCondition {
+    /// Create a new dict condition.
+    pub fn new(variable: impl Into<String>) -> Self {
+        Self {
+            variable: variable.into(),
+            routes: HashMap::new(),
+            default: Vec::new(),
+        }
+    }
+
+    /// Add a route for a value.
+    pub fn when(mut self, value: impl Into<String>, targets: Vec<String>) -> Self {
+        self.routes.insert(value.into(), targets);
+        self
+    }
+
+    /// Set default targets.
+    pub fn default_targets(mut self, targets: Vec<String>) -> Self {
+        self.default = targets;
+        self
+    }
+}
+
+impl ConditionProtocol for DictCondition {
+    fn evaluate(&self, context: &HashMap<String, serde_json::Value>) -> bool {
+        if let Some(value) = context.get(&self.variable) {
+            let key = match value {
+                serde_json::Value::String(s) => s.clone(),
+                serde_json::Value::Bool(b) => b.to_string(),
+                serde_json::Value::Number(n) => n.to_string(),
+                _ => return !self.default.is_empty(),
+            };
+            self.routes.contains_key(&key) || !self.default.is_empty()
+        } else {
+            !self.default.is_empty()
+        }
+    }
+}
+
+impl RoutingConditionProtocol for DictCondition {
+    fn get_target(&self, context: &HashMap<String, serde_json::Value>) -> Vec<String> {
+        if let Some(value) = context.get(&self.variable) {
+            let key = match value {
+                serde_json::Value::String(s) => s.clone(),
+                serde_json::Value::Bool(b) => b.to_string(),
+                serde_json::Value::Number(n) => n.to_string(),
+                _ => return self.default.clone(),
+            };
+            self.routes.get(&key).cloned().unwrap_or_else(|| self.default.clone())
+        } else {
+            self.default.clone()
+        }
+    }
+}
+
+/// Closure-based condition.
+///
+/// Wraps a closure for custom condition logic.
+pub struct ClosureCondition<F>
+where
+    F: Fn(&HashMap<String, serde_json::Value>) -> bool + Send + Sync,
+{
+    condition: F,
+}
+
+impl<F> ClosureCondition<F>
+where
+    F: Fn(&HashMap<String, serde_json::Value>) -> bool + Send + Sync,
+{
+    /// Create a new closure condition.
+    pub fn new(condition: F) -> Self {
+        Self { condition }
+    }
+}
+
+impl<F> ConditionProtocol for ClosureCondition<F>
+where
+    F: Fn(&HashMap<String, serde_json::Value>) -> bool + Send + Sync,
+{
+    fn evaluate(&self, context: &HashMap<String, serde_json::Value>) -> bool {
+        (self.condition)(context)
+    }
+}
+
+/// Evaluate a condition expression against a context.
+///
+/// Convenience function for simple condition evaluation.
+pub fn evaluate_condition(
+    expression: &str,
+    context: &HashMap<String, serde_json::Value>,
+) -> bool {
+    ExpressionCondition::new(expression).evaluate(context)
+}
+
+/// Builder for creating conditions.
+pub struct If;
+
+impl If {
+    /// Create an expression condition.
+    pub fn expr(expression: impl Into<String>) -> ExpressionCondition {
+        ExpressionCondition::new(expression)
+    }
+
+    /// Create a dict condition.
+    pub fn dict(variable: impl Into<String>) -> DictCondition {
+        DictCondition::new(variable)
+    }
+
+    /// Create a closure condition.
+    pub fn closure<F>(f: F) -> ClosureCondition<F>
+    where
+        F: Fn(&HashMap<String, serde_json::Value>) -> bool + Send + Sync,
+    {
+        ClosureCondition::new(f)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn make_context(pairs: &[(&str, serde_json::Value)]) -> HashMap<String, serde_json::Value> {
+        pairs.iter().map(|(k, v)| (k.to_string(), v.clone())).collect()
+    }
+
+    #[test]
+    fn test_expression_condition_numeric_greater() {
+        let cond = ExpressionCondition::new("score > 80");
+        
+        let ctx = make_context(&[("score", serde_json::json!(90))]);
+        assert!(cond.evaluate(&ctx));
+
+        let ctx = make_context(&[("score", serde_json::json!(70))]);
+        assert!(!cond.evaluate(&ctx));
+    }
+
+    #[test]
+    fn test_expression_condition_numeric_equal() {
+        let cond = ExpressionCondition::new("count == 5");
+        
+        let ctx = make_context(&[("count", serde_json::json!(5))]);
+        assert!(cond.evaluate(&ctx));
+
+        let ctx = make_context(&[("count", serde_json::json!(3))]);
+        assert!(!cond.evaluate(&ctx));
+    }
+
+    #[test]
+    fn test_expression_condition_string_equal() {
+        let cond = ExpressionCondition::new("status == 'approved'");
+        
+        let ctx = make_context(&[("status", serde_json::json!("approved"))]);
+        assert!(cond.evaluate(&ctx));
+
+        let ctx = make_context(&[("status", serde_json::json!("rejected"))]);
+        assert!(!cond.evaluate(&ctx));
+    }
+
+    #[test]
+    fn test_expression_condition_not_equal() {
+        let cond = ExpressionCondition::new("status != 'pending'");
+        
+        let ctx = make_context(&[("status", serde_json::json!("approved"))]);
+        assert!(cond.evaluate(&ctx));
+
+        let ctx = make_context(&[("status", serde_json::json!("pending"))]);
+        assert!(!cond.evaluate(&ctx));
+    }
+
+    #[test]
+    fn test_expression_condition_boolean() {
+        let cond = ExpressionCondition::new("is_valid");
+        
+        let ctx = make_context(&[("is_valid", serde_json::json!(true))]);
+        assert!(cond.evaluate(&ctx));
+
+        let ctx = make_context(&[("is_valid", serde_json::json!(false))]);
+        assert!(!cond.evaluate(&ctx));
+    }
+
+    #[test]
+    fn test_expression_condition_missing_variable() {
+        let cond = ExpressionCondition::new("score > 80");
+        let ctx = make_context(&[]);
+        assert!(!cond.evaluate(&ctx));
+    }
+
+    #[test]
+    fn test_dict_condition_basic() {
+        let cond = DictCondition::new("decision")
+            .when("approved", vec!["process_task".to_string()])
+            .when("rejected", vec!["revision_task".to_string()]);
+
+        let ctx = make_context(&[("decision", serde_json::json!("approved"))]);
+        assert!(cond.evaluate(&ctx));
+        assert_eq!(cond.get_target(&ctx), vec!["process_task"]);
+
+        let ctx = make_context(&[("decision", serde_json::json!("rejected"))]);
+        assert!(cond.evaluate(&ctx));
+        assert_eq!(cond.get_target(&ctx), vec!["revision_task"]);
+    }
+
+    #[test]
+    fn test_dict_condition_default() {
+        let cond = DictCondition::new("decision")
+            .when("approved", vec!["process_task".to_string()])
+            .default_targets(vec!["fallback_task".to_string()]);
+
+        let ctx = make_context(&[("decision", serde_json::json!("unknown"))]);
+        assert!(cond.evaluate(&ctx));
+        assert_eq!(cond.get_target(&ctx), vec!["fallback_task"]);
+    }
+
+    #[test]
+    fn test_dict_condition_no_match_no_default() {
+        let cond = DictCondition::new("decision")
+            .when("approved", vec!["process_task".to_string()]);
+
+        let ctx = make_context(&[("decision", serde_json::json!("unknown"))]);
+        assert!(!cond.evaluate(&ctx));
+        assert!(cond.get_target(&ctx).is_empty());
+    }
+
+    #[test]
+    fn test_closure_condition() {
+        let cond = ClosureCondition::new(|ctx| {
+            ctx.get("score")
+                .and_then(|v| v.as_f64())
+                .map(|s| s > 80.0)
+                .unwrap_or(false)
+        });
+
+        let ctx = make_context(&[("score", serde_json::json!(90))]);
+        assert!(cond.evaluate(&ctx));
+
+        let ctx = make_context(&[("score", serde_json::json!(70))]);
+        assert!(!cond.evaluate(&ctx));
+    }
+
+    #[test]
+    fn test_evaluate_condition_function() {
+        let ctx = make_context(&[("score", serde_json::json!(90))]);
+        assert!(evaluate_condition("score > 80", &ctx));
+        assert!(!evaluate_condition("score < 80", &ctx));
+    }
+
+    #[test]
+    fn test_if_builder() {
+        let expr_cond = If::expr("score > 80");
+        let ctx = make_context(&[("score", serde_json::json!(90))]);
+        assert!(expr_cond.evaluate(&ctx));
+
+        let dict_cond = If::dict("status")
+            .when("ok", vec!["proceed".to_string()]);
+        let ctx = make_context(&[("status", serde_json::json!("ok"))]);
+        assert!(dict_cond.evaluate(&ctx));
+    }
+
+    #[test]
+    fn test_expression_condition_greater_equal() {
+        let cond = ExpressionCondition::new("score >= 80");
+        
+        let ctx = make_context(&[("score", serde_json::json!(80))]);
+        assert!(cond.evaluate(&ctx));
+
+        let ctx = make_context(&[("score", serde_json::json!(79))]);
+        assert!(!cond.evaluate(&ctx));
+    }
+
+    #[test]
+    fn test_expression_condition_less_than() {
+        let cond = ExpressionCondition::new("score < 50");
+        
+        let ctx = make_context(&[("score", serde_json::json!(30))]);
+        assert!(cond.evaluate(&ctx));
+
+        let ctx = make_context(&[("score", serde_json::json!(60))]);
+        assert!(!cond.evaluate(&ctx));
+    }
+}
@@ -0,0 +1,888 @@
+//! Context Management Module for PraisonAI Agents.
+//!
+//! This module provides comprehensive context management capabilities:
+//! - Token estimation and budgeting
+//! - Context composition within limits
+//! - Optimization strategies (truncate, sliding window, summarize)
+//! - Multi-agent context isolation
+//!
+//! # Example
+//!
+//! ```ignore
+//! use praisonai::{ContextManager, ContextConfig, OptimizerStrategy};
+//!
+//! let config = ContextConfig::new()
+//!     .model("gpt-4o")
+//!     .strategy(OptimizerStrategy::Smart);
+//!
+//! let manager = ContextManager::new(config);
+//! let budget = manager.allocate_budget();
+//! ```
+
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+// =============================================================================
+// OPTIMIZER STRATEGY
+// =============================================================================
+
+/// Strategy for optimizing context when it exceeds limits.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum OptimizerStrategy {
+    /// Truncate oldest messages
+    Truncate,
+    /// Sliding window of recent messages
+    SlidingWindow,
+    /// Summarize older messages
+    Summarize,
+    /// Prune tool-related messages
+    PruneTools,
+    /// Non-destructive (fail if over limit)
+    NonDestructive,
+    /// Smart combination of strategies
+    #[default]
+    Smart,
+}
+
+// =============================================================================
+// CONTEXT SEGMENT
+// =============================================================================
+
+/// A segment of context with token count.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ContextSegment {
+    /// Segment name/type
+    pub name: String,
+    /// Token count for this segment
+    pub tokens: usize,
+    /// Priority (higher = more important)
+    pub priority: i32,
+    /// Content of the segment
+    pub content: Option<String>,
+}
+
+impl ContextSegment {
+    /// Create a new context segment
+    pub fn new(name: impl Into<String>, tokens: usize) -> Self {
+        Self {
+            name: name.into(),
+            tokens,
+            priority: 0,
+            content: None,
+        }
+    }
+
+    /// Set priority
+    pub fn priority(mut self, priority: i32) -> Self {
+        self.priority = priority;
+        self
+    }
+
+    /// Set content
+    pub fn content(mut self, content: impl Into<String>) -> Self {
+        self.content = Some(content.into());
+        self
+    }
+}
+
+// =============================================================================
+// CONTEXT LEDGER
+// =============================================================================
+
+/// Tracks token usage across different context segments.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct ContextLedger {
+    /// Segments in the ledger
+    pub segments: Vec<ContextSegment>,
+    /// Total tokens used
+    pub total_tokens: usize,
+    /// Maximum allowed tokens
+    pub max_tokens: usize,
+}
+
+impl ContextLedger {
+    /// Create a new ledger with max tokens
+    pub fn new(max_tokens: usize) -> Self {
+        Self {
+            segments: Vec::new(),
+            total_tokens: 0,
+            max_tokens,
+        }
+    }
+
+    /// Add a segment to the ledger
+    pub fn add(&mut self, segment: ContextSegment) {
+        self.total_tokens += segment.tokens;
+        self.segments.push(segment);
+    }
+
+    /// Get remaining tokens
+    pub fn remaining(&self) -> usize {
+        self.max_tokens.saturating_sub(self.total_tokens)
+    }
+
+    /// Check if over budget
+    pub fn is_over_budget(&self) -> bool {
+        self.total_tokens > self.max_tokens
+    }
+
+    /// Get utilization percentage
+    pub fn utilization(&self) -> f64 {
+        if self.max_tokens == 0 {
+            0.0
+        } else {
+            self.total_tokens as f64 / self.max_tokens as f64
+        }
+    }
+}
+
+// =============================================================================
+// BUDGET ALLOCATION
+// =============================================================================
+
+/// Budget allocation for different context components.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BudgetAllocation {
+    /// Total budget in tokens
+    pub total: usize,
+    /// Budget for system prompt
+    pub system: usize,
+    /// Budget for conversation history
+    pub history: usize,
+    /// Budget for tools
+    pub tools: usize,
+    /// Reserved for output
+    pub output_reserve: usize,
+}
+
+impl BudgetAllocation {
+    /// Create a new budget allocation
+    pub fn new(total: usize) -> Self {
+        // Default allocation: 10% system, 60% history, 10% tools, 20% output
+        let output_reserve = total / 5;
+        let available = total - output_reserve;
+        Self {
+            total,
+            system: available / 10,
+            history: available * 6 / 10,
+            tools: available / 10,
+            output_reserve,
+        }
+    }
+
+    /// Create with custom ratios
+    pub fn with_ratios(total: usize, system_pct: f64, history_pct: f64, tools_pct: f64) -> Self {
+        let output_reserve = total / 5;
+        let available = total - output_reserve;
+        Self {
+            total,
+            system: (available as f64 * system_pct) as usize,
+            history: (available as f64 * history_pct) as usize,
+            tools: (available as f64 * tools_pct) as usize,
+            output_reserve,
+        }
+    }
+}
+
+// =============================================================================
+// CONTEXT CONFIG
+// =============================================================================
+
+/// Configuration for context management.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ContextConfig {
+    /// Model name for token limits
+    #[serde(default = "default_model")]
+    pub model: String,
+
+    /// Maximum context tokens (0 = auto from model)
+    #[serde(default)]
+    pub max_tokens: usize,
+
+    /// Optimization strategy
+    #[serde(default)]
+    pub strategy: OptimizerStrategy,
+
+    /// Enable context monitoring
+    #[serde(default)]
+    pub monitoring: bool,
+
+    /// Output reserve percentage
+    #[serde(default = "default_output_reserve_pct")]
+    pub output_reserve_pct: f64,
+}
+
+fn default_model() -> String {
+    "gpt-4o".to_string()
+}
+
+fn default_output_reserve_pct() -> f64 {
+    0.2
+}
+
+impl Default for ContextConfig {
+    fn default() -> Self {
+        Self {
+            model: "gpt-4o".to_string(),
+            max_tokens: 0,
+            strategy: OptimizerStrategy::Smart,
+            monitoring: false,
+            output_reserve_pct: 0.2,
+        }
+    }
+}
+
+impl ContextConfig {
+    /// Create a new context config
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Set model
+    pub fn model(mut self, model: impl Into<String>) -> Self {
+        self.model = model.into();
+        self
+    }
+
+    /// Set max tokens
+    pub fn max_tokens(mut self, tokens: usize) -> Self {
+        self.max_tokens = tokens;
+        self
+    }
+
+    /// Set optimization strategy
+    pub fn strategy(mut self, strategy: OptimizerStrategy) -> Self {
+        self.strategy = strategy;
+        self
+    }
+
+    /// Enable monitoring
+    pub fn with_monitoring(mut self) -> Self {
+        self.monitoring = true;
+        self
+    }
+
+    /// Set output reserve percentage
+    pub fn output_reserve_pct(mut self, pct: f64) -> Self {
+        self.output_reserve_pct = pct;
+        self
+    }
+}
+
+// =============================================================================
+// MODEL LIMITS
+// =============================================================================
+
+/// Get context limit for a model.
+pub fn get_model_limit(model: &str) -> usize {
+    match model {
+        // GPT-4 variants
+        "gpt-4o" | "gpt-4o-2024-05-13" | "gpt-4o-2024-08-06" => 128_000,
+        "gpt-4o-mini" | "gpt-4o-mini-2024-07-18" => 128_000,
+        "gpt-4-turbo" | "gpt-4-turbo-preview" | "gpt-4-1106-preview" => 128_000,
+        "gpt-4" | "gpt-4-0613" => 8_192,
+        "gpt-4-32k" | "gpt-4-32k-0613" => 32_768,
+        // GPT-3.5 variants
+        "gpt-3.5-turbo" | "gpt-3.5-turbo-0125" => 16_385,
+        "gpt-3.5-turbo-16k" => 16_385,
+        // Claude variants
+        "claude-3-opus" | "claude-3-opus-20240229" => 200_000,
+        "claude-3-sonnet" | "claude-3-sonnet-20240229" => 200_000,
+        "claude-3-haiku" | "claude-3-haiku-20240307" => 200_000,
+        "claude-3-5-sonnet" | "claude-3-5-sonnet-20240620" => 200_000,
+        // Gemini variants
+        "gemini-pro" | "gemini-1.0-pro" => 32_760,
+        "gemini-1.5-pro" => 1_000_000,
+        "gemini-1.5-flash" => 1_000_000,
+        // Default
+        _ => 8_192,
+    }
+}
+
+/// Get recommended output reserve for a model.
+pub fn get_output_reserve(model: &str) -> usize {
+    match model {
+        "gpt-4o" | "gpt-4o-mini" => 16_384,
+        "gpt-4-turbo" => 4_096,
+        "gpt-4" => 2_048,
+        "claude-3-opus" | "claude-3-sonnet" | "claude-3-5-sonnet" => 4_096,
+        _ => 2_048,
+    }
+}
+
+// =============================================================================
+// TOKEN ESTIMATION
+// =============================================================================
+
+/// Estimate tokens for a string using heuristic (4 chars ≈ 1 token).
+pub fn estimate_tokens_heuristic(text: &str) -> usize {
+    // Rough heuristic: 4 characters per token on average
+    (text.len() + 3) / 4
+}
+
+/// Estimate tokens for messages.
+pub fn estimate_messages_tokens(messages: &[serde_json::Value]) -> usize {
+    let mut total = 0;
+    for msg in messages {
+        // Base overhead per message
+        total += 4;
+        if let Some(content) = msg.get("content").and_then(|c| c.as_str()) {
+            total += estimate_tokens_heuristic(content);
+        }
+        if let Some(role) = msg.get("role").and_then(|r| r.as_str()) {
+            total += estimate_tokens_heuristic(role);
+        }
+        if let Some(name) = msg.get("name").and_then(|n| n.as_str()) {
+            total += estimate_tokens_heuristic(name);
+        }
+    }
+    total
+}
+
+/// Estimate tokens for tool schemas.
+pub fn estimate_tool_schema_tokens(tools: &[serde_json::Value]) -> usize {
+    let mut total = 0;
+    for tool in tools {
+        let json_str = serde_json::to_string(tool).unwrap_or_default();
+        total += estimate_tokens_heuristic(&json_str);
+    }
+    total
+}
+
+// =============================================================================
+// CONTEXT BUDGETER
+// =============================================================================
+
+/// Manages context budget allocation.
+#[derive(Debug, Clone)]
+pub struct ContextBudgeter {
+    /// Model name
+    pub model: String,
+    /// Maximum tokens
+    pub max_tokens: usize,
+    /// Output reserve
+    pub output_reserve: usize,
+}
+
+impl ContextBudgeter {
+    /// Create a new budgeter for a model
+    pub fn new(model: impl Into<String>) -> Self {
+        let model = model.into();
+        let max_tokens = get_model_limit(&model);
+        let output_reserve = get_output_reserve(&model);
+        Self {
+            model,
+            max_tokens,
+            output_reserve,
+        }
+    }
+
+    /// Create with custom limits
+    pub fn with_limits(model: impl Into<String>, max_tokens: usize, output_reserve: usize) -> Self {
+        Self {
+            model: model.into(),
+            max_tokens,
+            output_reserve,
+        }
+    }
+
+    /// Get available tokens (total - output reserve)
+    pub fn available(&self) -> usize {
+        self.max_tokens.saturating_sub(self.output_reserve)
+    }
+
+    /// Allocate budget
+    pub fn allocate(&self) -> BudgetAllocation {
+        BudgetAllocation::new(self.available())
+    }
+
+    /// Allocate with custom ratios
+    pub fn allocate_custom(
+        &self,
+        system_pct: f64,
+        history_pct: f64,
+        tools_pct: f64,
+    ) -> BudgetAllocation {
+        BudgetAllocation::with_ratios(self.available(), system_pct, history_pct, tools_pct)
+    }
+}
+
+// =============================================================================
+// CONTEXT MANAGER
+// =============================================================================
+
+/// High-level context manager facade.
+#[derive(Debug, Clone)]
+pub struct ContextManager {
+    /// Configuration
+    pub config: ContextConfig,
+    /// Budgeter
+    pub budgeter: ContextBudgeter,
+    /// Current ledger
+    pub ledger: ContextLedger,
+}
+
+impl ContextManager {
+    /// Create a new context manager
+    pub fn new(config: ContextConfig) -> Self {
+        let max_tokens = if config.max_tokens > 0 {
+            config.max_tokens
+        } else {
+            get_model_limit(&config.model)
+        };
+        let output_reserve = (max_tokens as f64 * config.output_reserve_pct) as usize;
+        let budgeter = ContextBudgeter::with_limits(&config.model, max_tokens, output_reserve);
+        let ledger = ContextLedger::new(budgeter.available());
+
+        Self {
+            config,
+            budgeter,
+            ledger,
+        }
+    }
+
+    /// Create with default config
+    pub fn default_for_model(model: impl Into<String>) -> Self {
+        Self::new(ContextConfig::new().model(model))
+    }
+
+    /// Get budget allocation
+    pub fn allocate_budget(&self) -> BudgetAllocation {
+        self.budgeter.allocate()
+    }
+
+    /// Add a segment to the ledger
+    pub fn add_segment(&mut self, segment: ContextSegment) {
+        self.ledger.add(segment);
+    }
+
+    /// Get remaining tokens
+    pub fn remaining(&self) -> usize {
+        self.ledger.remaining()
+    }
+
+    /// Check if over budget
+    pub fn is_over_budget(&self) -> bool {
+        self.ledger.is_over_budget()
+    }
+
+    /// Get utilization
+    pub fn utilization(&self) -> f64 {
+        self.ledger.utilization()
+    }
+
+    /// Reset the ledger
+    pub fn reset(&mut self) {
+        self.ledger = ContextLedger::new(self.budgeter.available());
+    }
+
+    /// Estimate and track system prompt
+    pub fn track_system(&mut self, system_prompt: &str) {
+        let tokens = estimate_tokens_heuristic(system_prompt);
+        self.add_segment(ContextSegment::new("system", tokens).priority(100));
+    }
+
+    /// Estimate and track messages
+    pub fn track_messages(&mut self, messages: &[serde_json::Value]) {
+        let tokens = estimate_messages_tokens(messages);
+        self.add_segment(ContextSegment::new("history", tokens).priority(50));
+    }
+
+    /// Estimate and track tools
+    pub fn track_tools(&mut self, tools: &[serde_json::Value]) {
+        let tokens = estimate_tool_schema_tokens(tools);
+        self.add_segment(ContextSegment::new("tools", tokens).priority(75));
+    }
+}
+
+// =============================================================================
+// MULTI-AGENT CONTEXT MANAGER
+// =============================================================================
+
+/// Context manager for multi-agent scenarios.
+#[derive(Debug, Default)]
+pub struct MultiAgentContextManager {
+    /// Per-agent managers
+    managers: HashMap<String, ContextManager>,
+    /// Shared context segments
+    shared_segments: Vec<ContextSegment>,
+}
+
+impl MultiAgentContextManager {
+    /// Create a new multi-agent context manager
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Register an agent
+    pub fn register_agent(&mut self, agent_id: impl Into<String>, config: ContextConfig) {
+        let manager = ContextManager::new(config);
+        self.managers.insert(agent_id.into(), manager);
+    }
+
+    /// Get manager for an agent
+    pub fn get(&self, agent_id: &str) -> Option<&ContextManager> {
+        self.managers.get(agent_id)
+    }
+
+    /// Get mutable manager for an agent
+    pub fn get_mut(&mut self, agent_id: &str) -> Option<&mut ContextManager> {
+        self.managers.get_mut(agent_id)
+    }
+
+    /// Add shared segment
+    pub fn add_shared(&mut self, segment: ContextSegment) {
+        self.shared_segments.push(segment);
+    }
+
+    /// Get all agent IDs
+    pub fn agent_ids(&self) -> Vec<&String> {
+        self.managers.keys().collect()
+    }
+}
+
+// =============================================================================
+// TESTS
+// =============================================================================
+
+// =============================================================================
+// FAST CONTEXT TYPES
+// =============================================================================
+
+/// A line range within a file.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct LineRange {
+    /// Start line (1-indexed)
+    pub start: usize,
+    /// End line (1-indexed)
+    pub end: usize,
+    /// Content of the lines (optional)
+    pub content: Option<String>,
+    /// Relevance score (0.0 to 1.0)
+    pub relevance_score: f32,
+}
+
+impl LineRange {
+    /// Create a new line range.
+    pub fn new(start: usize, end: usize) -> Self {
+        Self {
+            start,
+            end,
+            content: None,
+            relevance_score: 1.0,
+        }
+    }
+
+    /// Set content.
+    pub fn content(mut self, content: impl Into<String>) -> Self {
+        self.content = Some(content.into());
+        self
+    }
+
+    /// Set relevance score.
+    pub fn relevance_score(mut self, score: f32) -> Self {
+        self.relevance_score = score;
+        self
+    }
+
+    /// Get line count.
+    pub fn line_count(&self) -> usize {
+        self.end.saturating_sub(self.start) + 1
+    }
+}
+
+/// A file match from a search.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FileMatch {
+    /// File path (relative to workspace)
+    pub path: String,
+    /// Relevance score (0.0 to 1.0)
+    pub relevance_score: f32,
+    /// Matching line ranges
+    pub line_ranges: Vec<LineRange>,
+}
+
+impl FileMatch {
+    /// Create a new file match.
+    pub fn new(path: impl Into<String>) -> Self {
+        Self {
+            path: path.into(),
+            relevance_score: 1.0,
+            line_ranges: Vec::new(),
+        }
+    }
+
+    /// Set relevance score.
+    pub fn relevance_score(mut self, score: f32) -> Self {
+        self.relevance_score = score;
+        self
+    }
+
+    /// Add a line range.
+    pub fn line_range(mut self, range: LineRange) -> Self {
+        self.line_ranges.push(range);
+        self
+    }
+}
+
+/// Result of a fast context search.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct FastContextResult {
+    /// Original query
+    pub query: String,
+    /// Matching files
+    pub files: Vec<FileMatch>,
+    /// Search time in milliseconds
+    pub search_time_ms: u64,
+    /// Number of turns used
+    pub turns_used: usize,
+    /// Total tool calls made
+    pub total_tool_calls: usize,
+    /// Whether result is from cache
+    pub from_cache: bool,
+}
+
+impl FastContextResult {
+    /// Create a new result.
+    pub fn new(query: impl Into<String>) -> Self {
+        Self {
+            query: query.into(),
+            ..Default::default()
+        }
+    }
+
+    /// Add a file match.
+    pub fn add_file(&mut self, file: FileMatch) {
+        self.files.push(file);
+    }
+
+    /// Get total number of files.
+    pub fn total_files(&self) -> usize {
+        self.files.len()
+    }
+
+    /// Check if empty.
+    pub fn is_empty(&self) -> bool {
+        self.files.is_empty()
+    }
+
+    /// Convert to context string for agent injection.
+    pub fn to_context_string(&self) -> String {
+        if self.files.is_empty() {
+            return format!("No relevant code found for: {}", self.query);
+        }
+
+        let mut lines = vec![
+            format!("# Relevant Code Context for: {}", self.query),
+            format!("Found {} file(s) in {}ms\n", self.files.len(), self.search_time_ms),
+        ];
+
+        for file in &self.files {
+            lines.push(format!("## {}", file.path));
+            for range in &file.line_ranges {
+                lines.push(format!("Lines {}-{}:", range.start, range.end));
+                if let Some(content) = &range.content {
+                    lines.push(format!("```\n{}\n```", content));
+                }
+            }
+            lines.push(String::new());
+        }
+
+        lines.join("\n")
+    }
+}
+
+/// Configuration for FastContext.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FastContextConfig {
+    /// Workspace path
+    pub workspace_path: Option<String>,
+    /// LLM model for intelligent search
+    pub model: String,
+    /// Maximum search turns
+    pub max_turns: usize,
+    /// Maximum parallel tool calls
+    pub max_parallel: usize,
+    /// Timeout per tool call in seconds
+    pub timeout: f64,
+    /// Enable caching
+    pub cache_enabled: bool,
+    /// Cache TTL in seconds
+    pub cache_ttl: u64,
+}
+
+impl Default for FastContextConfig {
+    fn default() -> Self {
+        Self {
+            workspace_path: None,
+            model: "gpt-4o-mini".to_string(),
+            max_turns: 4,
+            max_parallel: 8,
+            timeout: 30.0,
+            cache_enabled: true,
+            cache_ttl: 300,
+        }
+    }
+}
+
+impl FastContextConfig {
+    /// Create a new config.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Set workspace path.
+    pub fn workspace_path(mut self, path: impl Into<String>) -> Self {
+        self.workspace_path = Some(path.into());
+        self
+    }
+
+    /// Set model.
+    pub fn model(mut self, model: impl Into<String>) -> Self {
+        self.model = model.into();
+        self
+    }
+
+    /// Set max turns.
+    pub fn max_turns(mut self, turns: usize) -> Self {
+        self.max_turns = turns;
+        self
+    }
+
+    /// Set max parallel.
+    pub fn max_parallel(mut self, parallel: usize) -> Self {
+        self.max_parallel = parallel;
+        self
+    }
+
+    /// Set timeout.
+    pub fn timeout(mut self, timeout: f64) -> Self {
+        self.timeout = timeout;
+        self
+    }
+
+    /// Enable/disable caching.
+    pub fn cache_enabled(mut self, enabled: bool) -> Self {
+        self.cache_enabled = enabled;
+        self
+    }
+
+    /// Set cache TTL.
+    pub fn cache_ttl(mut self, ttl: u64) -> Self {
+        self.cache_ttl = ttl;
+        self
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_context_config_defaults() {
+        let config = ContextConfig::new();
+        assert_eq!(config.model, "gpt-4o");
+        assert_eq!(config.strategy, OptimizerStrategy::Smart);
+    }
+
+    #[test]
+    fn test_context_config_builder() {
+        let config = ContextConfig::new()
+            .model("gpt-4")
+            .max_tokens(8000)
+            .strategy(OptimizerStrategy::Truncate)
+            .with_monitoring();
+
+        assert_eq!(config.model, "gpt-4");
+        assert_eq!(config.max_tokens, 8000);
+        assert_eq!(config.strategy, OptimizerStrategy::Truncate);
+        assert!(config.monitoring);
+    }
+
+    #[test]
+    fn test_model_limits() {
+        assert_eq!(get_model_limit("gpt-4o"), 128_000);
+        assert_eq!(get_model_limit("gpt-4"), 8_192);
+        assert_eq!(get_model_limit("claude-3-opus"), 200_000);
+        assert_eq!(get_model_limit("unknown"), 8_192);
+    }
+
+    #[test]
+    fn test_token_estimation() {
+        let text = "Hello, world!"; // 13 chars
+        let tokens = estimate_tokens_heuristic(text);
+        assert!(tokens >= 3 && tokens <= 5);
+    }
+
+    #[test]
+    fn test_context_ledger() {
+        let mut ledger = ContextLedger::new(1000);
+        assert_eq!(ledger.remaining(), 1000);
+
+        ledger.add(ContextSegment::new("system", 100));
+        ledger.add(ContextSegment::new("history", 500));
+
+        assert_eq!(ledger.total_tokens, 600);
+        assert_eq!(ledger.remaining(), 400);
+        assert!(!ledger.is_over_budget());
+        assert!((ledger.utilization() - 0.6).abs() < 0.01);
+    }
+
+    #[test]
+    fn test_budget_allocation() {
+        let budget = BudgetAllocation::new(10000);
+        assert_eq!(budget.total, 10000);
+        assert_eq!(budget.output_reserve, 2000);
+        // Available = 8000, system = 800, history = 4800, tools = 800
+        assert_eq!(budget.system, 800);
+        assert_eq!(budget.history, 4800);
+        assert_eq!(budget.tools, 800);
+    }
+
+    #[test]
+    fn test_context_budgeter() {
+        let budgeter = ContextBudgeter::new("gpt-4o");
+        assert_eq!(budgeter.max_tokens, 128_000);
+        assert!(budgeter.available() < 128_000);
+    }
+
+    #[test]
+    fn test_context_manager() {
+        let config = ContextConfig::new().model("gpt-4o");
+        let mut manager = ContextManager::new(config);
+
+        manager.track_system("You are a helpful assistant.");
+        assert!(manager.ledger.total_tokens > 0);
+
+        let remaining_before = manager.remaining();
+        manager.track_messages(&[serde_json::json!({"role": "user", "content": "Hello"})]);
+        assert!(manager.remaining() < remaining_before);
+    }
+
+    #[test]
+    fn test_multi_agent_context_manager() {
+        let mut multi = MultiAgentContextManager::new();
+
+        multi.register_agent("agent_a", ContextConfig::new().model("gpt-4o"));
+        multi.register_agent("agent_b", ContextConfig::new().model("gpt-4"));
+
+        assert!(multi.get("agent_a").is_some());
+        assert!(multi.get("agent_b").is_some());
+        assert!(multi.get("agent_c").is_none());
+
+        assert_eq!(multi.agent_ids().len(), 2);
+    }
+
+    #[test]
+    fn test_context_segment() {
+        let segment = ContextSegment::new("test", 100)
+            .priority(50)
+            .content("Test content");
+
+        assert_eq!(segment.name, "test");
+        assert_eq!(segment.tokens, 100);
+        assert_eq!(segment.priority, 50);
+        assert_eq!(segment.content, Some("Test content".to_string()));
+    }
+}
@@ -0,0 +1,686 @@
+//! Display and callback system for PraisonAI
+//!
+//! This module provides display functions and callback registration matching the Python SDK's
+//! main.py display system.
+//!
+//! # Features
+//!
+//! - Display functions for various output types (interaction, tool calls, errors, etc.)
+//! - Callback registration for custom display handling
+//! - Approval callback for dangerous operations
+//! - Color palette for consistent UI
+//!
+//! # Example
+//!
+//! ```rust,ignore
+//! use praisonai::display::{register_display_callback, display_interaction, DisplayType};
+//!
+//! // Register a custom callback
+//! register_display_callback(DisplayType::Interaction, |event| {
+//!     println!("Agent: {} said: {}", event.agent_name, event.content);
+//! });
+//!
+//! // Display an interaction
+//! display_interaction("assistant", "Hello!", None);
+//! ```
+
+use once_cell::sync::Lazy;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::sync::{Arc, RwLock};
+
+// =============================================================================
+// COLOR PALETTE
+// =============================================================================
+
+/// PraisonAI color palette for consistent UI
+#[derive(Debug, Clone)]
+pub struct ColorPalette {
+    /// Agent identity color
+    pub agent: &'static str,
+    /// Agent text color
+    pub agent_text: &'static str,
+    /// Task/Question color
+    pub task: &'static str,
+    /// Task text color
+    pub task_text: &'static str,
+    /// Working/Processing color
+    pub working: &'static str,
+    /// Working text color
+    pub working_text: &'static str,
+    /// Response/Output color
+    pub response: &'static str,
+    /// Response text color
+    pub response_text: &'static str,
+    /// Tool calls color
+    pub tool: &'static str,
+    /// Tool text color
+    pub tool_text: &'static str,
+    /// Reasoning color
+    pub reasoning: &'static str,
+    /// Reasoning text color
+    pub reasoning_text: &'static str,
+    /// Error/Warning color
+    pub error: &'static str,
+    /// Error text color
+    pub error_text: &'static str,
+    /// Metrics color
+    pub metrics: &'static str,
+    /// Metrics text color
+    pub metrics_text: &'static str,
+}
+
+/// Default PraisonAI color palette
+pub static PRAISON_COLORS: Lazy<ColorPalette> = Lazy::new(|| ColorPalette {
+    agent: "#86A789",
+    agent_text: "#D2E3C8",
+    task: "#FF9B9B",
+    task_text: "#FFE5E5",
+    working: "#FFB347",
+    working_text: "#FFF3E0",
+    response: "#4A90D9",
+    response_text: "#E3F2FD",
+    tool: "#9B7EDE",
+    tool_text: "#EDE7F6",
+    reasoning: "#78909C",
+    reasoning_text: "#ECEFF1",
+    error: "#E57373",
+    error_text: "#FFEBEE",
+    metrics: "#B4B4B3",
+    metrics_text: "#FAFAFA",
+});
+
+/// Working animation frames
+pub static WORKING_FRAMES: &[&str] = &["●○○", "○●○", "○○●", "○●○"];
+
+/// Working animation phases
+pub static WORKING_PHASES: &[&str] = &[
+    "Analyzing query...",
+    "Processing context...",
+    "Generating response...",
+    "Finalizing output...",
+];
+
+// =============================================================================
+// DISPLAY TYPES
+// =============================================================================
+
+/// Types of display events
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum DisplayType {
+    /// Agent interaction (prompt/response)
+    Interaction,
+    /// Self-reflection output
+    SelfReflection,
+    /// Tool call execution
+    ToolCall,
+    /// Error message
+    Error,
+    /// Generating/working status
+    Generating,
+    /// Instruction display
+    Instruction,
+    /// Reasoning steps
+    Reasoning,
+    /// Working status animation
+    Working,
+}
+
+impl std::fmt::Display for DisplayType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            DisplayType::Interaction => write!(f, "interaction"),
+            DisplayType::SelfReflection => write!(f, "self_reflection"),
+            DisplayType::ToolCall => write!(f, "tool_call"),
+            DisplayType::Error => write!(f, "error"),
+            DisplayType::Generating => write!(f, "generating"),
+            DisplayType::Instruction => write!(f, "instruction"),
+            DisplayType::Reasoning => write!(f, "reasoning"),
+            DisplayType::Working => write!(f, "working"),
+        }
+    }
+}
+
+// =============================================================================
+// DISPLAY EVENT
+// =============================================================================
+
+/// Event data passed to display callbacks
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DisplayEvent {
+    /// Type of display event
+    pub display_type: DisplayType,
+    /// Agent name (if applicable)
+    pub agent_name: Option<String>,
+    /// Content to display
+    pub content: String,
+    /// Tool name (for tool calls)
+    pub tool_name: Option<String>,
+    /// Tool arguments (for tool calls)
+    pub tool_args: Option<serde_json::Value>,
+    /// Tool result (for tool calls)
+    pub tool_result: Option<String>,
+    /// Error message (for errors)
+    pub error_message: Option<String>,
+    /// Additional metadata
+    pub metadata: HashMap<String, serde_json::Value>,
+}
+
+impl DisplayEvent {
+    /// Create a new display event
+    pub fn new(display_type: DisplayType, content: impl Into<String>) -> Self {
+        Self {
+            display_type,
+            agent_name: None,
+            content: content.into(),
+            tool_name: None,
+            tool_args: None,
+            tool_result: None,
+            error_message: None,
+            metadata: HashMap::new(),
+        }
+    }
+
+    /// Set agent name
+    pub fn agent(mut self, name: impl Into<String>) -> Self {
+        self.agent_name = Some(name.into());
+        self
+    }
+
+    /// Set tool name
+    pub fn tool(mut self, name: impl Into<String>) -> Self {
+        self.tool_name = Some(name.into());
+        self
+    }
+
+    /// Set tool arguments
+    pub fn args(mut self, args: serde_json::Value) -> Self {
+        self.tool_args = Some(args);
+        self
+    }
+
+    /// Set tool result
+    pub fn result(mut self, result: impl Into<String>) -> Self {
+        self.tool_result = Some(result.into());
+        self
+    }
+
+    /// Set error message
+    pub fn error(mut self, error: impl Into<String>) -> Self {
+        self.error_message = Some(error.into());
+        self
+    }
+
+    /// Add metadata
+    pub fn meta(mut self, key: impl Into<String>, value: impl Into<serde_json::Value>) -> Self {
+        self.metadata.insert(key.into(), value.into());
+        self
+    }
+}
+
+// =============================================================================
+// CALLBACK TYPES
+// =============================================================================
+
+/// Synchronous display callback function type
+pub type SyncDisplayCallback = Box<dyn Fn(&DisplayEvent) + Send + Sync>;
+
+/// Asynchronous display callback function type
+pub type AsyncDisplayCallback = Box<dyn Fn(&DisplayEvent) -> std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>> + Send + Sync>;
+
+/// Approval decision for dangerous operations
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum ApprovalDecision {
+    /// Approve the operation
+    Approve,
+    /// Deny the operation
+    Deny,
+    /// Approve all similar operations
+    ApproveAll,
+    /// Deny all similar operations
+    DenyAll,
+}
+
+/// Risk level for operations requiring approval
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum RiskLevel {
+    /// Low risk operation
+    Low,
+    /// Medium risk operation
+    Medium,
+    /// High risk operation
+    High,
+    /// Critical risk operation
+    Critical,
+}
+
+/// Approval callback function type
+pub type ApprovalCallback = Box<dyn Fn(&str, &serde_json::Value, RiskLevel) -> ApprovalDecision + Send + Sync>;
+
+// =============================================================================
+// CALLBACK REGISTRY
+// =============================================================================
+
+/// Global callback registry
+struct CallbackRegistry {
+    sync_callbacks: HashMap<DisplayType, Vec<SyncDisplayCallback>>,
+    async_callbacks: HashMap<DisplayType, Vec<AsyncDisplayCallback>>,
+    approval_callback: Option<ApprovalCallback>,
+}
+
+impl CallbackRegistry {
+    fn new() -> Self {
+        Self {
+            sync_callbacks: HashMap::new(),
+            async_callbacks: HashMap::new(),
+            approval_callback: None,
+        }
+    }
+}
+
+static CALLBACK_REGISTRY: Lazy<RwLock<CallbackRegistry>> =
+    Lazy::new(|| RwLock::new(CallbackRegistry::new()));
+
+// =============================================================================
+// CALLBACK REGISTRATION
+// =============================================================================
+
+/// Register a synchronous display callback
+pub fn register_display_callback<F>(display_type: DisplayType, callback: F)
+where
+    F: Fn(&DisplayEvent) + Send + Sync + 'static,
+{
+    let mut registry = CALLBACK_REGISTRY.write().unwrap();
+    registry
+        .sync_callbacks
+        .entry(display_type)
+        .or_insert_with(Vec::new)
+        .push(Box::new(callback));
+}
+
+/// Register an asynchronous display callback
+pub fn register_async_display_callback<F, Fut>(display_type: DisplayType, callback: F)
+where
+    F: Fn(&DisplayEvent) -> Fut + Send + Sync + 'static,
+    Fut: std::future::Future<Output = ()> + Send + 'static,
+{
+    let mut registry = CALLBACK_REGISTRY.write().unwrap();
+    registry
+        .async_callbacks
+        .entry(display_type)
+        .or_insert_with(Vec::new)
+        .push(Box::new(move |event| {
+            let fut = callback(event);
+            Box::pin(fut)
+        }));
+}
+
+/// Register an approval callback for dangerous operations
+pub fn register_approval_callback<F>(callback: F)
+where
+    F: Fn(&str, &serde_json::Value, RiskLevel) -> ApprovalDecision + Send + Sync + 'static,
+{
+    let mut registry = CALLBACK_REGISTRY.write().unwrap();
+    registry.approval_callback = Some(Box::new(callback));
+}
+
+/// Alias for register_display_callback (consistent naming)
+pub fn add_display_callback<F>(display_type: DisplayType, callback: F)
+where
+    F: Fn(&DisplayEvent) + Send + Sync + 'static,
+{
+    register_display_callback(display_type, callback);
+}
+
+/// Alias for register_approval_callback (consistent naming)
+pub fn add_approval_callback<F>(callback: F)
+where
+    F: Fn(&str, &serde_json::Value, RiskLevel) -> ApprovalDecision + Send + Sync + 'static,
+{
+    register_approval_callback(callback);
+}
+
+/// Clear all callbacks for a display type
+pub fn clear_display_callbacks(display_type: DisplayType) {
+    let mut registry = CALLBACK_REGISTRY.write().unwrap();
+    registry.sync_callbacks.remove(&display_type);
+    registry.async_callbacks.remove(&display_type);
+}
+
+/// Clear all callbacks
+pub fn clear_all_callbacks() {
+    let mut registry = CALLBACK_REGISTRY.write().unwrap();
+    registry.sync_callbacks.clear();
+    registry.async_callbacks.clear();
+    registry.approval_callback = None;
+}
+
+// =============================================================================
+// CALLBACK EXECUTION
+// =============================================================================
+
+/// Execute synchronous callbacks for a display event
+pub fn execute_sync_callbacks(event: &DisplayEvent) {
+    let registry = CALLBACK_REGISTRY.read().unwrap();
+    if let Some(callbacks) = registry.sync_callbacks.get(&event.display_type) {
+        for callback in callbacks {
+            callback(event);
+        }
+    }
+}
+
+/// Execute asynchronous callbacks for a display event
+pub async fn execute_async_callbacks(event: &DisplayEvent) {
+    let callbacks: Vec<_> = {
+        let registry = CALLBACK_REGISTRY.read().unwrap();
+        registry
+            .async_callbacks
+            .get(&event.display_type)
+            .map(|cbs| cbs.iter().map(|cb| cb(event)).collect())
+            .unwrap_or_default()
+    };
+
+    for fut in callbacks {
+        fut.await;
+    }
+}
+
+/// Execute all callbacks (sync and async) for a display event
+pub async fn execute_callbacks(event: &DisplayEvent) {
+    execute_sync_callbacks(event);
+    execute_async_callbacks(event).await;
+}
+
+/// Request approval for a dangerous operation
+pub fn request_approval(
+    function_name: &str,
+    arguments: &serde_json::Value,
+    risk_level: RiskLevel,
+) -> ApprovalDecision {
+    let registry = CALLBACK_REGISTRY.read().unwrap();
+    if let Some(callback) = &registry.approval_callback {
+        callback(function_name, arguments, risk_level)
+    } else {
+        // Default to deny if no callback is registered
+        ApprovalDecision::Deny
+    }
+}
+
+// =============================================================================
+// DISPLAY FUNCTIONS
+// =============================================================================
+
+/// Display an agent interaction
+pub fn display_interaction(agent_name: &str, content: &str, response_type: Option<&str>) {
+    let event = DisplayEvent::new(DisplayType::Interaction, content)
+        .agent(agent_name)
+        .meta("response_type", response_type.unwrap_or("response"));
+
+    execute_sync_callbacks(&event);
+
+    // Default console output if no callbacks registered
+    let registry = CALLBACK_REGISTRY.read().unwrap();
+    if registry.sync_callbacks.get(&DisplayType::Interaction).is_none() {
+        println!("[{}] {}", agent_name, content);
+    }
+}
+
+/// Display an instruction
+pub fn display_instruction(agent_name: &str, instruction: &str) {
+    let event = DisplayEvent::new(DisplayType::Instruction, instruction).agent(agent_name);
+
+    execute_sync_callbacks(&event);
+
+    let registry = CALLBACK_REGISTRY.read().unwrap();
+    if registry.sync_callbacks.get(&DisplayType::Instruction).is_none() {
+        println!("📋 [{}] Instruction: {}", agent_name, instruction);
+    }
+}
+
+/// Display a tool call
+pub fn display_tool_call(
+    agent_name: &str,
+    tool_name: &str,
+    arguments: &serde_json::Value,
+    result: Option<&str>,
+) {
+    let mut event = DisplayEvent::new(DisplayType::ToolCall, format!("Calling {}", tool_name))
+        .agent(agent_name)
+        .tool(tool_name)
+        .args(arguments.clone());
+
+    if let Some(r) = result {
+        event = event.result(r);
+    }
+
+    execute_sync_callbacks(&event);
+
+    let registry = CALLBACK_REGISTRY.read().unwrap();
+    if registry.sync_callbacks.get(&DisplayType::ToolCall).is_none() {
+        println!("🔧 [{}] Tool: {} with args: {}", agent_name, tool_name, arguments);
+        if let Some(r) = result {
+            println!("   Result: {}", r);
+        }
+    }
+}
+
+/// Display an error
+pub fn display_error(agent_name: Option<&str>, error_message: &str) {
+    let mut event = DisplayEvent::new(DisplayType::Error, error_message).error(error_message);
+
+    if let Some(name) = agent_name {
+        event = event.agent(name);
+    }
+
+    execute_sync_callbacks(&event);
+
+    let registry = CALLBACK_REGISTRY.read().unwrap();
+    if registry.sync_callbacks.get(&DisplayType::Error).is_none() {
+        if let Some(name) = agent_name {
+            eprintln!("❌ [{}] Error: {}", name, error_message);
+        } else {
+            eprintln!("❌ Error: {}", error_message);
+        }
+    }
+}
+
+/// Display generating/working status
+pub fn display_generating(agent_name: &str, status: &str) {
+    let event = DisplayEvent::new(DisplayType::Generating, status).agent(agent_name);
+
+    execute_sync_callbacks(&event);
+
+    let registry = CALLBACK_REGISTRY.read().unwrap();
+    if registry.sync_callbacks.get(&DisplayType::Generating).is_none() {
+        println!("⏳ [{}] {}", agent_name, status);
+    }
+}
+
+/// Display reasoning steps
+pub fn display_reasoning_steps(agent_name: &str, steps: &[String]) {
+    let content = steps.join("\n");
+    let event = DisplayEvent::new(DisplayType::Reasoning, &content)
+        .agent(agent_name)
+        .meta("step_count", steps.len());
+
+    execute_sync_callbacks(&event);
+
+    let registry = CALLBACK_REGISTRY.read().unwrap();
+    if registry.sync_callbacks.get(&DisplayType::Reasoning).is_none() {
+        println!("🧠 [{}] Reasoning:", agent_name);
+        for (i, step) in steps.iter().enumerate() {
+            println!("   {}. {}", i + 1, step);
+        }
+    }
+}
+
+/// Display working status with animation frame
+pub fn display_working_status(agent_name: &str, phase_index: usize, frame_index: usize) {
+    let phase = WORKING_PHASES.get(phase_index % WORKING_PHASES.len()).unwrap_or(&"Working...");
+    let frame = WORKING_FRAMES.get(frame_index % WORKING_FRAMES.len()).unwrap_or(&"...");
+
+    let event = DisplayEvent::new(DisplayType::Working, format!("{} {}", frame, phase))
+        .agent(agent_name)
+        .meta("phase_index", phase_index)
+        .meta("frame_index", frame_index);
+
+    execute_sync_callbacks(&event);
+
+    let registry = CALLBACK_REGISTRY.read().unwrap();
+    if registry.sync_callbacks.get(&DisplayType::Working).is_none() {
+        print!("\r{} [{}] {}", frame, agent_name, phase);
+        use std::io::Write;
+        std::io::stdout().flush().ok();
+    }
+}
+
+/// Display self-reflection output
+pub fn display_self_reflection(agent_name: &str, reflection: &str, iteration: usize) {
+    let event = DisplayEvent::new(DisplayType::SelfReflection, reflection)
+        .agent(agent_name)
+        .meta("iteration", iteration);
+
+    execute_sync_callbacks(&event);
+
+    let registry = CALLBACK_REGISTRY.read().unwrap();
+    if registry.sync_callbacks.get(&DisplayType::SelfReflection).is_none() {
+        println!("🔄 [{}] Reflection (iteration {}): {}", agent_name, iteration, reflection);
+    }
+}
+
+// =============================================================================
+// HELPER FUNCTIONS
+// =============================================================================
+
+/// Clean content for display (truncate if too long)
+pub fn clean_display_content(content: &str, max_length: usize) -> String {
+    if content.len() <= max_length {
+        content.to_string()
+    } else {
+        format!("{}...", &content[..max_length - 3])
+    }
+}
+
+/// Check if callbacks are registered for a display type
+pub fn has_callbacks(display_type: DisplayType) -> bool {
+    let registry = CALLBACK_REGISTRY.read().unwrap();
+    registry.sync_callbacks.contains_key(&display_type)
+        || registry.async_callbacks.contains_key(&display_type)
+}
+
+/// Get the number of registered callbacks for a display type
+pub fn callback_count(display_type: DisplayType) -> usize {
+    let registry = CALLBACK_REGISTRY.read().unwrap();
+    let sync_count = registry
+        .sync_callbacks
+        .get(&display_type)
+        .map(|v| v.len())
+        .unwrap_or(0);
+    let async_count = registry
+        .async_callbacks
+        .get(&display_type)
+        .map(|v| v.len())
+        .unwrap_or(0);
+    sync_count + async_count
+}
+
+// =============================================================================
+// TESTS
+// =============================================================================
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    #[test]
+    fn test_display_event_builder() {
+        let event = DisplayEvent::new(DisplayType::Interaction, "Hello")
+            .agent("assistant")
+            .tool("search")
+            .args(serde_json::json!({"query": "test"}))
+            .result("Found 5 results")
+            .meta("custom", "value");
+
+        assert_eq!(event.display_type, DisplayType::Interaction);
+        assert_eq!(event.content, "Hello");
+        assert_eq!(event.agent_name, Some("assistant".to_string()));
+        assert_eq!(event.tool_name, Some("search".to_string()));
+        assert!(event.tool_args.is_some());
+        assert_eq!(event.tool_result, Some("Found 5 results".to_string()));
+        assert!(event.metadata.contains_key("custom"));
+    }
+
+    #[test]
+    fn test_display_type_display() {
+        assert_eq!(DisplayType::Interaction.to_string(), "interaction");
+        assert_eq!(DisplayType::ToolCall.to_string(), "tool_call");
+        assert_eq!(DisplayType::Error.to_string(), "error");
+    }
+
+    #[test]
+    fn test_clean_display_content() {
+        let short = "Hello";
+        assert_eq!(clean_display_content(short, 100), "Hello");
+
+        let long = "a".repeat(100);
+        let cleaned = clean_display_content(&long, 50);
+        assert_eq!(cleaned.len(), 50);
+        assert!(cleaned.ends_with("..."));
+    }
+
+    #[test]
+    fn test_callback_registration() {
+        // Clear any existing callbacks first
+        clear_all_callbacks();
+
+        static CALL_COUNT: AtomicUsize = AtomicUsize::new(0);
+
+        register_display_callback(DisplayType::Interaction, |_event| {
+            CALL_COUNT.fetch_add(1, Ordering::SeqCst);
+        });
+
+        assert!(has_callbacks(DisplayType::Interaction));
+        assert_eq!(callback_count(DisplayType::Interaction), 1);
+
+        let event = DisplayEvent::new(DisplayType::Interaction, "test");
+        execute_sync_callbacks(&event);
+
+        assert!(CALL_COUNT.load(Ordering::SeqCst) >= 1);
+
+        clear_display_callbacks(DisplayType::Interaction);
+        assert!(!has_callbacks(DisplayType::Interaction));
+    }
+
+    #[test]
+    fn test_approval_decision() {
+        clear_all_callbacks();
+
+        // Without callback, should deny
+        let decision = request_approval("delete_file", &serde_json::json!({}), RiskLevel::High);
+        assert_eq!(decision, ApprovalDecision::Deny);
+
+        // With callback
+        register_approval_callback(|_name, _args, _risk| ApprovalDecision::Approve);
+
+        let decision = request_approval("delete_file", &serde_json::json!({}), RiskLevel::High);
+        assert_eq!(decision, ApprovalDecision::Approve);
+
+        clear_all_callbacks();
+    }
+
+    #[test]
+    fn test_color_palette() {
+        assert_eq!(PRAISON_COLORS.agent, "#86A789");
+        assert_eq!(PRAISON_COLORS.error, "#E57373");
+    }
+
+    #[test]
+    fn test_working_frames() {
+        assert_eq!(WORKING_FRAMES.len(), 4);
+        assert_eq!(WORKING_PHASES.len(), 4);
+    }
+}
@@ -0,0 +1,592 @@
+//! Embedding Module for PraisonAI Rust SDK
+//!
+//! Provides text embedding capabilities with support for multiple providers.
+//!
+//! # Example
+//!
+//! ```rust,ignore
+//! use praisonai::{EmbeddingAgent, EmbeddingConfig};
+//!
+//! let agent = EmbeddingAgent::new()
+//!     .model("text-embedding-3-small")
+//!     .build()?;
+//!
+//! let embedding = agent.embed("Hello world").await?;
+//! println!("Dimension: {}", embedding.len());
+//! ```
+
+use async_trait::async_trait;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use crate::error::{Error, Result};
+
+/// Configuration for embedding generation.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct EmbeddingConfig {
+    /// Number of dimensions for the embedding (model-dependent)
+    pub dimensions: Option<usize>,
+    /// Encoding format: "float" or "base64"
+    pub encoding_format: String,
+    /// Timeout in seconds
+    pub timeout: u64,
+    /// Custom API base URL
+    pub api_base: Option<String>,
+    /// API key for authentication
+    pub api_key: Option<String>,
+}
+
+impl Default for EmbeddingConfig {
+    fn default() -> Self {
+        Self {
+            dimensions: None,
+            encoding_format: "float".to_string(),
+            timeout: 60,
+            api_base: None,
+            api_key: None,
+        }
+    }
+}
+
+impl EmbeddingConfig {
+    /// Create a new EmbeddingConfig with defaults
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Set dimensions
+    pub fn dimensions(mut self, dimensions: usize) -> Self {
+        self.dimensions = Some(dimensions);
+        self
+    }
+
+    /// Set encoding format
+    pub fn encoding_format(mut self, format: impl Into<String>) -> Self {
+        self.encoding_format = format.into();
+        self
+    }
+
+    /// Set timeout
+    pub fn timeout(mut self, timeout: u64) -> Self {
+        self.timeout = timeout;
+        self
+    }
+
+    /// Set API base URL
+    pub fn api_base(mut self, url: impl Into<String>) -> Self {
+        self.api_base = Some(url.into());
+        self
+    }
+
+    /// Set API key
+    pub fn api_key(mut self, key: impl Into<String>) -> Self {
+        self.api_key = Some(key.into());
+        self
+    }
+}
+
+/// Result of an embedding operation.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct EmbeddingResult {
+    /// The embedding vectors
+    pub embeddings: Vec<Vec<f32>>,
+    /// Model used for embedding
+    pub model: String,
+    /// Token usage information
+    pub usage: EmbeddingUsage,
+}
+
+impl EmbeddingResult {
+    /// Get the first embedding vector
+    pub fn first(&self) -> Option<&Vec<f32>> {
+        self.embeddings.first()
+    }
+
+    /// Get the number of embeddings
+    pub fn len(&self) -> usize {
+        self.embeddings.len()
+    }
+
+    /// Check if empty
+    pub fn is_empty(&self) -> bool {
+        self.embeddings.is_empty()
+    }
+
+    /// Get embedding dimension
+    pub fn dimension(&self) -> usize {
+        self.embeddings.first().map(|e| e.len()).unwrap_or(0)
+    }
+}
+
+/// Token usage for embedding operations.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct EmbeddingUsage {
+    /// Number of prompt tokens
+    pub prompt_tokens: u32,
+    /// Total tokens used
+    pub total_tokens: u32,
+}
+
+/// Similarity search result.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SimilarityResult {
+    /// The text that was compared
+    pub text: String,
+    /// Similarity score (0.0 to 1.0)
+    pub score: f32,
+    /// Index in the original list
+    pub index: usize,
+}
+
+/// Builder for EmbeddingAgent.
+#[derive(Debug, Clone)]
+pub struct EmbeddingAgentBuilder {
+    name: String,
+    model: String,
+    config: EmbeddingConfig,
+    verbose: bool,
+}
+
+impl Default for EmbeddingAgentBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl EmbeddingAgentBuilder {
+    /// Create a new builder
+    pub fn new() -> Self {
+        Self {
+            name: "EmbeddingAgent".to_string(),
+            model: std::env::var("PRAISONAI_EMBEDDING_MODEL")
+                .unwrap_or_else(|_| "text-embedding-3-small".to_string()),
+            config: EmbeddingConfig::default(),
+            verbose: true,
+        }
+    }
+
+    /// Set agent name
+    pub fn name(mut self, name: impl Into<String>) -> Self {
+        self.name = name.into();
+        self
+    }
+
+    /// Set model name
+    pub fn model(mut self, model: impl Into<String>) -> Self {
+        self.model = model.into();
+        self
+    }
+
+    /// Set embedding config
+    pub fn config(mut self, config: EmbeddingConfig) -> Self {
+        self.config = config;
+        self
+    }
+
+    /// Set verbose mode
+    pub fn verbose(mut self, verbose: bool) -> Self {
+        self.verbose = verbose;
+        self
+    }
+
+    /// Set API key
+    pub fn api_key(mut self, key: impl Into<String>) -> Self {
+        self.config.api_key = Some(key.into());
+        self
+    }
+
+    /// Set API base URL
+    pub fn api_base(mut self, url: impl Into<String>) -> Self {
+        self.config.api_base = Some(url.into());
+        self
+    }
+
+    /// Build the EmbeddingAgent
+    pub fn build(self) -> Result<EmbeddingAgent> {
+        Ok(EmbeddingAgent {
+            name: self.name,
+            model: self.model,
+            config: self.config,
+            verbose: self.verbose,
+        })
+    }
+}
+
+/// Agent for generating text embeddings.
+///
+/// Provides embedding capabilities for text using AI embedding models,
+/// with support for batch processing and similarity calculations.
+///
+/// # Supported Providers
+///
+/// - OpenAI: `text-embedding-3-small`, `text-embedding-3-large`, `text-embedding-ada-002`
+/// - Azure: `azure/text-embedding-3-small`
+/// - Cohere: `cohere/embed-english-v3.0`
+/// - Voyage: `voyage/voyage-3`
+/// - Mistral: `mistral/mistral-embed`
+#[derive(Debug, Clone)]
+pub struct EmbeddingAgent {
+    /// Agent name
+    pub name: String,
+    /// Model name
+    pub model: String,
+    /// Embedding configuration
+    pub config: EmbeddingConfig,
+    /// Verbose output
+    pub verbose: bool,
+}
+
+impl EmbeddingAgent {
+    /// Create a new builder
+    pub fn new() -> EmbeddingAgentBuilder {
+        EmbeddingAgentBuilder::new()
+    }
+
+    /// Create a simple embedding agent with default settings
+    pub fn simple() -> Result<Self> {
+        Self::new().build()
+    }
+
+    /// Generate embedding for a single text.
+    ///
+    /// # Arguments
+    ///
+    /// * `text` - Text to embed
+    ///
+    /// # Returns
+    ///
+    /// Vector of floats representing the embedding
+    pub async fn embed(&self, text: &str) -> Result<Vec<f32>> {
+        let result = self.embed_batch(&[text]).await?;
+        result
+            .embeddings
+            .into_iter()
+            .next()
+            .ok_or_else(|| Error::Embedding("No embedding returned".to_string()))
+    }
+
+    /// Generate embeddings for multiple texts.
+    ///
+    /// # Arguments
+    ///
+    /// * `texts` - Slice of texts to embed
+    ///
+    /// # Returns
+    ///
+    /// EmbeddingResult containing all embeddings
+    pub async fn embed_batch(&self, texts: &[&str]) -> Result<EmbeddingResult> {
+        if texts.is_empty() {
+            return Ok(EmbeddingResult {
+                embeddings: vec![],
+                model: self.model.clone(),
+                usage: EmbeddingUsage::default(),
+            });
+        }
+
+        // Get API key from config or environment
+        let api_key = self
+            .config
+            .api_key
+            .clone()
+            .or_else(|| std::env::var("OPENAI_API_KEY").ok())
+            .ok_or_else(|| Error::Config("No API key provided for embeddings".to_string()))?;
+
+        // Build API URL
+        let api_base = self
+            .config
+            .api_base
+            .clone()
+            .unwrap_or_else(|| "https://api.openai.com/v1".to_string());
+        let url = format!("{}/embeddings", api_base);
+
+        // Build request body
+        let mut body = serde_json::json!({
+            "model": self.model,
+            "input": texts,
+        });
+
+        if let Some(dims) = self.config.dimensions {
+            body["dimensions"] = serde_json::json!(dims);
+        }
+
+        if self.config.encoding_format != "float" {
+            body["encoding_format"] = serde_json::json!(self.config.encoding_format);
+        }
+
+        // Make HTTP request
+        let client = reqwest::Client::new();
+        let response = client
+            .post(&url)
+            .header("Authorization", format!("Bearer {}", api_key))
+            .header("Content-Type", "application/json")
+            .timeout(std::time::Duration::from_secs(self.config.timeout))
+            .json(&body)
+            .send()
+            .await
+            .map_err(|e| Error::Embedding(format!("HTTP request failed: {}", e)))?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let text = response
+                .text()
+                .await
+                .unwrap_or_else(|_| "Unknown error".to_string());
+            return Err(Error::Embedding(format!(
+                "API request failed ({}): {}",
+                status, text
+            )));
+        }
+
+        // Parse response
+        let response_json: serde_json::Value = response
+            .json()
+            .await
+            .map_err(|e| Error::Embedding(format!("Failed to parse response: {}", e)))?;
+
+        // Extract embeddings
+        let data = response_json["data"]
+            .as_array()
+            .ok_or_else(|| Error::Embedding("Invalid response format".to_string()))?;
+
+        let embeddings: Vec<Vec<f32>> = data
+            .iter()
+            .map(|item| {
+                item["embedding"]
+                    .as_array()
+                    .map(|arr| {
+                        arr.iter()
+                            .filter_map(|v| v.as_f64().map(|f| f as f32))
+                            .collect()
+                    })
+                    .unwrap_or_default()
+            })
+            .collect();
+
+        // Extract usage
+        let usage = EmbeddingUsage {
+            prompt_tokens: response_json["usage"]["prompt_tokens"]
+                .as_u64()
+                .unwrap_or(0) as u32,
+            total_tokens: response_json["usage"]["total_tokens"]
+                .as_u64()
+                .unwrap_or(0) as u32,
+        };
+
+        Ok(EmbeddingResult {
+            embeddings,
+            model: self.model.clone(),
+            usage,
+        })
+    }
+
+    /// Calculate cosine similarity between two texts.
+    ///
+    /// # Arguments
+    ///
+    /// * `text1` - First text
+    /// * `text2` - Second text
+    ///
+    /// # Returns
+    ///
+    /// Cosine similarity score (0.0 to 1.0)
+    pub async fn similarity(&self, text1: &str, text2: &str) -> Result<f32> {
+        let result = self.embed_batch(&[text1, text2]).await?;
+        if result.embeddings.len() < 2 {
+            return Err(Error::Embedding(
+                "Not enough embeddings returned".to_string(),
+            ));
+        }
+        Ok(cosine_similarity(&result.embeddings[0], &result.embeddings[1]))
+    }
+
+    /// Find the most similar texts to a query.
+    ///
+    /// # Arguments
+    ///
+    /// * `query` - Query text
+    /// * `candidates` - List of candidate texts to compare
+    /// * `top_k` - Number of top results to return
+    ///
+    /// # Returns
+    ///
+    /// List of SimilarityResult sorted by score (descending)
+    pub async fn find_most_similar(
+        &self,
+        query: &str,
+        candidates: &[&str],
+        top_k: usize,
+    ) -> Result<Vec<SimilarityResult>> {
+        if candidates.is_empty() {
+            return Ok(vec![]);
+        }
+
+        // Embed query and all candidates together
+        let mut all_texts: Vec<&str> = vec![query];
+        all_texts.extend(candidates);
+
+        let result = self.embed_batch(&all_texts).await?;
+        if result.embeddings.is_empty() {
+            return Ok(vec![]);
+        }
+
+        let query_embedding = &result.embeddings[0];
+        let candidate_embeddings = &result.embeddings[1..];
+
+        // Calculate similarities
+        let mut scores: Vec<SimilarityResult> = candidate_embeddings
+            .iter()
+            .enumerate()
+            .map(|(i, emb)| SimilarityResult {
+                text: candidates[i].to_string(),
+                score: cosine_similarity(query_embedding, emb),
+                index: i,
+            })
+            .collect();
+
+        // Sort by score descending
+        scores.sort_by(|a, b| b.score.partial_cmp(&a.score).unwrap_or(std::cmp::Ordering::Equal));
+
+        // Return top_k
+        scores.truncate(top_k);
+        Ok(scores)
+    }
+}
+
+impl Default for EmbeddingAgent {
+    fn default() -> Self {
+        Self::new().build().expect("Failed to build default EmbeddingAgent")
+    }
+}
+
+/// Calculate cosine similarity between two vectors.
+pub fn cosine_similarity(vec1: &[f32], vec2: &[f32]) -> f32 {
+    if vec1.len() != vec2.len() || vec1.is_empty() {
+        return 0.0;
+    }
+
+    let dot_product: f32 = vec1.iter().zip(vec2.iter()).map(|(a, b)| a * b).sum();
+    let norm1: f32 = vec1.iter().map(|x| x * x).sum::<f32>().sqrt();
+    let norm2: f32 = vec2.iter().map(|x| x * x).sum::<f32>().sqrt();
+
+    if norm1 == 0.0 || norm2 == 0.0 {
+        return 0.0;
+    }
+
+    dot_product / (norm1 * norm2)
+}
+
+/// Get embedding dimensions for a model.
+pub fn get_dimensions(model: &str) -> Option<usize> {
+    match model {
+        "text-embedding-3-small" => Some(1536),
+        "text-embedding-3-large" => Some(3072),
+        "text-embedding-ada-002" => Some(1536),
+        "cohere/embed-english-v3.0" => Some(1024),
+        "cohere/embed-multilingual-v3.0" => Some(1024),
+        "voyage/voyage-3" => Some(1024),
+        "voyage/voyage-3-lite" => Some(512),
+        "mistral/mistral-embed" => Some(1024),
+        _ => None,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_embedding_config_default() {
+        let config = EmbeddingConfig::default();
+        assert_eq!(config.encoding_format, "float");
+        assert_eq!(config.timeout, 60);
+        assert!(config.dimensions.is_none());
+    }
+
+    #[test]
+    fn test_embedding_config_builder() {
+        let config = EmbeddingConfig::new()
+            .dimensions(1536)
+            .timeout(30)
+            .api_key("test-key");
+
+        assert_eq!(config.dimensions, Some(1536));
+        assert_eq!(config.timeout, 30);
+        assert_eq!(config.api_key, Some("test-key".to_string()));
+    }
+
+    #[test]
+    fn test_embedding_agent_builder() {
+        let agent = EmbeddingAgent::new()
+            .name("TestAgent")
+            .model("text-embedding-3-small")
+            .verbose(false)
+            .build()
+            .unwrap();
+
+        assert_eq!(agent.name, "TestAgent");
+        assert_eq!(agent.model, "text-embedding-3-small");
+        assert!(!agent.verbose);
+    }
+
+    #[test]
+    fn test_cosine_similarity() {
+        let vec1 = vec![1.0, 0.0, 0.0];
+        let vec2 = vec![1.0, 0.0, 0.0];
+        assert!((cosine_similarity(&vec1, &vec2) - 1.0).abs() < 0.001);
+
+        let vec3 = vec![0.0, 1.0, 0.0];
+        assert!((cosine_similarity(&vec1, &vec3)).abs() < 0.001);
+
+        let vec4 = vec![0.707, 0.707, 0.0];
+        let sim = cosine_similarity(&vec1, &vec4);
+        assert!(sim > 0.7 && sim < 0.71);
+    }
+
+    #[test]
+    fn test_cosine_similarity_empty() {
+        let empty: Vec<f32> = vec![];
+        assert_eq!(cosine_similarity(&empty, &empty), 0.0);
+    }
+
+    #[test]
+    fn test_cosine_similarity_different_lengths() {
+        let vec1 = vec![1.0, 0.0];
+        let vec2 = vec![1.0, 0.0, 0.0];
+        assert_eq!(cosine_similarity(&vec1, &vec2), 0.0);
+    }
+
+    #[test]
+    fn test_get_dimensions() {
+        assert_eq!(get_dimensions("text-embedding-3-small"), Some(1536));
+        assert_eq!(get_dimensions("text-embedding-3-large"), Some(3072));
+        assert_eq!(get_dimensions("unknown-model"), None);
+    }
+
+    #[test]
+    fn test_embedding_result() {
+        let result = EmbeddingResult {
+            embeddings: vec![vec![1.0, 2.0, 3.0], vec![4.0, 5.0, 6.0]],
+            model: "test".to_string(),
+            usage: EmbeddingUsage::default(),
+        };
+
+        assert_eq!(result.len(), 2);
+        assert!(!result.is_empty());
+        assert_eq!(result.dimension(), 3);
+        assert_eq!(result.first(), Some(&vec![1.0, 2.0, 3.0]));
+    }
+
+    #[test]
+    fn test_similarity_result() {
+        let result = SimilarityResult {
+            text: "test".to_string(),
+            score: 0.95,
+            index: 0,
+        };
+
+        assert_eq!(result.text, "test");
+        assert_eq!(result.score, 0.95);
+        assert_eq!(result.index, 0);
+    }
+}
@@ -0,0 +1,913 @@
+//! Evaluation Module for PraisonAI Rust SDK.
+//!
+//! Provides comprehensive evaluation capabilities for AI agents.
+//!
+//! # Example
+//!
+//! ```ignore
+//! use praisonai::eval::{AccuracyEvaluator, EvaluationScore};
+//!
+//! let evaluator = AccuracyEvaluator::new()
+//!     .input("What is 2+2?")
+//!     .expected("4")
+//!     .build();
+//!
+//! let result = evaluator.run().await?;
+//! println!("Score: {}", result.score);
+//! ```
+
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::time::{Duration, Instant};
+
+// =============================================================================
+// EVALUATION SCORE
+// =============================================================================
+
+/// Score from an evaluation.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct EvaluationScore {
+    /// Score value (0.0 to 1.0)
+    pub value: f64,
+    /// Score reasoning
+    pub reasoning: Option<String>,
+    /// Confidence level
+    pub confidence: Option<f64>,
+}
+
+impl EvaluationScore {
+    /// Create a new score.
+    pub fn new(value: f64) -> Self {
+        Self {
+            value: value.clamp(0.0, 1.0),
+            reasoning: None,
+            confidence: None,
+        }
+    }
+
+    /// Set reasoning.
+    pub fn with_reasoning(mut self, reasoning: impl Into<String>) -> Self {
+        self.reasoning = Some(reasoning.into());
+        self
+    }
+
+    /// Set confidence.
+    pub fn with_confidence(mut self, confidence: f64) -> Self {
+        self.confidence = Some(confidence.clamp(0.0, 1.0));
+        self
+    }
+
+    /// Check if passing (>= threshold).
+    pub fn is_passing(&self, threshold: f64) -> bool {
+        self.value >= threshold
+    }
+
+    /// Convert to percentage.
+    pub fn as_percentage(&self) -> f64 {
+        self.value * 100.0
+    }
+}
+
+impl Default for EvaluationScore {
+    fn default() -> Self {
+        Self::new(0.0)
+    }
+}
+
+// =============================================================================
+// PERFORMANCE METRICS
+// =============================================================================
+
+/// Performance metrics from an evaluation.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PerformanceMetrics {
+    /// Total duration
+    pub duration: Duration,
+    /// Time to first token (if applicable)
+    pub ttft: Option<Duration>,
+    /// Tokens per second
+    pub tokens_per_second: Option<f64>,
+    /// Memory usage in bytes
+    pub memory_bytes: Option<usize>,
+    /// Input tokens
+    pub input_tokens: Option<usize>,
+    /// Output tokens
+    pub output_tokens: Option<usize>,
+}
+
+impl Default for PerformanceMetrics {
+    fn default() -> Self {
+        Self {
+            duration: Duration::ZERO,
+            ttft: None,
+            tokens_per_second: None,
+            memory_bytes: None,
+            input_tokens: None,
+            output_tokens: None,
+        }
+    }
+}
+
+impl PerformanceMetrics {
+    /// Create new metrics with duration.
+    pub fn new(duration: Duration) -> Self {
+        Self {
+            duration,
+            ..Default::default()
+        }
+    }
+
+    /// Set TTFT.
+    pub fn with_ttft(mut self, ttft: Duration) -> Self {
+        self.ttft = Some(ttft);
+        self
+    }
+
+    /// Set tokens per second.
+    pub fn with_tokens_per_second(mut self, tps: f64) -> Self {
+        self.tokens_per_second = Some(tps);
+        self
+    }
+
+    /// Set token counts.
+    pub fn with_tokens(mut self, input: usize, output: usize) -> Self {
+        self.input_tokens = Some(input);
+        self.output_tokens = Some(output);
+        self
+    }
+}
+
+// =============================================================================
+// TOOL CALL RESULT
+// =============================================================================
+
+/// Result of a tool call during evaluation.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolCallResult {
+    /// Tool name
+    pub name: String,
+    /// Whether the call was expected
+    pub expected: bool,
+    /// Whether the call was made
+    pub called: bool,
+    /// Arguments used
+    pub arguments: Option<serde_json::Value>,
+    /// Result returned
+    pub result: Option<serde_json::Value>,
+}
+
+impl ToolCallResult {
+    /// Create a new tool call result.
+    pub fn new(name: impl Into<String>, expected: bool, called: bool) -> Self {
+        Self {
+            name: name.into(),
+            expected,
+            called,
+            arguments: None,
+            result: None,
+        }
+    }
+
+    /// Check if correct (expected == called).
+    pub fn is_correct(&self) -> bool {
+        self.expected == self.called
+    }
+}
+
+// =============================================================================
+// CRITERIA SCORE
+// =============================================================================
+
+/// Score for a specific criterion.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CriteriaScore {
+    /// Criterion name
+    pub name: String,
+    /// Score value
+    pub score: f64,
+    /// Weight for this criterion
+    pub weight: f64,
+    /// Feedback
+    pub feedback: Option<String>,
+}
+
+impl CriteriaScore {
+    /// Create a new criteria score.
+    pub fn new(name: impl Into<String>, score: f64) -> Self {
+        Self {
+            name: name.into(),
+            score: score.clamp(0.0, 1.0),
+            weight: 1.0,
+            feedback: None,
+        }
+    }
+
+    /// Set weight.
+    pub fn with_weight(mut self, weight: f64) -> Self {
+        self.weight = weight;
+        self
+    }
+
+    /// Set feedback.
+    pub fn with_feedback(mut self, feedback: impl Into<String>) -> Self {
+        self.feedback = Some(feedback.into());
+        self
+    }
+
+    /// Get weighted score.
+    pub fn weighted_score(&self) -> f64 {
+        self.score * self.weight
+    }
+}
+
+// =============================================================================
+// EVALUATION RESULTS
+// =============================================================================
+
+/// Result from an accuracy evaluation.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AccuracyResult {
+    /// Overall score
+    pub score: EvaluationScore,
+    /// Input text
+    pub input: String,
+    /// Expected output
+    pub expected: String,
+    /// Actual output
+    pub actual: String,
+    /// Whether it passed
+    pub passed: bool,
+}
+
+/// Result from a performance evaluation.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PerformanceResult {
+    /// Overall score
+    pub score: EvaluationScore,
+    /// Performance metrics
+    pub metrics: PerformanceMetrics,
+    /// Whether it passed
+    pub passed: bool,
+}
+
+/// Result from a reliability evaluation.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ReliabilityResult {
+    /// Overall score
+    pub score: EvaluationScore,
+    /// Tool call results
+    pub tool_calls: Vec<ToolCallResult>,
+    /// Whether it passed
+    pub passed: bool,
+}
+
+/// Result from a criteria evaluation.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CriteriaResult {
+    /// Overall score
+    pub score: EvaluationScore,
+    /// Individual criteria scores
+    pub criteria: Vec<CriteriaScore>,
+    /// Whether it passed
+    pub passed: bool,
+}
+
+// =============================================================================
+// BASE EVALUATOR
+// =============================================================================
+
+/// Base trait for evaluators.
+pub trait Evaluator {
+    /// Result type for this evaluator.
+    type Result;
+
+    /// Run the evaluation.
+    fn evaluate(&self) -> Self::Result;
+}
+
+/// Configuration for evaluators.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct EvaluatorConfig {
+    /// Passing threshold
+    pub threshold: f64,
+    /// Whether to print summary
+    pub print_summary: bool,
+    /// Model to use for LLM-based evaluation
+    pub model: Option<String>,
+    /// Maximum retries
+    pub max_retries: usize,
+}
+
+impl Default for EvaluatorConfig {
+    fn default() -> Self {
+        Self {
+            threshold: 0.7,
+            print_summary: false,
+            model: None,
+            max_retries: 3,
+        }
+    }
+}
+
+// =============================================================================
+// ACCURACY EVALUATOR
+// =============================================================================
+
+/// Evaluator for accuracy (comparing output to expected).
+#[derive(Debug, Clone)]
+pub struct AccuracyEvaluator {
+    /// Input text
+    input: String,
+    /// Expected output
+    expected: String,
+    /// Actual output (if already available)
+    actual: Option<String>,
+    /// Configuration
+    config: EvaluatorConfig,
+}
+
+impl AccuracyEvaluator {
+    /// Create a new builder.
+    pub fn new() -> AccuracyEvaluatorBuilder {
+        AccuracyEvaluatorBuilder::default()
+    }
+
+    /// Evaluate accuracy using simple string comparison.
+    pub fn evaluate_simple(&self, actual: &str) -> AccuracyResult {
+        let similarity = self.calculate_similarity(&self.expected, actual);
+        let score = EvaluationScore::new(similarity);
+        let passed = score.is_passing(self.config.threshold);
+
+        AccuracyResult {
+            score,
+            input: self.input.clone(),
+            expected: self.expected.clone(),
+            actual: actual.to_string(),
+            passed,
+        }
+    }
+
+    /// Calculate string similarity (Jaccard).
+    fn calculate_similarity(&self, a: &str, b: &str) -> f64 {
+        let a_words: std::collections::HashSet<_> = a.split_whitespace().collect();
+        let b_words: std::collections::HashSet<_> = b.split_whitespace().collect();
+
+        if a_words.is_empty() && b_words.is_empty() {
+            return 1.0;
+        }
+
+        let intersection = a_words.intersection(&b_words).count();
+        let union = a_words.union(&b_words).count();
+
+        if union == 0 {
+            0.0
+        } else {
+            intersection as f64 / union as f64
+        }
+    }
+}
+
+impl Default for AccuracyEvaluator {
+    fn default() -> Self {
+        Self {
+            input: String::new(),
+            expected: String::new(),
+            actual: None,
+            config: EvaluatorConfig::default(),
+        }
+    }
+}
+
+/// Builder for AccuracyEvaluator.
+#[derive(Debug, Default)]
+pub struct AccuracyEvaluatorBuilder {
+    input: Option<String>,
+    expected: Option<String>,
+    actual: Option<String>,
+    config: EvaluatorConfig,
+}
+
+impl AccuracyEvaluatorBuilder {
+    /// Set input text.
+    pub fn input(mut self, input: impl Into<String>) -> Self {
+        self.input = Some(input.into());
+        self
+    }
+
+    /// Set expected output.
+    pub fn expected(mut self, expected: impl Into<String>) -> Self {
+        self.expected = Some(expected.into());
+        self
+    }
+
+    /// Set actual output.
+    pub fn actual(mut self, actual: impl Into<String>) -> Self {
+        self.actual = Some(actual.into());
+        self
+    }
+
+    /// Set threshold.
+    pub fn threshold(mut self, threshold: f64) -> Self {
+        self.config.threshold = threshold;
+        self
+    }
+
+    /// Build the evaluator.
+    pub fn build(self) -> AccuracyEvaluator {
+        AccuracyEvaluator {
+            input: self.input.unwrap_or_default(),
+            expected: self.expected.unwrap_or_default(),
+            actual: self.actual,
+            config: self.config,
+        }
+    }
+}
+
+// =============================================================================
+// PERFORMANCE EVALUATOR
+// =============================================================================
+
+/// Evaluator for performance metrics.
+#[derive(Debug, Clone)]
+pub struct PerformanceEvaluator {
+    /// Maximum allowed duration
+    max_duration: Duration,
+    /// Maximum allowed TTFT
+    max_ttft: Option<Duration>,
+    /// Configuration
+    config: EvaluatorConfig,
+}
+
+impl PerformanceEvaluator {
+    /// Create a new builder.
+    pub fn new() -> PerformanceEvaluatorBuilder {
+        PerformanceEvaluatorBuilder::default()
+    }
+
+    /// Evaluate performance metrics.
+    pub fn evaluate(&self, metrics: &PerformanceMetrics) -> PerformanceResult {
+        let mut score = 1.0;
+
+        // Penalize for duration
+        if metrics.duration > self.max_duration {
+            let ratio = self.max_duration.as_secs_f64() / metrics.duration.as_secs_f64();
+            score *= ratio;
+        }
+
+        // Penalize for TTFT
+        if let (Some(max_ttft), Some(ttft)) = (self.max_ttft, metrics.ttft) {
+            if ttft > max_ttft {
+                let ratio = max_ttft.as_secs_f64() / ttft.as_secs_f64();
+                score *= ratio;
+            }
+        }
+
+        let eval_score = EvaluationScore::new(score);
+        let passed = eval_score.is_passing(self.config.threshold);
+
+        PerformanceResult {
+            score: eval_score,
+            metrics: metrics.clone(),
+            passed,
+        }
+    }
+}
+
+impl Default for PerformanceEvaluator {
+    fn default() -> Self {
+        Self {
+            max_duration: Duration::from_secs(30),
+            max_ttft: None,
+            config: EvaluatorConfig::default(),
+        }
+    }
+}
+
+/// Builder for PerformanceEvaluator.
+#[derive(Debug, Default)]
+pub struct PerformanceEvaluatorBuilder {
+    max_duration: Option<Duration>,
+    max_ttft: Option<Duration>,
+    config: EvaluatorConfig,
+}
+
+impl PerformanceEvaluatorBuilder {
+    /// Set maximum duration.
+    pub fn max_duration(mut self, duration: Duration) -> Self {
+        self.max_duration = Some(duration);
+        self
+    }
+
+    /// Set maximum TTFT.
+    pub fn max_ttft(mut self, ttft: Duration) -> Self {
+        self.max_ttft = Some(ttft);
+        self
+    }
+
+    /// Set threshold.
+    pub fn threshold(mut self, threshold: f64) -> Self {
+        self.config.threshold = threshold;
+        self
+    }
+
+    /// Build the evaluator.
+    pub fn build(self) -> PerformanceEvaluator {
+        PerformanceEvaluator {
+            max_duration: self.max_duration.unwrap_or(Duration::from_secs(30)),
+            max_ttft: self.max_ttft,
+            config: self.config,
+        }
+    }
+}
+
+// =============================================================================
+// RELIABILITY EVALUATOR
+// =============================================================================
+
+/// Evaluator for reliability (tool call verification).
+#[derive(Debug, Clone)]
+pub struct ReliabilityEvaluator {
+    /// Expected tool calls
+    expected_tools: Vec<String>,
+    /// Configuration
+    config: EvaluatorConfig,
+}
+
+impl ReliabilityEvaluator {
+    /// Create a new builder.
+    pub fn new() -> ReliabilityEvaluatorBuilder {
+        ReliabilityEvaluatorBuilder::default()
+    }
+
+    /// Evaluate tool calls.
+    pub fn evaluate(&self, called_tools: &[String]) -> ReliabilityResult {
+        let mut results = Vec::new();
+        let mut correct = 0;
+
+        for expected in &self.expected_tools {
+            let called = called_tools.contains(expected);
+            if called {
+                correct += 1;
+            }
+            results.push(ToolCallResult::new(expected, true, called));
+        }
+
+        let score = if self.expected_tools.is_empty() {
+            1.0
+        } else {
+            correct as f64 / self.expected_tools.len() as f64
+        };
+
+        let eval_score = EvaluationScore::new(score);
+        let passed = eval_score.is_passing(self.config.threshold);
+
+        ReliabilityResult {
+            score: eval_score,
+            tool_calls: results,
+            passed,
+        }
+    }
+}
+
+impl Default for ReliabilityEvaluator {
+    fn default() -> Self {
+        Self {
+            expected_tools: Vec::new(),
+            config: EvaluatorConfig::default(),
+        }
+    }
+}
+
+/// Builder for ReliabilityEvaluator.
+#[derive(Debug, Default)]
+pub struct ReliabilityEvaluatorBuilder {
+    expected_tools: Vec<String>,
+    config: EvaluatorConfig,
+}
+
+impl ReliabilityEvaluatorBuilder {
+    /// Add expected tool.
+    pub fn expect_tool(mut self, tool: impl Into<String>) -> Self {
+        self.expected_tools.push(tool.into());
+        self
+    }
+
+    /// Set threshold.
+    pub fn threshold(mut self, threshold: f64) -> Self {
+        self.config.threshold = threshold;
+        self
+    }
+
+    /// Build the evaluator.
+    pub fn build(self) -> ReliabilityEvaluator {
+        ReliabilityEvaluator {
+            expected_tools: self.expected_tools,
+            config: self.config,
+        }
+    }
+}
+
+// =============================================================================
+// CRITERIA EVALUATOR
+// =============================================================================
+
+/// Evaluator for custom criteria.
+#[derive(Debug, Clone)]
+pub struct CriteriaEvaluator {
+    /// Criteria to evaluate
+    criteria: Vec<String>,
+    /// Configuration
+    config: EvaluatorConfig,
+}
+
+impl CriteriaEvaluator {
+    /// Create a new builder.
+    pub fn new() -> CriteriaEvaluatorBuilder {
+        CriteriaEvaluatorBuilder::default()
+    }
+
+    /// Evaluate with provided scores.
+    pub fn evaluate(&self, scores: &HashMap<String, f64>) -> CriteriaResult {
+        let mut criteria_scores = Vec::new();
+        let mut total_score = 0.0;
+        let mut total_weight = 0.0;
+
+        for criterion in &self.criteria {
+            let score = scores.get(criterion).copied().unwrap_or(0.0);
+            criteria_scores.push(CriteriaScore::new(criterion, score));
+            total_score += score;
+            total_weight += 1.0;
+        }
+
+        let avg_score = if total_weight > 0.0 {
+            total_score / total_weight
+        } else {
+            0.0
+        };
+
+        let eval_score = EvaluationScore::new(avg_score);
+        let passed = eval_score.is_passing(self.config.threshold);
+
+        CriteriaResult {
+            score: eval_score,
+            criteria: criteria_scores,
+            passed,
+        }
+    }
+}
+
+impl Default for CriteriaEvaluator {
+    fn default() -> Self {
+        Self {
+            criteria: Vec::new(),
+            config: EvaluatorConfig::default(),
+        }
+    }
+}
+
+/// Builder for CriteriaEvaluator.
+#[derive(Debug, Default)]
+pub struct CriteriaEvaluatorBuilder {
+    criteria: Vec<String>,
+    config: EvaluatorConfig,
+}
+
+impl CriteriaEvaluatorBuilder {
+    /// Add a criterion.
+    pub fn criterion(mut self, criterion: impl Into<String>) -> Self {
+        self.criteria.push(criterion.into());
+        self
+    }
+
+    /// Set threshold.
+    pub fn threshold(mut self, threshold: f64) -> Self {
+        self.config.threshold = threshold;
+        self
+    }
+
+    /// Build the evaluator.
+    pub fn build(self) -> CriteriaEvaluator {
+        CriteriaEvaluator {
+            criteria: self.criteria,
+            config: self.config,
+        }
+    }
+}
+
+// =============================================================================
+// JUDGE
+// =============================================================================
+
+/// Configuration for a judge.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct JudgeConfig {
+    /// Model to use
+    pub model: String,
+    /// Temperature
+    pub temperature: f64,
+    /// System prompt
+    pub system_prompt: Option<String>,
+}
+
+impl Default for JudgeConfig {
+    fn default() -> Self {
+        Self {
+            model: "gpt-4o-mini".to_string(),
+            temperature: 0.0,
+            system_prompt: None,
+        }
+    }
+}
+
+/// Result from a judge.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct JudgeResult {
+    /// Score
+    pub score: f64,
+    /// Reasoning
+    pub reasoning: String,
+    /// Pass/fail
+    pub passed: bool,
+    /// Metadata
+    pub metadata: HashMap<String, serde_json::Value>,
+}
+
+impl JudgeResult {
+    /// Create a new result.
+    pub fn new(score: f64, reasoning: impl Into<String>, passed: bool) -> Self {
+        Self {
+            score,
+            reasoning: reasoning.into(),
+            passed,
+            metadata: HashMap::new(),
+        }
+    }
+}
+
+/// A judge for evaluating outputs.
+#[derive(Debug, Clone)]
+pub struct Judge {
+    /// Judge name
+    pub name: String,
+    /// Configuration
+    pub config: JudgeConfig,
+    /// Threshold for passing
+    pub threshold: f64,
+}
+
+impl Judge {
+    /// Create a new judge.
+    pub fn new(name: impl Into<String>) -> Self {
+        Self {
+            name: name.into(),
+            config: JudgeConfig::default(),
+            threshold: 0.7,
+        }
+    }
+
+    /// Set configuration.
+    pub fn with_config(mut self, config: JudgeConfig) -> Self {
+        self.config = config;
+        self
+    }
+
+    /// Set threshold.
+    pub fn with_threshold(mut self, threshold: f64) -> Self {
+        self.threshold = threshold;
+        self
+    }
+
+    /// Judge an output (placeholder - would use LLM in real implementation).
+    pub fn judge(&self, _input: &str, _output: &str, _expected: Option<&str>) -> JudgeResult {
+        // Placeholder implementation
+        JudgeResult::new(0.8, "Placeholder evaluation", true)
+    }
+}
+
+// =============================================================================
+// TESTS
+// =============================================================================
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_evaluation_score() {
+        let score = EvaluationScore::new(0.85);
+        assert!((score.value - 0.85).abs() < 0.001);
+        assert!(score.is_passing(0.7));
+        assert!(!score.is_passing(0.9));
+    }
+
+    #[test]
+    fn test_evaluation_score_clamp() {
+        let score = EvaluationScore::new(1.5);
+        assert!((score.value - 1.0).abs() < 0.001);
+
+        let score = EvaluationScore::new(-0.5);
+        assert!((score.value - 0.0).abs() < 0.001);
+    }
+
+    #[test]
+    fn test_accuracy_evaluator() {
+        let evaluator = AccuracyEvaluator::new()
+            .input("What is 2+2?")
+            .expected("The answer is 4")
+            .threshold(0.5)
+            .build();
+
+        let result = evaluator.evaluate_simple("The answer is 4");
+        assert!(result.passed);
+        assert!((result.score.value - 1.0).abs() < 0.001);
+    }
+
+    #[test]
+    fn test_accuracy_evaluator_partial() {
+        let evaluator = AccuracyEvaluator::new()
+            .input("What is 2+2?")
+            .expected("The answer is 4")
+            .threshold(0.3)
+            .build();
+
+        let result = evaluator.evaluate_simple("The answer is 5");
+        assert!(result.score.value > 0.0);
+        assert!(result.score.value < 1.0);
+    }
+
+    #[test]
+    fn test_performance_evaluator() {
+        let evaluator = PerformanceEvaluator::new()
+            .max_duration(Duration::from_secs(10))
+            .threshold(0.5)
+            .build();
+
+        let metrics = PerformanceMetrics::new(Duration::from_secs(5));
+        let result = evaluator.evaluate(&metrics);
+        assert!(result.passed);
+    }
+
+    #[test]
+    fn test_performance_evaluator_slow() {
+        let evaluator = PerformanceEvaluator::new()
+            .max_duration(Duration::from_secs(10))
+            .threshold(0.9)
+            .build();
+
+        let metrics = PerformanceMetrics::new(Duration::from_secs(20));
+        let result = evaluator.evaluate(&metrics);
+        assert!(!result.passed);
+    }
+
+    #[test]
+    fn test_reliability_evaluator() {
+        let evaluator = ReliabilityEvaluator::new()
+            .expect_tool("search")
+            .expect_tool("calculate")
+            .threshold(0.5)
+            .build();
+
+        let called = vec!["search".to_string()];
+        let result = evaluator.evaluate(&called);
+        assert!((result.score.value - 0.5).abs() < 0.001);
+    }
+
+    #[test]
+    fn test_criteria_evaluator() {
+        let evaluator = CriteriaEvaluator::new()
+            .criterion("accuracy")
+            .criterion("clarity")
+            .threshold(0.6)
+            .build();
+
+        let mut scores = HashMap::new();
+        scores.insert("accuracy".to_string(), 0.8);
+        scores.insert("clarity".to_string(), 0.7);
+
+        let result = evaluator.evaluate(&scores);
+        assert!(result.passed);
+        assert!((result.score.value - 0.75).abs() < 0.001);
+    }
+
+    #[test]
+    fn test_judge() {
+        let judge = Judge::new("test-judge").with_threshold(0.5);
+        let result = judge.judge("input", "output", Some("expected"));
+        assert!(result.passed);
+    }
+
+    #[test]
+    fn test_tool_call_result() {
+        let result = ToolCallResult::new("search", true, true);
+        assert!(result.is_correct());
+
+        let result = ToolCallResult::new("search", true, false);
+        assert!(!result.is_correct());
+    }
+
+    #[test]
+    fn test_criteria_score() {
+        let score = CriteriaScore::new("accuracy", 0.8).with_weight(2.0);
+        assert!((score.weighted_score() - 1.6).abs() < 0.001);
+    }
+}
@@ -0,0 +1,725 @@
+//! Model Failover Module for PraisonAI Rust SDK
+//!
+//! Provides auth profile management and automatic failover between
+//! LLM providers when rate limits or errors occur.
+//!
+//! # Example
+//!
+//! ```rust,ignore
+//! use praisonai::{FailoverManager, AuthProfile, FailoverConfig};
+//!
+//! let mut manager = FailoverManager::new(FailoverConfig::default());
+//! manager.add_profile(AuthProfile::new("openai-primary", "openai", "sk-..."));
+//! manager.add_profile(AuthProfile::new("openai-backup", "openai", "sk-...").priority(1));
+//!
+//! // Get next available profile
+//! if let Some(profile) = manager.get_next_profile() {
+//!     println!("Using profile: {}", profile.name);
+//! }
+//! ```
+
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::time::{Duration, Instant};
+
+use crate::error::Result;
+
+/// Status of an LLM provider.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum ProviderStatus {
+    /// Provider is available for use
+    Available,
+    /// Provider is rate limited
+    RateLimited,
+    /// Provider encountered an error
+    Error,
+    /// Provider is disabled
+    Disabled,
+}
+
+impl Default for ProviderStatus {
+    fn default() -> Self {
+        Self::Available
+    }
+}
+
+impl std::fmt::Display for ProviderStatus {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Available => write!(f, "available"),
+            Self::RateLimited => write!(f, "rate_limited"),
+            Self::Error => write!(f, "error"),
+            Self::Disabled => write!(f, "disabled"),
+        }
+    }
+}
+
+/// Authentication profile for an LLM provider.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AuthProfile {
+    /// Profile name for identification
+    pub name: String,
+    /// Provider name (openai, anthropic, google, etc.)
+    pub provider: String,
+    /// API key for authentication
+    #[serde(skip_serializing)]
+    pub api_key: String,
+    /// Optional base URL override
+    pub base_url: Option<String>,
+    /// Default model for this profile
+    pub model: Option<String>,
+    /// Priority for failover (lower = higher priority)
+    pub priority: i32,
+    /// Requests per minute limit
+    pub rate_limit_rpm: Option<u32>,
+    /// Tokens per minute limit
+    pub rate_limit_tpm: Option<u32>,
+    /// Current status
+    pub status: ProviderStatus,
+    /// Last error message
+    pub last_error: Option<String>,
+    /// Last error timestamp
+    #[serde(skip)]
+    pub last_error_time: Option<Instant>,
+    /// Cooldown until timestamp
+    #[serde(skip)]
+    pub cooldown_until: Option<Instant>,
+    /// Additional provider-specific configuration
+    pub metadata: HashMap<String, String>,
+}
+
+impl AuthProfile {
+    /// Create a new auth profile.
+    pub fn new(name: impl Into<String>, provider: impl Into<String>, api_key: impl Into<String>) -> Self {
+        Self {
+            name: name.into(),
+            provider: provider.into(),
+            api_key: api_key.into(),
+            base_url: None,
+            model: None,
+            priority: 0,
+            rate_limit_rpm: None,
+            rate_limit_tpm: None,
+            status: ProviderStatus::Available,
+            last_error: None,
+            last_error_time: None,
+            cooldown_until: None,
+            metadata: HashMap::new(),
+        }
+    }
+
+    /// Set base URL
+    pub fn base_url(mut self, url: impl Into<String>) -> Self {
+        self.base_url = Some(url.into());
+        self
+    }
+
+    /// Set default model
+    pub fn model(mut self, model: impl Into<String>) -> Self {
+        self.model = Some(model.into());
+        self
+    }
+
+    /// Set priority (lower = higher priority)
+    pub fn priority(mut self, priority: i32) -> Self {
+        self.priority = priority;
+        self
+    }
+
+    /// Set rate limit (requests per minute)
+    pub fn rate_limit_rpm(mut self, rpm: u32) -> Self {
+        self.rate_limit_rpm = Some(rpm);
+        self
+    }
+
+    /// Set rate limit (tokens per minute)
+    pub fn rate_limit_tpm(mut self, tpm: u32) -> Self {
+        self.rate_limit_tpm = Some(tpm);
+        self
+    }
+
+    /// Add metadata
+    pub fn metadata(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
+        self.metadata.insert(key.into(), value.into());
+        self
+    }
+
+    /// Check if this profile is currently available.
+    pub fn is_available(&self) -> bool {
+        if self.status == ProviderStatus::Disabled {
+            return false;
+        }
+        if let Some(cooldown_until) = self.cooldown_until {
+            if Instant::now() < cooldown_until {
+                return false;
+            }
+        }
+        true
+    }
+
+    /// Mark this profile as rate limited.
+    pub fn mark_rate_limited(&mut self, cooldown: Duration) {
+        self.status = ProviderStatus::RateLimited;
+        self.cooldown_until = Some(Instant::now() + cooldown);
+        self.last_error = Some("Rate limited".to_string());
+        self.last_error_time = Some(Instant::now());
+    }
+
+    /// Mark this profile as having an error.
+    pub fn mark_error(&mut self, error: impl Into<String>, cooldown: Duration) {
+        self.status = ProviderStatus::Error;
+        self.cooldown_until = Some(Instant::now() + cooldown);
+        self.last_error = Some(error.into());
+        self.last_error_time = Some(Instant::now());
+    }
+
+    /// Reset this profile to available status.
+    pub fn reset(&mut self) {
+        self.status = ProviderStatus::Available;
+        self.cooldown_until = None;
+        self.last_error = None;
+        self.last_error_time = None;
+    }
+
+    /// Convert to dictionary (hides sensitive data).
+    pub fn to_dict(&self) -> HashMap<String, serde_json::Value> {
+        let mut map = HashMap::new();
+        map.insert("name".to_string(), serde_json::json!(self.name));
+        map.insert("provider".to_string(), serde_json::json!(self.provider));
+        
+        // Mask API key
+        let masked_key = if self.api_key.len() > 4 {
+            format!("***{}", &self.api_key[self.api_key.len()-4..])
+        } else {
+            "****".to_string()
+        };
+        map.insert("api_key".to_string(), serde_json::json!(masked_key));
+        
+        map.insert("base_url".to_string(), serde_json::json!(self.base_url));
+        map.insert("model".to_string(), serde_json::json!(self.model));
+        map.insert("priority".to_string(), serde_json::json!(self.priority));
+        map.insert("rate_limit_rpm".to_string(), serde_json::json!(self.rate_limit_rpm));
+        map.insert("rate_limit_tpm".to_string(), serde_json::json!(self.rate_limit_tpm));
+        map.insert("status".to_string(), serde_json::json!(self.status.to_string()));
+        map.insert("last_error".to_string(), serde_json::json!(self.last_error));
+        map
+    }
+}
+
+/// Configuration for failover behavior.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FailoverConfig {
+    /// Maximum retry attempts per request
+    pub max_retries: u32,
+    /// Base delay between retries (seconds)
+    pub retry_delay: f64,
+    /// Whether to use exponential backoff
+    pub exponential_backoff: bool,
+    /// Maximum retry delay (seconds)
+    pub max_retry_delay: f64,
+    /// Cooldown duration for rate limits (seconds)
+    pub cooldown_on_rate_limit: f64,
+    /// Cooldown duration for errors (seconds)
+    pub cooldown_on_error: f64,
+    /// Whether to rotate profiles on success
+    pub rotate_on_success: bool,
+}
+
+impl Default for FailoverConfig {
+    fn default() -> Self {
+        Self {
+            max_retries: 3,
+            retry_delay: 1.0,
+            exponential_backoff: true,
+            max_retry_delay: 60.0,
+            cooldown_on_rate_limit: 60.0,
+            cooldown_on_error: 30.0,
+            rotate_on_success: false,
+        }
+    }
+}
+
+impl FailoverConfig {
+    /// Create a new config with defaults
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Set max retries
+    pub fn max_retries(mut self, retries: u32) -> Self {
+        self.max_retries = retries;
+        self
+    }
+
+    /// Set retry delay
+    pub fn retry_delay(mut self, delay: f64) -> Self {
+        self.retry_delay = delay;
+        self
+    }
+
+    /// Set exponential backoff
+    pub fn exponential_backoff(mut self, enabled: bool) -> Self {
+        self.exponential_backoff = enabled;
+        self
+    }
+
+    /// Set max retry delay
+    pub fn max_retry_delay(mut self, delay: f64) -> Self {
+        self.max_retry_delay = delay;
+        self
+    }
+
+    /// Set cooldown on rate limit
+    pub fn cooldown_on_rate_limit(mut self, seconds: f64) -> Self {
+        self.cooldown_on_rate_limit = seconds;
+        self
+    }
+
+    /// Set cooldown on error
+    pub fn cooldown_on_error(mut self, seconds: f64) -> Self {
+        self.cooldown_on_error = seconds;
+        self
+    }
+}
+
+/// Callback type for failover events.
+pub type FailoverCallback = Box<dyn Fn(&AuthProfile, &AuthProfile) + Send + Sync>;
+
+/// Manages failover between multiple LLM auth profiles.
+///
+/// Provides automatic failover when rate limits or errors occur,
+/// with configurable retry behavior and cooldown periods.
+pub struct FailoverManager {
+    /// Failover configuration
+    pub config: FailoverConfig,
+    /// Registered profiles
+    profiles: Vec<AuthProfile>,
+    /// Current profile index
+    current_index: usize,
+    /// Failover callbacks
+    callbacks: Vec<FailoverCallback>,
+}
+
+impl FailoverManager {
+    /// Create a new failover manager.
+    pub fn new(config: FailoverConfig) -> Self {
+        Self {
+            config,
+            profiles: Vec::new(),
+            current_index: 0,
+            callbacks: Vec::new(),
+        }
+    }
+
+    /// Create with default config.
+    pub fn default_config() -> Self {
+        Self::new(FailoverConfig::default())
+    }
+
+    /// Add an auth profile.
+    pub fn add_profile(&mut self, profile: AuthProfile) {
+        self.profiles.push(profile);
+        self.profiles.sort_by_key(|p| p.priority);
+    }
+
+    /// Remove a profile by name.
+    pub fn remove_profile(&mut self, name: &str) -> bool {
+        if let Some(pos) = self.profiles.iter().position(|p| p.name == name) {
+            self.profiles.remove(pos);
+            true
+        } else {
+            false
+        }
+    }
+
+    /// Get a profile by name.
+    pub fn get_profile(&self, name: &str) -> Option<&AuthProfile> {
+        self.profiles.iter().find(|p| p.name == name)
+    }
+
+    /// Get a mutable profile by name.
+    pub fn get_profile_mut(&mut self, name: &str) -> Option<&mut AuthProfile> {
+        self.profiles.iter_mut().find(|p| p.name == name)
+    }
+
+    /// List all profiles.
+    pub fn list_profiles(&self) -> &[AuthProfile] {
+        &self.profiles
+    }
+
+    /// Get the next available profile.
+    ///
+    /// Returns profiles in priority order, skipping those that are
+    /// rate limited or in cooldown.
+    pub fn get_next_profile(&mut self) -> Option<&AuthProfile> {
+        if self.profiles.is_empty() {
+            return None;
+        }
+
+        // First, check if any cooldowns have expired
+        let now = Instant::now();
+        for profile in &mut self.profiles {
+            if let Some(cooldown_until) = profile.cooldown_until {
+                if now >= cooldown_until {
+                    profile.reset();
+                }
+            }
+        }
+
+        // Find first available profile
+        for profile in &self.profiles {
+            if profile.is_available() {
+                return Some(profile);
+            }
+        }
+
+        // If none available, return the one with shortest remaining cooldown
+        self.profiles
+            .iter()
+            .filter(|p| p.status != ProviderStatus::Disabled)
+            .min_by_key(|p| {
+                p.cooldown_until
+                    .map(|t| t.duration_since(now))
+                    .unwrap_or(Duration::ZERO)
+            })
+    }
+
+    /// Mark a profile as failed.
+    pub fn mark_failure(&mut self, profile_name: &str, error: &str, is_rate_limit: bool) {
+        let cooldown = if is_rate_limit {
+            Duration::from_secs_f64(self.config.cooldown_on_rate_limit)
+        } else {
+            Duration::from_secs_f64(self.config.cooldown_on_error)
+        };
+
+        if let Some(profile) = self.get_profile_mut(profile_name) {
+            if is_rate_limit {
+                profile.mark_rate_limited(cooldown);
+            } else {
+                profile.mark_error(error, cooldown);
+            }
+        }
+
+        // Notify callbacks
+        let failed_profile = self.get_profile(profile_name).cloned();
+        if let (Some(failed), Some(next)) = (failed_profile, self.get_next_profile().cloned()) {
+            if failed.name != next.name {
+                for callback in &self.callbacks {
+                    callback(&failed, &next);
+                }
+            }
+        }
+    }
+
+    /// Mark a profile as successful.
+    pub fn mark_success(&mut self, profile_name: &str) {
+        if let Some(profile) = self.get_profile_mut(profile_name) {
+            if profile.status != ProviderStatus::Available {
+                profile.reset();
+            }
+        }
+    }
+
+    /// Register a callback for failover events.
+    pub fn on_failover(&mut self, callback: FailoverCallback) {
+        self.callbacks.push(callback);
+    }
+
+    /// Calculate retry delay for an attempt.
+    pub fn get_retry_delay(&self, attempt: u32) -> Duration {
+        let delay = if self.config.exponential_backoff {
+            self.config.retry_delay * 2.0_f64.powi(attempt as i32)
+        } else {
+            self.config.retry_delay
+        };
+
+        Duration::from_secs_f64(delay.min(self.config.max_retry_delay))
+    }
+
+    /// Get failover manager status.
+    pub fn status(&self) -> FailoverStatus {
+        let available = self.profiles.iter().filter(|p| p.is_available()).count();
+        FailoverStatus {
+            total_profiles: self.profiles.len(),
+            available_profiles: available,
+            profiles: self.profiles.iter().map(|p| p.to_dict()).collect(),
+            config: self.config.clone(),
+        }
+    }
+
+    /// Reset all profiles to available status.
+    pub fn reset_all(&mut self) {
+        for profile in &mut self.profiles {
+            profile.reset();
+        }
+    }
+
+    /// Get the number of profiles.
+    pub fn len(&self) -> usize {
+        self.profiles.len()
+    }
+
+    /// Check if empty.
+    pub fn is_empty(&self) -> bool {
+        self.profiles.is_empty()
+    }
+}
+
+impl Default for FailoverManager {
+    fn default() -> Self {
+        Self::default_config()
+    }
+}
+
+/// Status information for the failover manager.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FailoverStatus {
+    /// Total number of profiles
+    pub total_profiles: usize,
+    /// Number of available profiles
+    pub available_profiles: usize,
+    /// Profile information
+    pub profiles: Vec<HashMap<String, serde_json::Value>>,
+    /// Configuration
+    pub config: FailoverConfig,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_provider_status() {
+        assert_eq!(ProviderStatus::default(), ProviderStatus::Available);
+        assert_eq!(ProviderStatus::Available.to_string(), "available");
+        assert_eq!(ProviderStatus::RateLimited.to_string(), "rate_limited");
+    }
+
+    #[test]
+    fn test_auth_profile_new() {
+        let profile = AuthProfile::new("test", "openai", "sk-test123");
+        assert_eq!(profile.name, "test");
+        assert_eq!(profile.provider, "openai");
+        assert_eq!(profile.api_key, "sk-test123");
+        assert_eq!(profile.priority, 0);
+        assert!(profile.is_available());
+    }
+
+    #[test]
+    fn test_auth_profile_builder() {
+        let profile = AuthProfile::new("test", "openai", "sk-test")
+            .base_url("https://api.example.com")
+            .model("gpt-4")
+            .priority(1)
+            .rate_limit_rpm(100);
+
+        assert_eq!(profile.base_url, Some("https://api.example.com".to_string()));
+        assert_eq!(profile.model, Some("gpt-4".to_string()));
+        assert_eq!(profile.priority, 1);
+        assert_eq!(profile.rate_limit_rpm, Some(100));
+    }
+
+    #[test]
+    fn test_auth_profile_rate_limited() {
+        let mut profile = AuthProfile::new("test", "openai", "sk-test");
+        profile.mark_rate_limited(Duration::from_secs(60));
+
+        assert_eq!(profile.status, ProviderStatus::RateLimited);
+        assert!(!profile.is_available());
+        assert!(profile.last_error.is_some());
+    }
+
+    #[test]
+    fn test_auth_profile_error() {
+        let mut profile = AuthProfile::new("test", "openai", "sk-test");
+        profile.mark_error("Connection failed", Duration::from_secs(30));
+
+        assert_eq!(profile.status, ProviderStatus::Error);
+        assert!(!profile.is_available());
+        assert_eq!(profile.last_error, Some("Connection failed".to_string()));
+    }
+
+    #[test]
+    fn test_auth_profile_reset() {
+        let mut profile = AuthProfile::new("test", "openai", "sk-test");
+        profile.mark_error("Error", Duration::from_secs(30));
+        profile.reset();
+
+        assert_eq!(profile.status, ProviderStatus::Available);
+        assert!(profile.is_available());
+        assert!(profile.last_error.is_none());
+    }
+
+    #[test]
+    fn test_auth_profile_to_dict() {
+        let profile = AuthProfile::new("test", "openai", "sk-test123");
+        let dict = profile.to_dict();
+
+        assert_eq!(dict.get("name").unwrap(), "test");
+        assert_eq!(dict.get("provider").unwrap(), "openai");
+        // API key should be masked
+        let api_key = dict.get("api_key").unwrap().as_str().unwrap();
+        assert!(api_key.starts_with("***"));
+    }
+
+    #[test]
+    fn test_failover_config_default() {
+        let config = FailoverConfig::default();
+        assert_eq!(config.max_retries, 3);
+        assert_eq!(config.retry_delay, 1.0);
+        assert!(config.exponential_backoff);
+    }
+
+    #[test]
+    fn test_failover_config_builder() {
+        let config = FailoverConfig::new()
+            .max_retries(5)
+            .retry_delay(2.0)
+            .exponential_backoff(false);
+
+        assert_eq!(config.max_retries, 5);
+        assert_eq!(config.retry_delay, 2.0);
+        assert!(!config.exponential_backoff);
+    }
+
+    #[test]
+    fn test_failover_manager_new() {
+        let manager = FailoverManager::default();
+        assert!(manager.is_empty());
+        assert_eq!(manager.len(), 0);
+    }
+
+    #[test]
+    fn test_failover_manager_add_profile() {
+        let mut manager = FailoverManager::default();
+        manager.add_profile(AuthProfile::new("primary", "openai", "sk-1").priority(0));
+        manager.add_profile(AuthProfile::new("backup", "openai", "sk-2").priority(1));
+
+        assert_eq!(manager.len(), 2);
+        assert!(!manager.is_empty());
+    }
+
+    #[test]
+    fn test_failover_manager_get_profile() {
+        let mut manager = FailoverManager::default();
+        manager.add_profile(AuthProfile::new("test", "openai", "sk-test"));
+
+        let profile = manager.get_profile("test");
+        assert!(profile.is_some());
+        assert_eq!(profile.unwrap().name, "test");
+
+        let missing = manager.get_profile("missing");
+        assert!(missing.is_none());
+    }
+
+    #[test]
+    fn test_failover_manager_remove_profile() {
+        let mut manager = FailoverManager::default();
+        manager.add_profile(AuthProfile::new("test", "openai", "sk-test"));
+
+        assert!(manager.remove_profile("test"));
+        assert!(!manager.remove_profile("test"));
+        assert!(manager.is_empty());
+    }
+
+    #[test]
+    fn test_failover_manager_get_next_profile() {
+        let mut manager = FailoverManager::default();
+        manager.add_profile(AuthProfile::new("primary", "openai", "sk-1").priority(0));
+        manager.add_profile(AuthProfile::new("backup", "openai", "sk-2").priority(1));
+
+        let profile = manager.get_next_profile();
+        assert!(profile.is_some());
+        assert_eq!(profile.unwrap().name, "primary");
+    }
+
+    #[test]
+    fn test_failover_manager_priority_order() {
+        let mut manager = FailoverManager::default();
+        // Add in reverse priority order
+        manager.add_profile(AuthProfile::new("backup", "openai", "sk-2").priority(1));
+        manager.add_profile(AuthProfile::new("primary", "openai", "sk-1").priority(0));
+
+        // Should still get primary first due to sorting
+        let profile = manager.get_next_profile();
+        assert_eq!(profile.unwrap().name, "primary");
+    }
+
+    #[test]
+    fn test_failover_manager_mark_failure() {
+        let mut manager = FailoverManager::default();
+        manager.add_profile(AuthProfile::new("primary", "openai", "sk-1").priority(0));
+        manager.add_profile(AuthProfile::new("backup", "openai", "sk-2").priority(1));
+
+        manager.mark_failure("primary", "Rate limit", true);
+
+        // Should now get backup
+        let profile = manager.get_next_profile();
+        assert_eq!(profile.unwrap().name, "backup");
+    }
+
+    #[test]
+    fn test_failover_manager_mark_success() {
+        let mut manager = FailoverManager::default();
+        manager.add_profile(AuthProfile::new("test", "openai", "sk-test"));
+        manager.mark_failure("test", "Error", false);
+        manager.mark_success("test");
+
+        let profile = manager.get_profile("test").unwrap();
+        assert_eq!(profile.status, ProviderStatus::Available);
+    }
+
+    #[test]
+    fn test_failover_manager_retry_delay() {
+        let manager = FailoverManager::new(
+            FailoverConfig::new()
+                .retry_delay(1.0)
+                .exponential_backoff(true)
+                .max_retry_delay(10.0)
+        );
+
+        assert_eq!(manager.get_retry_delay(0), Duration::from_secs(1));
+        assert_eq!(manager.get_retry_delay(1), Duration::from_secs(2));
+        assert_eq!(manager.get_retry_delay(2), Duration::from_secs(4));
+        assert_eq!(manager.get_retry_delay(10), Duration::from_secs(10)); // Capped
+    }
+
+    #[test]
+    fn test_failover_manager_retry_delay_no_backoff() {
+        let manager = FailoverManager::new(
+            FailoverConfig::new()
+                .retry_delay(2.0)
+                .exponential_backoff(false)
+        );
+
+        assert_eq!(manager.get_retry_delay(0), Duration::from_secs(2));
+        assert_eq!(manager.get_retry_delay(1), Duration::from_secs(2));
+        assert_eq!(manager.get_retry_delay(5), Duration::from_secs(2));
+    }
+
+    #[test]
+    fn test_failover_manager_status() {
+        let mut manager = FailoverManager::default();
+        manager.add_profile(AuthProfile::new("primary", "openai", "sk-1"));
+        manager.add_profile(AuthProfile::new("backup", "openai", "sk-2"));
+
+        let status = manager.status();
+        assert_eq!(status.total_profiles, 2);
+        assert_eq!(status.available_profiles, 2);
+    }
+
+    #[test]
+    fn test_failover_manager_reset_all() {
+        let mut manager = FailoverManager::default();
+        manager.add_profile(AuthProfile::new("primary", "openai", "sk-1"));
+        manager.add_profile(AuthProfile::new("backup", "openai", "sk-2"));
+
+        manager.mark_failure("primary", "Error", false);
+        manager.mark_failure("backup", "Error", false);
+
+        manager.reset_all();
+
+        let status = manager.status();
+        assert_eq!(status.available_profiles, 2);
+    }
+}
Author	SHA1	Message	Date
Mervin Praison	841c51df84	Release v4.5.5	2026-02-15 01:04:07 +00:00
Mervin Praison	6709ae17e9	Release v4.5.3	2026-02-14 14:24:05 +00:00
Mervin Praison	8ddbb4ee71	Release v4.5.2	2026-02-14 00:06:53 +00:00
Mervin Praison	371ec987ac	Release v4.5.1	2026-02-13 15:00:40 +00:00
github-actions[bot]	0885a9b65d	docs: auto-update api.md [skip ci]	2026-02-13 14:11:15 +00:00
Mervin Praison	fe8f52c1b4	Release v4.5.0	2026-02-13 14:10:58 +00:00
github-actions[bot]	951dfd36c8	docs: auto-update api.md [skip ci]	2026-02-13 07:59:22 +00:00
Mervin Praison	7d0657632f	Release v4.4.12	2026-02-13 07:59:05 +00:00
Mervin Praison	ab80807b34	Release v4.4.11	2026-02-12 14:26:25 +00:00
Mervin Praison	38888c745e	Release v4.4.10	2026-02-12 12:44:16 +00:00
github-actions[bot]	d905a25833	docs: auto-update api.md [skip ci]	2026-02-12 11:33:34 +00:00
Mervin Praison	ec0b435ab3	Release v4.4.9	2026-02-12 11:33:17 +00:00
github-actions[bot]	4833b86863	docs: auto-update api.md [skip ci]	2026-02-12 08:03:44 +00:00
Mervin Praison	42af95d9ab	Release v4.4.8	2026-02-12 08:03:28 +00:00
github-actions[bot]	0ec7cec870	docs: auto-update api.md [skip ci]	2026-02-12 07:41:46 +00:00
Mervin Praison	458af24852	Release v4.4.7	2026-02-12 07:41:29 +00:00
github-actions[bot]	cd8c8acd69	docs: auto-update api.md [skip ci]	2026-02-12 06:26:12 +00:00
Mervin Praison	90b00f9a25	Release v4.4.6	2026-02-12 06:25:59 +00:00
github-actions[bot]	cf558bc741	docs: auto-update api.md [skip ci]	2026-02-12 05:46:19 +00:00
Mervin Praison	9a3363c900	Release v4.4.5	2026-02-12 05:46:02 +00:00
Mervin Praison	8affc9ec53	feat: Implement comprehensive documentation parity tracking by categorizing features, identifying doc stubs, and automating report generation for Python, Rust, and TypeScript SDKs.	2026-02-05 16:59:00 +00:00
Mervin Praison	2e135e6b6e	upgrade rust and ts	2026-02-05 10:52:43 +00:00
github-actions[bot]	1bdd7cf16a	docs: auto-update api.md [skip ci]	2026-02-05 10:42:58 +00:00