lynkr 9.9.1 → 9.10.0

package/src/agents/executor.js

@@ -1,457 +0,0 @@
-const logger = require("../logger");
-const { executeToolCall, listTools } = require("../tools");
-const { invokeModel } = require("../clients/databricks");
-const { STANDARD_TOOLS } = require("../clients/standard-tools");
-const ContextManager = require("./context-manager");
-const Skillbook = require("./skillbook");
-const Reflector = require("./reflector");
-
-const contextManager = new ContextManager();
-
-class SubagentExecutor {
-  /**
-   * @param {Object} [options]
-   * @param {Object} [options.definitionLoader] - Agent definition loader. When
-   *   provided, newly-learned skills are re-injected into agent prompts live
-   *   (within the running process). Optional so the executor still works
-   *   standalone (e.g. in tests); without it, learning still persists to disk
-   *   and is picked up on the next process start.
-   */
-  constructor({ definitionLoader = null } = {}) {
-    this.definitionLoader = definitionLoader;
-  }
-
-  /**
-   * Execute a single subagent
-   * @param {Object} agentDef - Agent definition
-   * @param {string} taskPrompt - Task to perform
-   * @param {Object} options - sessionId, mainContext, etc.
-   * @returns {Promise<Object>} - { success, result, stats }
-   */
-  async execute(agentDef, taskPrompt, options = {}) {
-    // Create fresh isolated context
-    const context = contextManager.createSubagentContext(
-      agentDef,
-      taskPrompt,
-      options.mainContext
-    );
-
-    // Store client CWD in context for tool execution
-    context.cwd = options.cwd;
-
-    try {
-      // Set timeout
-      const timeout = options.timeout || 120000; // 2 minutes
-      const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => reject(new Error("Subagent timeout")), timeout);
-      });
-
-      const executionPromise = this._runAgentLoop(context, options.sessionId);
-
-      await Promise.race([executionPromise, timeoutPromise]);
-
-      // Extract final result (summary only, not intermediate steps)
-      const finalResult = this._extractFinalResult(context);
-
-      contextManager.completeExecution(context, finalResult);
-
-      // Learn from successful execution (async, non-blocking)
-      this._learnFromExecution(context, true).catch(err => {
-        logger.warn({
-          agentType: agentDef.name,
-          error: err.message
-        }, "Failed to learn from execution");
-      });
-
-      return {
-        success: true,
-        result: finalResult,
-        stats: {
-          agentId: context.agentId,
-          steps: context.steps,
-          durationMs: Date.now() - context.startTime,
-          inputTokens: context.inputTokens,
-          outputTokens: context.outputTokens
-        }
-      };
-
-    } catch (error) {
-      contextManager.failExecution(context, error);
-
-      // Learn from failed execution (async, non-blocking)
-      this._learnFromExecution(context, false).catch(err => {
-        logger.debug({
-          agentType: agentDef.name,
-          error: err.message
-        }, "Failed to learn from failed execution");
-      });
-
-      return {
-        success: false,
-        error: error.message,
-        stats: {
-          agentId: context.agentId,
-          steps: context.steps,
-          durationMs: Date.now() - context.startTime
-        }
-      };
-    }
-  }
-
-  /**
-   * Run agent loop (similar to main orchestrator but isolated)
-   */
-  async _runAgentLoop(context, sessionId) {
-    while (context.steps < context.maxSteps && !context.terminated) {
-      context.steps++;
-
-      logger.debug({
-        agentId: context.agentId,
-        step: context.steps,
-        messageCount: context.messages.length
-      }, "Subagent step starting");
-
-      // Call model with filtered tools
-      const response = await this._callModel(context);
-
-      // Update token usage
-      context.inputTokens += response.usage?.input_tokens || 0;
-      context.outputTokens += response.usage?.output_tokens || 0;
-
-      // Check stop reason
-      if (response.stop_reason === "end_turn" || response.stop_reason === "stop_sequence") {
-        // Agent finished - extract result
-        context.result = this._extractTextFromContent(response.content);
-        context.terminated = true;
-
-        contextManager.addMessage(context, {
-          role: "assistant",
-          content: response.content
-        });
-
-        break;
-      }
-
-      // Execute tool calls if any
-      if (response.stop_reason === "tool_use") {
-        await this._executeTools(context, response.content, sessionId);
-      } else {
-        logger.warn({
-          agentId: context.agentId,
-          stopReason: response.stop_reason
-        }, "Unexpected stop reason in subagent");
-
-        context.result = this._extractTextFromContent(response.content);
-        context.terminated = true;
-        break;
-      }
-    }
-
-    if (context.steps >= context.maxSteps && !context.terminated) {
-      logger.warn({
-        agentId: context.agentId,
-        maxSteps: context.maxSteps
-      }, "Subagent reached max steps");
-
-      context.result = "Subagent incomplete - reached maximum steps";
-    }
-  }
-
-  /**
-   * Call model with subagent context
-   */
-  async _callModel(context) {
-    const payload = {
-      model: this._resolveModel(context.model),
-      messages: context.messages,
-      max_tokens: 4096,
-      temperature: 0.3
-    };
-
-    // Add filtered tools for subagent (based on allowedTools)
-    const filteredTools = this._getFilteredTools(context.allowedTools);
-    if (filteredTools.length > 0) {
-      payload.tools = filteredTools;
-    }
-
-    // Determine provider based on model family.
-    // Subagents should use the currently configured MODEL_PROVIDER and avoid
-    // hard-fallbacks to Azure when Azure is not selected/configured.
-    let forceProvider = null;
-    const modelLower = String(payload.model || "").toLowerCase();
-    const isClaudeFamilyModel =
-      modelLower.includes("claude") ||
-      modelLower.includes("sonnet") ||
-      modelLower.includes("haiku") ||
-      modelLower.includes("opus");
-    const isGptFamilyModel = modelLower.includes("gpt");
-
-    if (isClaudeFamilyModel || isGptFamilyModel) {
-      const config = require('../config');
-      // `type` is the canonical key; `provider` kept as legacy fallback.
-      forceProvider = config.modelProvider?.type || config.modelProvider?.provider || null;
-    }
-
-    logger.debug({
-      agentId: context.agentId,
-      model: payload.model,
-      forceProvider,
-      messageCount: context.messages.length,
-      toolCount: filteredTools.length,
-      toolNames: filteredTools.map(t => t.name)
-    }, "Calling model for subagent");
-
-    // Use invokeModel with forceProvider to ensure correct model routing
-    const response = await invokeModel(payload, { forceProvider });
-
-    if (!response.json) {
-      throw new Error("Invalid model response");
-    }
-
-    return response.json;
-  }
-
-  /**
-   * Execute tools (with restrictions)
-   */
-  async _executeTools(context, content, sessionId) {
-    const toolUseBlocks = content.filter(block => block.type === "tool_use");
-
-    if (toolUseBlocks.length === 0) {
-      return;
-    }
-
-    // Add assistant message with tool calls
-    contextManager.addMessage(context, {
-      role: "assistant",
-      content: content
-    });
-
-    // Execute each tool (sequentially for now, can parallelize later)
-    const toolResults = [];
-
-    for (const toolUse of toolUseBlocks) {
-      const toolStart = Date.now();
-
-      try {
-        // Check if tool is allowed
-        if (context.allowedTools.length > 0 && !this._isToolAllowed(toolUse.name, context.allowedTools)) {
-          throw new Error(`Tool ${toolUse.name} not allowed for agent ${context.agentName}`);
-        }
-
-        // CRITICAL: Block Task tool for subagents (prevents recursion)
-        if (toolUse.name === "Task") {
-          throw new Error("Subagents cannot spawn other subagents");
-        }
-
-        logger.debug({
-          agentId: context.agentId,
-          step: context.steps,
-          toolName: toolUse.name
-        }, "Subagent executing tool");
-
-        // Execute tool
-        const result = await executeToolCall({
-          name: toolUse.name,
-          arguments: toolUse.input
-        }, {
-          sessionId: sessionId,
-          agentId: context.agentId,
-          cwd: context.cwd,
-          isSubagent: true
-        });
-
-        const toolDuration = Date.now() - toolStart;
-
-        // Record in transcript
-        contextManager.recordToolCall(
-          context,
-          toolUse.name,
-          toolUse.input,
-          result.content,
-          null
-        );
-
-        toolResults.push({
-          type: "tool_result",
-          tool_use_id: toolUse.id,
-          content: result.content
-        });
-
-      } catch (error) {
-        const toolDuration = Date.now() - toolStart;
-
-        logger.warn({
-          agentId: context.agentId,
-          toolName: toolUse.name,
-          error: error.message
-        }, "Subagent tool execution failed");
-
-        contextManager.recordToolCall(
-          context,
-          toolUse.name,
-          toolUse.input,
-          null,
-          error
-        );
-
-        toolResults.push({
-          type: "tool_result",
-          tool_use_id: toolUse.id,
-          content: `Error: ${error.message}`,
-          is_error: true
-        });
-      }
-    }
-
-    // Add tool results as user message
-    contextManager.addMessage(context, {
-      role: "user",
-      content: toolResults
-    });
-  }
-
-  /**
-   * Get filtered tools for subagent (based on allowedTools)
-   * Returns tools in Anthropic format (conversion to OpenAI happens in invokeModel)
-   */
-  _getFilteredTools(allowedTools) {
-    if (!allowedTools || allowedTools.length === 0) {
-      return [];
-    }
-
-    // Filter STANDARD_TOOLS based on allowedTools list
-    // Exclude Task tool (subagents cannot spawn other subagents)
-    return STANDARD_TOOLS.filter(tool => {
-      if (tool.name === "Task") {
-        return false; // Never allow subagents to spawn subagents
-      }
-      return this._isToolAllowed(tool.name, allowedTools);
-    });
-  }
-
-  /**
-   * Check if tool is allowed (case-insensitive)
-   */
-  _isToolAllowed(toolName, allowedTools) {
-    const normalized = toolName.toLowerCase();
-    return allowedTools.some(allowed => allowed.toLowerCase() === normalized);
-  }
-
-  /**
-   * Extract text from content blocks
-   */
-  _extractTextFromContent(content) {
-    if (!Array.isArray(content)) {
-      return String(content);
-    }
-
-    const textBlocks = content.filter(block => block.type === "text");
-    return textBlocks.map(block => block.text).join("\n");
-  }
-
-  /**
-   * Extract FINAL RESULT only (not intermediate steps)
-   */
-  _extractFinalResult(context) {
-    if (context.result) {
-      return context.result;
-    }
-
-    // Look for summary markers in last assistant message
-    const reversedMessages = [...context.messages].reverse();
-    const lastMessage = reversedMessages.find(m => m.role === "assistant");
-
-    if (lastMessage && lastMessage.content) {
-      const text = this._extractTextFromContent(lastMessage.content);
-
-      // Look for summary markers
-      const markers = [
-        "EXPLORATION COMPLETE:",
-        "IMPLEMENTATION PLAN:",
-        "TASK COMPLETE:",
-        "SUMMARY:",
-        "FINDINGS:"
-      ];
-
-      for (const marker of markers) {
-        const index = text.indexOf(marker);
-        if (index !== -1) {
-          return text.substring(index);
-        }
-      }
-
-      return text;
-    }
-
-    return "Subagent completed with no result";
-  }
-
-  /**
-   * Resolve model name to full model identifier
-   */
-  _resolveModel(modelName) {
-    const modelMap = {
-      "haiku": "claude-3-haiku-20240307",
-      "sonnet": "claude-3-5-sonnet-20241022",
-      "opus": "claude-3-opus-20240229",
-      "gpt-4o-mini": "gpt-4o-mini",
-      "gpt-4o": "gpt-4o"
-    };
-
-    return modelMap[modelName] || modelName;
-  }
-
-  /**
-   * Learn from execution (async, non-blocking)
-   * Uses Reflector to extract patterns and updates skillbook
-   */
-  async _learnFromExecution(context, successful) {
-    try {
-      // Use Reflector to extract sophisticated patterns
-      const patterns = Reflector.reflect(context, successful);
-
-      if (patterns.length === 0) {
-        return; // Nothing to learn
-      }
-
-      // Prefer the loader's live skillbook instance (so use-counts/confidence
-      // accumulate in one place); fall back to loading from disk when running
-      // standalone.
-      const skillbook =
-        this.definitionLoader?.getSkillbook(context.agentName) ||
-        (await Skillbook.load(context.agentName));
-
-      // Add each learned pattern
-      for (const pattern of patterns) {
-        skillbook.addSkill(pattern);
-      }
-
-      // Save skillbook (persists learning)
-      await skillbook.save();
-
-      // Re-inject into the agent's prompt so the next run benefits without a
-      // restart. No-op when no loader was provided.
-      if (this.definitionLoader) {
-        this.definitionLoader.setSkillbook(context.agentName, skillbook);
-      }
-
-      logger.info({
-        agentType: context.agentName,
-        patternsLearned: patterns.length,
-        totalSkills: skillbook.skills.size,
-        successful
-      }, "Agent learned from execution");
-
-    } catch (error) {
-      // Don't throw - learning failures shouldn't break execution
-      logger.warn({
-        agentType: context.agentName,
-        error: error.message
-      }, "Learning failed");
-    }
-  }
-
-}
-
-module.exports = SubagentExecutor;

