lynkr 1.0.0 → 2.0.0

package/src/orchestrator/index.js

@@ -699,10 +699,10 @@ function toAnthropicResponse(openai, requestedModel, wantsThinking) {
       choice?.finish_reason === "stop"
         ? "end_turn"
         : choice?.finish_reason === "length"
-        ? "max_tokens"
-        : choice?.finish_reason === "tool_calls"
-        ? "tool_use"
-        : choice?.finish_reason ?? "end_turn",
+          ? "max_tokens"
+          : choice?.finish_reason === "tool_calls"
+            ? "tool_use"
+            : choice?.finish_reason ?? "end_turn",
     stop_sequence: null,
     usage: {
       input_tokens: usage.prompt_tokens ?? 0,
@@ -874,9 +874,9 @@ function sanitizePayload(payload) {
       tools && tools.length > 0
         ? tools
         : DEFAULT_AZURE_TOOLS.map((tool) => ({
-            name: tool.name,
-            input_schema: JSON.parse(JSON.stringify(tool.input_schema)),
-          }));
+          name: tool.name,
+          input_schema: JSON.parse(JSON.stringify(tool.input_schema)),
+        }));
     delete clean.tool_choice;
   } else if (providerType === "ollama") {
     // Check if model supports tools
@@ -1122,7 +1122,7 @@ async function runAgentLoop({
         "Azure Anthropic request payload structure",
       );
     }
-    
+
     const databricksResponse = await invokeModel(cleanPayload);
 
     // Handle streaming responses (pass through without buffering)
@@ -1195,7 +1195,7 @@ async function runAgentLoop({
     // Extract message and tool calls based on provider response format
     let message = {};
     let toolCalls = [];
-    
+
     if (providerType === "azure-anthropic") {
       // Anthropic format: { content: [{ type: "tool_use", ... }], stop_reason: "tool_use" }
       message = {
@@ -1203,8 +1203,8 @@ async function runAgentLoop({
         stop_reason: databricksResponse.json?.stop_reason,
       };
       // Extract tool_use blocks from content array
-      const contentArray = Array.isArray(databricksResponse.json?.content) 
-        ? databricksResponse.json.content 
+      const contentArray = Array.isArray(databricksResponse.json?.content)
+        ? databricksResponse.json.content
         : [];
       toolCalls = contentArray
         .filter(block => block?.type === "tool_use")
@@ -1217,7 +1217,7 @@ async function runAgentLoop({
           // Keep original block for reference
           _anthropic_block: block,
         }));
-      
+
       logger.debug(
         {
           sessionId: session?.id ?? null,
@@ -1331,23 +1331,51 @@ async function runAgentLoop({
 
       // Check if tool execution should happen on client side
       const executionMode = config.toolExecutionMode || "server";
-      if (executionMode === "passthrough" || executionMode === "client") {
+
+      // IMPORTANT: Task tools (subagents) and Web Search tools ALWAYS execute server-side, regardless of execution mode to ensure reliability
+      // Separate Server-side tools from Client-side tools
+      const serverSideToolCalls = [];
+      const clientSideToolCalls = [];
+
+      const SERVER_SIDE_TOOLS = new Set(["task", "web_search", "web_fetch", "websearch", "webfetch"]);
+
+      for (const call of toolCalls) {
+        const toolName = (call.function?.name ?? call.name ?? "").toLowerCase();
+        if (SERVER_SIDE_TOOLS.has(toolName)) {
+          serverSideToolCalls.push(call);
+        } else {
+          clientSideToolCalls.push(call);
+        }
+      }
+
+      // If in passthrough/client mode and there are client-side tools, return them to client
+      // Server-side tools (Task, Web) will be executed below
+      if ((executionMode === "passthrough" || executionMode === "client") && clientSideToolCalls.length > 0) {
         logger.info(
           {
             sessionId: session?.id ?? null,
-            toolCount: toolCalls.length,
+            totalToolCount: toolCalls.length,
+            serverToolCount: serverSideToolCalls.length,
+            clientToolCount: clientSideToolCalls.length,
             executionMode,
-            toolNames: toolCalls.map((c) => c.function?.name ?? c.name),
+            clientTools: clientSideToolCalls.map((c) => c.function?.name ?? c.name),
           },
-          "Passthrough mode: returning tool calls to client for execution"
+          "Hybrid mode: returning non-Task tools to client, executing Task tools on server"
         );
 
+        // Filter sessionContent to only include client-side tool_use blocks
+        const clientContent = sessionContent.filter(block => {
+          if (block.type !== "tool_use") return true; // Keep text blocks
+          const toolName = (block.name ?? "").toLowerCase();
+          return !SERVER_SIDE_TOOLS.has(toolName); // Keep client-side tool_use blocks
+        });
+
         // Convert OpenRouter response to Anthropic format for CLI
         const anthropicResponse = {
           id: databricksResponse.json?.id || `msg_${Date.now()}`,
           type: "message",
           role: "assistant",
-          content: sessionContent, // Already in Anthropic format with tool_use blocks
+          content: clientContent,
           model: databricksResponse.json?.model || clean.model,
           stop_reason: "tool_use",
           usage: databricksResponse.json?.usage || {
@@ -1356,32 +1384,51 @@ async function runAgentLoop({
           },
         };
 
-        // Debug: Log the actual content being returned
         logger.debug(
           {
             sessionId: session?.id ?? null,
-            contentLength: Array.isArray(sessionContent) ? sessionContent.length : 0,
-            contentTypes: Array.isArray(sessionContent) ? sessionContent.map(b => b.type) : [],
-            firstBlock: Array.isArray(sessionContent) && sessionContent.length > 0 ? sessionContent[0] : null,
-            responseId: anthropicResponse.id,
-            stopReason: anthropicResponse.stop_reason,
+            clientContentLength: clientContent.length,
+            clientContentTypes: clientContent.map(b => b.type),
           },
-          "Passthrough: returning Anthropic-formatted response with content blocks"
+          "Passthrough: returning client-side tools to client"
         );
 
-        // Return Anthropic-formatted response to CLI
-        // The CLI will execute the tools and send another request with tool_result blocks
-        // IMPORTANT: Must match agent loop return format (response wrapper)
-        return {
-          response: {
-            status: 200,
-            body: anthropicResponse,
+        // If there are server-side tools, we need to execute them server-side first
+        // then continue the conversation loop. For now, let's fall through to execute server-side tools.
+        if (serverSideToolCalls.length === 0) {
+          // No server-side tools - pure passthrough
+          return {
+            response: {
+              status: 200,
+              body: anthropicResponse,
+              terminationReason: "tool_use",
+            },
+            steps,
+            durationMs: Date.now() - start,
             terminationReason: "tool_use",
+          };
+        }
+
+        // Has Server-side tools - we need to execute them and continue
+        // Override toolCalls to only include Server-side tools for server execution
+        toolCalls = serverSideToolCalls;
+
+        logger.info(
+          {
+            sessionId: session?.id ?? null,
+            serverToolCount: serverSideToolCalls.length,
           },
-          steps,
-          durationMs: Date.now() - start,
-          terminationReason: "tool_use",
-        };
+          "Executing server-side tools in hybrid mode"
+        );
+      } else if (executionMode === "passthrough" || executionMode === "client") {
+        // Only Server-side tools, no Client-side tools - execute all server-side
+        logger.info(
+          {
+            sessionId: session?.id ?? null,
+            serverToolCount: serverSideToolCalls.length,
+          },
+          "All tools are server-side tools - executing server-side"
+        );
       }
 
       logger.debug(
@@ -1413,8 +1460,127 @@ async function runAgentLoop({
         toolCallsWithPolicy.push({ call, decision });
       }
 
-      // Now process results (still sequential for message ordering)
-      for (const { call, decision } of toolCallsWithPolicy) {
+      // Identify Task tool calls for parallel execution
+      const taskCalls = [];
+      const nonTaskCalls = [];
+
+      for (const item of toolCallsWithPolicy) {
+        const toolName = (item.call.function?.name ?? item.call.name ?? "").toLowerCase();
+        if (toolName === "task" && item.decision.allowed) {
+          taskCalls.push(item);
+        } else {
+          nonTaskCalls.push(item);
+        }
+      }
+
+      // Execute Task tools in parallel if multiple exist
+      if (taskCalls.length > 1) {
+        logger.info({
+          taskCount: taskCalls.length,
+          sessionId: session?.id
+        }, "Executing multiple Task tools in parallel");
+
+        try {
+          // Execute all Task tools in parallel
+          const taskExecutions = await Promise.all(
+            taskCalls.map(({ call }) => executeToolCall(call, {
+              session,
+              requestMessages: cleanPayload.messages,
+            }))
+          );
+
+          // Process results and add to messages
+          taskExecutions.forEach((execution, index) => {
+            const call = taskCalls[index].call;
+            toolCallsExecuted += 1;
+
+            let toolMessage;
+            if (providerType === "azure-anthropic") {
+              const parsedContent = parseExecutionContent(execution.content);
+              const serialisedContent =
+                typeof parsedContent === "string" || parsedContent === null
+                  ? parsedContent ?? ""
+                  : JSON.stringify(parsedContent);
+
+              toolMessage = {
+                role: "user",
+                content: [
+                  {
+                    type: "tool_result",
+                    tool_use_id: call.id ?? execution.id,
+                    content: serialisedContent,
+                    is_error: execution.ok === false,
+                  },
+                ],
+              };
+
+              toolCallNames.set(
+                call.id ?? execution.id,
+                normaliseToolIdentifier(
+                  call.function?.name ?? call.name ?? execution.name ?? "tool",
+                ),
+              );
+            } else {
+              toolMessage = {
+                role: "tool",
+                tool_call_id: execution.id,
+                name: execution.name,
+                content: execution.content,
+              };
+            }
+
+            cleanPayload.messages.push(toolMessage);
+
+            // Convert to Anthropic format for session storage
+            let sessionToolResultContent;
+            if (providerType === "azure-anthropic") {
+              sessionToolResultContent = toolMessage.content;
+            } else {
+              sessionToolResultContent = [
+                {
+                  type: "tool_result",
+                  tool_use_id: toolMessage.tool_call_id,
+                  content: toolMessage.content,
+                  is_error: execution.ok === false,
+                },
+              ];
+            }
+
+            appendTurnToSession(session, {
+              role: "tool",
+              type: "tool_result",
+              status: execution.status,
+              content: sessionToolResultContent,
+              metadata: {
+                tool: execution.name,
+                ok: execution.ok,
+                parallel: true,
+                parallelIndex: index,
+                totalParallel: taskExecutions.length
+              },
+            });
+          });
+
+          logger.info({
+            completedTasks: taskExecutions.length,
+            sessionId: session?.id
+          }, "Completed parallel Task execution");
+        } catch (error) {
+          logger.error({
+            error: error.message,
+            taskCount: taskCalls.length
+          }, "Error in parallel Task execution");
+
+          // Fall back to sequential execution on error
+          taskCalls.forEach(item => nonTaskCalls.push(item));
+        }
+      } else if (taskCalls.length === 1) {
+        // Single Task tool - add back to non-task calls for normal processing
+        nonTaskCalls.push(...taskCalls);
+      }
+
+      // Now process results (sequential for non-Task tools or blocked tools)
+      for (const { call, decision } of nonTaskCalls) {
 
         if (!decision.allowed) {
           policy.logPolicyDecision(decision, {
@@ -1653,6 +1819,57 @@ async function runAgentLoop({
         databricksResponse.json,
         requestedModel,
       );
+      anthropicPayload.content = policy.sanitiseContent(anthropicPayload.content);
+    } else if (actualProvider === "azure-openai") {
+      const { convertOpenRouterResponseToAnthropic } = require("../clients/openrouter-utils");
+
+      // Validate Azure OpenAI response has choices array before conversion
+      if (!databricksResponse.json?.choices?.length) {
+        logger.warn({
+          json: databricksResponse.json,
+          status: databricksResponse.status
+        }, "Azure OpenAI response missing choices array");
+
+        appendTurnToSession(session, {
+          role: "assistant",
+          type: "error",
+          status: databricksResponse.status,
+          content: databricksResponse.json,
+          metadata: { termination: "malformed_response" },
+        });
+
+        const response = buildErrorResponse(databricksResponse);
+        return {
+          response,
+          steps,
+          durationMs: Date.now() - start,
+          terminationReason: response.terminationReason,
+        };
+      }
+
+      // Log Azure OpenAI raw response
+      logger.info({
+        hasChoices: !!databricksResponse.json?.choices,
+        choiceCount: databricksResponse.json?.choices?.length || 0,
+        firstChoice: databricksResponse.json?.choices?.[0],
+        hasToolCalls: !!databricksResponse.json?.choices?.[0]?.message?.tool_calls,
+        toolCallCount: databricksResponse.json?.choices?.[0]?.message?.tool_calls?.length || 0,
+        finishReason: databricksResponse.json?.choices?.[0]?.finish_reason
+      }, "=== AZURE OPENAI RAW RESPONSE ===");
+
+      // Convert OpenAI format to Anthropic format (reuse OpenRouter utility)
+      anthropicPayload = convertOpenRouterResponseToAnthropic(
+        databricksResponse.json,
+        requestedModel,
+      );
+
+      logger.info({
+        contentBlocks: anthropicPayload.content?.length || 0,
+        contentTypes: anthropicPayload.content?.map(c => c.type) || [],
+        stopReason: anthropicPayload.stop_reason,
+        hasToolUse: anthropicPayload.content?.some(c => c.type === 'tool_use')
+      }, "=== CONVERTED ANTHROPIC RESPONSE ===");
+
       anthropicPayload.content = policy.sanitiseContent(anthropicPayload.content);
     } else {
       anthropicPayload = toAnthropicResponse(

package/src/server.js

@@ -26,6 +26,7 @@ const { registerGitTools } = require("./tools/git");
 const { registerTaskTools } = require("./tools/tasks");
 const { registerTestTools } = require("./tools/tests");
 const { registerMcpTools } = require("./tools/mcp");
+const { registerAgentTaskTool } = require("./tools/agent-task");
 
 initialiseMcp();
 registerStubTools();
@@ -38,6 +39,7 @@ registerGitTools();
 registerTaskTools();
 registerTestTools();
 registerMcpTools();
+registerAgentTaskTool();
 
 function createApp() {
   const app = express();

package/src/tools/agent-task.js

@@ -0,0 +1,96 @@
+const { registerTool } = require(".");
+const { spawnAgent, autoSelectAgent } = require("../agents");
+const logger = require("../logger");
+
+function registerAgentTaskTool() {
+  registerTool(
+    "Task",
+    async ({ args = {} }, context = {}) => {
+      let subagentType = args.subagent_type || args.type;
+      const prompt = args.prompt;
+      const description = args.description || "Agent task";
+
+      if (!prompt) {
+        return {
+          ok: false,
+          status: 400,
+          content: JSON.stringify({
+            error: "prompt is required"
+          }, null, 2)
+        };
+      }
+
+      // Auto-select agent if not specified
+      if (!subagentType) {
+        const selected = autoSelectAgent(prompt);
+        if (selected) {
+          subagentType = selected.name;
+          logger.info({
+            selectedAgent: subagentType,
+            prompt: prompt.slice(0, 50)
+          }, "Auto-selected subagent");
+        } else {
+          subagentType = "Explore"; // Default fallback
+        }
+      }
+
+      logger.info({
+        subagentType,
+        prompt: prompt.slice(0, 100),
+        sessionId: context.sessionId
+      }, "Task tool: spawning subagent");
+
+      try {
+        const result = await spawnAgent(subagentType, prompt, {
+          sessionId: context.sessionId,
+          mainContext: context.mainContext // Pass minimal context
+        });
+
+        if (result.success) {
+          return {
+            ok: true,
+            status: 200,
+            content: result.result,
+            metadata: {
+              agentType: subagentType,
+              agentId: result.stats.agentId,
+              steps: result.stats.steps,
+              durationMs: result.stats.durationMs
+            }
+          };
+        } else {
+          return {
+            ok: false,
+            status: 500,
+            content: JSON.stringify({
+              error: "Subagent execution failed",
+              message: result.error
+            }, null, 2)
+          };
+        }
+
+      } catch (error) {
+        logger.error({
+          error: error.message,
+          subagentType
+        }, "Task tool: subagent error");
+
+        return {
+          ok: false,
+          status: 500,
+          content: JSON.stringify({
+            error: "Subagent error",
+            message: error.message
+          }, null, 2)
+        };
+      }
+    },
+    { category: "agents" }
+  );
+
+  logger.info("Task tool registered");
+}
+
+module.exports = {
+  registerAgentTaskTool
+};