@jellyos/agent 0.1.4 → 0.1.5

package/dist/mcp/server.js

@@ -0,0 +1,128 @@
+/**
+ * MCPServer — Model Context Protocol server over stdio. (#28)
+ *
+ * Exposes all JellyOS registered tools as MCP tools so they can be used
+ * by Claude Desktop, Cursor, Continue, and any MCP-compatible client.
+ *
+ * Protocol: JSON-RPC 2.0 over stdin/stdout (MCP stdio transport).
+ *
+ * Usage:
+ *   jellyos-mcp                        # exposes built-in tools
+ *   jellyos-mcp --extension ./my.ts    # includes extension tools
+ *
+ * Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json):
+ *   {
+ *     "mcpServers": {
+ *       "jellyos": {
+ *         "command": "jellyos-mcp",
+ *         "env": { "OPENROUTER_API_KEY": "sk-or-..." }
+ *       }
+ *     }
+ *   }
+ */
+import { createInterface } from "node:readline";
+export class MCPServer {
+    registry;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    async run() {
+        const rl = createInterface({ input: process.stdin, terminal: false });
+        // MCP uses newline-delimited JSON-RPC 2.0
+        rl.on("line", async (line) => {
+            const trimmed = line.trim();
+            if (!trimmed)
+                return;
+            let req;
+            try {
+                req = JSON.parse(trimmed);
+            }
+            catch {
+                this.respond({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } });
+                return;
+            }
+            const response = await this.handle(req);
+            this.respond(response);
+        });
+        rl.on("close", () => process.exit(0));
+        // MCP servers send an initialization notification on stderr
+        process.stderr.write("[JellyOS MCP] Server ready\n");
+    }
+    respond(res) {
+        process.stdout.write(JSON.stringify(res) + "\n");
+    }
+    async handle(req) {
+        try {
+            switch (req.method) {
+                case "initialize":
+                    return {
+                        jsonrpc: "2.0", id: req.id,
+                        result: {
+                            protocolVersion: "2024-11-05",
+                            capabilities: { tools: {} },
+                            serverInfo: { name: "jellyos", version: "0.1.5" },
+                        },
+                    };
+                case "notifications/initialized":
+                    // No response needed for notifications
+                    return { jsonrpc: "2.0", id: req.id, result: null };
+                case "tools/list":
+                    return {
+                        jsonrpc: "2.0", id: req.id,
+                        result: {
+                            tools: this.registry.listTools().map(t => ({
+                                name: t.name,
+                                description: t.description,
+                                inputSchema: {
+                                    ...t.parameters,
+                                    type: "object", // MCP requires explicit type
+                                },
+                            })),
+                        },
+                    };
+                case "tools/call": {
+                    const { name, arguments: args } = (req.params ?? {});
+                    if (!name) {
+                        return { jsonrpc: "2.0", id: req.id, error: { code: -32602, message: "Missing tool name" } };
+                    }
+                    const tool = this.registry.getTool(name);
+                    if (!tool) {
+                        return { jsonrpc: "2.0", id: req.id, error: { code: -32601, message: `Tool not found: ${name}` } };
+                    }
+                    try {
+                        const result = await tool.execute("mcp", (args ?? {}));
+                        return {
+                            jsonrpc: "2.0", id: req.id,
+                            result: {
+                                content: result.content.map(c => ({ type: "text", text: c.text })),
+                                isError: false,
+                            },
+                        };
+                    }
+                    catch (e) {
+                        const msg = e instanceof Error ? e.message : String(e);
+                        return {
+                            jsonrpc: "2.0", id: req.id,
+                            result: {
+                                content: [{ type: "text", text: `Tool error: ${msg}` }],
+                                isError: true,
+                            },
+                        };
+                    }
+                }
+                case "ping":
+                    return { jsonrpc: "2.0", id: req.id, result: {} };
+                default:
+                    return {
+                        jsonrpc: "2.0", id: req.id,
+                        error: { code: -32601, message: `Method not found: ${req.method}` },
+                    };
+            }
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return { jsonrpc: "2.0", id: req.id, error: { code: -32603, message: `Internal error: ${msg}` } };
+        }
+    }
+}
+//# sourceMappingURL=server.js.map