package/src/agents/index.js

@@ -1,165 +0,0 @@
-const logger = require("../logger");
-const config = require("../config");
-const AgentDefinitionLoader = require("./definitions/loader");
-const ParallelCoordinator = require("./parallel-coordinator");
-const agentStore = require("./store");
-
-const definitionLoader = new AgentDefinitionLoader();
-const coordinator = new ParallelCoordinator(config.agents?.maxConcurrent || 10, {
-  definitionLoader,
-});
-
-// Periodically drop learned skills that have proven unhelpful. Only when the
-// agents subsystem is active; the timer is unref'd so it never blocks exit.
-if (config.agents?.enabled) {
-  definitionLoader.startSkillPruning();
-}
-
-/**
- * Spawn and execute subagent(s)
- * @param {string|Array} agentType - Agent type(s) to spawn
- * @param {string|Array} prompt - Task prompt(s)
- * @param {Object} options - sessionId, mainContext, etc.
- * @returns {Promise<Object>} - Execution result(s)
- */
-async function spawnAgent(agentType, prompt, options = {}) {
-  if (!config.agents?.enabled) {
-    throw new Error("Agents disabled. Set AGENTS_ENABLED=true");
-  }
-
-  // Handle parallel execution
-  if (Array.isArray(agentType)) {
-    return await spawnParallel(agentType, prompt, options);
-  }
-
-  // Single agent execution
-  logger.info({
-    agentType,
-    prompt: prompt.slice(0, 100),
-    sessionId: options.sessionId
-  }, "Spawning subagent");
-
-  // Get agent definition
-  const agentDef = definitionLoader.getAgent(agentType);
-
-  if (!agentDef) {
-    throw new Error(`Unknown agent type: ${agentType}`);
-  }
-
-  // Record in store
-  const executionId = agentStore.createExecution({
-    sessionId: options.sessionId,
-    agentType,
-    prompt,
-    model: agentDef.model
-  });
-
-  // Execute
-  const result = await coordinator.executeSingle(agentDef, prompt, options);
-
-  // Update store
-  if (result.success) {
-    agentStore.completeExecution(executionId, result.result, result.stats);
-  } else {
-    agentStore.failExecution(executionId, { message: result.error }, result.stats);
-  }
-
-  return result;
-}
-
-/**
- * Spawn multiple agents in parallel
- */
-async function spawnParallel(agentTypes, prompts, options = {}) {
-  if (!Array.isArray(prompts) || agentTypes.length !== prompts.length) {
-    throw new Error("agentTypes and prompts must be arrays of same length");
-  }
-
-  logger.info({
-    count: agentTypes.length,
-    sessionId: options.sessionId
-  }, "Spawning parallel subagents");
-
-  // Build tasks
-  const tasks = agentTypes.map((type, i) => {
-    const agentDef = definitionLoader.getAgent(type);
-
-    if (!agentDef) {
-      throw new Error(`Unknown agent type: ${type}`);
-    }
-
-    const executionId = agentStore.createExecution({
-      sessionId: options.sessionId,
-      agentType: type,
-      prompt: prompts[i],
-      model: agentDef.model
-    });
-
-    return {
-      agentDef,
-      taskPrompt: prompts[i],
-      options: { ...options, executionId }
-    };
-  });
-
-  // Execute in parallel with batching
-  const results = await coordinator.executeBatched(tasks);
-
-  // Update store for each result
-  results.forEach((result, i) => {
-    const executionId = tasks[i].options.executionId;
-
-    if (result.success) {
-      agentStore.completeExecution(executionId, result.result, result.stats);
-    } else {
-      agentStore.failExecution(executionId, { message: result.error }, result.stats);
-    }
-  });
-
-  return results;
-}
-
-/**
- * Auto-select agent based on task description
- */
-function autoSelectAgent(taskDescription) {
-  return definitionLoader.findAgentForTask(taskDescription);
-}
-
-/**
- * Register custom agent programmatically
- */
-function registerAgent(name, definition) {
-  definitionLoader.registerAgent(name, definition);
-}
-
-/**
- * Get all available agents
- */
-function listAgents() {
-  return definitionLoader.getAllAgents();
-}
-
-/**
- * Get agent execution stats
- */
-function getAgentStats() {
-  return agentStore.getStats();
-}
-
-/**
- * Get specific execution details
- */
-function getAgentExecution(executionId) {
-  return agentStore.getExecution(executionId);
-}
-
-module.exports = {
-  spawnAgent,
-  spawnParallel,
-  autoSelectAgent,
-  registerAgent,
-  listAgents,
-  getAgentStats,
-  getAgentExecution
-};

