@zhijiewang/openharness 2.1.0 → 2.3.1

package/dist/query/index.js

@@ -7,22 +7,21 @@
  * - errors.ts — error classification and recovery
  * - types.ts — shared types
  */
-import { toolToAPIFormat } from "../Tool.js";
 import { DeferredTool } from "../DeferredTool.js";
-import { ContextManager } from "./context-manager.js";
-import { createAssistantMessage, createUserMessage } from "../types/message.js";
-import { StreamingToolExecutor } from "../services/StreamingToolExecutor.js";
 import { getContextWindow } from "../harness/cost.js";
-import { createToolResultMessage } from "../types/message.js";
-import { makeTokenEstimator, estimateMessagesTokens, compressMessages, summarizeConversation } from "./compress.js";
+import { StreamingToolExecutor } from "../services/StreamingToolExecutor.js";
+import { toolToAPIFormat } from "../Tool.js";
+import { createAssistantMessage, createToolResultMessage, createUserMessage } from "../types/message.js";
+import { compressMessages, estimateMessagesTokens, makeTokenEstimator, summarizeConversation } from "./compress.js";
+import { ContextManager } from "./context-manager.js";
+import { isNetworkError, isOverloadError, isPromptTooLongError, isRateLimitError, MAX_CONSECUTIVE_ERRORS, MAX_RATE_LIMIT_RETRIES, } from "./errors.js";
 import { executeToolCalls } from "./tools.js";
