@acmecloud/core 1.0.2

package/dist/agent/index.d.ts

@@ -0,0 +1,52 @@
+import { ProviderType } from "../llm/provider.js";
+import { ReasoningLevel, AgentMode } from "../config/index.js";
+export type AgentEvent = {
+    type: "text";
+    text: string;
+} | {
+    type: "tool-call";
+    name: string;
+    args: Record<string, unknown>;
+    toolCallId?: string;
+} | {
+    type: "tool-call-delta";
+    name: string;
+    args: Record<string, unknown>;
+    partial?: boolean;
+    toolCallId?: string;
+} | {
+    type: "tool-result";
+    name: string;
+    result: string;
+    toolCallId?: string;
+} | {
+    type: "tool-generating";
+    name: string;
+    args: Record<string, unknown>;
+} | {
+    type: "tool-approval-required";
+    name: string;
+    args: Record<string, unknown>;
+    riskLevel?: string;
+    isLocalGuard?: boolean;
+} | {
+    type: "messages";
+    messages: any[];
+    promptLength?: number;
+} | {
+    type: "step";
+    step: number;
+    maxSteps: number;
+} | {
+    type: "finish";
+    usage: any;
+} | {
+    type: "mode-changed";
+    mode: AgentMode;
+    planFile?: string;
+};
+/**
+ * Run the AI agent with streaming, multi-step tool calls, and structured events.
+ * Inspired by opencode's LLM.stream() pattern.
+ */
+export declare function runAgent(provider: ProviderType, modelName: string, messages: any[], systemPrompt?: string, abortSignal?: AbortSignal, reasoningLevel?: ReasoningLevel, agentMode?: AgentMode, activePlanFile?: string, activeSkillContent?: string): AsyncGenerator<AgentEvent, any[], unknown>;

package/dist/agent/index.js

