dashclaw 1.8.3 → 1.9.0

package/README.md

@@ -558,6 +558,46 @@ Report a token usage snapshot for this agent.
 
 **Returns:** `Promise<{snapshot: Object}>`
 
+### claw.wrapClient(llmClient, options?)
+Wrap an Anthropic or OpenAI client to auto-report token usage after every call. Returns the same client instance for fluent usage. Streaming calls (where response lacks `.usage`) are safely ignored.
+
+**Parameters:**
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| llmClient | Object | Yes | An Anthropic or OpenAI SDK client instance |
+| options.provider | string | No | Force `'anthropic'` or `'openai'` if auto-detect fails |
+
+**Returns:** The wrapped client (same instance)
+
+**Example (Anthropic):**
+```javascript
+import Anthropic from '@anthropic-ai/sdk';
+import { DashClaw } from 'dashclaw';
+
+const claw = new DashClaw({ baseUrl: 'http://localhost:3000', agentId: 'my-agent', apiKey: '...' });
+const anthropic = claw.wrapClient(new Anthropic());
+
+const msg = await anthropic.messages.create({
+  model: 'claude-sonnet-4-20250514',
+  max_tokens: 1024,
+  messages: [{ role: 'user', content: 'Hello' }],
+});
+// Token usage auto-reported to DashClaw
+```
+
+**Example (OpenAI):**
+```javascript
+import OpenAI from 'openai';
+
+const openai = claw.wrapClient(new OpenAI());
+
+const chat = await openai.chat.completions.create({
+  model: 'gpt-4o',
+  messages: [{ role: 'user', content: 'Hello' }],
+});
+// Token usage auto-reported to DashClaw
+```
+
 ### claw.recordDecision(entry)
 Record a decision for the learning database. Track what your agent decides and why.
 
@@ -1093,6 +1133,27 @@ Scan text and store finding metadata for audit trails. The original content is n
 
 **Returns:** `Promise<{clean: boolean, findings_count: number, findings: Object[], redacted_text: string}>`
 
+### claw.scanPromptInjection(text, options?)
+Scan text for prompt injection attacks — role overrides, delimiter injection, instruction smuggling, data exfiltration attempts, and encoding evasion. Returns risk level and actionable recommendation.
+
+**Parameters:**
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| text | string | Yes | Text to scan for injection attacks |
+| options.source | string | No | Where this text came from (e.g. user_input, tool_output, retrieval) |
+
+**Returns:** `Promise<{clean: boolean, risk_level: string, recommendation: string, findings_count: number, critical_count: number, categories: string[], findings: Object[]}>`
+
+**Example:**
+```javascript
+const result = await claw.scanPromptInjection(userMessage, { source: 'user_input' });
+if (result.recommendation === 'block') {
+  console.error(`Blocked: ${result.findings_count} injection patterns detected`);
+} else if (result.recommendation === 'warn') {
+  console.warn(`Warning: ${result.categories.join(', ')} detected`);
+}
+```
+
 ---
 
 ## Agent Messaging

package/dashclaw.js

@@ -13,7 +13,7 @@
  * - Automation Snippets (5)
  * - User Preferences (6)
  * - Daily Digest (1)
- * - Security Scanning (2)
+ * - Security Scanning (3)
  * - Agent Messaging (9)
  * - Behavior Guard (2)
  * - Agent Pairing (3)
@@ -885,7 +885,7 @@ class DashClaw {
   }
 
   // ══════════════════════════════════════════════
