erosolar-cli 1.7.14 → 1.7.16

package/dist/bin/core/agent.js

@@ -1,362 +0,0 @@
-/**
- * Maximum number of context overflow recovery attempts
- */
-const MAX_CONTEXT_RECOVERY_ATTEMPTS = 3;
-/**
- * Check if an error is a context overflow error
- */
-function isContextOverflowError(error) {
-    if (!(error instanceof Error))
-        return false;
-    const message = error.message.toLowerCase();
-    return (message.includes('context length') ||
-        message.includes('token') && (message.includes('limit') || message.includes('exceed') || message.includes('maximum')) ||
-        message.includes('too long') ||
-        message.includes('too many tokens') ||
-        message.includes('max_tokens') ||
-        message.includes('context window'));
-}
-export class AgentRuntime {
-    constructor(options) {
-        this.messages = [];
-        this.activeRun = null;
-        this.provider = options.provider;
-        this.toolRuntime = options.toolRuntime;
-        this.callbacks = options.callbacks ?? {};
-        this.contextManager = options.contextManager ?? null;
-        const trimmedPrompt = options.systemPrompt.trim();
-        this.baseSystemPrompt = trimmedPrompt || null;
-        if (trimmedPrompt) {
-            this.messages.push({ role: 'system', content: trimmedPrompt });
-        }
-    }
-    async send(text, useStreaming = false) {
-        const prompt = text.trim();
-        if (!prompt) {
-            return '';
-        }
-        this.messages.push({ role: 'user', content: prompt });
-        const run = { startedAt: Date.now() };
-        this.activeRun = run;
-        try {
-            if (useStreaming && this.provider.generateStream) {
-                return await this.processConversationStreaming();
-            }
-            return await this.processConversation();
-        }
-        finally {
-            if (this.activeRun === run) {
-                this.activeRun = null;
-            }
-        }
-    }
-    async processConversation() {
-        let contextRecoveryAttempts = 0;
-        while (true) {
-            // Prune messages if approaching context limit (BEFORE generation)
-            await this.pruneMessagesIfNeeded();
-            try {
-                const response = await this.provider.generate(this.messages, this.providerTools);
-                const usage = response.usage ?? null;
-                const contextStats = this.getContextStats();
-                // Reset recovery attempts on successful generation
-                contextRecoveryAttempts = 0;
-                if (response.type === 'tool_calls') {
-                    const narration = response.content?.trim();
-                    if (narration) {
-                        this.emitAssistantMessage(narration, { isFinal: false, usage, contextStats });
-                    }
-                    const assistantMessage = {
-                        role: 'assistant',
-                        content: response.content ?? '',
-                    };
-                    if (response.toolCalls?.length) {
-                        assistantMessage.toolCalls = response.toolCalls;
-                    }
-                    this.messages.push(assistantMessage);
-                    await this.resolveToolCalls(response.toolCalls);
-                    continue;
-                }
-                const reply = response.content?.trim() ?? '';
-                if (reply) {
-                    this.emitAssistantMessage(reply, { isFinal: true, usage, contextStats });
-                }
-                this.messages.push({ role: 'assistant', content: reply });
-                return reply;
-            }
-            catch (error) {
-                // Auto-recover from context overflow errors
-                if (isContextOverflowError(error) && contextRecoveryAttempts < MAX_CONTEXT_RECOVERY_ATTEMPTS) {
-                    contextRecoveryAttempts++;
-                    const recovered = await this.recoverFromContextOverflow(contextRecoveryAttempts);
-                    if (recovered) {
-                        // Retry the generation with reduced context
-                        continue;
-                    }
-                }
-                // Re-throw if not recoverable or recovery failed
-                throw error;
-            }
-        }
-    }
-    async processConversationStreaming() {
-        if (!this.provider.generateStream) {
-            return this.processConversation();
-        }
-        let contextRecoveryAttempts = 0;
-        while (true) {
-            // Prune messages if approaching context limit (BEFORE generation)
-            await this.pruneMessagesIfNeeded();
-            try {
-                let fullContent = '';
-                const toolCalls = [];
-                let usage = null;
-                const stream = this.provider.generateStream(this.messages, this.providerTools);
-                for await (const chunk of stream) {
-                    if (chunk.type === 'content' && chunk.content) {
-                        fullContent += chunk.content;
-                        this.callbacks.onStreamChunk?.(chunk.content);
-                    }
-                    else if (chunk.type === 'tool_call' && chunk.toolCall) {
-                        toolCalls.push(chunk.toolCall);
-                    }
-                    else if (chunk.type === 'usage' && chunk.usage) {
-                        usage = chunk.usage;
-                    }
-                }
-                // Reset recovery attempts on successful generation
-                contextRecoveryAttempts = 0;
-                const contextStats = this.getContextStats();
-                // Check if we got tool calls
-                if (toolCalls.length > 0) {
-                    const narration = fullContent.trim();
-                    if (narration) {
-                        this.emitAssistantMessage(narration, { isFinal: false, usage, contextStats });
-                    }
-                    const assistantMessage = {
-                        role: 'assistant',
-                        content: fullContent,
-                        toolCalls,
-                    };
-                    this.messages.push(assistantMessage);
-                    await this.resolveToolCalls(toolCalls);
-                    continue;
-                }
-                // Final message
-                const reply = fullContent.trim();
-                if (reply) {
-                    this.emitAssistantMessage(reply, { isFinal: true, usage, contextStats });
-                }
-                this.messages.push({ role: 'assistant', content: reply });
-                return reply;
-            }
-            catch (error) {
-                // Auto-recover from context overflow errors
-                if (isContextOverflowError(error) && contextRecoveryAttempts < MAX_CONTEXT_RECOVERY_ATTEMPTS) {
-                    contextRecoveryAttempts++;
-                    const recovered = await this.recoverFromContextOverflow(contextRecoveryAttempts);
-                    if (recovered) {
-                        // Retry the generation with reduced context
-                        continue;
-                    }
-                }
-                // Re-throw if not recoverable or recovery failed
-                throw error;
-            }
-        }
-    }
-    async resolveToolCalls(toolCalls) {
-        // Execute all tool calls in parallel for better performance
-        const results = await Promise.all(toolCalls.map(async (call) => ({
-            call,
-            output: await this.toolRuntime.execute(call),
-        })));
-        // Add results to messages in the same order as tool calls
-        for (const { call, output } of results) {
-            this.messages.push({
-                role: 'tool',
-                name: call.name,
-                toolCallId: call.id,
-                content: output,
-            });
-        }
-    }
-    get providerTools() {
-        return this.toolRuntime.listProviderTools();
-    }
-    emitAssistantMessage(content, metadata) {
-        if (!content) {
-            return;
-        }
-        const elapsedMs = this.activeRun ? Date.now() - this.activeRun.startedAt : undefined;
-        const payload = { ...metadata };
-        if (typeof elapsedMs === 'number') {
-            payload.elapsedMs = elapsedMs;
-        }
-        this.callbacks.onAssistantMessage?.(content, payload);
-    }
-    getHistory() {
-        return this.messages.map(cloneMessage);
-    }
-    loadHistory(history) {
-        this.messages.length = 0;
-        if (history.length === 0) {
-            if (this.baseSystemPrompt) {
-                this.messages.push({ role: 'system', content: this.baseSystemPrompt });
-            }
-            return;
-        }
-        for (const message of history) {
-            this.messages.push(cloneMessage(message));
-        }
-    }
-    clearHistory() {
-        this.messages.length = 0;
-        if (this.baseSystemPrompt) {
-            this.messages.push({ role: 'system', content: this.baseSystemPrompt });
-        }
-    }
-    /**
-     * Prune messages if approaching context limit
-     *
-     * This runs BEFORE each generation to ensure we stay within budget.
-     * If LLM summarization is available, it will create intelligent summaries
-     * instead of just removing old messages.
-     */
-    async pruneMessagesIfNeeded() {
-        if (!this.contextManager) {
-            return;
-        }
-        if (this.contextManager.isApproachingLimit(this.messages)) {
-            // Try LLM-based summarization first (preserves context better)
-            const result = await this.contextManager.pruneMessagesWithSummary(this.messages);
-            if (result.removed > 0) {
-                // Replace messages with pruned/summarized version
-                this.messages.length = 0;
-                this.messages.push(...result.pruned);
-                // Notify callback with enriched stats
-                const stats = this.contextManager.getStats(this.messages);
-                const enrichedStats = {
-                    ...stats,
-                    summarized: result.summarized,
-                    method: result.summarized ? 'llm-summary' : 'simple-prune',
-                };
-                this.callbacks.onContextPruned?.(result.removed, enrichedStats);
-                if (process.env['DEBUG_CONTEXT']) {
-                    console.warn(`[Context Manager] ${result.summarized ? 'Summarized' : 'Pruned'} ${result.removed} messages. ` +
-                        `Tokens: ${stats.totalTokens} (${stats.percentage}%)`);
-                }
-            }
-        }
-    }
-    /**
-     * Get current context statistics
-     */
-    getContextStats() {
-        if (!this.contextManager) {
-            return null;
-        }
-        return this.contextManager.getStats(this.messages);
-    }
-    /**
-     * Get context manager instance
-     */
-    getContextManager() {
-        return this.contextManager;
-    }
-    /**
-     * Auto-recover from context overflow errors by aggressively pruning messages.
-     *
-     * This is called when an API call fails due to context length exceeding limits.
-     * It performs increasingly aggressive pruning on each attempt:
-     * - Attempt 1: Remove 30% of oldest messages
-     * - Attempt 2: Remove 50% of oldest messages
-     * - Attempt 3: Remove 70% of oldest messages (keep only recent)
-     *
-     * @returns true if recovery was successful (context was reduced)
-     */
-    async recoverFromContextOverflow(attempt) {
-        // Calculate reduction percentage based on attempt
-        const reductionPercentages = [0.3, 0.5, 0.7];
-        const reductionPercent = reductionPercentages[attempt - 1] ?? 0.7;
-        // Notify UI about recovery attempt
-        const message = `Context overflow detected. Auto-squishing context (attempt ${attempt}/${MAX_CONTEXT_RECOVERY_ATTEMPTS}, removing ${Math.round(reductionPercent * 100)}% of history)...`;
-        this.callbacks.onContextRecovery?.(attempt, MAX_CONTEXT_RECOVERY_ATTEMPTS, message);
-        this.callbacks.onContextSquishing?.(message);
-        // Separate system messages from conversation
-        const systemMessages = [];
-        const conversationMessages = [];
-        for (const msg of this.messages) {
-            if (msg.role === 'system') {
-                systemMessages.push(msg);
-            }
-            else {
-                conversationMessages.push(msg);
-            }
-        }
-        // Calculate how many messages to remove
-        const removeCount = Math.floor(conversationMessages.length * reductionPercent);
-        if (removeCount === 0 || conversationMessages.length <= 2) {
-            // Nothing to remove or too few messages - can't recover
-            return false;
-        }
-        // Keep recent messages
-        const keepMessages = conversationMessages.slice(removeCount);
-        // Rebuild message array
-        this.messages.length = 0;
-        // Add system messages
-        for (const sys of systemMessages) {
-            this.messages.push(sys);
-        }
-        // Add summary notice
-        this.messages.push({
-            role: 'system',
-            content: `[Auto Context Recovery] Removed ${removeCount} earlier messages to stay within token limits. Conversation context has been compressed.`,
-        });
-        // Add remaining conversation
-        for (const msg of keepMessages) {
-            this.messages.push(msg);
-        }
-        // Notify about pruning
-        const stats = this.contextManager?.getStats(this.messages) ?? {};
-        this.callbacks.onContextPruned?.(removeCount, {
-            ...stats,
-            method: 'emergency-recovery',
-            attempt,
-            removedPercent: reductionPercent * 100,
-        });
-        return true;
-    }
-}
-function cloneMessage(message) {
-    switch (message.role) {
-        case 'assistant':
-            const clone = {
-                role: 'assistant',
-                content: message.content,
-            };
-            if (message.toolCalls) {
-                clone.toolCalls = message.toolCalls.map(cloneToolCall);
-            }
-            return clone;
-        case 'tool':
-            return {
-                role: 'tool',
-                name: message.name,
-                content: message.content,
-                toolCallId: message.toolCallId,
-            };
-        case 'system':
-            return { role: 'system', content: message.content };
-        case 'user':
-        default:
-            return { role: 'user', content: message.content };
-    }
-}
-function cloneToolCall(call) {
-    return {
-        id: call.id,
-        name: call.name,
-        arguments: { ...(call.arguments ?? {}) },
-    };
-}

