@dotsetlabs/dotclaw 1.9.0 → 2.1.0

package/container/agent-runner/src/agent-config.ts

@@ -43,26 +43,6 @@ export type AgentRuntimeConfig = {
     models: {
       summary: string;
       memory: string;
-      planner: string;
-      responseValidation: string;
-      toolSummary: string;
-    };
-    planner: {
-      enabled: boolean;
-      mode: string;
-      minTokens: number;
-      triggerRegex: string;
-      maxOutputTokens: number;
-      temperature: number;
-    };
-    responseValidation: {
-      enabled: boolean;
-      maxOutputTokens: number;
-      temperature: number;
-      maxRetries: number;
-      allowToolCalls: boolean;
-      minPromptTokens: number;
-      minResponseTokens: number;
     };
     tools: {
       maxToolSteps: number;
@@ -113,6 +93,37 @@ export type AgentRuntimeConfig = {
       tokensPerMessage: number;
       tokensPerRequest: number;
     };
+    tts: {
+      enabled: boolean;
+      model: string;
+      baseUrl: string;
+      defaultVoice: string;
+    };
+    browser: {
+      enabled: boolean;
+      timeoutMs: number;
+      screenshotQuality: number;
+    };
+    mcp: {
+      enabled: boolean;
+      servers: Array<{
+        name: string;
+        transport: 'stdio';
+        command?: string;
+        args?: string[];
+        env?: Record<string, string>;
+        url?: string;
+      }>;
+      connectionTimeoutMs: number;
+    };
+    reasoning: {
+      effort: 'off' | 'low' | 'medium' | 'high';
+    };
+    skills: {
+      enabled: boolean;
+      maxSkills: number;
+      maxSummaryChars: number;
+    };
   };
 };
 
