dashclaw 2.9.0 → 2.10.0

package/README.md

@@ -1,4 +1,4 @@
-# DashClaw SDK (v2.7.0)
+# DashClaw SDK (v2.10.0)
 
 **Minimal governance runtime for AI agents.**
 
@@ -70,9 +70,9 @@ claw.update_outcome(action_id, status="completed")
 
 ---
 
-## SDK Surface Area (v2.5.0)
+## SDK Surface Area (v2.10.0)
 
-The v2 SDK exposes **45 methods** optimized for stability and zero-overhead governance:
+The v2 SDK exposes **67 methods** optimized for stability and zero-overhead governance:
 
 ### Core Runtime
 - `guard(context)` -- Policy evaluation ("Can I do X?"). Returns `risk_score` (server-computed) and `agent_risk_score` (raw agent value)
@@ -387,5 +387,120 @@ Methods moved to v1 only: `createWebhook`, `getActivityLogs`, `mapCompliance`, `
 
 ---
 
+## Execution Studio
+
+Governance packaging and discovery — workflow templates, model strategies, knowledge collections, a capability registry, and a read-only execution graph. Added in v2.10.0.
+
+### Execution Graph
+
+```javascript
+// Fetch the execution graph for any action (reuses existing trace data)
+const { rootActionId, nodes, edges } = await claw.getActionGraph(actionId);
+// nodes: action:<id>, assumption:<id>, loop:<id>
+// edges: parent_child | related | assumption_of | loop_from
+```
+
+### Workflow Templates
+
+```javascript
+// List templates
+const { templates } = await claw.listWorkflowTemplates({ status: 'active' });
+
+// Create a template
+const { template } = await claw.createWorkflowTemplate({
+  name: 'Release Hotfix',
+  description: 'Ship urgent production patches safely',
+  objective: 'Deploy with full policy + approval coverage',
+  linked_policy_ids: ['pol_prod_deploy'],
+  linked_capability_tags: ['deploy'],
+  model_strategy_id: 'mst_balanced_default'
+});
+
+// Get / update / duplicate
+const detail = await claw.getWorkflowTemplate(templateId);
+await claw.updateWorkflowTemplate(templateId, {
+  steps: [{ id: 'plan' }, { id: 'test' }, { id: 'deploy' }]
+}); // bumps version when steps change
+await claw.duplicateWorkflowTemplate(templateId);
+
+// Launch — creates a traceable action_records row with workflow metadata.
+// If the template links a model_strategy_id, the resolved config is snapshotted.
+const { launch } = await claw.launchWorkflowTemplate(templateId, { agent_id: 'deploy-bot' });
+console.log(launch.action_id); // act_... — view it in /decisions/<action_id>
+```
+
+### Model Strategies
+
+```javascript
+// List and create
+const { strategies } = await claw.listModelStrategies();
+const { strategy } = await claw.createModelStrategy({
+  name: 'Balanced Default',
+  description: 'GPT-4.1 primary, Claude Sonnet 4 fallback',
+  config: {
+    primary: { provider: 'openai', model: 'gpt-4.1' },
+    fallback: [{ provider: 'anthropic', model: 'claude-sonnet-4' }],
+    costSensitivity: 'balanced',        // 'low' | 'balanced' | 'high-quality'
+    latencySensitivity: 'medium',       // 'low' | 'medium' | 'high'
+    maxBudgetUsd: 0.5,
+    maxRetries: 2,
+    allowedProviders: ['openai', 'anthropic']
+  }
+});
+
+// Update (config patches merge over existing config)
+await claw.updateModelStrategy(strategyId, { config: { maxBudgetUsd: 1.0 } });
+
+// Delete (soft references on linked workflow_templates are nulled out)
+await claw.deleteModelStrategy(strategyId);
+```
+
+### Knowledge Collections
+
+Metadata-only layer — no embedding or retrieval yet. Ingestion execution is planned for Phase 2b.
+
+```javascript
+// Create a collection
+const { collection } = await claw.createKnowledgeCollection({
+  name: 'Runbook Library',
+  description: 'Incident response runbooks',
+  source_type: 'files',  // 'files' | 'urls' | 'external' | 'notes'
+  tags: ['ops', 'oncall']
+});
+
+// Add items (bumps parent doc_count; transitions ingestion_status from empty → pending)
+await claw.addKnowledgeCollectionItem(collection.collection_id, {
+  source_uri: 'https://docs.example.com/runbook.md',
+  title: 'Deploy runbook',
+  mime_type: 'text/markdown'
+});
+
+// List items
+const { items } = await claw.listKnowledgeCollectionItems(collection.collection_id);
+```
+
+### Capability Registry
+
+```javascript
+// Search the registry (category, risk_level, and search are combinable)
+const { capabilities } = await claw.listCapabilities({ risk_level: 'medium', search: 'slack' });
+
+// Register a capability
+await claw.createCapability({
+  name: 'Send Slack Message',
+  description: 'Posts to a configured Slack channel',
+  category: 'messaging',
+  source_type: 'http_api',        // 'internal_sdk' | 'http_api' | 'webhook' | 'human_approval' | 'external_marketplace'
+  auth_type: 'oauth',
+  risk_level: 'medium',           // 'low' | 'medium' | 'high' | 'critical'
+  requires_approval: false,
+  tags: ['notify', 'slack'],
+  health_status: 'healthy',
+  docs_url: 'https://docs.example.com/slack'
+});
+```
+
+---
+
 ## License
 MIT

package/dashclaw.js

@@ -1,5 +1,5 @@
 /**
- * DashClaw SDK v2.8.0 (Stable Runtime API)
+ * DashClaw SDK v2.10.0 (Stable Runtime API)
  * Focused governance runtime client for AI agents.
  */
 
@@ -643,6 +643,190 @@ class DashClaw {
   async getSessionEvents(sessionId) {
     return this._request(`/api/sessions/${sessionId}/events`, 'GET');
   }
+
+  // ---------------------------------------------------------------------------
+  // Execution Studio — Execution Graph
+  // ---------------------------------------------------------------------------
+
+  /**
+   * GET /api/actions/:id/graph — Read-only execution graph (nodes + edges).
+   */
+  async getActionGraph(actionId) {
+    return this._request(`/api/actions/${actionId}/graph`, 'GET');
+  }
+
+  // ---------------------------------------------------------------------------
+  // Execution Studio — Workflow Templates
+  // ---------------------------------------------------------------------------
+
+  /**
+   * GET /api/workflows/templates — List workflow templates.
+   * @param {Object} [filters={}] - { status, limit, offset }
+   */
+  async listWorkflowTemplates(filters = {}) {
+    return this._request('/api/workflows/templates', 'GET', null, filters);
+  }
+
+  /**
+   * POST /api/workflows/templates — Create a workflow template.
+   */
+  async createWorkflowTemplate(data) {
+    return this._request('/api/workflows/templates', 'POST', data);
+  }
+
+  /**
+   * GET /api/workflows/templates/:id — Fetch a single template.
+   */
+  async getWorkflowTemplate(templateId) {
+    return this._request(`/api/workflows/templates/${templateId}`, 'GET');
+  }
+
+  /**
+   * PATCH /api/workflows/templates/:id — Partial update. Bumps version when steps change.
+   */
+  async updateWorkflowTemplate(templateId, patch) {
+    return this._request(`/api/workflows/templates/${templateId}`, 'PATCH', patch);
+  }
+
+  /**
+   * POST /api/workflows/templates/:id/duplicate — Clone as a new draft.
+   */
+  async duplicateWorkflowTemplate(templateId, overrides = {}) {
+    return this._request(`/api/workflows/templates/${templateId}/duplicate`, 'POST', overrides);
+  }
+
+  /**
+   * POST /api/workflows/templates/:id/launch — Create a traceable action record.
+   * Resolves any linked model strategy into a snapshot at launch time.
+   */
+  async launchWorkflowTemplate(templateId, options = {}) {
+    return this._request(`/api/workflows/templates/${templateId}/launch`, 'POST', options);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Execution Studio — Model Strategies
+  // ---------------------------------------------------------------------------
+
+  /**
+   * GET /api/model-strategies — List model strategies.
+   */
+  async listModelStrategies() {
+    return this._request('/api/model-strategies', 'GET');
+  }
+
+  /**
+   * POST /api/model-strategies — Create a model strategy.
+   * @param {Object} data - { name, description, config: { primary, fallback, costSensitivity, ... } }
+   */
+  async createModelStrategy(data) {
+    return this._request('/api/model-strategies', 'POST', data);
+  }
+
+  /**
+   * GET /api/model-strategies/:id — Fetch a single strategy.
+   */
+  async getModelStrategy(strategyId) {
+    return this._request(`/api/model-strategies/${strategyId}`, 'GET');
+  }
+
+  /**
+   * PATCH /api/model-strategies/:id — Partial update. Config patches merge over existing.
+   */
+  async updateModelStrategy(strategyId, patch) {
+    return this._request(`/api/model-strategies/${strategyId}`, 'PATCH', patch);
+  }
+
+  /**
+   * DELETE /api/model-strategies/:id — Delete. Nulls soft refs on linked templates.
+   */
+  async deleteModelStrategy(strategyId) {
+    return this._request(`/api/model-strategies/${strategyId}`, 'DELETE');
+  }
+
+  // ---------------------------------------------------------------------------
+  // Execution Studio — Knowledge Collections
+  // ---------------------------------------------------------------------------
+
+  /**
+   * GET /api/knowledge/collections — List knowledge collections.
+   * @param {Object} [filters={}] - { sourceType, limit, offset }
+   */
+  async listKnowledgeCollections(filters = {}) {
+    const params = {};
+    if (filters.sourceType) params.source_type = filters.sourceType;
+    if (filters.limit) params.limit = filters.limit;
+    if (filters.offset) params.offset = filters.offset;
+    return this._request('/api/knowledge/collections', 'GET', null, params);
+  }
+
+  /**
+   * POST /api/knowledge/collections — Create a knowledge collection.
+   */
+  async createKnowledgeCollection(data) {
+    return this._request('/api/knowledge/collections', 'POST', data);
+  }
+
+  /**
+   * GET /api/knowledge/collections/:id — Fetch a single collection.
+   */
+  async getKnowledgeCollection(collectionId) {
+    return this._request(`/api/knowledge/collections/${collectionId}`, 'GET');
+  }
+
+  /**
+   * PATCH /api/knowledge/collections/:id — Update collection metadata.
+   */
+  async updateKnowledgeCollection(collectionId, patch) {
+    return this._request(`/api/knowledge/collections/${collectionId}`, 'PATCH', patch);
+  }
+
+  /**
+   * GET /api/knowledge/collections/:id/items — List items in a collection.
+   * @param {Object} [filters={}] - { limit, offset }
+   */
+  async listKnowledgeCollectionItems(collectionId, filters = {}) {
+    return this._request(`/api/knowledge/collections/${collectionId}/items`, 'GET', null, filters);
+  }
+
+  /**
+   * POST /api/knowledge/collections/:id/items — Add an item. Bumps parent doc_count.
+   */
+  async addKnowledgeCollectionItem(collectionId, data) {
+    return this._request(`/api/knowledge/collections/${collectionId}/items`, 'POST', data);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Execution Studio — Capability Registry
+  // ---------------------------------------------------------------------------
+
+  /**
+   * GET /api/capabilities — Search the capability registry.
+   * @param {Object} [filters={}] - { category, risk_level, search, limit, offset }
+   */
+  async listCapabilities(filters = {}) {
+    return this._request('/api/capabilities', 'GET', null, filters);
+  }
+
+  /**
+   * POST /api/capabilities — Register a capability.
+   */
+  async createCapability(data) {
+    return this._request('/api/capabilities', 'POST', data);
+  }
+
+  /**
+   * GET /api/capabilities/:id — Fetch a single capability.
+   */
+  async getCapability(capabilityId) {
+    return this._request(`/api/capabilities/${capabilityId}`, 'GET');
+  }
+
+  /**
+   * PATCH /api/capabilities/:id — Update a capability.
+   */
+  async updateCapability(capabilityId, patch) {
+    return this._request(`/api/capabilities/${capabilityId}`, 'PATCH', patch);
+  }
 }
 
 export { DashClaw, ApprovalDeniedError, GuardBlockedError };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dashclaw",
-  "version": "2.9.0",
+  "version": "2.10.0",
   "description": "Minimal governance runtime for AI agents. Intercept, govern, and verify agent actions.",
   "type": "module",
   "publishConfig": {