package/dist/bin/core/agentProfileManifest.js

@@ -1,187 +0,0 @@
-import { getAgentSchemas } from './agentSchemaLoader.js';
-// Load from centralized schema
-const manifest = (() => {
-    const schemas = getAgentSchemas();
-    const rawManifest = {
-        contractVersion: schemas.contractVersion,
-        version: schemas.version,
-        label: schemas.label,
-        description: schemas.description,
-        profiles: schemas.profiles,
-        metadata: schemas.metadata,
-    };
-    return normalizeManifest(rawManifest);
-})();
-export function getAgentProfileManifest() {
-    return manifest;
-}
-function normalizeManifest(raw) {
-    if (!isRecord(raw)) {
-        throw new Error('Agent profile manifest is malformed: expected an object.');
-    }
-    const profiles = Array.isArray(raw.profiles) ? raw.profiles.map(normalizeProfileEntry) : null;
-    if (!profiles?.length) {
-        throw new Error('Agent profile manifest must include at least one profile entry.');
-    }
-    const seen = new Set();
-    for (const entry of profiles) {
-        if (seen.has(entry.name)) {
-            throw new Error(`Agent profile manifest contains duplicate profile id "${entry.name}".`);
-        }
-        seen.add(entry.name);
-    }
-    const manifest = {
-        contractVersion: requireString(raw.contractVersion, 'contractVersion'),
-        version: requireString(raw.version, 'version'),
-        profiles,
-    };
-    const label = optionalString(raw.label);
-    if (label) {
-        manifest.label = label;
-    }
-    const description = optionalString(raw.description);
-    if (description) {
-        manifest.description = description;
-    }
-    const metadata = normalizeRecord(raw.metadata);
-    if (metadata) {
-        manifest.metadata = metadata;
-    }
-    return manifest;
-}
-function normalizeProfileEntry(raw) {
-    const name = requireString(raw.name, 'profile.name');
-    const profile = {
-        name,
-        label: requireString(raw.label, `profiles["${name}"].label`),
-        defaultProvider: requireProvider(raw.defaultProvider, name),
-        defaultModel: requireString(raw.defaultModel, `profiles["${name}"].defaultModel`),
-        systemPrompt: normalizePrompt(raw.systemPrompt, name),
-        rulebook: normalizeRulebook(raw.rulebook, name),
-    };
-    const description = optionalString(raw.description);
-    if (description) {
-        profile.description = description;
-    }
-    const temperature = optionalNumber(raw.temperature, `profiles["${name}"].temperature`);
-    if (typeof temperature === 'number') {
-        profile.temperature = temperature;
-    }
-    const maxTokens = optionalInteger(raw.maxTokens, `profiles["${name}"].maxTokens`);
-    if (typeof maxTokens === 'number') {
-        profile.maxTokens = maxTokens;
-    }
-    const metadata = normalizeRecord(raw.metadata);
-    if (metadata) {
-        profile.metadata = metadata;
-    }
-    return profile;
-}
-function normalizePrompt(raw, profile) {
-    if (!isRecord(raw)) {
-        throw new Error(`Profile "${profile}" is missing a valid systemPrompt definition.`);
-    }
-    if (raw.type === 'literal') {
-        return normalizeLiteralPrompt(raw, profile);
-    }
-    if (raw.type === 'rulebook') {
-        return normalizeRulebookPrompt(raw, profile);
-    }
-    throw new Error(`Profile "${profile}" has an unsupported systemPrompt type.`);
-}
-function normalizeLiteralPrompt(raw, profile) {
-    const prompt = {
-        type: 'literal',
-        content: requireString(raw.content, `profiles["${profile}"].systemPrompt.content`),
-    };
-    const metadata = normalizeRecord(raw.metadata);
-    if (metadata) {
-        prompt.metadata = metadata;
-    }
-    return prompt;
-}
-function normalizeRulebookPrompt(raw, _profile) {
-    const prompt = { type: 'rulebook' };
-    const template = optionalString(raw.template);
-    if (template) {
-        prompt.template = template;
-    }
-    const metadata = normalizeRecord(raw.metadata);
-    if (metadata) {
-        prompt.metadata = metadata;
-    }
-    return prompt;
-}
-function normalizeRulebook(raw, profile) {
-    if (!isRecord(raw)) {
-        throw new Error(`Profile "${profile}" is missing a valid rulebook reference.`);
-    }
-    const reference = {
-        file: requireString(raw.file, `profiles["${profile}"].rulebook.file`),
-    };
-    const version = optionalString(raw.version);
-    if (version) {
-        reference.version = version;
-    }
-    const contractVersion = optionalString(raw.contractVersion);
-    if (contractVersion) {
-        reference.contractVersion = contractVersion;
-    }
-    const description = optionalString(raw.description);
-    if (description) {
-        reference.description = description;
-    }
-    const metadata = normalizeRecord(raw.metadata);
-    if (metadata) {
-        reference.metadata = metadata;
-    }
-    return reference;
-}
-function requireProvider(value, profile) {
-    const resolved = requireString(value, `profiles["${profile}"].defaultProvider`);
-    return resolved;
-}
-function requireString(value, field) {
-    if (typeof value !== 'string') {
-        throw new Error(`Agent profile manifest is missing required field "${field}".`);
-    }
-    const trimmed = value.trim();
-    if (!trimmed) {
-        throw new Error(`Agent profile manifest field "${field}" cannot be blank.`);
-    }
-    return trimmed;
-}
-function optionalString(value) {
-    if (typeof value !== 'string') {
-        return undefined;
-    }
-    const trimmed = value.trim();
-    return trimmed.length ? trimmed : undefined;
-}
-function optionalNumber(value, field) {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (typeof value !== 'number' || !Number.isFinite(value)) {
-        throw new Error(`Agent profile manifest field "${field}" must be a finite number when provided.`);
-    }
-    return value;
-}
-function optionalInteger(value, field) {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (typeof value !== 'number' || !Number.isInteger(value) || value <= 0) {
-        throw new Error(`Agent profile manifest field "${field}" must be a positive integer when provided.`);
-    }
-    return value;
-}
-function normalizeRecord(record) {
-    if (!isRecord(record)) {
-        return undefined;
-    }
-    return { ...record };
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}

package/dist/bin/core/agentProfiles.js

@@ -1,34 +0,0 @@
-const registry = new Map();
-export function registerAgentProfile(blueprint) {
-    if (!blueprint?.name) {
-        throw new Error('Agent profile name is required.');
-    }
-    const trimmedName = blueprint.name.trim();
-    if (!trimmedName) {
-        throw new Error('Agent profile name cannot be blank.');
-    }
-    const payload = Object.freeze({
-        ...blueprint,
-        name: trimmedName,
-        label: blueprint.label.trim() || trimmedName,
-        frozen: true,
-    });
-    registry.set(trimmedName, payload);
-}
-export function hasAgentProfile(name) {
-    return registry.has(name.trim());
-}
-export function getAgentProfile(name) {
-    const profile = registry.get(name.trim());
-    if (!profile) {
-        const known = listAgentProfiles()
-            .map((entry) => entry.name)
-            .sort()
-            .join(', ');
-        throw new Error(`Unknown profile "${name}". Registered profiles: ${known || 'none'}.`);
-    }
-    return profile;
-}
-export function listAgentProfiles() {
-    return Array.from(registry.values());
-}