skyloom 1.13.6 → 1.13.8

package/src/core/mcp_server.ts

@@ -1,176 +1,176 @@
-/**
- * MCP server — expose Skyloom agents as tools for external MCP clients.
- *
- * Runs over stdio (JSON-RPC 2.0). Any MCP-compatible client (Claude Desktop,
- * Zed, Continue, etc.) can connect and call Skyloom agents as tools.
- *
- * Registered tools:
- * - mcp_chat   — single-turn question to any agent
- * - mcp_task   — multi-agent orchestration
- * - list_agents — return available agent names + specialties
- */
-
-import * as readline from 'readline';
-import { createSystemContext, orchestrateTask } from './factory';
-
-const MCP_VERSION = '2025-03-26';
-const SERVER_INFO = { name: 'skyloom', version: '1.4.0' };
-
-const TOOL_DEFS = [
-  {
-    name: 'mcp_chat',
-    description: 'Ask a Skyloom agent a question. Use fair for companionship, fog for research, rain for code, frost for review, dew for ops, snow for planning.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        agent: { type: 'string', description: 'Agent name: fog/rain/frost/snow/dew/fair (default: fair)' },
-        message: { type: 'string', description: 'What to ask the agent' },
-      },
-      required: ['message'],
-    },
-  },
-  {
-    name: 'mcp_task',
-    description: 'Run multi-agent orchestration. Snow plans, then agents collaborate. Use for complex multi-step goals.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        goal: { type: 'string', description: 'The goal to accomplish' },
-      },
-      required: ['goal'],
-    },
-  },
-  {
-    name: 'list_agents',
-    description: 'List available Skyloom agents and their specialties.',
-    inputSchema: { type: 'object', properties: {}, required: [] },
-  },
-];
-
-export class MCPServer {
-  private initialized = false;
-  private ctx: any = null;
-  private agents: Map<string, any> = new Map();
-
-  async run(): Promise<void> {
-    const rl = readline.createInterface({ input: process.stdin });
-    for await (const line of rl) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      try {
-        const msg = JSON.parse(trimmed);
-        const resp = await this.handle(msg);
-        if (resp !== null) {
-          process.stdout.write(JSON.stringify(resp) + '\n');
-        }
-      } catch {
-        // Ignore parse errors
-      }
-    }
-  }
-
-  private async handle(msg: Record<string, any>): Promise<Record<string, any> | null> {
-    const mid = msg.id;
-    const method = msg.method || '';
-    const params = msg.params || {};
-
-    // Notifications — no response
-    if (method.startsWith('notifications/')) return null;
-
-    try {
-      let result: any;
-      if (method === 'initialize') {
-        result = await this.init();
-      } else if (method === 'tools/list') {
-        result = { tools: TOOL_DEFS };
-      } else if (method === 'tools/call') {
-        result = await this.toolsCall(params);
-      } else {
-        return { jsonrpc: '2.0', id: mid, error: { code: -32601, message: `unknown method: ${method}` } };
-      }
-      return { jsonrpc: '2.0', id: mid, result };
-    } catch (e: any) {
-      return { jsonrpc: '2.0', id: mid, error: { code: -32603, message: e.message || String(e) } };
-    }
-  }
-
-  private async init(): Promise<Record<string, any>> {
-    this.initialized = true;
-    return { protocolVersion: MCP_VERSION, capabilities: { tools: {} }, serverInfo: SERVER_INFO };
-  }
-
-  private async ensureCtx(): Promise<void> {
-    if (!this.ctx) {
-      this.ctx = createSystemContext();
-      await this.ctx.initAll();
-      this.agents = this.ctx.agentMap;
-    }
-  }
-
-  private async toolsCall(params: Record<string, any>): Promise<Record<string, any>> {
-    const name = params.name || '';
-    const args = params.arguments || {};
-
-    if (name === 'list_agents') return this.handleListAgents();
-    if (name === 'mcp_chat') return this.handleChat(args);
-    if (name === 'mcp_task') return this.handleTask(args);
-    return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
-  }
-
-  private async handleListAgents(): Promise<Record<string, any>> {
-    await this.ensureCtx();
-    const lines = ['Available agents:'];
-    for (const [name, agent] of this.agents) {
-      lines.push(`- ${name} (${agent.displayName}): ${agent.specialty}`);
-    }
-    return { content: [{ type: 'text', text: lines.join('\n') }] };
-  }
-
-  private async handleChat(args: Record<string, any>): Promise<Record<string, any>> {
-    const agentName = String(args.agent || 'fair').trim().toLowerCase();
-    const message = String(args.message || '').trim();
-    if (!message) {
-      return { content: [{ type: 'text', text: 'Error: message is required' }], isError: true };
-    }
-
-    await this.ensureCtx();
-    const agent = this.agents.get(agentName);
-    if (!agent) {
-      return { content: [{ type: 'text', text: `Unknown agent '${agentName}'. Available: ${[...this.agents.keys()].join(', ')}` }], isError: true };
-    }
-
-    try {
-      const reply = await agent.chat(message);
-      return { content: [{ type: 'text', text: reply }] };
-    } catch (e: any) {
-      return { content: [{ type: 'text', text: `Agent error: ${e.message || e}` }], isError: true };
-    }
-  }
-
-  private async handleTask(args: Record<string, any>): Promise<Record<string, any>> {
-    const goal = String(args.goal || '').trim();
-    if (!goal) {
-      return { content: [{ type: 'text', text: 'Error: goal is required' }], isError: true };
-    }
-
-    await this.ensureCtx();
-    try {
-      const [_tasks, results, summary] = await orchestrateTask(goal, this.agents);
-      const ok = results.filter(r => r.success).length;
-      const total = results.length;
-      const contentLines = [`[${ok}/${total} tasks completed]`];
-      for (const r of results) {
-        contentLines.push(`## ${r.agent}: ${r.description}\n${r.content || '(no content)'}`);
-      }
-      if (summary) contentLines.push(`\n${summary}`);
-      return { content: [{ type: 'text', text: contentLines.join('\n') }] };
-    } catch (e: any) {
-      return { content: [{ type: 'text', text: `Task error: ${e.message || e}` }], isError: true };
-    }
-  }
-}
-
-export async function startMCPServer(): Promise<void> {
-  const server = new MCPServer();
-  await server.run();
-}
+/**
+ * MCP server — expose Skyloom agents as tools for external MCP clients.
+ *
+ * Runs over stdio (JSON-RPC 2.0). Any MCP-compatible client (Claude Desktop,
+ * Zed, Continue, etc.) can connect and call Skyloom agents as tools.
+ *
+ * Registered tools:
+ * - mcp_chat   — single-turn question to any agent
+ * - mcp_task   — multi-agent orchestration
+ * - list_agents — return available agent names + specialties
+ */
+
+import * as readline from 'readline';
+import { createSystemContext, orchestrateTask } from './factory';
+
+const MCP_VERSION = '2025-03-26';
+const SERVER_INFO = { name: 'skyloom', version: '1.4.0' };
+
+const TOOL_DEFS = [
+  {
+    name: 'mcp_chat',
+    description: 'Ask a Skyloom agent a question. Use fair for companionship, fog for research, rain for code, frost for review, dew for ops, snow for planning.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        agent: { type: 'string', description: 'Agent name: fog/rain/frost/snow/dew/fair (default: fair)' },
+        message: { type: 'string', description: 'What to ask the agent' },
+      },
+      required: ['message'],
+    },
+  },
+  {
+    name: 'mcp_task',
+    description: 'Run multi-agent orchestration. Snow plans, then agents collaborate. Use for complex multi-step goals.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        goal: { type: 'string', description: 'The goal to accomplish' },
+      },
+      required: ['goal'],
+    },
+  },
+  {
+    name: 'list_agents',
+    description: 'List available Skyloom agents and their specialties.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+];
+
+export class MCPServer {
+  private initialized = false;
+  private ctx: any = null;
+  private agents: Map<string, any> = new Map();
+
+  async run(): Promise<void> {
+    const rl = readline.createInterface({ input: process.stdin });
+    for await (const line of rl) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const msg = JSON.parse(trimmed);
+        const resp = await this.handle(msg);
+        if (resp !== null) {
+          process.stdout.write(JSON.stringify(resp) + '\n');
+        }
+      } catch {
+        // Ignore parse errors
+      }
+    }
+  }
+
+  private async handle(msg: Record<string, any>): Promise<Record<string, any> | null> {
+    const mid = msg.id;
+    const method = msg.method || '';
+    const params = msg.params || {};
+
+    // Notifications — no response
+    if (method.startsWith('notifications/')) return null;
+
+    try {
+      let result: any;
+      if (method === 'initialize') {
+        result = await this.init();
+      } else if (method === 'tools/list') {
+        result = { tools: TOOL_DEFS };
+      } else if (method === 'tools/call') {
+        result = await this.toolsCall(params);
+      } else {
+        return { jsonrpc: '2.0', id: mid, error: { code: -32601, message: `unknown method: ${method}` } };
+      }
+      return { jsonrpc: '2.0', id: mid, result };
+    } catch (e: any) {
+      return { jsonrpc: '2.0', id: mid, error: { code: -32603, message: e.message || String(e) } };
+    }
+  }
+
+  private async init(): Promise<Record<string, any>> {
+    this.initialized = true;
+    return { protocolVersion: MCP_VERSION, capabilities: { tools: {} }, serverInfo: SERVER_INFO };
+  }
+
+  private async ensureCtx(): Promise<void> {
+    if (!this.ctx) {
+      this.ctx = createSystemContext();
+      await this.ctx.initAll();
+      this.agents = this.ctx.agentMap;
+    }
+  }
+
+  private async toolsCall(params: Record<string, any>): Promise<Record<string, any>> {
+    const name = params.name || '';
+    const args = params.arguments || {};
+
+    if (name === 'list_agents') return this.handleListAgents();
+    if (name === 'mcp_chat') return this.handleChat(args);
+    if (name === 'mcp_task') return this.handleTask(args);
+    return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+  }
+
+  private async handleListAgents(): Promise<Record<string, any>> {
+    await this.ensureCtx();
+    const lines = ['Available agents:'];
+    for (const [name, agent] of this.agents) {
+      lines.push(`- ${name} (${agent.displayName}): ${agent.specialty}`);
+    }
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+  }
+
+  private async handleChat(args: Record<string, any>): Promise<Record<string, any>> {
+    const agentName = String(args.agent || 'fair').trim().toLowerCase();
+    const message = String(args.message || '').trim();
+    if (!message) {
+      return { content: [{ type: 'text', text: 'Error: message is required' }], isError: true };
+    }
+
+    await this.ensureCtx();
+    const agent = this.agents.get(agentName);
+    if (!agent) {
+      return { content: [{ type: 'text', text: `Unknown agent '${agentName}'. Available: ${[...this.agents.keys()].join(', ')}` }], isError: true };
+    }
+
+    try {
+      const reply = await agent.chat(message);
+      return { content: [{ type: 'text', text: reply }] };
+    } catch (e: any) {
+      return { content: [{ type: 'text', text: `Agent error: ${e.message || e}` }], isError: true };
+    }
+  }
+
+  private async handleTask(args: Record<string, any>): Promise<Record<string, any>> {
+    const goal = String(args.goal || '').trim();
+    if (!goal) {
+      return { content: [{ type: 'text', text: 'Error: goal is required' }], isError: true };
+    }
+
+    await this.ensureCtx();
+    try {
+      const [_tasks, results, summary] = await orchestrateTask(goal, this.agents);
+      const ok = results.filter(r => r.success).length;
+      const total = results.length;
+      const contentLines = [`[${ok}/${total} tasks completed]`];
+      for (const r of results) {
+        contentLines.push(`## ${r.agent}: ${r.description}\n${r.content || '(no content)'}`);
+      }
+      if (summary) contentLines.push(`\n${summary}`);
+      return { content: [{ type: 'text', text: contentLines.join('\n') }] };
+    } catch (e: any) {
+      return { content: [{ type: 'text', text: `Task error: ${e.message || e}` }], isError: true };
+    }
+  }
+}
+
+export async function startMCPServer(): Promise<void> {
+  const server = new MCPServer();
+  await server.run();
+}