-  // Category 4: Dashboard Data (8 methods)
+  // Category 4: Dashboard Data (9 methods)
   // ══════════════════════════════════════════════
 
   /**
@@ -905,6 +905,79 @@ class DashClaw {
     });
   }
 
+  /**
+   * Internal: fire-and-forget token report extracted from an LLM response.
+   * @private
+   */
+  async _reportTokenUsageFromLLM({ tokens_in, tokens_out, model }) {
+    if (tokens_in == null && tokens_out == null) return;
+    try {
+      await this._request('/api/tokens', 'POST', {
+        tokens_in: tokens_in || 0,
+        tokens_out: tokens_out || 0,
+        model: model || undefined,
+        agent_id: this.agentId,
+      });
+    } catch (_) {
+      // fire-and-forget: never let telemetry break the caller
+    }
+  }
+
+  /**
+   * Wrap an Anthropic or OpenAI client to auto-report token usage after each call.
+   * Returns the same client instance (mutated) for fluent usage.
+   *
+   * @param {Object} llmClient - An Anthropic or OpenAI SDK client instance
+   * @param {Object} [options]
+   * @param {'anthropic'|'openai'} [options.provider] - Force provider detection
+   * @returns {Object} The wrapped client
+   *
+   * @example
+   * const anthropic = claw.wrapClient(new Anthropic());
+   * const msg = await anthropic.messages.create({ model: 'claude-sonnet-4-20250514', max_tokens: 1024, messages: [...] });
+   * // Token usage is auto-reported to DashClaw
+   */
+  wrapClient(llmClient, { provider } = {}) {
+    if (llmClient._dashclawWrapped) return llmClient;
+
+    const detected = provider
+      || (llmClient.messages?.create ? 'anthropic' : null)
+      || (llmClient.chat?.completions?.create ? 'openai' : null);
+
+    if (!detected) {
+      throw new Error(
+        'DashClaw.wrapClient: unable to detect provider. Pass { provider: "anthropic" } or { provider: "openai" }.'
+      );
+    }
+
+    if (detected === 'anthropic') {
+      const original = llmClient.messages.create.bind(llmClient.messages);
+      llmClient.messages.create = async (...args) => {
+        const response = await original(...args);
+        this._reportTokenUsageFromLLM({
+          tokens_in: response?.usage?.input_tokens ?? null,
+          tokens_out: response?.usage?.output_tokens ?? null,
+          model: response?.model ?? null,
+        });
+        return response;
+      };
+    } else if (detected === 'openai') {
+      const original = llmClient.chat.completions.create.bind(llmClient.chat.completions);
+      llmClient.chat.completions.create = async (...args) => {
+        const response = await original(...args);
+        this._reportTokenUsageFromLLM({
+          tokens_in: response?.usage?.prompt_tokens ?? null,
+          tokens_out: response?.usage?.completion_tokens ?? null,
+          model: response?.model ?? null,
+        });
+        return response;
+      };
+    }
+
+    llmClient._dashclawWrapped = true;
+    return llmClient;
+  }
+
   /**
    * Record a decision for the learning database.
    * @param {Object} entry
@@ -1497,7 +1570,7 @@ class DashClaw {
   }
 
   // ══════════════════════════════════════════════
-  // Category 10: Security Scanning (2 methods)
+  // Category 10: Security Scanning (3 methods)
   // ══════════════════════════════════════════════
 
   /**
@@ -1532,6 +1605,22 @@ class DashClaw {
     });
   }
 
+  /**
+   * Scan text for prompt injection attacks (role overrides, delimiter injection,
+   * instruction smuggling, data exfiltration attempts, etc.).
+   * @param {string} text - Text to scan
+   * @param {Object} [options]
+   * @param {string} [options.source] - Where this text came from (for context)
+   * @returns {Promise<{clean: boolean, risk_level: string, recommendation: string, findings_count: number, critical_count: number, categories: string[], findings: Object[]}>}
+   */
+  async scanPromptInjection(text, options = {}) {
+    return this._request('/api/security/prompt-injection', 'POST', {
+      text,
+      source: options.source,
+      agent_id: this.agentId,
+    });
+  }
+
   // ══════════════════════════════════════════════
   // Category 11: Agent Messaging (11 methods)
   // ══════════════════════════════════════════════

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dashclaw",
-  "version": "1.8.3",
+  "version": "1.9.0",
   "description": "Full-featured agent toolkit for the DashClaw platform. 96+ methods across 22+ categories for action recording, context management, session handoffs, security scanning, behavior guard, compliance, task routing, identity binding, organization management, webhooks, bulk sync, and more.",
   "type": "module",
   "publishConfig": {