-import { isRateLimitError, isOverloadError, isPromptTooLongError, isNetworkError, MAX_CONSECUTIVE_ERRORS, MAX_RATE_LIMIT_RETRIES } from "./errors.js";
 export { compressMessages } from "./compress.js";
 const DEFAULT_MAX_TURNS = 50;
 export async function* query(userMessage, config, existingMessages = []) {
     const maxTurns = config.maxTurns ?? DEFAULT_MAX_TURNS;
     const toolContext = {
-        workingDir: process.cwd(),
+        workingDir: config.workingDir ?? process.cwd(),
         abortSignal: config.abortSignal,
         provider: config.provider,
         model: config.model,
@@ -34,22 +33,30 @@ export async function* query(userMessage, config, existingMessages = []) {
     const estimateTokens = makeTokenEstimator(config.provider);
     const contextManager = new ContextManager(undefined, config.model);
     // Check provider capabilities
-    const modelInfo = config.provider.getModelInfo?.(config.model ?? '');
+    const modelInfo = config.provider.getModelInfo?.(config.model ?? "");
     const toolsSupported = !modelInfo || modelInfo.supportsTools;
     const apiTools = toolsSupported ? config.tools.map(toolToAPIFormat) : undefined;
-    let toolPrompts = toolsSupported
-        ? config.tools.map((t) => t.prompt()).join("\n\n")
-        : "";
+    let toolPrompts = toolsSupported ? config.tools.map((t) => t.prompt()).join("\n\n") : "";
     // Hint about deferred tools available via ToolSearch
     if (toolsSupported) {
-        const deferredCount = config.tools.filter(t => t instanceof DeferredTool && !t.activated).length;
+        const deferredCount = config.tools.filter((t) => t instanceof DeferredTool && !t.activated).length;
         if (deferredCount > 0) {
             toolPrompts += `\n\n[${deferredCount} additional tools available — use ToolSearch to discover them]`;
         }
     }
-    const fullSystemPrompt = toolPrompts
-        ? config.systemPrompt + "\n\n# Available Tools\n\n" + toolPrompts
+    let fullSystemPrompt = toolPrompts
+        ? `${config.systemPrompt}\n\n# Available Tools\n\n${toolPrompts}`
         : config.systemPrompt;
+    // Auto-trigger skills matching user message
+    try {
+        const { findTriggeredSkills } = await import("../harness/plugins.js");
+        const triggered = findTriggeredSkills(userMessage);
+        if (triggered.length > 0) {
+            const hints = triggered.map((s) => `- **${s.name}**: ${s.description}`).join("\n");
+            fullSystemPrompt += `\n\n# Suggested Skills\nThese skills match your request. Use Skill tool to load them:\n${hints}`;
+        }
+    }
+    catch { /* skills optional */ }
     const state = {
         messages: [...existingMessages, createUserMessage(userMessage)],
         turn: 0,
@@ -81,7 +88,9 @@ export async function* query(userMessage, config, existingMessages = []) {
                     state.messages = await summarizeConversation(config.provider, state.messages, config.model, Math.floor(contextWindow * 0.5));
                     yield { type: "error", message: "Context compressed with LLM summarization." };
                 }
-                catch { /* continue with basic compression */ }
+                catch {
+                    /* continue with basic compression */
+                }
             }
         }
         // ── LLM call with streaming ──
@@ -131,7 +140,10 @@ export async function* query(userMessage, config, existingMessages = []) {
             state.consecutiveErrors++;
             // Circuit breaker
             if (state.consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
-                yield { type: "error", message: `Too many consecutive errors (${state.consecutiveErrors}): ${streamError.message}` };
+                yield {
+                    type: "error",
+                    message: `Too many consecutive errors (${state.consecutiveErrors}): ${streamError.message}`,
+                };
                 yield { type: "turn_complete", reason: "error" };
                 return;
             }
@@ -140,13 +152,16 @@ export async function* query(userMessage, config, existingMessages = []) {
                 const attempt = state.consecutiveErrors;
                 const isOverload = isOverloadError(streamError);
                 if (attempt <= MAX_RATE_LIMIT_RETRIES) {
-                    const baseRetry = Math.pow(2, attempt) * (isOverload ? 2 : 1);
+                    const baseRetry = 2 ** attempt * (isOverload ? 2 : 1);
                     const retryIn = baseRetry * (0.5 + Math.random());
                     yield { type: "rate_limited", retryIn: Math.round(retryIn), attempt };
                     await new Promise((r) => setTimeout(r, retryIn * 1000));
                     continue;
                 }
-                yield { type: "error", message: `${isOverload ? "Server overloaded" : "Rate limit exceeded"} after ${MAX_RATE_LIMIT_RETRIES} retries.` };
+                yield {
+                    type: "error",
+                    message: `${isOverload ? "Server overloaded" : "Rate limit exceeded"} after ${MAX_RATE_LIMIT_RETRIES} retries.`,
+                };
                 yield { type: "turn_complete", reason: "error" };
                 return;
             }
@@ -164,7 +179,7 @@ export async function* query(userMessage, config, existingMessages = []) {
             }
             if (isNetworkError(streamError)) {
                 state.transition = "retry_network";
-                const delay = 1000 * Math.pow(2, state.consecutiveErrors - 1);
+                const delay = 1000 * 2 ** (state.consecutiveErrors - 1);
                 yield { type: "error", message: `Network error, retrying in ${delay / 1000}s...` };
                 await new Promise((r) => setTimeout(r, delay));
                 continue;
@@ -178,7 +193,10 @@ export async function* query(userMessage, config, existingMessages = []) {
             return;
         }
         if (assistantContent === "" && toolCalls.length === 0) {
-            yield { type: "error", message: "No response received. Check that your model server is running and the model name is correct." };
+            yield {
+                type: "error",
+                message: "No response received. Check that your model server is running and the model name is correct.",
+            };
             return;
         }
         state.messages.push(createAssistantMessage(assistantContent, toolCalls.length > 0 ? toolCalls : undefined));
@@ -189,9 +207,9 @@ export async function* query(userMessage, config, existingMessages = []) {
         // Collect streaming tool results
         await streamingExecutor.waitForAll();
         const completedResults = [...streamingExecutor.getCompletedResults()];
-        const executedIds = new Set(completedResults.map(r => r.toolCall.id));
+        const executedIds = new Set(completedResults.map((r) => r.toolCall.id));
         for (const { callId, chunk } of streamingExecutor.outputChunks) {
-            yield { type: 'tool_output_delta', callId, chunk };
+            yield { type: "tool_output_delta", callId, chunk };
         }
         for (const { toolCall: tc, result } of completedResults) {
             yield { type: "tool_call_end", callId: tc.id, output: result.output, isError: result.isError };
@@ -200,7 +218,7 @@ export async function* query(userMessage, config, existingMessages = []) {
             state.messages.push(createToolResultMessage({ callId: tc.id, output: budgetedOutput, isError: result.isError }));
         }
         // Execute remaining tools not started during streaming
-        const remaining = toolCalls.filter(tc => !executedIds.has(tc.id));
+        const remaining = toolCalls.filter((tc) => !executedIds.has(tc.id));
         if (remaining.length > 0) {
             yield* executeToolCalls(remaining, config.tools, toolContext, config.permissionMode, config.askUser, state);
         }

package/dist/query/tools.js

@@ -1,11 +1,11 @@
 /**
  * Tool execution — permission checking, batching, output capping.
  */
+import { createCheckpoint, getAffectedFiles } from "../harness/checkpoints.js";
+import { emitHook } from "../harness/hooks.js";
 import { findToolByName } from "../Tool.js";
 import { createToolResultMessage } from "../types/message.js";
 import { checkPermission } from "../types/permissions.js";
-import { emitHook } from "../harness/hooks.js";
-import { createCheckpoint, getAffectedFiles } from "../harness/checkpoints.js";
 const MAX_TOOL_RESULT_CHARS = 100_000;
 const TOOL_TIMEOUT_MS = 120_000;
 export function partitionToolCalls(toolCalls, tools) {
@@ -86,17 +86,17 @@ export async function executeSingleTool(toolCall, tools, context, permissionMode
             toolOutput: result.output.slice(0, 1000),
         });
         // Emit fileChanged hook for file-modifying tools
-        if (!result.isError && ['Edit', 'Write', 'MultiEdit'].includes(tool.name)) {
+        if (!result.isError && ["Edit", "Write", "MultiEdit"].includes(tool.name)) {
             const filePaths = getAffectedFiles(tool.name, parsed.data);
             for (const fp of filePaths) {
                 emitHook("fileChanged", { filePath: fp, toolName: tool.name });
             }
         }
         // Verification loop: auto-run lint/typecheck after file-modifying tools
-        let verificationSuffix = '';
-        if (!result.isError && ['Edit', 'Write', 'MultiEdit'].includes(tool.name)) {
+        let verificationSuffix = "";
+        if (!result.isError && ["Edit", "Write", "MultiEdit"].includes(tool.name)) {
             try {
-                const { runVerificationForFiles, getVerificationConfig, extractFilePaths } = await import('../harness/verification.js');
+                const { runVerificationForFiles, getVerificationConfig, extractFilePaths } = await import("../harness/verification.js");
                 const vConfig = getVerificationConfig();
                 if (vConfig?.enabled) {
                     const filePaths = extractFilePaths(tool.name, parsed.data);
@@ -105,24 +105,27 @@ export async function executeSingleTool(toolCall, tools, context, permissionMode
                         if (vResult.ran) {
                             if (!vResult.passed) {
                                 verificationSuffix = `\n\n[Verification FAILED]\n${vResult.summary}`;
-                                if (vConfig.mode === 'block') {
+                                if (vConfig.mode === "block") {
                                     result = { output: result.output, isError: true };
                                 }
                             }
                             else {
-                                verificationSuffix = '\n\n[Verification passed]';
+                                verificationSuffix = "\n\n[Verification passed]";
                             }
                         }
                     }
                 }
             }
-            catch { /* verification should never break tool execution */ }
+            catch {
+                /* verification should never break tool execution */
+            }
         }
         // Strip ANSI and cap output, then append verification suffix
         let output = result.output.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "") + verificationSuffix;
         if (output.length > MAX_TOOL_RESULT_CHARS) {
-            output = output.slice(0, MAX_TOOL_RESULT_CHARS)
-                + `\n\n[TRUNCATED: output was ${output.length.toLocaleString()} chars, showing first ${MAX_TOOL_RESULT_CHARS.toLocaleString()}]`;
+            output =
+                output.slice(0, MAX_TOOL_RESULT_CHARS) +
+                    `\n\n[TRUNCATED: output was ${output.length.toLocaleString()} chars, showing first ${MAX_TOOL_RESULT_CHARS.toLocaleString()}]`;
         }
         return { output, isError: result.isError };
     }
@@ -134,7 +137,7 @@ export async function* executeToolCalls(toolCalls, tools, context, permissionMod
     const batches = partitionToolCalls(toolCalls, tools);
     const outputChunks = [];
     const onOutputChunk = (callId, chunk) => {
-        outputChunks.push({ type: 'tool_output_delta', callId, chunk });
+        outputChunks.push({ type: "tool_output_delta", callId, chunk });
     };
     for (const batch of batches) {
         if (batch.concurrent) {

package/dist/query/types.d.ts

@@ -1,9 +1,9 @@
 /**
  * Shared types for the query loop sub-modules.
  */
-import type { Message } from "../types/message.js";
 import type { Provider } from "../providers/base.js";
 import type { Tools } from "../Tool.js";
+import type { Message } from "../types/message.js";
 import type { AskUserFn, PermissionMode } from "../types/permissions.js";
 export type QueryConfig = {
     provider: Provider;
@@ -16,6 +16,8 @@ export type QueryConfig = {
     maxCost?: number;
     model?: string;
     abortSignal?: AbortSignal;
+    /** Working directory for tool execution (defaults to process.cwd()) */
+    workingDir?: string;
 };
 export type TransitionReason = "next_turn" | "retry_network" | "retry_prompt_too_long" | "retry_max_output_tokens";
 export type QueryLoopState = {

package/dist/query.d.ts

@@ -6,6 +6,6 @@
  * - query/errors.ts — error classification and recovery
  * - query/types.ts — shared types
  */
-export { query, compressMessages } from "./query/index.js";
 export type { QueryConfig, QueryLoopState } from "./query/index.js";
+export { compressMessages, query } from "./query/index.js";
 //# sourceMappingURL=query.d.ts.map

package/dist/query.js

@@ -6,5 +6,5 @@
  * - query/errors.ts — error classification and recovery
  * - query/types.ts — shared types
  */
-export { query, compressMessages } from "./query/index.js";
+export { compressMessages, query } from "./query/index.js";
 //# sourceMappingURL=query.js.map

package/dist/remote/auth.d.ts

@@ -2,8 +2,8 @@
  * API security layer — auth, rate limiting, and tool access control
  * for the remote server.
  */
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { Tools } from '../Tool.js';
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { Tools } from "../Tool.js";
 /** Check if a request is within rate limits. Returns true if allowed. */
 export declare function checkRateLimit(ip: string, maxPerMinute: number): boolean;
 /** Validate a bearer token against configured tokens. Returns true if valid. */

package/dist/remote/auth.js

@@ -2,7 +2,7 @@
  * API security layer — auth, rate limiting, and tool access control
  * for the remote server.
  */
-import { readOhConfig } from '../harness/config.js';
+import { readOhConfig } from "../harness/config.js";
 const rateLimitMap = new Map();
 const WINDOW_MS = 60_000; // 1 minute sliding window
 /** Check if a request is within rate limits. Returns true if allowed. */
@@ -28,7 +28,7 @@ export function validateToken(authHeader) {
         return true;
     if (!authHeader)
         return false;
-    const token = authHeader.replace(/^Bearer\s+/i, '').trim();
+    const token = authHeader.replace(/^Bearer\s+/i, "").trim();
     if (!token)
         return false;
     return tokens.includes(token);
@@ -40,8 +40,8 @@ export function filterRemoteTools(tools) {
     const allowed = config?.remote?.allowedTools;
     if (!allowed || allowed.length === 0)
         return tools;
-    const allowSet = new Set(allowed.map(n => n.toLowerCase()));
-    const filtered = tools.filter(t => allowSet.has(t.name.toLowerCase()));
+    const allowSet = new Set(allowed.map((n) => n.toLowerCase()));
+    const filtered = tools.filter((t) => allowSet.has(t.name.toLowerCase()));
     return filtered.length > 0 ? filtered : tools; // fallback to all if filter empties
 }
 // ── Request ID ──
@@ -56,17 +56,17 @@ export function generateRequestId() {
  */
 export function authenticateRequest(req, res) {
     const requestId = generateRequestId();
-    res.setHeader('X-Request-ID', requestId);
+    res.setHeader("X-Request-ID", requestId);
     // Token auth
     if (!validateToken(req.headers.authorization)) {
-        return { allowed: false, reason: 'Invalid or missing bearer token', requestId };
+        return { allowed: false, reason: "Invalid or missing bearer token", requestId };
     }
     // Rate limiting
     const config = readOhConfig();
     const rateLimit = config?.remote?.rateLimit ?? 60; // default 60/min
-    const ip = req.socket.remoteAddress ?? 'unknown';
+    const ip = req.socket.remoteAddress ?? "unknown";
     if (!checkRateLimit(ip, rateLimit)) {
-        return { allowed: false, reason: 'Rate limit exceeded', requestId };
+        return { allowed: false, reason: "Rate limit exceeded", requestId };
     }
     return { allowed: true, requestId };
 }

package/dist/remote/server.d.ts

@@ -10,9 +10,9 @@
  *
  * Security: bearer token auth, per-IP rate limiting, tool allowlists.
  */
-import type { Provider } from '../providers/base.js';
-import type { Tools } from '../Tool.js';
-import type { PermissionMode } from '../types/permissions.js';
+import type { Provider } from "../providers/base.js";
+import type { Tools } from "../Tool.js";
+import type { PermissionMode } from "../types/permissions.js";
 export type RemoteServerConfig = {
     port: number;
     provider: Provider;

package/dist/remote/server.js

@@ -10,10 +10,10 @@
  *
  * Security: bearer token auth, per-IP rate limiting, tool allowlists.
  */
-import { createServer } from 'node:http';
-import { WebSocketServer, WebSocket } from 'ws';
-import { authenticateRequest, filterRemoteTools } from './auth.js';
-import { createSessionCard, publishCard, unpublishCard, discoverAgents, generateMessageId, } from '../services/a2a.js';
+import { createServer } from "node:http";
+import { WebSocket, WebSocketServer } from "ws";
+import { createSessionCard, discoverAgents, generateMessageId, publishCard, unpublishCard, } from "../services/a2a.js";
+import { authenticateRequest, filterRemoteTools } from "./auth.js";
 export class RemoteServer {
     config;
     channels = new Map();
@@ -27,8 +27,8 @@ export class RemoteServer {
             this.server = createServer((req, res) => this.handleHttp(req, res));
             // WebSocket upgrade
             const wss = new WebSocketServer({ noServer: true });
-            this.server.on('upgrade', (request, socket, head) => {
-                if (request.url === '/channel') {
+            this.server.on("upgrade", (request, socket, head) => {
+                if (request.url === "/channel") {
                     wss.handleUpgrade(request, socket, head, (ws) => {
                         this.handleChannel(ws);
                     });
@@ -69,29 +69,29 @@ export class RemoteServer {
     }
     async handleHttp(req, res) {
         // CORS headers
-        res.setHeader('Access-Control-Allow-Origin', '*');
-        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
-        if (req.method === 'OPTIONS') {
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+        if (req.method === "OPTIONS") {
             res.writeHead(204);
             res.end();
             return;
         }
         // Auth check (skip for /status which is a health check)
-        if (req.url !== '/status') {
+        if (req.url !== "/status") {
             const auth = authenticateRequest(req, res);
             if (!auth.allowed) {
-                const status = auth.reason?.includes('Rate limit') ? 429 : 401;
-                res.writeHead(status, { 'Content-Type': 'application/json' });
+                const status = auth.reason?.includes("Rate limit") ? 429 : 401;
+                res.writeHead(status, { "Content-Type": "application/json" });
                 res.end(JSON.stringify({ error: auth.reason, requestId: auth.requestId }));
                 return;
             }
         }
         // ── GET /status ──
-        if (req.url === '/status' && req.method === 'GET') {
-            res.writeHead(200, { 'Content-Type': 'application/json' });
+        if (req.url === "/status" && req.method === "GET") {
+            res.writeHead(200, { "Content-Type": "application/json" });
             res.end(JSON.stringify({
-                status: 'ok',
+                status: "ok",
                 provider: this.config.provider.name,
                 model: this.config.model,
                 channels: this.channels.size,
@@ -100,24 +100,24 @@ export class RemoteServer {
             return;
         }
         // ── POST /dispatch ──
-        if (req.url === '/dispatch' && req.method === 'POST') {
+        if (req.url === "/dispatch" && req.method === "POST") {
             await this.handleDispatch(req, res);
             return;
         }
         // ── POST /a2a ──
-        if (req.url === '/a2a' && req.method === 'POST') {
+        if (req.url === "/a2a" && req.method === "POST") {
             await this.handleA2A(req, res);
             return;
         }
-        res.writeHead(404, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'Not found' }));
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Not found" }));
     }
     async handleDispatch(req, res) {
         const body = await readBody(req);
         try {
             const { prompt, maxTurns } = JSON.parse(body);
             if (!prompt) {
-                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.writeHead(400, { "Content-Type": "application/json" });
                 res.end(JSON.stringify({ error: 'Missing "prompt" field' }));
                 return;
             }
@@ -125,11 +125,11 @@ export class RemoteServer {
             const tools = filterRemoteTools(this.config.tools);
             // Stream response as Server-Sent Events
             res.writeHead(200, {
-                'Content-Type': 'text/event-stream',
-                'Cache-Control': 'no-cache',
-                'Connection': 'keep-alive',
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                Connection: "keep-alive",
             });
-            const { query } = await import('../query.js');
+            const { query } = await import("../query.js");
             const config = {
                 provider: this.config.provider,
                 tools,
@@ -142,12 +142,12 @@ export class RemoteServer {
                 const data = JSON.stringify(event);
                 res.write(`data: ${data}\n\n`);
             }
-            res.write('data: [DONE]\n\n');
+            res.write("data: [DONE]\n\n");
             res.end();
         }
         catch (err) {
             if (!res.headersSent) {
-                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.writeHead(500, { "Content-Type": "application/json" });
             }
             res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
         }
@@ -166,26 +166,26 @@ export class RemoteServer {
         try {
             const message = JSON.parse(body);
             switch (message.payload.kind) {
-                case 'discover': {
+                case "discover": {
                     // Return our agent card
                     const agents = discoverAgents();
-                    const self = agents.find(a => a.id === this.agentCardId);
+                    const self = agents.find((a) => a.id === this.agentCardId);
                     const response = {
                         id: generateMessageId(),
-                        from: this.agentCardId ?? 'unknown',
+                        from: this.agentCardId ?? "unknown",
                         to: message.from,
-                        type: 'result',
-                        payload: { kind: 'result', taskId: message.id, output: self ?? { error: 'agent not found' } },
+                        type: "result",
+                        payload: { kind: "result", taskId: message.id, output: self ?? { error: "agent not found" } },
                         timestamp: Date.now(),
                     };
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.writeHead(200, { "Content-Type": "application/json" });
                     res.end(JSON.stringify(response));
                     return;
                 }
-                case 'task': {
+                case "task": {
                     // Execute the task via query loop
                     const tools = filterRemoteTools(this.config.tools);
-                    const { query } = await import('../query.js');
+                    const { query } = await import("../query.js");
                     const config = {
                         provider: this.config.provider,
                         tools,
@@ -194,45 +194,45 @@ export class RemoteServer {
                         model: this.config.model,
                         maxTurns: 10,
                     };
-                    let output = '';
+                    let output = "";
                     for await (const event of query(String(message.payload.input), config)) {
-                        if (event.type === 'text_delta')
+                        if (event.type === "text_delta")
                             output += event.content;
                     }
                     const response = {
                         id: generateMessageId(),
-                        from: this.agentCardId ?? 'unknown',
+                        from: this.agentCardId ?? "unknown",
                         to: message.from,
-                        type: 'result',
-                        payload: { kind: 'result', taskId: message.id, output },
+                        type: "result",
+                        payload: { kind: "result", taskId: message.id, output },
                         timestamp: Date.now(),
                     };
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.writeHead(200, { "Content-Type": "application/json" });
                     res.end(JSON.stringify(response));
                     return;
                 }
-                case 'status': {
+                case "status": {
                     const response = {
                         id: generateMessageId(),
-                        from: this.agentCardId ?? 'unknown',
+                        from: this.agentCardId ?? "unknown",
                         to: message.from,
-                        type: 'status',
-                        payload: { kind: 'status', state: 'idle' },
+                        type: "status",
+                        payload: { kind: "status", state: "idle" },
                         timestamp: Date.now(),
                     };
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.writeHead(200, { "Content-Type": "application/json" });
                     res.end(JSON.stringify(response));
                     return;
                 }
                 default: {
-                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.writeHead(400, { "Content-Type": "application/json" });
                     res.end(JSON.stringify({ error: `Unknown A2A message kind: ${message.payload.kind}` }));
                     return;
                 }
             }
         }
         catch (err) {
-            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.writeHead(400, { "Content-Type": "application/json" });
             res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
         }
     }
@@ -242,13 +242,13 @@ export class RemoteServer {
         const channel = { id, ws, abortController };
         this.channels.set(id, channel);
         process.stderr.write(`[remote] Channel ${id} connected\n`);
-        ws.send(JSON.stringify({ type: 'connected', channelId: id }));
-        ws.on('message', async (data) => {
+        ws.send(JSON.stringify({ type: "connected", channelId: id }));
+        ws.on("message", async (data) => {
             try {
                 const msg = JSON.parse(data.toString());
-                if (msg.type === 'dispatch') {
+                if (msg.type === "dispatch") {
                     const tools = filterRemoteTools(this.config.tools);
-                    const { query } = await import('../query.js');
+                    const { query } = await import("../query.js");
                     const config = {
                         provider: this.config.provider,
                         tools,
@@ -263,18 +263,18 @@ export class RemoteServer {
                             break;
                         ws.send(JSON.stringify(event));
                     }
-                    ws.send(JSON.stringify({ type: 'dispatch_complete' }));
+                    ws.send(JSON.stringify({ type: "dispatch_complete" }));
                 }
-                if (msg.type === 'abort') {
+                if (msg.type === "abort") {
                     abortController.abort();
-                    ws.send(JSON.stringify({ type: 'aborted' }));
+                    ws.send(JSON.stringify({ type: "aborted" }));
                 }
             }
             catch (err) {
-                ws.send(JSON.stringify({ type: 'error', message: err instanceof Error ? err.message : String(err) }));
+                ws.send(JSON.stringify({ type: "error", message: err instanceof Error ? err.message : String(err) }));
             }
         });
-        ws.on('close', () => {
+        ws.on("close", () => {
             abortController.abort();
             this.channels.delete(id);
             process.stderr.write(`[remote] Channel ${id} disconnected\n`);
@@ -284,9 +284,9 @@ export class RemoteServer {
 function readBody(req) {
     return new Promise((resolve, reject) => {
         const chunks = [];
-        req.on('data', (chunk) => chunks.push(chunk));
-        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
-        req.on('error', reject);
+        req.on("data", (chunk) => chunks.push(chunk));
+        req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+        req.on("error", reject);
     });
 }
 //# sourceMappingURL=server.js.map