package/src/agents/parallel-coordinator.js

@@ -1,68 +0,0 @@
-const logger = require("../logger");
-const SubagentExecutor = require("./executor");
-
-class ParallelCoordinator {
-  constructor(maxConcurrent = 10, { definitionLoader = null } = {}) {
-    this.maxConcurrent = maxConcurrent;
-    this.executor = new SubagentExecutor({ definitionLoader });
-  }
-
-  /**
-   * Execute multiple subagents in parallel with batching
-   * @param {Array} tasks - Array of { agentDef, taskPrompt, options }
-   * @returns {Promise<Array>} - Array of results
-   */
-  async executeBatched(tasks) {
-    if (tasks.length === 0) {
-      return [];
-    }
-
-    logger.info({
-      totalTasks: tasks.length,
-      maxConcurrent: this.maxConcurrent
-    }, "Starting batched subagent execution");
-
-    const results = [];
-    let processed = 0;
-
-    // Process in batches
-    while (processed < tasks.length) {
-      const batch = tasks.slice(processed, processed + this.maxConcurrent);
-
-      logger.debug({
-        batchSize: batch.length,
-        processed,
-        remaining: tasks.length - processed - batch.length
-      }, "Processing subagent batch");
-
-      // Execute batch in parallel
-      const batchResults = await Promise.all(
-        batch.map(task => this.executor.execute(
-          task.agentDef,
-          task.taskPrompt,
-          task.options
-        ))
-      );
-
-      results.push(...batchResults);
-      processed += batch.length;
-
-      logger.info({
-        completedInBatch: batch.length,
-        totalCompleted: processed,
-        totalTasks: tasks.length
-      }, "Completed subagent batch");
-    }
-
-    return results;
-  }
-
-  /**
-   * Execute single subagent (convenience method)
-   */
-  async executeSingle(agentDef, taskPrompt, options = {}) {
-    return this.executor.execute(agentDef, taskPrompt, options);
-  }
-}
-
-module.exports = ParallelCoordinator;