package/dist/models/ModelRegistry.d.ts

@@ -81,13 +81,24 @@ export declare class ModelRegistry {
      * consecutive failures (which get a 5-minute cooldown).
      */
     pick(tier: ModelTier): OpenRouterModel | null;
+    /**
+     * Per-model and per-tier temperature profiles.
+     * Reasoning/thinking models REQUIRE temperature=1.0 (API enforces).
+     * Code/structured tasks want low temp; creative analysis wants higher.
+     */
+    private getTemperature;
+    /**
+     * Per-tier max token budgets.
+     * Orchestrators get generous budgets; free workers get minimal.
+     */
+    private getTokenBudget;
     /**
      * Build a full ModelConfig chain from the tiered pool.
      * Uses user-configured models from env first, then fills with tiered picks.
      */
     buildModelChain(userModels: string[]): ModelConfig[];
     /** Build a single ModelConfig, preferring direct provider when possible. */
-    buildConfig(modelId: string, maxTokens: number, temperature: number): ModelConfig | null;
+    buildConfig(modelId: string, maxTokens: number, temperature: number, tier?: ModelTier): ModelConfig | null;
     recordFailure(modelId: string): void;
     recordSuccess(modelId: string, latencyMs: number): void;
     /** Mark a model as permanently deprecated (404, model removed). */

package/dist/models/ModelRegistry.js

@@ -20,13 +20,25 @@ import { Type } from "@sinclair/typebox";
  * are met. Fallback is "worker".
  */
 const TIER_RULES = [
-    // Orchestrator: top-tier reasoning models
-    { tier: "orchestrator", pattern: /claude.*opus|o1-pro|gemini-2\.[5-9]-pro|gpt-4\.5|deepseek-v4-671b/i, notFree: true },
-    // Analyst: strong reasoning, moderate cost
-    { tier: "analyst", pattern: /claude.*sonnet|gpt-4o(?!-mini)|gemini-(?!.*flash)|gemma-4.*(2[7-9]b|3[0-9]b)|deepseek.*(?:r1|chat)|grok.*(?:build|3)/i, notFree: true },
-    // Free tier: zero-cost models
+    // ── Orchestrator: top-tier reasoning models (2024-2026) ──────────────────
+    // Claude Opus 4.x, GPT-5.x flagship/pro, Gemini 3.x Pro, DeepSeek V4 Pro,
+    // Grok 4.x, o3-pro/o4, Qwen3 Max variants, Kimi K2
+    {
+        tier: "orchestrator",
+        pattern: /claude.*opus[-.]?4|gpt-5\.[3-9].*pro|gpt-5\.5(?!-nano|-mini)|o3-pro|o4[-.]|gemini-3\.[0-9]-pro|deepseek-v4-pro|grok[-.]?4\.[0-9]|qwen3.*max(?!-thinking)|qwen3\.6-max|kimi-k2(?!-thinking)/i,
+        notFree: true,
+    },
+    // ── Analyst: strong reasoning, moderate cost (2024-2026) ─────────────────
+    // Claude Sonnet 4.x, GPT-5.x mid-tier, Gemini 3.x Flash,
+    // DeepSeek V4 (non-pro), Grok 3.x, Qwen3 235B, Mistral Medium 3
+    {
+        tier: "analyst",
+        pattern: /claude.*sonnet[-.]?4|gpt-5\.[0-4](?!.*-pro)|gpt-5\.5-mini|gemini-3\.[0-9]-flash|deepseek-v4(?!-pro)|grok[-.]?3|qwen3-235b|qwen3\.6-(?!max)|mistral-medium-3|claude.*haiku[-.]?4/i,
+        notFree: true,
+    },
+    // ── Free tier: zero-cost models ──────────────────────────────────────────
     { tier: "free", pattern: /:free$|openrouter\/free/i },
-    // Default: worker
+    // ── Worker: everything else (default) ────────────────────────────────────
     { tier: "worker", pattern: /.*/ },
 ];
 export function classifyModel(model) {
@@ -155,13 +167,70 @@ export class ModelRegistry {
         }
         return null;
     }
+    /**
+     * Per-model and per-tier temperature profiles.
+     * Reasoning/thinking models REQUIRE temperature=1.0 (API enforces).
+     * Code/structured tasks want low temp; creative analysis wants higher.
+     */
+    getTemperature(modelId, tier, envTemp) {
+        // Exact model overrides (reasoning models MUST be 1.0)
+        const MODEL_TEMPS = {
+            // OpenAI o-series — no temperature param supported at all
+            "openai/o3": 1.0,
+            "openai/o3-pro": 1.0,
+            "openai/o3-mini": 1.0,
+            "openai/o4": 1.0,
+            "openai/o4-mini": 1.0,
+            // Thinking variants require 1.0
+            "qwen/qwen3-max-thinking": 1.0,
+            "qwen/qwen3.6-max-preview": 1.0,
+            "qwen/qwen3-235b-a22b-thinking-2507": 1.0,
+            "moonshotai/kimi-k2-thinking": 1.0,
+            "arcee-ai/trinity-large-thinking": 1.0,
+        };
+        if (MODEL_TEMPS[modelId] !== undefined)
+            return MODEL_TEMPS[modelId];
+        // Any model with "thinking" in the ID needs 1.0
+        if (/thinking/i.test(modelId))
+            return 1.0;
+        // Tier defaults
+        const TIER_TEMPS = {
+            orchestrator: 0.7, // balanced reasoning
+            analyst: 0.5, // more deterministic for analysis
+            worker: 0.3, // deterministic for structured tasks
+            free: 0.5,
+        };
+        // User env var overrides tier defaults (but not model-specific overrides)
+        if (process.env.TEMPERATURE)
+            return envTemp;
+        return TIER_TEMPS[tier] ?? 0.7;
+    }
+    /**
+     * Per-tier max token budgets.
+     * Orchestrators get generous budgets; free workers get minimal.
+     */
+    getTokenBudget(modelId, tier, envMax) {
+        const TIER_BUDGETS = {
+            orchestrator: 32_768,
+            analyst: 16_384,
+            worker: 4_096,
+            free: 2_048,
+        };
+        // Thinking models need at least 16K for the thinking budget
+        const isThinking = /thinking|o3|o4/i.test(modelId);
+        const base = isThinking
+            ? Math.max(16_384, TIER_BUDGETS[tier])
+            : TIER_BUDGETS[tier];
+        // User env var is a hard cap
+        return Math.min(base, envMax);
+    }
     /**
      * Build a full ModelConfig chain from the tiered pool.
      * Uses user-configured models from env first, then fills with tiered picks.
      */
     buildModelChain(userModels) {
         const env = process.env;
-        const tokens = parseInt(env.MAX_TOKENS ?? "8192");
+        const tokens = parseInt(env.MAX_TOKENS ?? "99999"); // now used as cap, not target
         const temp = parseFloat(env.TEMPERATURE ?? "0.7");
         const results = [];
         // User-specified models always come first
@@ -196,11 +265,38 @@ export class ModelRegistry {
         return results.slice(0, 5);
     }
     /** Build a single ModelConfig, preferring direct provider when possible. */
-    buildConfig(modelId, maxTokens, temperature) {
+    buildConfig(modelId, maxTokens, temperature, tier) {
+        // Apply per-model/per-tier temperature and token budget
+        const resolvedTier = tier ?? this.getTier(modelId);
         const env = process.env;
+        const envMax = parseInt(env.MAX_TOKENS ?? "99999");
+        const envTemp = parseFloat(env.TEMPERATURE ?? "0.7");
+        temperature = this.getTemperature(modelId, resolvedTier, envTemp);
+        maxTokens = this.getTokenBudget(modelId, resolvedTier, Math.min(maxTokens, envMax));
         // Direct Anthropic routing (cheaper — no OR markup)
         if (modelId.startsWith("anthropic/") && env.ANTHROPIC_API_KEY) {
-            const model = modelId.replace("anthropic/", "");
+            const stripped = modelId.replace("anthropic/", "");
+            // OpenRouter model IDs differ from Anthropic API IDs — map them correctly
+            const ANTHROPIC_API_ALIASES = {
+                // Opus 4.x
+                "claude-opus-4.7": "claude-opus-4-20260101",
+                "claude-opus-4.7-fast": "claude-opus-4-20260101",
+                "claude-opus-4.6": "claude-opus-4-20251120",
+                "claude-opus-4.6-fast": "claude-opus-4-20251120",
+                "claude-opus-4.5": "claude-opus-4-20251015",
+                "claude-opus-4": "claude-opus-4-20250514",
+                // Sonnet 4.x
+                "claude-sonnet-4.6": "claude-sonnet-4-20251120",
+                "claude-sonnet-4.5": "claude-sonnet-4-20251015",
+                "claude-sonnet-4": "claude-sonnet-4-20250514",
+                // Haiku 4.x
+                "claude-haiku-4.5": "claude-haiku-4-20251015",
+                "claude-haiku-4": "claude-haiku-4-20250514",
+                // Legacy aliases (safe to keep)
+                "claude-3-5-sonnet-20241022": "claude-3-5-sonnet-20241022",
+                "claude-3-haiku-20240307": "claude-3-haiku-20240307",
+            };
+            const model = ANTHROPIC_API_ALIASES[stripped] ?? stripped;
             return {
                 baseUrl: "https://api.anthropic.com/v1",
                 apiKey: env.ANTHROPIC_API_KEY,

package/dist/runner/AgentRunner.d.ts

@@ -11,6 +11,9 @@ import type { SessionManager } from "../session/SessionManager.js";
 import type { SessionContext } from "../api/ExtensionAPI.js";
 import type { ModelRegistry } from "../models/ModelRegistry.js";
 import type { CostTracker } from "../models/CostTracker.js";
+import type { GoalManager } from "../session/GoalManager.js";
+import type { ContextStore } from "../session/ContextStore.js";
+import { Tracer } from "../telemetry/Tracer.js";
 export type RunnerEvent = {
     type: "text_delta";
     text: string;
@@ -42,6 +45,13 @@ export type RunnerEvent = {
 } | {
     type: "error";
     message: string;
+}
+/** #10: Approval gate — TUI pauses and waits for user y/n */
+ | {
+    type: "approval_request";
+    toolName: string;
+    args: string;
+    approve: (yes: boolean) => void;
 };
 export type RunnerEventHandler = (event: RunnerEvent) => void;
 export declare class AgentRunner {
@@ -50,12 +60,17 @@ export declare class AgentRunner {
     private onEvent;
     private sessionCtx;
     private effectLevel;
+    private goalManager?;
+    private contextStore?;
     private modelChain;
     private dispatcher;
     private swarmRouter;
     private modelRegistry?;
     private costTracker?;
-    constructor(registry: Registry, session: SessionManager, onEvent: RunnerEventHandler, sessionCtx: SessionContext, effectLevel?: string, modelReg?: ModelRegistry, costTracker?: CostTracker);
+    private abortController;
+    /** #25: Cancel the current in-flight stream immediately */
+    abort(): void;
+    constructor(registry: Registry, session: SessionManager, onEvent: RunnerEventHandler, sessionCtx: SessionContext, effectLevel?: string, modelReg?: ModelRegistry, costTracker?: CostTracker, goalManager?: GoalManager | undefined, contextStore?: ContextStore | undefined);
     /**
      * Live reconfigure effect level without recreating the runner.
      * Called by the /effect REPL command immediately on each invocation so that
@@ -64,7 +79,9 @@ export declare class AgentRunner {
     setEffectLevel(level: string): void;
     /** Run one user turn — may invoke multiple tool rounds and model fallbacks internally */
     run(userMessage: string): Promise<void>;
+    private buildLiveContext;
+    private buildDynamicSystemSuffix;
     private runSwarm;
-    runSingleAgent(): Promise<void>;
+    runSingleAgent(userMessage?: string, tracer?: Tracer): Promise<void>;
 }
 //# sourceMappingURL=AgentRunner.d.ts.map