@poolzin/pool-bot 2026.3.7 → 2026.3.10

package/dist/context-engine/legacy.js

@@ -0,0 +1,179 @@
+/**
+ * Legacy Context Engine
+ *
+ * Maintains PoolBot's original context management behavior.
+ * This is the default engine that preserves backward compatibility.
+ *
+ * Strategy:
+ * - Simple message accumulation
+ * - Truncation-based overflow handling
+ * - Basic compaction via summarization
+ */
+export class LegacyContextEngine {
+    info = {
+        id: "legacy",
+        name: "Legacy Context Engine",
+        description: "PoolBot's original context management with simple accumulation and truncation",
+        supportsVectorSearch: false,
+        supportsFullTextSearch: false,
+        tokenLimit: undefined, // No explicit limit
+    };
+    sessions = new Map();
+    async bootstrap(params) {
+        try {
+            // Initialize session storage
+            this.sessions.set(params.sessionId, {
+                messages: [],
+                lastAccessed: new Date(),
+            });
+            return {
+                success: true,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async ingest(params) {
+        try {
+            const session = this.sessions.get(params.sessionId);
+            if (!session) {
+                return {
+                    success: false,
+                    error: `Session ${params.sessionId} not found`,
+                };
+            }
+            session.messages.push(params.message);
+            session.lastAccessed = new Date();
+            // Estimate tokens (rough approximation)
+            const content = typeof params.message.content === "string"
+                ? params.message.content
+                : JSON.stringify(params.message.content);
+            const estimatedTokens = Math.ceil(content.length / 4);
+            return {
+                success: true,
+                tokensConsumed: estimatedTokens,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async assemble(params) {
+        const session = this.sessions.get(params.sessionId);
+        const messages = session?.messages ?? params.messages;
+        // Apply token budget if specified
+        let resultMessages = messages;
+        let wasTruncated = false;
+        let excludedMessages = [];
+        if (params.tokenBudget && params.tokenBudget > 0) {
+            const estimate = this.estimateTokenCount(messages);
+            if (estimate > params.tokenBudget) {
+                // Simple truncation: keep newest messages that fit
+                const reversed = [...messages].reverse();
+                const fitting = [];
+                let currentTokens = 0;
+                for (const msg of reversed) {
+                    const msgTokens = this.estimateTokenCount([msg]);
+                    if (currentTokens + msgTokens <= params.tokenBudget) {
+                        fitting.unshift(msg);
+                        currentTokens += msgTokens;
+                    }
+                    else {
+                        excludedMessages.unshift(msg);
+                    }
+                }
+                resultMessages = fitting;
+                wasTruncated = true;
+            }
+        }
+        return {
+            messages: resultMessages,
+            totalTokens: this.estimateTokenCount(resultMessages),
+            wasTruncated,
+            excludedMessages: wasTruncated ? excludedMessages : undefined,
+        };
+    }
+    async compact(params) {
+        try {
+            const session = this.sessions.get(params.sessionId);
+            if (!session || session.messages.length === 0) {
+                return {
+                    success: true,
+                    tokensSaved: 0,
+                };
+            }
+            const originalTokens = this.estimateTokenCount(session.messages);
+            // Legacy compaction: summarize older messages
+            // Keep recent messages, summarize older ones
+            const keepRecent = 4; // Keep last 2 exchanges
+            const toSummarize = session.messages.slice(0, -keepRecent);
+            const toKeep = session.messages.slice(-keepRecent);
+            if (toSummarize.length === 0) {
+                return {
+                    success: true,
+                    tokensSaved: 0,
+                };
+            }
+            // Create summary message
+            const summary = {
+                role: "system",
+                content: `[${toSummarize.length} earlier messages summarized]`,
+                metadata: { compacted: true, originalCount: toSummarize.length },
+            };
+            session.messages = [summary, ...toKeep];
+            const newTokens = this.estimateTokenCount(session.messages);
+            return {
+                success: true,
+                summary: summary.content,
+                tokensSaved: originalTokens - newTokens,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async cleanup(params) {
+        this.sessions.delete(params.sessionId);
+    }
+    async getStats(params) {
+        const session = this.sessions.get(params.sessionId);
+        if (!session) {
+            return {
+                messageCount: 0,
+            };
+        }
+        return {
+            messageCount: session.messages.length,
+            totalTokens: this.estimateTokenCount(session.messages),
+            lastAccessed: session.lastAccessed,
+        };
+    }
+    /**
+     * Estimate token count for messages
+     * Rough approximation: ~4 characters per token
+     */
+    estimateTokenCount(messages) {
+        let totalChars = 0;
+        for (const msg of messages) {
+            const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+            totalChars += content.length;
+        }
+        return Math.ceil(totalChars / 4);
+    }
+}
+/**
+ * Create the default legacy context engine
+ */
+export function createLegacyContextEngine() {
+    return new LegacyContextEngine();
+}

package/dist/context-engine/registry.js

@@ -0,0 +1,86 @@
+/**
+ * Context Engine Registry
+ *
+ * Manages available context engines and provides
+ * factory methods for creating engine instances.
+ */
+export class ContextEngineRegistry {
+    engines = new Map();
+    instances = new Map();
+    /**
+     * Register a new context engine
+     */
+    register(id, EngineClass) {
+        this.engines.set(id, EngineClass);
+    }
+    /**
+     * Check if an engine is registered
+     */
+    has(id) {
+        return this.engines.has(id);
+    }
+    /**
+     * Get available engine IDs
+     */
+    getAvailableEngines() {
+        return Array.from(this.engines.keys());
+    }
+    /**
+     * Create or get a cached engine instance
+     */
+    getEngine(id) {
+        // Return cached instance if exists
+        const cached = this.instances.get(id);
+        if (cached) {
+            return cached;
+        }
+        // Create new instance
+        const EngineClass = this.engines.get(id);
+        if (!EngineClass) {
+            throw new Error(`Context engine "${id}" not registered. Available: ${this.getAvailableEngines().join(", ")}`);
+        }
+        const instance = new EngineClass();
+        this.instances.set(id, instance);
+        return instance;
+    }
+    /**
+     * Remove cached instance (for cleanup/testing)
+     */
+    clearCache(id) {
+        if (id) {
+            this.instances.delete(id);
+        }
+        else {
+            this.instances.clear();
+        }
+    }
+    /**
+     * Get engine info for all registered engines
+     */
+    getEngineInfos() {
+        return this.getAvailableEngines().map((id) => {
+            const engine = this.getEngine(id);
+            return {
+                id,
+                name: engine.info.name,
+                description: engine.info.description,
+            };
+        });
+    }
+}
+/**
+ * Global registry instance
+ */
+export const globalContextEngineRegistry = new ContextEngineRegistry();
+/**
+ * Resolve which engine to use based on configuration
+ */
+export function resolveContextEngine(sessionId, config, registry = globalContextEngineRegistry) {
+    // Check for session-specific override
+    const engineId = config.sessionEngines?.[sessionId] ?? config.defaultEngine;
+    if (!registry.has(engineId)) {
+        throw new Error(`Context engine "${engineId}" not found for session ${sessionId}. ` +
+            `Available engines: ${registry.getAvailableEngines().join(", ")}`);
+    }
+    return registry.getEngine(engineId);
+}

package/dist/context-engine/summarizing.js

@@ -0,0 +1,290 @@
+/**
+ * Summarizing Context Engine
+ *
+ * Advanced context management with intelligent summarization.
+ * Provides better token efficiency than the legacy engine.
+ *
+ * Features:
+ * - Sliding window with summarization
+ * - Token-aware message prioritization
+ * - Configurable summarization strategy
+ */
+/**
+ * Token estimator using character-based approximation
+ * More accurate than simple division
+ */
+function estimateTokens(text) {
+    // GPT-style tokenization approximation
+    // - Average English word: ~1.3 tokens
+    // - Whitespace and punctuation: ~0.5 tokens each
+    // - Code/non-English: ~2-3 tokens per word
+    const words = text.trim().split(/\s+/).length;
+    const chars = text.length;
+    const punctuation = (text.match(/[.,!?;:()[\]{}"']/g) ?? []).length;
+    // Heuristic: code detection (high special char ratio)
+    const specialChars = (text.match(/[^\w\s]/g) ?? []).length;
+    const isCode = specialChars / chars > 0.15;
+    if (isCode) {
+        return Math.ceil(chars / 2.5); // Code: ~2.5 chars/token
+    }
+    // Regular text estimation
+    const wordTokens = words * 1.3;
+    const punctTokens = punctuation * 0.5;
+    const overhead = Math.ceil(chars / 100); // Metadata overhead
+    return Math.ceil(wordTokens + punctTokens + overhead);
+}
+/**
+ * Summarizing Context Engine
+ *
+ * Implements sliding window with intelligent summarization:
+ * 1. Keep system messages (highest priority)
+ * 2. Keep recent conversation (high priority)
+ * 3. Summarize older messages into running summary
+ */
+export class SummarizingContextEngine {
+    info = {
+        id: "summarizing",
+        name: "Summarizing Context Engine",
+        description: "Sliding window with intelligent message summarization",
+        supportsVectorSearch: false,
+        supportsFullTextSearch: false,
+        tokenLimit: undefined,
+    };
+    config;
+    sessions = new Map();
+    constructor(config) {
+        this.config = {
+            maxTokens: config?.maxTokens ?? 8000,
+            keepRecentMessages: config?.keepRecentMessages ?? 6,
+            summarizationThreshold: config?.summarizationThreshold ?? 4000,
+        };
+    }
+    async bootstrap(params) {
+        try {
+            this.sessions.set(params.sessionId, {
+                messages: [],
+                summary: undefined,
+                summaryTokens: 0,
+                lastAccessed: new Date(),
+                totalIngested: 0,
+            });
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async ingest(params) {
+        try {
+            const session = this.sessions.get(params.sessionId);
+            if (!session) {
+                return {
+                    success: false,
+                    error: `Session ${params.sessionId} not found`,
+                };
+            }
+            const content = typeof params.message.content === "string"
+                ? params.message.content
+                : JSON.stringify(params.message.content);
+            const estimatedTokens = estimateTokens(content);
+            // Calculate priority
+            const priority = this.calculatePriority(params.message, session.messages.length);
+            const prioritized = {
+                ...params.message,
+                priority,
+                estimatedTokens,
+                internalTimestamp: Date.now(),
+            };
+            session.messages.push(prioritized);
+            session.totalIngested++;
+            session.lastAccessed = new Date();
+            // Check if we need to compact
+            const currentTokens = this.getTotalTokenCount(session);
+            if (currentTokens > this.config.summarizationThreshold) {
+                await this.compact({ sessionId: params.sessionId });
+            }
+            return {
+                success: true,
+                tokensConsumed: estimatedTokens,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async assemble(params) {
+        const session = this.sessions.get(params.sessionId);
+        if (!session) {
+            return {
+                messages: params.messages ?? [],
+                totalTokens: 0,
+                wasTruncated: false,
+            };
+        }
+        // Build context: summary + recent messages
+        const resultMessages = [];
+        let totalTokens = 0;
+        // Add summary if exists
+        if (session.summary) {
+            const summaryMsg = {
+                role: "system",
+                content: `[Previous conversation summary: ${session.summary}]`,
+                metadata: { isSummary: true },
+            };
+            resultMessages.push(summaryMsg);
+            totalTokens += session.summaryTokens;
+        }
+        // Add messages within budget
+        const budget = params.tokenBudget ?? this.config.maxTokens;
+        const sortedMessages = [...session.messages].sort((a, b) => b.priority - a.priority || a.internalTimestamp - b.internalTimestamp);
+        const included = [];
+        const excluded = [];
+        for (const msg of sortedMessages) {
+            if (totalTokens + msg.estimatedTokens <= budget) {
+                // Strip priority metadata before returning
+                const { priority: _, estimatedTokens: __, internalTimestamp: ___, ...cleanMsg } = msg;
+                included.push(cleanMsg);
+                totalTokens += msg.estimatedTokens;
+            }
+            else {
+                const { priority: _, estimatedTokens: __, internalTimestamp: ___, ...cleanMsg } = msg;
+                excluded.push(cleanMsg);
+            }
+        }
+        // Sort by internalTimestamp for final output
+        included.sort((a, b) => {
+            const ta = session.messages.find((m) => m.id === a.id)?.internalTimestamp ?? 0;
+            const tb = session.messages.find((m) => m.id === b.id)?.internalTimestamp ?? 0;
+            return ta - tb;
+        });
+        resultMessages.push(...included);
+        return {
+            messages: resultMessages,
+            totalTokens,
+            wasTruncated: excluded.length > 0,
+            excludedMessages: excluded.length > 0 ? excluded : undefined,
+        };
+    }
+    async compact(params) {
+        try {
+            const session = this.sessions.get(params.sessionId);
+            if (!session || session.messages.length <= this.config.keepRecentMessages) {
+                return { success: true, tokensSaved: 0 };
+            }
+            const originalTokens = this.getTotalTokenCount(session);
+            // Messages to summarize (older ones)
+            const toSummarize = session.messages.slice(0, -this.config.keepRecentMessages);
+            const toKeep = session.messages.slice(-this.config.keepRecentMessages);
+            if (toSummarize.length === 0) {
+                return { success: true, tokensSaved: 0 };
+            }
+            // Generate summary (simplified - in production, use LLM)
+            const summary = this.generateSummary(toSummarize);
+            const _summaryTokens = estimateTokens(summary);
+            // Update session
+            session.summary = session.summary ? `${session.summary} ${summary}` : summary;
+            session.summaryTokens = estimateTokens(session.summary);
+            session.messages = toKeep;
+            const newTokens = this.getTotalTokenCount(session);
+            const tokensSaved = originalTokens - newTokens;
+            return {
+                success: true,
+                summary: session.summary,
+                tokensSaved: Math.max(0, tokensSaved),
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async cleanup(params) {
+        this.sessions.delete(params.sessionId);
+    }
+    async getStats(params) {
+        const session = this.sessions.get(params.sessionId);
+        if (!session) {
+            return { messageCount: 0 };
+        }
+        return {
+            messageCount: session.messages.length,
+            totalTokens: this.getTotalTokenCount(session),
+            lastAccessed: session.lastAccessed,
+        };
+    }
+    /**
+     * Calculate message priority (0-100)
+     */
+    calculatePriority(message, index) {
+        let priority = 50; // Base priority
+        // System messages are highest priority
+        if (message.role === "system") {
+            priority += 40;
+        }
+        // Recent messages get boost
+        if (index > -5) {
+            priority += 20;
+        }
+        // Messages with tool calls/results are important
+        if (message.metadata?.tool_calls || message.metadata?.tool_call_id) {
+            priority += 15;
+        }
+        return Math.min(100, priority);
+    }
+    /**
+     * Get total token count for session
+     */
+    getTotalTokenCount(session) {
+        const messageTokens = session.messages.reduce((sum, m) => sum + m.estimatedTokens, 0);
+        return messageTokens + session.summaryTokens;
+    }
+    /**
+     * Generate a simple summary of messages
+     * In production, this would use an LLM
+     */
+    generateSummary(messages) {
+        const userMsgs = messages.filter((m) => m.role === "user");
+        const assistantMsgs = messages.filter((m) => m.role === "assistant");
+        const topics = this.extractTopics(messages);
+        return (`Conversation covered ${userMsgs.length} user queries and ${assistantMsgs.length} responses. ` +
+            `Topics: ${topics.join(", ") || "general discussion"}.`);
+    }
+    /**
+     * Extract key topics from messages (simplified)
+     */
+    extractTopics(messages) {
+        const allContent = messages
+            .map((m) => (typeof m.content === "string" ? m.content : JSON.stringify(m.content)))
+            .join(" ")
+            .toLowerCase();
+        // Simple keyword extraction
+        const keywords = [
+            "code",
+            "function",
+            "error",
+            "bug",
+            "fix",
+            "implement",
+            "create",
+            "update",
+            "delete",
+            "configure",
+            "setup",
+        ];
+        return keywords.filter((kw) => allContent.includes(kw)).slice(0, 3);
+    }
+}
+/**
+ * Create a summarizing context engine
+ */
+export function createSummarizingContextEngine(config) {
+    return new SummarizingContextEngine(config);
+}

package/dist/context-engine/types.js

@@ -0,0 +1,7 @@
+/**
+ * Context Engine - Pluggable conversation context management
+ *
+ * Provides a modular architecture for managing conversation context
+ * with support for different storage and retrieval strategies.
+ */
+export {};

package/dist/cron/service/timer.js

@@ -618,6 +618,24 @@ function emitJobFinished(state, job, result, runAtMs) {
         provider: result.provider,
         usage: result.usage,
     });
+    // Emit telemetry metrics
+    if (state.deps.onJobMetrics) {
+        const scheduleStr = job.schedule.kind === "cron"
+            ? job.schedule.expr
+            : job.schedule.kind === "every"
+                ? `every ${job.schedule.everyMs}ms`
+                : job.schedule.kind === "at"
+                    ? job.schedule.at
+                    : "unknown";
+        state.deps.onJobMetrics({
+            jobId: job.id,
+            jobName: job.name,
+            schedule: scheduleStr,
+            success: result.status === "ok",
+            durationMs: job.state.lastDurationMs ?? 0,
+            errorType: result.status === "error" ? (result.error ?? "unknown") : undefined,
+        });
+    }
 }
 export function wake(state, opts) {
     const text = opts.text.trim();

package/dist/gateway/protocol/index.js

@@ -1,5 +1,5 @@
 import AjvPkg from "ajv";
-import { AgentEventSchema, AgentIdentityParamsSchema, AgentIdentityResultSchema, AgentParamsSchema, AgentSummarySchema, AgentsFileEntrySchema, AgentsCreateParamsSchema, AgentsCreateResultSchema, AgentsUpdateParamsSchema, AgentsUpdateResultSchema, AgentsDeleteParamsSchema, AgentsDeleteResultSchema, AgentsFilesGetParamsSchema, AgentsFilesGetResultSchema, AgentsFilesListParamsSchema, AgentsFilesListResultSchema, AgentsFilesSetParamsSchema, AgentsFilesSetResultSchema, AgentsListParamsSchema, AgentsListResultSchema, AgentWaitParamsSchema, ChannelsLogoutParamsSchema, TalkConfigParamsSchema, TalkConfigResultSchema, ChannelsStatusParamsSchema, ChannelsStatusResultSchema, ChatAbortParamsSchema, ChatEventSchema, ChatHistoryParamsSchema, ChatInjectParamsSchema, ChatSendParamsSchema, ConfigApplyParamsSchema, ConfigGetParamsSchema, ConfigPatchParamsSchema, ConfigSchemaParamsSchema, ConfigSchemaResponseSchema, ConfigSetParamsSchema, ConnectParamsSchema, CronAddParamsSchema, CronJobSchema, CronListParamsSchema, CronRemoveParamsSchema, CronRunParamsSchema, CronRunsParamsSchema, CronStatusParamsSchema, CronUpdateParamsSchema, DevicePairApproveParamsSchema, DevicePairListParamsSchema, DevicePairRemoveParamsSchema, DevicePairRejectParamsSchema, DeviceTokenRevokeParamsSchema, DeviceTokenRotateParamsSchema, ExecApprovalsGetParamsSchema, ExecApprovalsNodeGetParamsSchema, ExecApprovalsNodeSetParamsSchema, ExecApprovalsSetParamsSchema, ExecApprovalRequestParamsSchema, ExecApprovalResolveParamsSchema, ErrorCodes, ErrorShapeSchema, EventFrameSchema, errorShape, GatewayFrameSchema, HelloOkSchema, LogsTailParamsSchema, LogsTailResultSchema, ModelsListParamsSchema, NodeDescribeParamsSchema, NodeEventParamsSchema, NodeInvokeParamsSchema, NodeInvokeResultParamsSchema, NodeListParamsSchema, NodePairApproveParamsSchema, NodePairListParamsSchema, NodePairRejectParamsSchema, NodePairRequestParamsSchema, NodePairVerifyParamsSchema, NodeRenameParamsSchema, PollParamsSchema, PROTOCOL_VERSION, PushTestParamsSchema, PushTestResultSchema, PresenceEntrySchema, ProtocolSchemas, RequestFrameSchema, ResponseFrameSchema, SendParamsSchema, SessionsCompactParamsSchema, SessionsDeleteParamsSchema, SessionsListParamsSchema, SessionsPatchParamsSchema, SessionsPreviewParamsSchema, SessionsResetParamsSchema, SessionsResolveParamsSchema, SessionsUsageParamsSchema, ShutdownEventSchema, SkillsBinsParamsSchema, SkillsInstallParamsSchema, SkillsStatusParamsSchema, SkillsUpdateParamsSchema, SnapshotSchema, StateVersionSchema, TalkModeParamsSchema, TickEventSchema, UpdateRunParamsSchema, WakeParamsSchema, WebLoginStartParamsSchema, WebLoginWaitParamsSchema, WizardCancelParamsSchema, WizardNextParamsSchema, WizardNextResultSchema, WizardStartParamsSchema, WizardStartResultSchema, WizardStatusParamsSchema, WizardStatusResultSchema, WizardStepSchema, } from "./schema.js";
+import { AgentEventSchema, AgentIdentityParamsSchema, AgentIdentityResultSchema, AgentParamsSchema, AgentSummarySchema, AgentsFileEntrySchema, AgentsCreateParamsSchema, AgentsCreateResultSchema, AgentsUpdateParamsSchema, AgentsUpdateResultSchema, AgentsDeleteParamsSchema, AgentsDeleteResultSchema, AgentsFilesGetParamsSchema, AgentsFilesGetResultSchema, AgentsFilesListParamsSchema, AgentsFilesListResultSchema, AgentsFilesSetParamsSchema, AgentsFilesSetResultSchema, AgentsListParamsSchema, AgentsListResultSchema, AgentWaitParamsSchema, ChannelsLogoutParamsSchema, TalkConfigParamsSchema, TalkConfigResultSchema, ChannelsStatusParamsSchema, ChannelsStatusResultSchema, ChatAbortParamsSchema, ChatEventSchema, ChatHistoryParamsSchema, ChatInjectParamsSchema, ChatSendParamsSchema, ConfigApplyParamsSchema, ConfigGetParamsSchema, ConfigPatchParamsSchema, ConfigSchemaParamsSchema, ConfigSchemaResponseSchema, ConfigSetParamsSchema, ConnectParamsSchema, CronAddParamsSchema, CronJobSchema, CronListParamsSchema, CronRemoveParamsSchema, CronRunParamsSchema, CronRunsParamsSchema, CronStatusParamsSchema, CronUpdateParamsSchema, DevicePairApproveParamsSchema, DevicePairListParamsSchema, DevicePairRemoveParamsSchema, DevicePairRejectParamsSchema, DeviceTokenRevokeParamsSchema, DeviceTokenRotateParamsSchema, ExecApprovalsGetParamsSchema, ExecApprovalsNodeGetParamsSchema, ExecApprovalsNodeSetParamsSchema, ExecApprovalsSetParamsSchema, ExecApprovalRequestParamsSchema, ExecApprovalResolveParamsSchema, ErrorCodes, ErrorShapeSchema, EventFrameSchema, errorShape, GatewayFrameSchema, HelloOkSchema, LogsTailParamsSchema, LogsTailResultSchema, ModelsListParamsSchema, NodeDescribeParamsSchema, NodeEventParamsSchema, NodeInvokeParamsSchema, NodeInvokeResultParamsSchema, NodeListParamsSchema, NodePairApproveParamsSchema, NodePairListParamsSchema, NodePairRejectParamsSchema, NodePairRequestParamsSchema, NodePairVerifyParamsSchema, NodeRenameParamsSchema, PollParamsSchema, PROTOCOL_VERSION, PushTestParamsSchema, PushTestResultSchema, PresenceEntrySchema, ProtocolSchemas, RequestFrameSchema, ResponseFrameSchema, SendParamsSchema, SessionsCompactParamsSchema, SessionsDeleteParamsSchema, SessionsListParamsSchema, SessionsPatchParamsSchema, SessionsPreviewParamsSchema, SessionsResetParamsSchema, SessionsResolveParamsSchema, SessionsUsageParamsSchema, ShutdownEventSchema, SkillsBinsParamsSchema, SkillsInstallParamsSchema, SkillsStatusParamsSchema, SkillsUpdateParamsSchema, SnapshotSchema, StateVersionSchema, TalkModeParamsSchema, TickEventSchema, UpdateRunParamsSchema, WakeParamsSchema, WebLoginStartParamsSchema, WebLoginWaitParamsSchema, WizardCancelParamsSchema, WizardNextParamsSchema, WizardNextResultSchema, WizardStartParamsSchema, WizardStartResultSchema, WizardStatusParamsSchema, WizardStatusResultSchema, WizardStepSchema, SwarmListParamsSchema, SwarmStatusParamsSchema, SwarmCreateParamsSchema, SwarmListResultSchema, SwarmStatusResultSchema, SwarmCreateResultSchema, SwarmStateSchema, SwarmMemberSchema, SwarmTaskSchema, SwarmStrategySchema, } from "./schema.js";
 const ajv = new AjvPkg({
     allErrors: true,
     strict: false,
@@ -88,6 +88,9 @@ export const validateChatEvent = ajv.compile(ChatEventSchema);
 export const validateUpdateRunParams = ajv.compile(UpdateRunParamsSchema);
 export const validateWebLoginStartParams = ajv.compile(WebLoginStartParamsSchema);
 export const validateWebLoginWaitParams = ajv.compile(WebLoginWaitParamsSchema);
+export const validateSwarmListParams = ajv.compile(SwarmListParamsSchema);
+export const validateSwarmStatusParams = ajv.compile(SwarmStatusParamsSchema);
+export const validateSwarmCreateParams = ajv.compile(SwarmCreateParamsSchema);
 export function formatValidationErrors(errors) {
     if (!errors?.length) {
         return "unknown validation error";
@@ -117,4 +120,4 @@ export function formatValidationErrors(errors) {
     }
     return unique.join("; ");
 }
-export { ConnectParamsSchema, HelloOkSchema, RequestFrameSchema, ResponseFrameSchema, EventFrameSchema, GatewayFrameSchema, PresenceEntrySchema, SnapshotSchema, ErrorShapeSchema, StateVersionSchema, AgentEventSchema, ChatEventSchema, SendParamsSchema, PollParamsSchema, AgentParamsSchema, AgentIdentityParamsSchema, AgentIdentityResultSchema, WakeParamsSchema, PushTestParamsSchema, PushTestResultSchema, NodePairRequestParamsSchema, NodePairListParamsSchema, NodePairApproveParamsSchema, NodePairRejectParamsSchema, NodePairVerifyParamsSchema, NodeListParamsSchema, NodeInvokeParamsSchema, SessionsListParamsSchema, SessionsPreviewParamsSchema, SessionsPatchParamsSchema, SessionsResetParamsSchema, SessionsDeleteParamsSchema, SessionsCompactParamsSchema, SessionsUsageParamsSchema, ConfigGetParamsSchema, ConfigSetParamsSchema, ConfigApplyParamsSchema, ConfigPatchParamsSchema, ConfigSchemaParamsSchema, ConfigSchemaResponseSchema, WizardStartParamsSchema, WizardNextParamsSchema, WizardCancelParamsSchema, WizardStatusParamsSchema, WizardStepSchema, WizardNextResultSchema, WizardStartResultSchema, WizardStatusResultSchema, TalkConfigParamsSchema, TalkConfigResultSchema, ChannelsStatusParamsSchema, ChannelsStatusResultSchema, ChannelsLogoutParamsSchema, WebLoginStartParamsSchema, WebLoginWaitParamsSchema, AgentSummarySchema, AgentsFileEntrySchema, AgentsCreateParamsSchema, AgentsCreateResultSchema, AgentsUpdateParamsSchema, AgentsUpdateResultSchema, AgentsDeleteParamsSchema, AgentsDeleteResultSchema, AgentsFilesListParamsSchema, AgentsFilesListResultSchema, AgentsFilesGetParamsSchema, AgentsFilesGetResultSchema, AgentsFilesSetParamsSchema, AgentsFilesSetResultSchema, AgentsListParamsSchema, AgentsListResultSchema, ModelsListParamsSchema, SkillsStatusParamsSchema, SkillsInstallParamsSchema, SkillsUpdateParamsSchema, CronJobSchema, CronListParamsSchema, CronStatusParamsSchema, CronAddParamsSchema, CronUpdateParamsSchema, CronRemoveParamsSchema, CronRunParamsSchema, CronRunsParamsSchema, LogsTailParamsSchema, LogsTailResultSchema, ChatHistoryParamsSchema, ChatSendParamsSchema, ChatInjectParamsSchema, UpdateRunParamsSchema, TickEventSchema, ShutdownEventSchema, ProtocolSchemas, PROTOCOL_VERSION, ErrorCodes, errorShape, };
+export { ConnectParamsSchema, HelloOkSchema, RequestFrameSchema, ResponseFrameSchema, EventFrameSchema, GatewayFrameSchema, PresenceEntrySchema, SnapshotSchema, ErrorShapeSchema, StateVersionSchema, AgentEventSchema, ChatEventSchema, SendParamsSchema, PollParamsSchema, AgentParamsSchema, AgentIdentityParamsSchema, AgentIdentityResultSchema, WakeParamsSchema, PushTestParamsSchema, PushTestResultSchema, NodePairRequestParamsSchema, NodePairListParamsSchema, NodePairApproveParamsSchema, NodePairRejectParamsSchema, NodePairVerifyParamsSchema, NodeListParamsSchema, NodeInvokeParamsSchema, SessionsListParamsSchema, SessionsPreviewParamsSchema, SessionsPatchParamsSchema, SessionsResetParamsSchema, SessionsDeleteParamsSchema, SessionsCompactParamsSchema, SessionsUsageParamsSchema, ConfigGetParamsSchema, ConfigSetParamsSchema, ConfigApplyParamsSchema, ConfigPatchParamsSchema, ConfigSchemaParamsSchema, ConfigSchemaResponseSchema, WizardStartParamsSchema, WizardNextParamsSchema, WizardCancelParamsSchema, WizardStatusParamsSchema, WizardStepSchema, WizardNextResultSchema, WizardStartResultSchema, WizardStatusResultSchema, TalkConfigParamsSchema, TalkConfigResultSchema, ChannelsStatusParamsSchema, ChannelsStatusResultSchema, ChannelsLogoutParamsSchema, WebLoginStartParamsSchema, WebLoginWaitParamsSchema, AgentSummarySchema, AgentsFileEntrySchema, AgentsCreateParamsSchema, AgentsCreateResultSchema, AgentsUpdateParamsSchema, AgentsUpdateResultSchema, AgentsDeleteParamsSchema, AgentsDeleteResultSchema, AgentsFilesListParamsSchema, AgentsFilesListResultSchema, AgentsFilesGetParamsSchema, AgentsFilesGetResultSchema, AgentsFilesSetParamsSchema, AgentsFilesSetResultSchema, AgentsListParamsSchema, AgentsListResultSchema, ModelsListParamsSchema, SkillsStatusParamsSchema, SkillsInstallParamsSchema, SkillsUpdateParamsSchema, CronJobSchema, CronListParamsSchema, CronStatusParamsSchema, CronAddParamsSchema, CronUpdateParamsSchema, CronRemoveParamsSchema, CronRunParamsSchema, CronRunsParamsSchema, LogsTailParamsSchema, LogsTailResultSchema, ChatHistoryParamsSchema, ChatSendParamsSchema, ChatInjectParamsSchema, UpdateRunParamsSchema, TickEventSchema, ShutdownEventSchema, ProtocolSchemas, PROTOCOL_VERSION, ErrorCodes, errorShape, SwarmListParamsSchema, SwarmStatusParamsSchema, SwarmCreateParamsSchema, SwarmListResultSchema, SwarmStatusResultSchema, SwarmCreateResultSchema, SwarmStateSchema, SwarmMemberSchema, SwarmTaskSchema, SwarmStrategySchema, };

package/dist/gateway/protocol/schema/error-codes.js

@@ -4,6 +4,7 @@ export const ErrorCodes = {
     AGENT_TIMEOUT: "AGENT_TIMEOUT",
     INVALID_REQUEST: "INVALID_REQUEST",
     UNAVAILABLE: "UNAVAILABLE",
+    INTERNAL_ERROR: "INTERNAL_ERROR",
 };
 export function errorShape(code, message, opts) {
     return {