scalix 1.2.0 → 1.3.2

package/dist/agent.js

@@ -1,7 +1,7 @@
-import { ScalixClient } from './api-client.js';
+import { ScalixClient, ApiError } from './api-client.js';
 import { EventEmitter } from 'eventemitter3';
 import { randomUUID } from 'node:crypto';
-import { getToolPermission } from './sandbox.js';
+import { getToolPermissionWithArgs } from './sandbox.js';
 import { logger } from './logger.js';
 import { DEFAULT_MODELS as FALLBACK_MODELS, DEFAULT_INSTRUCTIONS, AGENT_DEFAULTS, TOOL_DEFAULTS, BACKOFF_DEFAULTS, modelSupportsVision, getModelSpec } from './constants.js';
 import { estimateMessageTokens as estimateTokenCount } from './token-counter.js';
@@ -156,6 +156,8 @@ export class Agent extends EventEmitter {
     groundingConfig = null;
     groundingNudgeCount = 0;
     retrievalConfig = null;
+    _sending = false;
+    outputFormatInstructionIndex = null;
     constructor(config) {
         super();
         this.agentId = config.agentId ?? generateAgentId();
@@ -185,6 +187,7 @@ export class Agent extends EventEmitter {
             circuitBreakerResetMs: config.circuitBreakerResetMs ?? AGENT_DEFAULTS.circuitBreakerResetMs,
             fileRefTruncation: config.fileRefTruncation ?? TOOL_DEFAULTS.fileRefTruncation,
             thinkingMode: config.thinkingMode ?? 'off',
+            workspaceRoot: config.workspaceRoot ?? process.cwd(),
         };
         this.contextManager = new ContextManager(config.contextManager);
         if (config.dynamicToolSelection) {
@@ -252,22 +255,22 @@ export class Agent extends EventEmitter {
     shouldFallbackToNext(err) {
         const e = err;
         const message = (e?.message || e?.error?.message || '').toLowerCase();
-        const statusCode = e?.status || e?.statusCode || e?.error?.code;
-        if (statusCode === 401 || statusCode === 403 || message.includes('unauthorized') || message.includes('forbidden') || message.includes('invalid api key')) {
+        // Prefer the structured status carried by ApiError; fall back to other shapes.
+        const status = err instanceof ApiError ? err.status : (e?.status ?? e?.statusCode ?? e?.error?.code);
+        if (status === 401 || status === 403 || message.includes('unauthorized') || message.includes('forbidden') || message.includes('invalid api key')) {
             return false;
         }
+        // Retry/fallback on transient upstream statuses.
+        if (status === 429 || status === 500 || status === 502 || status === 503 || status === 408 || status === 404) {
+            return true;
+        }
         return (message.includes('429') ||
             message.includes('rate limit') ||
             message.includes('provider returned error') ||
             message.includes('safety') ||
             message.includes('streaming failed') ||
             message.includes('stream error') ||
-            message.includes('try again') ||
-            statusCode === 429 ||
-            statusCode === 500 ||
-            statusCode === 502 ||
-            statusCode === 503 ||
-            statusCode === 404);
+            message.includes('try again'));
     }
     isModelCircuitOpen(model) {
         const state = this.modelFailures.get(model);
@@ -294,6 +297,10 @@ export class Agent extends EventEmitter {
         const keepCount = Math.floor(this.config.maxMessages * this.config.messageKeepRatio);
         const dropped = this.messages.length - keepCount;
         this.messages = this.messages.slice(dropped);
+        // Drop leading orphan tool messages — a tool result whose preceding
+        // assistant tool_call was sliced away would be rejected by the API.
+        while (this.messages[0]?.role === 'tool')
+            this.messages.shift();
         this.log.info(`Truncated ${dropped} oldest messages, keeping ${this.messages.length}`);
     }
     emitThinkingEnd() {
@@ -331,7 +338,7 @@ export class Agent extends EventEmitter {
                 model,
                 messages: apiMessages,
                 stream: false,
-            });
+            }, this._abortController?.signal);
             const summary = result.choices?.[0]?.message?.content?.trim() || '';
             if (!summary)
                 return 'Compaction failed: no summary generated.';
@@ -386,7 +393,7 @@ export class Agent extends EventEmitter {
                     { role: 'user', content: prompt },
                 ],
                 stream: false,
-            });
+            }, this._abortController?.signal);
             const summary = result.choices?.[0]?.message?.content?.trim() || '';
             if (summary) {
                 this.messages = [
@@ -451,6 +458,9 @@ export class Agent extends EventEmitter {
     deregisterFromRegistry(status) {
         if (!this.registeredInRegistry)
             return;
+        // Reset so a fresh send() re-registers, and guard against double-deregister
+        // (e.g. an aborted turn followed by the send() catch/finally path).
+        this.registeredInRegistry = false;
         AgentRegistry.getInstance().deregister(this.agentId, status);
     }
     checkInbox() {
@@ -540,7 +550,15 @@ export class Agent extends EventEmitter {
         else {
             instruction = 'IMPORTANT: Your final response MUST be valid JSON. Do not include any text outside the JSON object. No markdown code fences, no explanation — only the raw JSON.';
         }
+        // Inject the format instruction only once per session — refresh the existing
+        // system message in place if it's still valid, otherwise append once.
+        const existing = this.outputFormatInstructionIndex;
+        if (existing !== null && this.messages[existing]?.role === 'system') {
+            this.messages[existing] = { role: 'system', content: instruction };
+            return;
+        }
         this.messages.push({ role: 'system', content: instruction });
+        this.outputFormatInstructionIndex = this.messages.length - 1;
     }
     extractJsonFromResponse(response) {
         const trimmed = response.trim();
@@ -868,7 +886,28 @@ export class Agent extends EventEmitter {
                                 continue;
                             }
                         }
-                        const permission = getToolPermission(call.name, this.config.permissionMode);
+                        // Parse tool arguments once, up front, so the permission decision,
+                        // the confirmation prompt, and execution all see the same values.
+                        let parsedArgs;
+                        const rawArgs = (call.arguments ?? '').trim();
+                        if (rawArgs === '') {
+                            parsedArgs = {};
+                        }
+                        else {
+                            try {
+                                parsedArgs = JSON.parse(call.arguments);
+                            }
+                            catch {
+                                result = { error: 'Malformed JSON arguments — resend the tool call with valid JSON' };
+                                reqLog.warn('Malformed tool arguments', { tool: call.name });
+                                this.emit('tool:blocked', call.name, 'Malformed arguments');
+                                this.messages.push({ role: 'tool', content: JSON.stringify(result), tool_call_id: call.id, name: call.name });
+                                this.emit('tool:result', call.name, result);
+                                continue;
+                            }
+                        }
+                        // Args-aware permission so scoped allow/deny rules are enforced.
+                        const permission = getToolPermissionWithArgs(call.name, this.config.permissionMode, parsedArgs);
                         if (permission === 'block') {
                             result = { denied: true, message: `Tool ${call.name} is blocked in ${this.config.permissionMode} mode` };
                             reqLog.info('Tool blocked by permission mode', { tool: call.name, mode: this.config.permissionMode });
@@ -884,8 +923,8 @@ export class Agent extends EventEmitter {
                         }
                         if (permission === 'ask') {
                             if (!this.config.confirmToolCall) {
-                                if (this.config.permissionMode === 'auto') {
-                                    reqLog.info('Auto-approving tool (no confirmation handler in auto mode)', { tool: call.name });
+                                if (this.config.permissionMode === 'yolo') {
+                                    reqLog.info('Auto-approving tool (yolo mode, no confirmation handler)', { tool: call.name });
                                 }
                                 else {
                                     result = { denied: true, message: `Tool ${call.name} requires confirmation but no confirmation handler is available` };
@@ -902,13 +941,7 @@ export class Agent extends EventEmitter {
                                 }
                             }
                             else {
-                                let args;
-                                try {
-                                    args = JSON.parse(call.arguments);
-                                }
-                                catch {
-                                    args = call.arguments;
-                                }
+                                const args = parsedArgs;
                                 const CONFIRM_TIMEOUT_MS = 300_000;
                                 const confirmed = await new Promise((resolve) => {
                                     const timer = setTimeout(() => resolve(false), CONFIRM_TIMEOUT_MS);
@@ -940,20 +973,14 @@ export class Agent extends EventEmitter {
                         const execFn = tool?.function?.execute ?? tool?.execute;
                         if (tool && typeof execFn === 'function') {
                             try {
-                                let args;
-                                try {
-                                    args = normalizeArgs(JSON.parse(call.arguments));
-                                }
-                                catch {
-                                    args = {};
-                                }
+                                const args = normalizeArgs(parsedArgs);
                                 reqLog.debug('Executing tool', { tool: call.name });
                                 const toolTimeout = (typeof args?.timeout === 'number' && args.timeout > 0)
                                     ? Math.min(args.timeout, TOOL_DEFAULTS.maxCommandTimeoutMs)
                                     : this.config.toolTimeoutMs;
                                 result = await withTimeout(execFn(args, {
                                     context: {},
-                                    workspaceRoot: process.cwd(),
+                                    workspaceRoot: this.config.workspaceRoot ?? process.cwd(),
                                     permissionMode: this.config.permissionMode,
                                     agentId: this.agentId,
                                     agentConfig: {

package/dist/api-client.js

@@ -1,13 +1,28 @@
+export class ApiError extends Error {
+    status;
+    body;
+    constructor(status, statusText, body) {
+        super(`API request failed: ${status} ${statusText}${body ? ` — ${body.slice(0, 200)}` : ''}`);
+        this.name = 'ApiError';
+        this.status = status;
+        this.body = body;
+    }
+}
+const DEFAULT_TIMEOUT_MS = 120_000;
 export class ScalixClient {
     baseURL;
     apiKey;
-    constructor(baseURL, apiKey) {
+    timeoutMs;
+    constructor(baseURL, apiKey, timeoutMs = DEFAULT_TIMEOUT_MS) {
         this.baseURL = baseURL.replace(/\/+$/, '');
         this.apiKey = apiKey;
+        this.timeoutMs = timeoutMs;
     }
     async chatComplete(req, signal) {
         const url = `${this.baseURL}/chat/completions`;
         const body = JSON.stringify(req);
+        const timeoutSignal = AbortSignal.timeout(this.timeoutMs);
+        const combined = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
         const response = await fetch(url, {
             method: 'POST',
             headers: {
@@ -16,11 +31,11 @@ export class ScalixClient {
                 'User-Agent': 'Scalix-Coder/1.0',
             },
             body,
-            signal,
+            signal: combined,
         });
         if (!response.ok) {
             const text = await response.text().catch(() => '');
-            throw new Error(`API request failed: ${response.status} ${response.statusText}${text ? ` — ${text.slice(0, 200)}` : ''}`);
+            throw new ApiError(response.status, response.statusText, text);
         }
         if (req.stream) {
             return this.parseSSEStream(response);
@@ -45,32 +60,52 @@ export class ScalixClient {
                     const trimmed = line.trim();
                     if (!trimmed || trimmed.startsWith(':'))
                         continue;
-                    if (trimmed.startsWith('data: ')) {
-                        const data = trimmed.slice(6);
+                    if (trimmed.startsWith('data:')) {
+                        const data = trimmed.slice(5).replace(/^ /, '');
                         if (data === '[DONE]')
                             return;
+                        let parsed;
                         try {
-                            yield JSON.parse(data);
+                            parsed = JSON.parse(data);
                         }
                         catch {
                             // skip malformed chunks
+                            continue;
+                        }
+                        if (parsed && parsed.error) {
+                            const err = parsed.error;
+                            throw new Error(`Stream error: ${typeof err === 'string' ? err : (err?.message || JSON.stringify(err))}`);
                         }
+                        yield parsed;
                     }
                 }
             }
-            if (buffer.trim().startsWith('data: ')) {
-                const data = buffer.trim().slice(6);
+            const tail = buffer.trim();
+            if (tail.startsWith('data:')) {
+                const data = tail.slice(5).replace(/^ /, '');
                 if (data !== '[DONE]') {
+                    let parsed;
                     try {
-                        yield JSON.parse(data);
+                        parsed = JSON.parse(data);
                     }
                     catch {
                         // skip
                     }
+                    if (parsed) {
+                        if (parsed.error) {
+                            const err = parsed.error;
+                            throw new Error(`Stream error: ${typeof err === 'string' ? err : (err?.message || JSON.stringify(err))}`);
+                        }
+                        yield parsed;
+                    }
                 }
             }
         }
         finally {
+            try {
+                await reader.cancel();
+            }
+            catch { }
             reader.releaseLock();
         }
     }

package/dist/auto-verify.js

@@ -74,7 +74,8 @@ async function detectChecker(filePath, projectRoot) {
         }
         // Verify the tool is available
         try {
-            await execFileAsync('which', [checker.command[0]], { timeout: 3000 });
+            const probe = process.platform === 'win32' ? 'where' : 'which';
+            await execFileAsync(probe, [checker.command[0]], { timeout: 3000, shell: process.platform === 'win32' });
         }
         catch {
             // Tool not installed, skip
@@ -100,6 +101,7 @@ export async function runVerification(filePath, projectRoot, config = VERIFY_DEF
             cwd: projectRoot,
             timeout: config.timeoutMs,
             maxBuffer: 512 * 1024,
+            shell: process.platform === 'win32',
         });
         const output = (stderr || stdout).trim();
         return {