kernelbot 1.0.25 → 1.0.28

package/src/providers/base.js

@@ -4,11 +4,84 @@
  */
 
 export class BaseProvider {
-  constructor({ model, maxTokens, temperature, apiKey }) {
+  constructor({ model, maxTokens, temperature, apiKey, timeout }) {
     this.model = model;
     this.maxTokens = maxTokens;
     this.temperature = temperature;
     this.apiKey = apiKey;
+    this.timeout = timeout || 60_000;
+  }
+
+  /**
+   * Wrap an async LLM call with timeout + single retry on transient errors.
+   * Composes an internal timeout AbortController with an optional external signal
+   * (e.g. worker cancellation). Either aborting will cancel the call.
+   *
+   * @param {(signal: AbortSignal) => Promise<any>} fn - The API call, receives composed signal
+   * @param {AbortSignal} [externalSignal] - Optional external abort signal
+   * @returns {Promise<any>}
+   */
+  async _callWithResilience(fn, externalSignal) {
+    for (let attempt = 1; attempt <= 2; attempt++) {
+      const ac = new AbortController();
+      const timer = setTimeout(
+        () => ac.abort(new Error(`LLM call timed out after ${this.timeout / 1000}s`)),
+        this.timeout,
+      );
+
+      // If external signal already aborted, bail immediately
+      if (externalSignal?.aborted) {
+        clearTimeout(timer);
+        throw externalSignal.reason || new Error('Aborted');
+      }
+
+      // Forward external abort to our internal controller
+      let removeListener;
+      if (externalSignal) {
+        const onAbort = () => {
+          clearTimeout(timer);
+          ac.abort(externalSignal.reason || new Error('Cancelled'));
+        };
+        externalSignal.addEventListener('abort', onAbort, { once: true });
+        removeListener = () => externalSignal.removeEventListener('abort', onAbort);
+      }
+
+      try {
+        const result = await fn(ac.signal);
+        clearTimeout(timer);
+        removeListener?.();
+        return result;
+      } catch (err) {
+        clearTimeout(timer);
+        removeListener?.();
+
+        if (attempt < 2 && this._isTransient(err)) {
+          await new Promise((r) => setTimeout(r, 1500));
+          continue;
+        }
+        throw err;
+      }
+    }
+  }
+
+  /**
+   * Determine if an error is transient and worth retrying.
+   * Covers connection errors, timeouts, 5xx, and 429 rate limits.
+   */
+  _isTransient(err) {
+    const msg = err?.message || '';
+    if (
+      msg.includes('Connection error') ||
+      msg.includes('ECONNRESET') ||
+      msg.includes('socket hang up') ||
+      msg.includes('ETIMEDOUT') ||
+      msg.includes('fetch failed') ||
+      msg.includes('timed out')
+    ) {
+      return true;
+    }
+    const status = err?.status || err?.statusCode;
+    return (status >= 500 && status < 600) || status === 429;
   }
 
   /**
@@ -17,9 +90,10 @@ export class BaseProvider {
    * @param {string} opts.system - System prompt
    * @param {Array} opts.messages - Anthropic-format messages
    * @param {Array} opts.tools - Anthropic-format tool definitions
+   * @param {AbortSignal} [opts.signal] - Optional AbortSignal for cancellation
    * @returns {Promise<{stopReason: 'end_turn'|'tool_use', text: string, toolCalls: Array<{id,name,input}>, rawContent: Array}>}
    */
-  async chat({ system, messages, tools }) {
+  async chat({ system, messages, tools, signal }) {
     throw new Error('chat() not implemented');
   }
 

package/src/providers/index.js

@@ -22,6 +22,7 @@ export function createProvider(config) {
     maxTokens: max_tokens,
     temperature,
     apiKey: api_key,
+    timeout: config.brain.timeout,
   };
 
   if (provider === 'anthropic') {

package/src/providers/models.js

@@ -27,8 +27,9 @@ export const PROVIDERS = {
     envKey: 'GOOGLE_API_KEY',
     baseUrl: 'https://generativelanguage.googleapis.com/v1beta/openai/',
     models: [
-      { id: 'gemini-2.0-flash', label: 'Gemini 2.0 Flash' },
+      { id: 'gemini-2.5-flash', label: 'Gemini 2.5 Flash' },
       { id: 'gemini-2.5-pro', label: 'Gemini 2.5 Pro' },
+      { id: 'gemini-2.0-flash', label: 'Gemini 2.0 Flash' },
     ],
   },
   groq: {

package/src/providers/openai-compat.js

@@ -128,7 +128,7 @@ export class OpenAICompatProvider extends BaseProvider {
 
   // ── Public API ──
 
-  async chat({ system, messages, tools }) {
+  async chat({ system, messages, tools, signal }) {
     const params = {
       model: this.model,
       messages: this._convertMessages(system, messages),
@@ -145,8 +145,10 @@ export class OpenAICompatProvider extends BaseProvider {
       params.tools = convertedTools;
     }
 
-    const response = await this.client.chat.completions.create(params);
-    return this._normalizeResponse(response);
+    return this._callWithResilience(async (timedSignal) => {
+      const response = await this.client.chat.completions.create(params, { signal: timedSignal });
+      return this._normalizeResponse(response);
+    }, signal);
   }
 
   async ping() {

package/src/security/confirm.js

@@ -6,7 +6,7 @@ const DANGEROUS_PATTERNS = [
   { tool: 'github_create_repo', pattern: null, label: 'create a GitHub repository' },
   { tool: 'docker_compose', param: 'action', value: 'down', label: 'take down containers' },
   { tool: 'git_push', param: 'force', value: true, label: 'force push' },
-  { tool: 'interact_with_page', pattern: null, label: 'interact with a webpage (click, type, execute scripts)' },
+  { tool: 'interact_with_page', param: 'actions', check: (actions) => Array.isArray(actions) && actions.some((a) => a.type === 'evaluate'), label: 'execute JavaScript on a webpage' },
 ];
 
 export function requiresConfirmation(toolName, params, config) {
@@ -22,7 +22,12 @@ export function requiresConfirmation(toolName, params, config) {
     }
 
     // Param value match
-    if (rule.param && params[rule.param] === rule.value) {
+    if (rule.param && rule.value !== undefined && params[rule.param] === rule.value) {
+      return rule.label;
+    }
+
+    // Custom check function
+    if (rule.param && rule.check && rule.check(params[rule.param])) {
       return rule.label;
     }