package/src/core/model_config.ts

@@ -0,0 +1,157 @@
+/**
+ * 模型配置管理 — unified default with optional per-agent overrides.
+ *
+ * Resolution order (already honored by LLMClient.getModel / getApiKey):
+ *   model:   agents.<name>.model  →  default_model
+ *   apiKey:  agents.<name>.api_key → env var → api_keys.<provider>
+ *
+ * This module provides the write path: mutate the *runtime* config object
+ * (shared by reference across LLMClient and every agent, so changes apply to
+ * the very next call — agents can hot-swap their own model mid-session) and
+ * persist a narrow patch to ~/.skyloom/config.yaml (never the merged config,
+ * so defaults don't leak into the user file).
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'yaml';
+import { USER_CONFIG_DIR } from './config';
+import { listProviders, modelsFor, validateModel } from './catalog';
+
+export interface ModelDescription {
+  model: string;
+  /** 'agent' = per-agent override, 'unified' = default_model. */
+  source: 'agent' | 'unified';
+  provider: string | null;
+  /** Where the API key would come from for this agent. */
+  keySource: 'agent' | 'env' | 'global' | 'missing';
+}
+
+/** Find which provider a catalog model id belongs to. */
+export function providerOfModel(modelId: string): string | null {
+  if (modelId.includes('/')) return modelId.split('/')[0];
+  for (const p of listProviders()) {
+    if (modelsFor(p).some(m => m.id === modelId)) return p;
+  }
+  return null;
+}
+
+/** Read-mutate-write the raw user config file (narrow patch). */
+function patchUserConfig(mutate: (cfg: any) => void, dir: string = USER_CONFIG_DIR): void {
+  const file = path.join(dir, 'config.yaml');
+  let cfg: any = {};
+  if (fs.existsSync(file)) {
+    try { cfg = yaml.parse(fs.readFileSync(file, 'utf-8')) || {}; } catch { cfg = {}; }
+  }
+  mutate(cfg);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(file, yaml.stringify(cfg), 'utf-8');
+}
+
+/** Apply the same mutation to the in-memory runtime config (hot effect). */
+function ensureAgentSlot(runtimeConfig: any, agentName: string): any {
+  if (!runtimeConfig.agents) runtimeConfig.agents = {};
+  if (!runtimeConfig.agents[agentName]) runtimeConfig.agents[agentName] = {};
+  return runtimeConfig.agents[agentName];
+}
+
+export interface SetModelResult {
+  ok: boolean;
+  suggestions: string[];
+  provider: string | null;
+}
+
+/** Per-agent model override (独立配置). */
+export function setAgentModel(
+  runtimeConfig: any,
+  agentName: string,
+  modelId: string,
+  dir?: string
+): SetModelResult {
+  const v = validateModel(modelId);
+  if (!v.ok) return { ok: false, suggestions: v.suggestions, provider: null };
+  const provider = providerOfModel(modelId);
+
+  const slot = ensureAgentSlot(runtimeConfig, agentName);
+  slot.model = modelId;
+  if (provider) slot.provider = provider;
+
+  patchUserConfig(cfg => {
+    if (!cfg.agents) cfg.agents = {};
+    if (!cfg.agents[agentName]) cfg.agents[agentName] = {};
+    cfg.agents[agentName].model = modelId;
+    if (provider) cfg.agents[agentName].provider = provider;
+  }, dir);
+  return { ok: true, suggestions: [], provider };
+}
+
+/** Remove the per-agent override — the agent follows the unified default again. */
+export function clearAgentModel(runtimeConfig: any, agentName: string, dir?: string): void {
+  if (runtimeConfig.agents?.[agentName]) {
+    delete runtimeConfig.agents[agentName].model;
+    delete runtimeConfig.agents[agentName].provider;
+  }
+  patchUserConfig(cfg => {
+    if (cfg.agents?.[agentName]) {
+      delete cfg.agents[agentName].model;
+      delete cfg.agents[agentName].provider;
+      if (Object.keys(cfg.agents[agentName]).length === 0) delete cfg.agents[agentName];
+    }
+  }, dir);
+}
+
+/** 统一配置 — the default model every agent without an override uses. */
+export function setUnifiedModel(runtimeConfig: any, modelId: string, dir?: string): SetModelResult {
+  const v = validateModel(modelId);
+  if (!v.ok) return { ok: false, suggestions: v.suggestions, provider: null };
+  const provider = providerOfModel(modelId);
+
+  runtimeConfig.default_model = modelId;
+  if (provider) runtimeConfig.default_provider = provider;
+
+  patchUserConfig(cfg => {
+    cfg.default_model = modelId;
+    if (provider) cfg.default_provider = provider;
+  }, dir);
+  return { ok: true, suggestions: [], provider };
+}
+
+/** Per-agent API key (独立 key；该 agent 的所有调用优先用它). */
+export function setAgentApiKey(runtimeConfig: any, agentName: string, key: string, dir?: string): void {
+  ensureAgentSlot(runtimeConfig, agentName).api_key = key;
+  patchUserConfig(cfg => {
+    if (!cfg.agents) cfg.agents = {};
+    if (!cfg.agents[agentName]) cfg.agents[agentName] = {};
+    cfg.agents[agentName].api_key = key;
+  }, dir);
+}
+
+export function clearAgentApiKey(runtimeConfig: any, agentName: string, dir?: string): void {
+  if (runtimeConfig.agents?.[agentName]) delete runtimeConfig.agents[agentName].api_key;
+  patchUserConfig(cfg => {
+    if (cfg.agents?.[agentName]) delete cfg.agents[agentName].api_key;
+  }, dir);
+}
+
+/** Describe how an agent's model & key resolve right now. */
+export function describeAgentLLM(runtimeConfig: any, agentName: string, dir: string = USER_CONFIG_DIR): ModelDescription {
+  const agentCfg = runtimeConfig.agents?.[agentName] || {};
+  const model: string = agentCfg.model
+    || runtimeConfig.default_model
+    || runtimeConfig.llm?.default_model
+    || 'gpt-4o';
+  const source: 'agent' | 'unified' = agentCfg.model ? 'agent' : 'unified';
+  const provider = providerOfModel(model);
+
+  let keySource: ModelDescription['keySource'] = 'missing';
+  if (agentCfg.api_key) keySource = 'agent';
+  else if (provider && process.env[`${provider.toUpperCase()}_API_KEY`]) keySource = 'env';
+  else {
+    try {
+      const file = path.join(dir, 'config.yaml');
+      const cfg = fs.existsSync(file) ? yaml.parse(fs.readFileSync(file, 'utf-8')) || {} : {};
+      if (provider && cfg.api_keys?.[provider]) keySource = 'global';
+    } catch { /* missing */ }
+  }
+  return { model, source, provider, keySource };
+}