@@ -126,8 +137,8 @@ const DEFAULT_AGENT_CONFIG: AgentRuntimeConfig['agent'] = {
   openrouter: {
     timeoutMs: 180_000,
     retry: true,
-    siteUrl: '',
-    siteName: ''
+    siteUrl: 'https://github.com/dotsetlabs/dotclaw',
+    siteName: 'DotClaw'
   },
   promptPacks: {
     enabled: true,
@@ -140,7 +151,7 @@ const DEFAULT_AGENT_CONFIG: AgentRuntimeConfig['agent'] = {
     compactionTriggerTokens: 20_000,
     recentContextTokens: 8000,
     summaryUpdateEveryMessages: 20,
-    maxOutputTokens: 1024,
+    maxOutputTokens: 4096,
     summaryMaxOutputTokens: 2048,
     temperature: 0.2,
     maxContextMessageTokens: 3000
@@ -158,31 +169,11 @@ const DEFAULT_AGENT_CONFIG: AgentRuntimeConfig['agent'] = {
     extractScheduled: false
   },
   models: {
-    summary: 'openai/gpt-5-nano',
-    memory: 'openai/gpt-5-mini',
-    planner: 'openai/gpt-5-nano',
-    responseValidation: 'openai/gpt-5-nano',
-    toolSummary: 'openai/gpt-5-nano'
-  },
-  planner: {
-    enabled: true,
-    mode: 'auto',
-    minTokens: 800,
-    triggerRegex: '(plan|steps|roadmap|research|design|architecture|spec|strategy)',
-    maxOutputTokens: 1024,
-    temperature: 0.2
-  },
-  responseValidation: {
-    enabled: true,
-    maxOutputTokens: 1024,
-    temperature: 0,
-    maxRetries: 1,
-    allowToolCalls: false,
-    minPromptTokens: 400,
-    minResponseTokens: 160
+    summary: 'deepseek/deepseek-v3.2',
+    memory: 'deepseek/deepseek-v3.2'
   },
   tools: {
-    maxToolSteps: 96,
+    maxToolSteps: 50,
     outputLimitBytes: 400_000,
     enableBash: true,
     enableWebSearch: true,
@@ -222,13 +213,37 @@ const DEFAULT_AGENT_CONFIG: AgentRuntimeConfig['agent'] = {
     }
   },
   ipc: {
-    requestTimeoutMs: 6000,
+    requestTimeoutMs: 30_000,
     requestPollMs: 150
   },
   tokenEstimate: {
     tokensPerChar: 0.25,
     tokensPerMessage: 3,
     tokensPerRequest: 0
+  },
+  tts: {
+    enabled: true,
+    model: 'edge-tts',
+    baseUrl: '',
+    defaultVoice: 'en-US-AriaNeural'
+  },
+  browser: {
+    enabled: true,
+    timeoutMs: 30_000,
+    screenshotQuality: 80
+  },
+  mcp: {
+    enabled: false,
+    servers: [],
+    connectionTimeoutMs: 10_000
+  },
+  reasoning: {
+    effort: 'low',
+  },
+  skills: {
+    enabled: true,
+    maxSkills: 32,
+    maxSummaryChars: 4000,
   }
 };
 

package/container/agent-runner/src/browser.ts

@@ -0,0 +1,180 @@
+import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+const SCREENSHOTS_DIR = '/workspace/group/screenshots';
+const BROWSER_CMD = 'agent-browser';
+
+export interface BrowserResult {
+  success: boolean;
+  title?: string;
+  url?: string;
+  elements?: unknown[];
+  text?: string;
+  html?: string;
+  result?: unknown;
+  path?: string;
+  width?: number;
+  height?: number;
+  error?: string;
+}
+
+export class BrowserSession {
+  private timeoutMs: number;
+  private screenshotQuality: number;
+
+  constructor(options?: { timeoutMs?: number; screenshotQuality?: number }) {
+    this.timeoutMs = options?.timeoutMs ?? 30_000;
+    this.screenshotQuality = options?.screenshotQuality ?? 80;
+  }
+
+  private async exec(args: string[]): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const proc = spawn(BROWSER_CMD, args, {
+        timeout: this.timeoutMs,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: { ...process.env, BROWSER_JSON_OUTPUT: '1' }
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      proc.stdout?.on('data', (data: Buffer) => {
+        stdout += data.toString();
+      });
+      proc.stderr?.on('data', (data: Buffer) => {
+        stderr += data.toString();
+      });
+
+      proc.on('close', (code) => {
+        if (code !== 0) {
+          reject(new Error(stderr.trim() || `Browser command exited with code ${code}`));
+        } else {
+          resolve(stdout);
+        }
+      });
+
+      proc.on('error', (err) => {
+        reject(new Error(`Browser command failed: ${err.message}`));
+      });
+    });
+  }
+
+  private parseOutput(raw: string): unknown {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return { text: raw.trim() };
+    }
+  }
+
+  async navigate(url: string): Promise<BrowserResult> {
+    try {
+      const output = await this.exec(['navigate', url]);
+      const parsed = this.parseOutput(output) as Record<string, unknown>;
+      return {
+        success: true,
+        title: parsed.title as string | undefined,
+        url: parsed.url as string | undefined
+      };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+
+  async snapshot(interactive?: boolean): Promise<BrowserResult> {
+    try {
+      const args = ['snapshot'];
+      if (interactive) args.push('--interactive');
+      const output = await this.exec(args);
+      const parsed = this.parseOutput(output) as Record<string, unknown>;
+      return {
+        success: true,
+        elements: parsed.elements as unknown[] | undefined,
+        text: parsed.text as string | undefined
+      };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+
+  async click(ref: string): Promise<BrowserResult> {
+    try {
+      const output = await this.exec(['click', ref]);
+      const parsed = this.parseOutput(output) as Record<string, unknown>;
+      return {
+        success: true,
+        url: parsed.url as string | undefined
+      };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+
+  async fill(ref: string, text: string): Promise<BrowserResult> {
+    try {
+      await this.exec(['fill', ref, text]);
+      return { success: true };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+
+  async screenshot(fullPage?: boolean): Promise<BrowserResult> {
+    try {
+      fs.mkdirSync(SCREENSHOTS_DIR, { recursive: true });
+      const filename = `screenshot_${Date.now()}.png`;
+      const filepath = path.join(SCREENSHOTS_DIR, filename);
+      const args = ['screenshot', '--output', filepath, '--quality', String(this.screenshotQuality)];
+      if (fullPage) args.push('--full-page');
+      await this.exec(args);
+      if (!fs.existsSync(filepath)) {
+        return { success: false, error: 'Screenshot file not created' };
+      }
+      return {
+        success: true,
+        path: filepath
+      };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+
+  async extract(selector?: string): Promise<BrowserResult> {
+    try {
+      const args = ['extract'];
+      if (selector) args.push('--selector', selector);
+      const output = await this.exec(args);
+      const parsed = this.parseOutput(output) as Record<string, unknown>;
+      return {
+        success: true,
+        text: parsed.text as string | undefined,
+        html: parsed.html as string | undefined
+      };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+
+  async evaluate(js: string): Promise<BrowserResult> {
+    try {
+      const output = await this.exec(['evaluate', js]);
+      const parsed = this.parseOutput(output);
+      return {
+        success: true,
+        result: parsed
+      };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+
+  async close(): Promise<BrowserResult> {
+    try {
+      await this.exec(['close']);
+      return { success: true };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+}

package/container/agent-runner/src/container-protocol.ts

@@ -8,10 +8,7 @@ export interface ContainerInput {
   chatJid: string;
   isMain: boolean;
   isScheduledTask?: boolean;
-  isBackgroundTask?: boolean;
-  isBackgroundJob?: boolean;
   taskId?: string;
-  jobId?: string;
   userId?: string;
   userName?: string;
   maxToolSteps?: number;
@@ -37,15 +34,14 @@ export interface ContainerInput {
   behaviorConfig?: Record<string, unknown>;
   toolPolicy?: Record<string, unknown>;
   modelOverride?: string;
+  modelFallbacks?: string[];
+  reasoningEffort?: 'off' | 'low' | 'medium' | 'high';
   modelContextTokens?: number;
   modelMaxOutputTokens?: number;
   modelTemperature?: number;
   timezone?: string;
   hostPlatform?: string;
-  disablePlanner?: boolean;
-  disableResponseValidation?: boolean;
-  responseValidationMaxRetries?: number;
-  disableMemoryExtraction?: boolean;
+  streamDir?: string;
   attachments?: Array<{
     type: 'photo' | 'document' | 'voice' | 'video' | 'audio';
     path: string;
@@ -55,6 +51,7 @@ export interface ContainerInput {
     duration?: number;
     width?: number;
     height?: number;
+    transcript?: string;
   }>;
 }
 
@@ -74,8 +71,6 @@ export interface ContainerOutput {
   memory_items_upserted?: number;
   memory_items_extracted?: number;
   timings?: {
-    planner_ms?: number;
-    response_validation_ms?: number;
     memory_extraction_ms?: number;
     tool_ms?: number;
   };

package/container/agent-runner/src/id.ts

@@ -1,4 +1,5 @@
+import { randomUUID } from 'crypto';
+
 export function generateId(prefix: string): string {
-  if (!prefix) return `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  return prefix ? `${prefix}-${randomUUID()}` : randomUUID();
 }