@@ -0,0 +1,476 @@
+import { streamText } from "ai";
+import { getModel } from "../llm/provider.js";
+import { builtInTools, toolExecutors, isCommandSafe } from "../tools/index.js";
+import { getMcpTools } from "../mcp/index.js";
+import { getSystemPrompt } from "../prompt/index.js";
+// ── Configuration ──
+const MAX_STEPS = 80;
+const MAX_OUTPUT_LENGTH = 30000;
+const MAX_RETRIES = 2;
+// ── Model-specific output token limits ──
+function getMaxOutputTokens(modelName, level) {
+    const lower = modelName.toLowerCase();
+    const isReasoningModel = lower.includes("o1") || lower.includes("o3") || lower.includes("o4");
+    if (isReasoningModel) {
+        if (level === "max" || level === "xhigh")
+            return 100000;
+        if (level === "high")
+            return 64000;
+        return 32000;
+    }
+    if (lower.includes("4-6") || lower.includes("4.6")) {
+        // User specified Opus 4.6 (relay variant) supports 16000
+        return 16000;
+    }
+    if (lower.includes("claude-3-5") || lower.includes("sonnet")) {
+        return 8192;
+    }
+    if (lower.includes("claude")) {
+        // Standard Opus and other Claude models usually have a 4096 output limit.
+        return 4096;
+    }
+    if (lower.includes("gpt-4"))
+        return 16384;
+    if (lower.includes("gemini"))
+        return 65536;
+    if (lower.includes("deepseek"))
+        return 16384;
+    return 4096; // Safe default for most models
+}
+// ── Reasoning Attempt Mapping ──
+function getReasoningEffort(level) {
+    switch (level) {
+        case "low":
+            return "low";
+        case "medium":
+            return "medium";
+        case "high":
+            return "high";
+        case "max":
+            return "high";
+        case "xhigh":
+            return "high";
+        default:
+            return undefined;
+    }
+}
+// ── Temperature defaults ──
+function getDefaultTemperature(modelName) {
+    const lower = modelName.toLowerCase();
+    // Reasoning models and Claude don't support temperature or it's better to let provider decide
+    if (lower.includes("o1") || lower.includes("o3") || lower.includes("o4"))
+        return undefined;
+    if (lower.includes("claude"))
+        return undefined;
+    if (lower.includes("deepseek-r1") || lower.includes("deepseek-reasoner"))
+        return undefined;
+    return 0;
+}
+/**
+ * Run the AI agent with streaming, multi-step tool calls, and structured events.
+ * Inspired by opencode's LLM.stream() pattern.
+ */
+export async function* runAgent(provider, modelName, messages, systemPrompt, abortSignal, reasoningLevel = "medium", agentMode = "agent", activePlanFile, activeSkillContent) {
+    const model = getModel(provider, modelName);
+    const mcpTools = await getMcpTools();
+    let currentMessages = [...messages];
+    let stepCount = 0;
+    const globalCalledSet = new Set();
+    const temperature = getDefaultTemperature(modelName);
+    const maxOutputTokens = getMaxOutputTokens(modelName, reasoningLevel);
+    const reasoningEffort = getReasoningEffort(reasoningLevel);
+    let currentMode = agentMode;
+    let currentPlanFile = activePlanFile;
+    // We keep system dynamic so it updates properly if the agent switches mode mid-loop.
+    let system = systemPrompt ||
+        (await getSystemPrompt(provider, modelName, currentMode, currentPlanFile, activeSkillContent));
+    yield {
+        type: "messages",
+        messages: [...messages],
+        promptLength: system.length,
+    };
+    let consecutiveErrors = 0;
+    while (stepCount < MAX_STEPS) {
+        stepCount++;
+        yield { type: "step", step: stepCount, maxSteps: MAX_STEPS };
+        const currentTools = {
+            ...builtInTools,
+            ...mcpTools,
+        };
+        if (currentMode === "plan") {
+            delete currentTools["run_command"];
+            delete currentTools["edit_file"];
+            delete currentTools["lsp"];
+            delete currentTools["grep_search"];
+        }
+        let stepText = "";
+        const collectedToolCalls = [];
+        const collectedToolResults = [];
+        let modeDidSwitch = false;
+        // ── Message cleaning (especially for Anthropic) ──
+        const purifiedMessages = currentMessages
+            .map((msg) => {
+            if (typeof msg.content === "string")
+                return msg;
+            if (!Array.isArray(msg.content))
+                return msg;
+            return {
+                ...msg,
+                content: msg.content.filter((part) => {
+                    if (part.type === "text")
+                        return part.text && part.text.trim().length > 0;
+                    if (part.type === "tool-call" || part.type === "tool-result") {
+                        // Normalize tool call IDs to alphanumeric + underscores
+                        if (part.toolCallId) {
+                            part.toolCallId = part.toolCallId.replace(/[^a-zA-Z0-9_-]/g, "_");
+                        }
+                    }
+                    return true;
+                }),
+            };
+        })
+            .filter((msg) => {
+            if (!msg.content)
+                return false;
+            if (Array.isArray(msg.content) && msg.content.length === 0)
+                return false;
+            return true;
+        });
+        try {
+            const result = await streamText({
+                model,
+                messages: purifiedMessages,
+                system,
+                tools: currentTools,
+                maxSteps: 1,
+                maxRetries: MAX_RETRIES,
+                temperature,
+                maxOutputTokens,
+                abortSignal,
+                experimental_toolCallStreaming: true,
+                providerOptions: {
+                    openai: reasoningEffort ? { reasoningEffort } : undefined,
+                    anthropic: provider === "anthropic" &&
+                        (modelName.includes("sonnet") || modelName.includes("opus"))
+                        ? {
+                            thinking: {
+                                type: "enabled",
+                                budgetTokens: Math.min(maxOutputTokens || 4096, 16000),
+                            },
+                        }
+                        : undefined,
+                    google: provider === "google" && modelName.includes("thinking")
+                        ? {
+                            thinkingConfig: { includeThoughts: true },
+                        }
+                        : undefined,
+                },
+                // ── Tool name repair (from opencode) ──
+                async experimental_repairToolCall(failed) {
+                    const lower = failed.toolCall.toolName.toLowerCase();
+                    if (lower !== failed.toolCall.toolName && currentTools[lower]) {
+                        return { ...failed.toolCall, toolName: lower };
+                    }
+                    return {
+                        ...failed.toolCall,
+                        input: JSON.stringify({
+                            tool: failed.toolCall.toolName,
+                            error: failed.error?.message || "Unknown tool",
+                        }),
+                        toolName: "invalid",
+                    };
+                },
+            });
+            let lastFinishReason;
+            const yieldedToolCalls = new Set();
+            for await (const chunk of result.fullStream) {
+                if (abortSignal?.aborted) {
+                    yield { type: "text", text: "\n[Aborted by user]\n" };
+                    yield { type: "messages", messages: currentMessages };
+                    return [];
+                }
+                if (chunk.type === "text-delta") {
+                    const text = chunk.textDelta || chunk.text || "";
+                    if (text) {
+                        stepText += text;
+                        if (stepText.length > MAX_OUTPUT_LENGTH) {
+                            yield {
+                                type: "text",
+                                text: "\n[Error: Output exceeded maximum length]\n",
+                            };
+                            break;
+                        }
+                        yield { type: "text", text };
+                    }
+                }
+                else if (chunk.type === "tool-call") {
+                    const name = chunk.toolName || "";
+                    const rawArgs = chunk.input || chunk.args;
+                    const args = typeof rawArgs?.toObject === "function"
+                        ? rawArgs.toObject()
+                        : rawArgs || {};
+                    const id = chunk.toolCallId;
+                    if (name && id && !yieldedToolCalls.has(id)) {
+                        yieldedToolCalls.add(id);
+                        collectedToolCalls.push({ name, args });
+                        yield { type: "tool-call", name, args, toolCallId: id };
+                    }
+                }
+                else if (chunk.type === "tool-call-delta") {
+                    const name = chunk.toolName || "";
+                    const rawArgs = chunk.input || chunk.args;
+                    const args = typeof rawArgs?.toObject === "function"
+                        ? rawArgs.toObject()
+                        : rawArgs || {};
+                    const id = chunk.toolCallId;
+                    if (name && id) {
+                        yield {
+                            type: "tool-call-delta",
+                            name,
+                            args,
+                            partial: !!chunk.partial,
+                        };
+                    }
+                }
+                else if (chunk.type === "tool-result") {
+                    const name = chunk.toolName || "";
+                    const toolCallId = chunk.toolCallId;
+                    const rawResult = chunk.result ?? chunk.output ?? "";
+                    const resultStr = typeof rawResult === "string"
+                        ? rawResult
+                        : JSON.stringify(rawResult);
+                    collectedToolResults.push({ name, result: resultStr });
+                    yield { type: "tool-result", name, result: resultStr, toolCallId };
+                    if (name === "switch_mode") {
+                        try {
+                            const parsed = typeof rawResult === "object"
+                                ? rawResult
+                                : JSON.parse(resultStr);
+                            if (parsed.switched_mode) {
+                                currentMode = parsed.switched_mode;
+                                currentPlanFile = parsed.contextFile;
+                                modeDidSwitch = true;
+                                yield {
+                                    type: "mode-changed",
+                                    mode: currentMode,
+                                    planFile: currentPlanFile,
+                                };
+                            }
+                        }
+                        catch { }
+                    }
+                }
+                else if (chunk.type === "finish") {
+                    lastFinishReason = chunk.finishReason || "unknown";
+                }
+            }
+            // Proactive checks for silent stream drops (graceful socket close but incomplete thought)
+            const isAbruptDrop = !lastFinishReason ||
+                ["unknown", "error", "length"].includes(lastFinishReason);
+            if (isAbruptDrop && collectedToolCalls.length === 0) {
+                // Ignore abrupt drops if it's obvious a tool was meant to be used but we couldn't parse it?
+                // Actually, if we couldn't parse it, we want the LLM to resume and finish the syntax.
+                throw new Error(`Stream terminated prematurely with finish_reason: ${lastFinishReason || "No finish chunk received"}`);
+            }
+            consecutiveErrors = 0; // Reset upon successful stream completion
+        }
+        catch (err) {
+            if (err.name === "AbortError" || abortSignal?.aborted) {
+                yield { type: "text", text: "\n[Aborted by user]\n" };
+                yield { type: "messages", messages: currentMessages };
+                return [];
+            }
+            else {
+                yield {
+                    type: "text",
+                    text: `\n[Error: ${err.message}]\n[Auto-recovering from stream drop...]\n`,
+                };
+                if (stepText.trim()) {
+                    currentMessages.push({ role: "assistant", content: stepText });
+                }
+                consecutiveErrors++;
+                if (consecutiveErrors >= 3) {
+                    yield {
+                        type: "text",
+                        text: `\n[Fatal Error: Stream dropped ${consecutiveErrors} times consecutively. Halting agent to prevent infinite loops.]\n`,
+                    };
+                    yield { type: "messages", messages: currentMessages };
+                    return [];
+                }
+                currentMessages.push({
+                    role: "user",
+                    content: `[System Error: The network stream disconnected prematurely with error: ${err.message || err}. Please carefully analyze the incomplete text you just generated, and continue your thought or tool execution precisely from where it was cut off without repeating yourself.]`,
+                });
+                await new Promise((resolve) => setTimeout(resolve, 2000));
+                continue;
+            }
+        }
+        if (collectedToolCalls.length === 0) {
+            const parseText = stepText
+                .replace(/<think>[\s\S]*?<\/think>/g, "")
+                .trim();
+            for (const [toolName, toolFn] of Object.entries(toolExecutors)) {
+                const patterns = [
+                    new RegExp(`<${toolName}>([\\s\\S]*?)<\\/${toolName}>`, "g"),
+                    new RegExp(`\\[${toolName}\\(([^\\[\\]]*)\\)\\]`, "g"),
+                ];
+                for (const regex of patterns) {
+                    regex.lastIndex = 0;
+                    let match;
+                    while ((match = regex.exec(parseText)) !== null) {
+                        const innerText = match[1].trim();
+                        const args = {};
+                        const argRegex = /<(\w+)>([\s\S]*?)<\/\1>/g;
+                        let argMatch;
+                        let foundInnerArgs = false;
+                        while ((argMatch = argRegex.exec(innerText)) !== null) {
+                            args[argMatch[1]] = argMatch[2].trim();
+                            foundInnerArgs = true;
+                        }
+                        if (!foundInnerArgs && innerText) {
+                            if (toolName === "list_dir" || toolName === "read_file") {
+                                args.path = innerText.replace(/^["']|["']$/g, "").trim();
+                            }
+                            else if (toolName === "run_command") {
+                                args.command = innerText.replace(/^["']|["']$/g, "").trim();
+                                if (!args.riskLevel) {
+                                    // Default to high if model didn't self-assess in fallback tag
+                                    args.riskLevel = "high";
+                                }
+                            }
+                        }
+                        const firstArgValue = Object.values(args)[0];
+                        if (!firstArgValue)
+                            continue;
+                        const dedupKey = `${toolName}:${JSON.stringify(args)}`;
+                        if (globalCalledSet.has(dedupKey))
+                            continue;
+                        globalCalledSet.add(dedupKey);
+                        collectedToolCalls.push({ name: toolName, args });
+                        // Safety Check for run_command
+                        if (toolName === "run_command") {
+                            const localDanger = !isCommandSafe(args.command);
+                            const modelRisk = args.riskLevel;
+                            const needsApproval = localDanger || modelRisk === "medium" || modelRisk === "high";
+                            if (needsApproval) {
+                                const approved = yield {
+                                    type: "tool-approval-required",
+                                    name: toolName,
+                                    args,
+                                    riskLevel: modelRisk,
+                                    isLocalGuard: localDanger,
+                                };
+                                if (!approved) {
+                                    const resultStr = "Error: User denied execution of dangerous command.";
+                                    collectedToolResults.push({
+                                        name: toolName,
+                                        result: resultStr,
+                                    });
+                                    yield { type: "tool-call", name: toolName, args };
+                                    yield {
+                                        type: "tool-result",
+                                        name: toolName,
+                                        result: resultStr,
+                                    };
+                                    continue;
+                                }
+                            }
+                        }
+                        yield { type: "tool-call", name: toolName, args };
+                        yield { type: "tool-generating", name: toolName, args };
+                        try {
+                            const result = await toolFn(args);
+                            const resultStr = typeof result === "string" ? result : JSON.stringify(result);
+                            collectedToolResults.push({ name: toolName, result: resultStr });
+                            yield { type: "tool-result", name: toolName, result: resultStr };
+                            if (toolName === "switch_mode") {
+                                try {
+                                    const parsed = typeof result === "object" ? result : JSON.parse(resultStr);
+                                    if (parsed.switched_mode) {
+                                        currentMode = parsed.switched_mode;
+                                        currentPlanFile = parsed.contextFile;
+                                        modeDidSwitch = true;
+                                        yield {
+                                            type: "mode-changed",
+                                            mode: currentMode,
+                                            planFile: currentPlanFile,
+                                        };
+                                    }
+                                }
+                                catch { }
+                            }
+                        }
+                        catch (err) {
+                            const resultStr = `Error: ${err.message}`;
+                            collectedToolResults.push({ name: toolName, result: resultStr });
+                            yield { type: "tool-call", name: toolName, args }; // Emitted after error for history mapping
+                            yield { type: "tool-result", name: toolName, result: resultStr };
+                        }
+                    }
+                }
+            }
+        }
+        if (collectedToolCalls.length === 0) {
+            if (!stepText.trim()) {
+                consecutiveErrors++;
+                if (consecutiveErrors < 3) {
+                    yield {
+                        type: "text",
+                        text: `\n[System Notice: The model returned an empty response. Auto-retrying (${consecutiveErrors}/3)...]\n`,
+                    };
+                    currentMessages.push({
+                        role: "user",
+                        content: `[System] Your previous response was empty. Please continue your task or provide a status update.`,
+                    });
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
+                    continue;
+                }
+                else {
+                    yield {
+                        type: "text",
+                        text: `\n[Fatal Error: Model returned empty response 3 times consecutively. Halting.]\n`,
+                    };
+                    currentMessages.push({ role: "assistant", content: stepText });
+                    yield { type: "messages", messages: currentMessages };
+                    return [];
+                }
+            }
+            currentMessages.push({ role: "assistant", content: stepText });
+            yield { type: "messages", messages: currentMessages };
+            return [];
+        }
+        yield { type: "text", text: "\n" };
+        const toolSummary = collectedToolResults
+            .map((tr, i) => {
+            const tc = collectedToolCalls[i];
+            const argsStr = tc
+                ? Object.entries(tc.args)
+                    .filter(([k]) => k !== "content")
+                    .map(([k, v]) => `${k}=${JSON.stringify(v)}`)
+                    .join(", ")
+                : "";
+            const resultBody = tr.result.length > 10000
+                ? tr.result.slice(0, 10000) + "\n... (truncated)"
+                : tr.result;
+            return `### Tool: ${tr.name}(${argsStr})\n\`\`\`\n${resultBody}\n\`\`\``;
+        })
+            .join("\n\n");
+        currentMessages.push({ role: "assistant", content: stepText });
+        currentMessages.push({
+            role: "user",
+            content: `[SYSTEM] Tool results:\n\n${toolSummary}\n\nContinue with your task. Do NOT re-call the same tools.`,
+        });
+        // Recompute system prompt immediately if mode changed so the next loop has the right persona/length
+        if (modeDidSwitch && !systemPrompt) {
+            system = await getSystemPrompt(provider, modelName, currentMode, currentPlanFile, activeSkillContent);
+        }
+        yield {
+            type: "messages",
+            messages: currentMessages,
+            promptLength: system.length,
+        };
+    }
+    yield { type: "text", text: "\n[Reached maximum steps]\n" };
+    yield { type: "messages", messages: currentMessages };
+    return [];
+}

package/dist/config/index.d.ts

@@ -0,0 +1,83 @@
+export interface ModelConfig {
+    provider: string;
+    model: string;
+    visionProvider?: string;
+    visionModel?: string;
+}
+export interface ProviderSettings {
+    apiKey: string;
+    baseUrl?: string;
+    isCustom?: boolean;
+    protocol?: string;
+}
+export type AgentMode = "plan" | "code" | "agent" | "zen";
+export type ReasoningLevel = "low" | "medium" | "high" | "max" | "xhigh";
+/**
+ * Load model config with priority: project .acmecode/config.json > global ~/.acmecode/config.json > defaults
+ */
+export declare function loadModelConfig(): ModelConfig;
+/**
+ * Load language config with priority: project .acmecode/config.json > global ~/.acmecode/config.json > default "en"
+ */
+export declare function loadLangConfig(): string;
+/**
+ * Load theme config with priority: project .acmecode/config.json > global ~/.acmecode/config.json > default "dark"
+ */
+export declare function loadThemeConfig(): string;
+/**
+ * Load reasoning level config with priority: project .acmecode/config.json > global ~/.acmecode/config.json > default "medium"
+ */
+export declare function loadReasoningLevel(): ReasoningLevel;
+/**
+ * Load agent mode config with priority: project .acmecode/config.json > default "agent"
+ */
+export declare function loadAgentModeConfig(): {
+    mode: AgentMode;
+    planFile?: string;
+};
+/**
+ * Save model config to the project's .acmecode/config.json
+ */
+export declare function saveProjectModelConfig(provider: string, model: string, visionProvider?: string, visionModel?: string): void;
+/**
+ * Save agent mode config to the project's .acmecode/config.json
+ */
+export declare function saveAgentModeConfig(mode: AgentMode, planFile?: string): void;
+/**
+ * Save model config to the global ~/.acmecode/config.json
+ */
+export declare function saveGlobalModelConfig(provider: string, model: string): void;
+/**
+ * Save language config to the global ~/.acmecode/config.json
+ */
+export declare function saveGlobalLangConfig(lang: string): void;
+/**
+ * Save theme config to the global ~/.acmecode/config.json
+ */
+export declare function saveGlobalThemeConfig(theme: string): void;
+/**
+ * Save reasoning level config to the global ~/.acmecode/config.json
+ */
+export declare function saveGlobalReasoningLevel(level: ReasoningLevel): void;
+/**
+ * Save provider-specific settings to ~/.acmecode/config.json
+ */
+export declare function saveProviderConfig(provider: string, config: ProviderSettings): void;
+/**
+ * Load all custom providers from global config
+ */
+export declare function loadCustomProviders(): Record<string, ProviderSettings>;
+export declare const getProviderKey: (provider: string) => any;
+/**
+ * Normalizes a base URL by removing trailing slashes and ensuring consistency.
+ */
+export declare const normalizeBaseUrl: (url: string | undefined) => string | undefined;
+/**
+ * Intelligently adapts a base URL for a given protocol if version segments are missing.
+ */
+export declare const getAdaptedBaseUrl: (protocol: string, baseUrl: string | undefined) => string | undefined;
+export declare const getProviderBaseUrl: (provider: string) => string | undefined;
+/**
+ * Get the protocol for a provider (e.g. 'openai', 'anthropic', 'google')
+ */
+export declare const getProviderProtocol: (provider: string) => string;