acpreact 1.1.1 → 1.1.2

package/core.js

@@ -6,14 +6,12 @@ import { FallbackEngine } from './fallback.js';
 
 const DEFAULT_TIMEOUT_MS = 120_000;
 
-function attachOutputs(err, output, errorOutput) {
-  err.output = output;
-  err.stderr = errorOutput;
-  return err;
-}
+function attachOutputs(err, output, errorOutput) { err.output = output; err.stderr = errorOutput; return err; }
 
 function spawnService(entry, prompt, options, callbacks) {
+  const abortSignal = options?._abortSignal;
   return new Promise((resolve, reject) => {
+    if (abortSignal?.aborted) return reject(new Error('Aborted'));
     const binary = entry.config?.binary || entry.name;
     const args = entry.config?.buildArgs
       ? entry.config.buildArgs(prompt, options)
@@ -23,17 +21,21 @@ function spawnService(entry, prompt, options, callbacks) {
     child.stdin.end();
     child.stdout.on('data', (d) => { const c = d.toString(); output += c; callbacks?.onOutput?.(c); });
     child.stderr.on('data', (d) => { const c = d.toString(); errorOutput += c; callbacks?.onStderr?.(c); });
+    const timeoutMs = options?.timeout ?? DEFAULT_TIMEOUT_MS;
     const timer = setTimeout(() => {
       child.kill();
-      reject(attachOutputs(new Error(`Timeout after ${DEFAULT_TIMEOUT_MS}ms`), output, errorOutput));
-    }, options?.timeout ?? DEFAULT_TIMEOUT_MS);
+      reject(attachOutputs(new Error(`Timeout after ${timeoutMs}ms`), output, errorOutput));
+    }, timeoutMs);
+    const onAbort = () => { child.kill(); clearTimeout(timer); reject(attachOutputs(new Error('Aborted'), output, errorOutput)); };
+    abortSignal?.addEventListener('abort', onAbort, { once: true });
     child.on('close', (code) => {
       clearTimeout(timer);
+      abortSignal?.removeEventListener('abort', onAbort);
       if (code !== 0 && code !== null && !output)
         return reject(attachOutputs(new Error(`${binary} exited with code ${code}: ${errorOutput}`), output, errorOutput));
       resolve({ rawOutput: output, stderr: errorOutput, code });
     });
-    child.on('error', (err) => { clearTimeout(timer); reject(attachOutputs(err, output, errorOutput)); });
+    child.on('error', (err) => { clearTimeout(timer); abortSignal?.removeEventListener('abort', onAbort); reject(attachOutputs(err, output, errorOutput)); });
   });
 }
 
@@ -55,9 +57,13 @@ class ACPProtocol extends EventEmitter {
       }
     }
     this.fallback = new FallbackEngine([]);
-    this.fallback.on('rate-limited', (e) => this.emit('rate-limited', e));
+    this.fallback.on('rate-limited', (e) => {
+      this.registry.markRateLimited(e.name, e.profileId, e.cooldownMs);
+      this.emit('rate-limited', e);
+    });
     this.fallback.on('fallback', (e) => this.emit('fallback', e));
     this.fallback.on('success', (e) => this.emit('success', e));
+    this._abortController = null;
   }
 
   generateRequestId() { return ++this.messageId; }
@@ -109,12 +115,7 @@ class ACPProtocol extends EventEmitter {
 
   createJsonRpcResponse(id, result) { return { jsonrpc: '2.0', id, result }; }
 
-  createJsonRpcError(id, error) {
-    return {
-      jsonrpc: '2.0', id,
-      error: { code: error?.code ?? -32000, message: error instanceof Error ? error.message : String(error) },
-    };
-  }
+  createJsonRpcError(id, error) { return { jsonrpc: '2.0', id, error: { code: error?.code ?? -32000, message: error instanceof Error ? error.message : String(error) } }; }
 
   validateToolCall(toolName) {
     if (!this.toolWhitelist.has(toolName)) {
@@ -149,16 +150,22 @@ class ACPProtocol extends EventEmitter {
     if (options.services) {
       stack = createServiceStack(options.services);
     } else if (options.cli) {
-      stack = [{ name: options.cli, profileId: '__default__', config: {} }];
+      stack = [{ name: options.cli, profileId: '__default__', config: { cli: options.cli } }];
     } else {
       stack = this.registry.getAll().length > 0
         ? this.registry.getAvailable()
-        : [{ name: 'kilo', profileId: '__default__', config: {} }];
+        : [{ name: 'kilo', profileId: '__default__', config: { cli: 'kilo' } }];
     }
 
-    this.fallback._stack = stack;
+    this._abortController = new AbortController();
+    const runOptions = { ...options, _abortSignal: this._abortController.signal };
+    const engine = new FallbackEngine(stack);
+    engine.on('rate-limited', (e) => this.fallback.emit('rate-limited', e));
+    engine.on('fallback', (e) => this.fallback.emit('fallback', e));
+    engine.on('success', (e) => this.fallback.emit('success', e));
 
-    const { rawOutput } = await this.fallback.run(spawnService, fullPrompt, options);
+    const { rawOutput } = await engine.run(spawnService, fullPrompt, runOptions);
+    this._abortController = null;
 
     try {
       const toolCalls = parseToolCalls(rawOutput);
@@ -176,7 +183,7 @@ class ACPProtocol extends EventEmitter {
     }
   }
 
-  stop() {}
+  stop() { if (this._abortController) { this._abortController.abort(); this._abortController = null; } }
 }
 
 export { ACPProtocol };

package/index.js

@@ -1,8 +1,8 @@
 import { ACPProtocol } from './core.js';
-import { ServiceRegistry, isRateLimited, createServiceStack } from './services.js';
+import { ServiceRegistry, isRateLimited, createServiceStack, buildArgs, DEFAULT_COOLDOWN_MS } from './services.js';
 import { FallbackEngine } from './fallback.js';
 
-export { ACPProtocol, ServiceRegistry, FallbackEngine, isRateLimited, createServiceStack };
+export { ACPProtocol, ServiceRegistry, FallbackEngine, isRateLimited, createServiceStack, buildArgs, DEFAULT_COOLDOWN_MS };
 
 /*
  * acpreact - ACP SDK for registering tools with multi-service fallback

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "acpreact",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "type": "module",
   "main": "index.js",
   "description": "ACP SDK for monitoring and reacting to chat conversations",