Full reference for the DashClaw SDK (Node.js). For Python, see the Python SDK docs.

DashClaw treats every agent action as a governed decision. The SDK provides decision recording, policy enforcement, assumption tracking, and compliance mapping. It proves what your agents decided and why.

Install, configure, and govern your AI agents with 95+ methods across 21+ categories including action recording, behavior guard, context management, session handoffs, security scanning, agent messaging, agent pairing, identity binding, organization management, webhooks, policy testing, compliance, task routing, and more.

Install from npm, or copy the single-file SDK directly.

npm install dashclaw

import { DashClaw } from 'dashclaw';

const claw = new DashClaw({
  baseUrl: process.env.DASHCLAW_BASE_URL || 'http://localhost:3000',
  // Use http://localhost:3000 for local, or https://your-app.vercel.app for cloud
  apiKey: process.env.DASHCLAW_API_KEY,
  agentId: 'my-agent',
  agentName: 'My Agent',
  hitlMode: 'wait', // Optional: automatically wait for human approval
});

// Create an action before doing work
const { action_id } = await claw.createAction({
  action_type: 'deploy',
  declared_goal: 'Deploy authentication service',
  risk_score: 60,
});

// ... do the work ...

// Update when done
await claw.updateOutcome(action_id, {
  status: 'completed',
  output_summary: 'Auth service deployed to prod',
});

Create a DashClaw instance. Requires Node 18+ (native fetch).

const claw = new DashClaw({
  baseUrl,
  apiKey,
  agentId,
  agentName,
  swarmId,
  guardMode,
  guardCallback,
  autoRecommend,
  recommendationConfidenceMin,
  recommendationCallback,
  hitlMode,
});

When enabled, every call to createAction() can run recommendation adaptation and guard checks before submission.

import { DashClaw, GuardBlockedError, ApprovalDeniedError } from 'dashclaw';

const claw = new DashClaw({
  baseUrl: 'http://localhost:3000',
  apiKey: process.env.DASHCLAW_API_KEY,
  agentId: 'my-agent',
  autoRecommend: 'enforce', // apply safe recommendation hints
  recommendationConfidenceMin: 80,
  guardMode: 'enforce', // throws GuardBlockedError on block
  hitlMode: 'wait',     // poll until approved or throw ApprovalDeniedError
});

try {
  await claw.createAction({ action_type: 'deploy', declared_goal: 'Ship v2' });
  // If a policy triggers 'require_approval', the SDK will pause here until an admin clicks 'Allow'
} catch (err) {
  if (err instanceof GuardBlockedError) {
    console.log('Blocked by policy:', err.reasons);
  } else if (err instanceof ApprovalDeniedError) {
    console.log('Denied by human operator');
  }
}

DashClaw's guard + action recording pipeline maps directly to compliance controls.

SOC 2 CC6.1: Logical Access Controls

// Before any high-risk operation, enforce policy
const guardResult = await claw.guard({
  action_type: 'database_write',
  risk_score: 85,
  systems_touched: ['production_db'],
  reversible: false,
  declared_goal: 'Drop legacy user table'
});

if (guardResult.decision === 'block') {
  // SOC 2 control satisfied: unauthorized action prevented
  console.log('Policy blocked:', guardResult.reasons);
  return;
}

// Decision is governed. Record with full lineage
const { action_id } = await claw.createAction({
  action_type: 'database_write',
  declared_goal: 'Drop legacy user table',
  risk_score: 85,
  reversible: false,
  authorization_scope: 'admin-approved'
});

// Register the assumption this decision relies on
await claw.registerAssumption({
  action_id,
  assumption: 'Legacy table has zero active references',
  basis: 'Schema dependency scan completed 2h ago'
});

EU AI Act Article 14: Human Oversight

// require_approval forces human-in-the-loop
const result = await claw.guard({
  action_type: 'customer_communication',
  risk_score: 60,
  declared_goal: 'Send pricing update to 500 customers'
});

if (result.decision === 'require_approval') {
  // Create action in pending state, wait for human approval
  const { action_id } = await claw.createAction({
    action_type: 'customer_communication',
    declared_goal: 'Send pricing update to 500 customers',
    status: 'pending'
  });
  // Approval queue at /approvals shows this to operators
}

ISO 42001: AI Decision Accountability

// Full decision lineage: guard → action → assumptions → outcome
const { action_id } = await claw.createAction({
  action_type: 'data_processing',
  declared_goal: 'Rebuild customer segmentation model',
  risk_score: 45,
  systems_touched: ['ml-pipeline', 'customer-db']
});

await claw.registerAssumption({
  action_id,
  assumption: 'Customer data is current as of today',
  basis: 'CRM sync completed at 09:00 UTC'
});

// Later: validate or invalidate assumptions
await claw.validateAssumption(assumptionId, true);

// Decision integrity signals auto-detect when assumptions drift
const signals = await claw.getSignals();
// → Returns 'assumption_drift' if too many invalidated

Create, update, and query action records. Every agent action is a governed decision with a full audit trail capturing intent, reasoning, and outcome for compliance and review.

Create a new action record. The agent's agentId, agentName, and swarmId are automatically attached.

If hitlMode is set to 'wait' and the action requires approval, this method will not return until the action is approved or denied (or it times out).

Parameters:

Returns: Promise<{ action: Object, action_id: string }>

Example:

const { action_id } = await claw.createAction({
  action_type: 'deploy',
  declared_goal: 'Deploy auth service to production',
  risk_score: 70,
  systems_touched: ['kubernetes', 'auth-service'],
  reasoning: 'Scheduled release after QA approval',
});

Manual poll for human approval. Only needed if hitlMode is 'off'.

Parameters:

Returns: Promise<{ action: Object, action_id: string }> Throws: ApprovalDeniedError if denied.

Update the outcome of an existing action. Automatically sets timestamp_end if not provided.

Parameters:

Returns: Promise<{ action: Object }>

Helper that creates an action, runs your async function, and auto-updates the outcome. If fn throws, the action is marked as failed with the error message.

Parameters:

Returns: Promise<*> (the return value of fn)

Get a list of actions with optional filters. Returns paginated results with stats.

Parameters:

Returns: Promise<{ actions: Object[], total: number, stats: Object }>

Get a single action with its associated open loops and assumptions.

Parameters:

Returns: Promise<{ action: Object, open_loops: Object[], assumptions: Object[] }>

Get root-cause trace for an action, including its assumptions, open loops, parent chain, and related actions.

Parameters:

Returns: Promise<{ action: Object, trace: Object }>

Stream actions live to the dashboard as they happen.

(Already documented above) - Use track() to automatically emit running events at start and completed/failed events at finish. These show up instantly on the "Flight Recorder" dashboard.

Subscribe to server-sent events (SSE) for instant push notifications. Eliminates polling for approvals, policy changes, and task assignments.

Open a persistent SSE connection. Returns a chainable handle with .on(event, callback) and .close().

Supported events: action.created, action.updated, message.created, policy.updated, task.assigned, task.completed

const stream = claw.events();

stream
  .on('action.created', (data) => console.log('New action:', data.action_id))
  .on('action.updated', (data) => {
    if (data.status === 'running') console.log('Approved:', data.action_id);
  })
  .on('policy.updated', (data) => console.log('Policy changed:', data.change_type))
  .on('task.assigned', (data) => console.log('Task routed:', data.task?.title))
  .on('task.completed', (data) => console.log('Task done:', data.task?.task_id))
  .on('error', (err) => console.error('Stream error:', err));

// When done:
stream.close();

SSE-powered approval waiting. Resolves instantly when the operator approves/denies instead of polling every 5 seconds.

// SSE mode (instant, recommended)
const { action } = await claw.waitForApproval('act_abc', { useEvents: true });

// Polling mode (default, backward-compatible)
const { action } = await claw.waitForApproval('act_abc');

Track token usage and estimated costs for every action. DashClaw automatically aggregates these into "Cost per Goal" metrics.

Usage: Pass tokens_in, tokens_out, and model when creating or updating actions.

await claw.createAction({
  action_type: 'generation',
  declared_goal: 'Generate blog post',
  model: 'gpt-4o',
  tokens_in: 1500,
  tokens_out: 400,
  // cost_estimate is auto-calculated on the server if model is known
});

Supported Models for Auto-Pricing:

• GPT-4o, GPT-4-Turbo
• Claude 3.5 Sonnet, Claude 3 Opus, Claude 3 Haiku
• Llama 3 (70b, 8b)

Track unresolved dependencies and log what your agents assume. Catch drift before it causes failures.

Register an open loop (unresolved dependency, pending approval, etc.) for an action.

Parameters:

Returns: Promise<{ loop: Object, loop_id: string }>

Resolve or cancel an open loop.

Parameters:

Returns: Promise<{ loop: Object }>

Register an assumption made during an action. Track what your agent assumes so you can validate or invalidate later.

Parameters:

Returns: Promise<{ assumption: Object, assumption_id: string }>

Get a single assumption by ID.

Parameters:

Returns: Promise<{ assumption: Object }>

Validate or invalidate an assumption. When invalidating, a reason is required.

Parameters:

Returns: Promise<{ assumption: Object }>

Get open loops with optional filters. Returns paginated results with stats.

Parameters:

Returns: Promise<{ loops: Object[], total: number, stats: Object }>

Get drift report for assumptions with risk scoring. Shows which assumptions are stale, unvalidated, or contradicted by outcomes.

Parameters:

Returns: Promise<{ assumptions: Object[], drift_summary: Object }>

Automatic detection of problematic agent behavior. Seven signal types fire based on action patterns - no configuration required.

Get current risk signals across all agents. Returns 7 signal types: autonomy_spike, high_impact_low_oversight, repeated_failures, stale_loop, assumption_drift, stale_assumption, and stale_running_action.

Returns: Promise<{ signals: Object[], counts: { red: number, amber: number, total: number } }>

• autonomy_spike: Agent taking too many actions without human checkpoints
• high_impact_low_oversight: Critical actions without sufficient review
• repeated_failures: Same action type failing multiple times
• stale_loop: Open loops unresolved past their expected timeline
• assumption_drift: Assumptions becoming stale or contradicted by outcomes
• stale_assumption: Assumptions not validated within expected timeframe
• stale_running_action: Actions stuck in running state for over 4 hours

Guard is the heart of DashClaw. Every action can be checked against policies before execution. Returns allow, warn, block, or require_approval based on configured guard policies.

Evaluate guard policies for a proposed action. Call this before risky operations to get a go/no-go decision. The agent_id is auto-attached from the SDK constructor.

Parameters:

Returns: Promise<{ decision: string, reasons: string[], warnings: string[], matched_policies: string[], evaluated_at: string }>

Retrieve recent guard evaluation decisions for audit and review.

Parameters:

Returns: Promise<{ decisions: Object[], total: number, stats: Object }>

Push data from your agent directly to the DashClaw dashboard. All methods auto-attach the agent's agentId.

Report a token usage snapshot for this agent.

Parameters:

Returns: Promise<{snapshot: Object}>

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:

Returns: The wrapped client (same instance)

Example (Anthropic):

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):

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

Record a decision for the learning database. Track what your agent decides and why.

Parameters:

Returns: Promise<{ decision: Object }>

Get adaptive recommendations synthesized from scored historical episodes.

Parameters:

Returns: Promise<{ recommendations: Object[], metrics?: Object, total: number }>

Get recommendation telemetry and effectiveness deltas.

Parameters:

Returns: Promise<{ metrics: Object[], summary: Object, lookback_days: number }>

Write recommendation telemetry events (single event or batch).

Returns: Promise<{ created: Object[], created_count: number }>

Enable or disable one recommendation.

Returns: Promise<{ recommendation: Object }>

Recompute recommendations from recent learning episodes.

Parameters:

Returns: Promise<{ recommendations: Object[], total: number, episodes_scanned: number }>

Apply top recommendation hints to an action payload without mutating the original object.

Returns: Promise<{ action: Object, recommendation: Object|null, adapted_fields: string[] }>

Create a goal in the goals tracker.

Parameters:

Returns: Promise<{ goal: Object }>

Record content creation (articles, posts, documents).

Parameters:

Returns: Promise<{ content: Object }>

Record a relationship interaction (message, meeting, email).

Parameters:

Returns: Promise<{ interaction: Object }>

Report active connections/integrations for this agent.

Parameters:

Returns: Promise<{ connections: Object[], created: number }>

Create a calendar event.

Parameters:

Returns: Promise<{event: Object}>

Record an idea or inspiration for later review.

Parameters:

Returns: Promise<{idea: Object}>

Report a memory health snapshot with entities and topics.

Parameters:

Returns: Promise<{snapshot: Object, entities_count: number, topics_count: number}>

Create a session handoff document summarizing work done, decisions made, and next priorities.

Parameters:

Returns: Promise<{handoff: Object, handoff_id: string}>

Get handoffs for this agent with optional date and limit filters.

Parameters:

Returns: Promise<{handoffs: Object[], total: number}>

Get the most recent handoff for this agent. Useful for resuming context at the start of a new session.

Returns: Promise<{handoff: Object|null}>

Example:

const { handoff } = await claw.getLatestHandoff();
if (handoff) {
  console.log('Last session:', handoff.summary);
  console.log('Next priorities:', handoff.next_priorities);
}

Capture key points and organize context into threads for long-running topics.

Capture a key point from the current session for later recall.

Parameters:

Returns: Promise<{point: Object, point_id: string}>

Create a context thread for tracking a topic across multiple entries.

Parameters:

Returns: Promise<{thread: Object, thread_id: string}>

Get key points with optional filters.

Parameters:

Returns: Promise<{points: Object[], total: number}>

Add an entry to an existing thread.

Parameters:

Returns: Promise<{entry: Object, entry_id: string}>

Close a context thread with an optional final summary.

Parameters:

Returns: Promise<{thread: Object}>

Get context threads with optional filters.

Parameters:

Returns: Promise<{threads: Object[], total: number}>

Get a combined context summary containing today's key points and all active threads. Convenience method that calls getKeyPoints() and getThreads() in parallel.

Returns: Promise<{points: Object[], threads: Object[]}>

Example:

const { points, threads } = await claw.getContextSummary();
console.log(`${points.length} key points today, ${threads.length} active threads`);

Save, search, and reuse code snippets across agent sessions.

Save or update a reusable code snippet. Upserts on name.

Parameters:

Returns: Promise<{snippet: Object, snippet_id: string}>

Example:

await claw.saveSnippet({
  name: 'fetch-with-retry',
  code: 'async function fetchRetry(url, n = 3) { ... }',
  language: 'javascript',
  tags: ['fetch', 'retry'],
});

Fetch a single snippet by ID.

Parameters:

Returns: Promise<{snippet: Object}>

Example:

const { snippet } = await claw.getSnippet('sn_abc123');
console.log(snippet.name, snippet.language);

Search and list snippets.

Parameters:

Returns: Promise<{snippets: Object[], total: number}>

Example:

const { snippets } = await claw.getSnippets({ language: 'javascript' });

Mark a snippet as used (increments use_count).

Parameters:

Returns: Promise<{snippet: Object}>

Example:

await claw.useSnippet('sn_abc123');

Delete a snippet.

Parameters:

Returns: Promise<{deleted: boolean, id: string}>

Example:

await claw.deleteSnippet('sn_abc123');

Track user observations, learned preferences, mood/energy, and approach effectiveness across sessions.

Log a user observation (what you noticed about the user's behavior or preferences).

Parameters:

Returns: Promise<{observation: Object, observation_id: string}>

Example:

await claw.logObservation({
  observation: 'User prefers concise responses over detailed explanations',
  category: 'communication',
  importance: 8,
});

Set a learned user preference. Use this to record patterns you detect about how the user likes to work.

Parameters:

Returns: Promise<{preference: Object, preference_id: string}>

Log user mood/energy for a session. Helps track patterns in productivity and satisfaction.

Parameters:

Returns: Promise<{mood: Object, mood_id: string}>

Track an approach and whether it succeeded or failed. Builds a knowledge base of what works.

Parameters:

Returns: Promise<{approach: Object, approach_id: string}>

Get a summary of all user preference data including observations, preferences, moods, and approaches.

Returns: Promise<{summary: Object}>

Get tracked approaches with success/fail counts.

Parameters:

Returns: Promise<{approaches: Object[], total: number}>

Get a daily activity digest aggregated from all data sources (actions, decisions, handoffs, context, etc.).

Parameters:

Returns: Promise<{date: string, digest: Object, summary: Object}>

Example:

const { digest, summary } = await claw.getDailyDigest('2025-01-15');
console.log(`Actions: ${summary.actions_count}, Decisions: ${summary.decisions_count}`);

Scan text for sensitive data before sending it anywhere. The scanner detects API keys, tokens, PII, and other secrets.

Scan text for sensitive data. Returns findings and redacted text. Does NOT store the original content.

Parameters:

Returns: Promise<{clean: boolean, findings_count: number, findings: Object[], redacted_text: string}>

Example:

const result = await claw.scanContent(
  'Deploy with key sk-abc123xyz to production',
  'slack'
);
if (!result.clean) {
  console.log(`Found ${result.findings_count} issues`);
  console.log('Safe version:', result.redacted_text);
}

Scan text and store finding metadata for audit trails. The original content is never stored, only the finding metadata.

Parameters:

Returns: Promise<{clean: boolean, findings_count: number, findings: Object[], redacted_text: string}>

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:

Returns: Promise<{clean: boolean, risk_level: string, recommendation: string, findings_count: number, critical_count: number, categories: string[], findings: Object[]}>

Example:

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`);
}

Send a message to another agent or broadcast.

Parameters:

Returns: Promise<{message: Object, message_id: string}>

Get inbox messages for this agent.

Parameters:

Returns: Promise<{messages: Object[], total: number, unread_count: number}>

Mark messages as read.

Parameters:

Returns: Promise<{updated: number}>

Archive messages.

Parameters:

Returns: Promise<{updated: number}>

Broadcast a message to all agents in the organization.

Parameters:

Returns: Promise<{message: Object, message_id: string}>

Create a new message thread for multi-turn conversations between agents.

Parameters:

Returns: Promise<{thread: Object, thread_id: string}>

List message threads.

Parameters:

Returns: Promise<{threads: Object[], total: number}>

Resolve (close) a message thread with an optional summary.

Parameters:

Returns: Promise<{thread: Object}>

Create or update a shared workspace document. Upserts by name.

Parameters:

Returns: Promise<{doc: Object, doc_id: string}>

Get a URL to download an attachment.

Returns: string: URL to fetch the attachment binary

Download an attachment as a Buffer.

Returns: Promise<{ data: Buffer, filename: string, mimeType: string }>

const inbox = await claw.getInbox();
for (const msg of inbox.messages) {
  for (const att of msg.attachments || []) {
    const { data, filename } = await claw.getAttachment(att.id);
    fs.writeFileSync(filename, data);
  }
}

Pair agents with user accounts via public key registration and approval flow.

Create an agent pairing request. Returns a link the user can click to approve the pairing.

Parameters:

Returns: Promise<{pairing: Object, pairing_url: string}>

Convenience method that derives the public PEM from a private JWK and creates a pairing request.

Parameters:

Returns: Promise<{pairing: Object, pairing_url: string}>

Poll a pairing request until it is approved or expired.

Parameters:

Returns: Promise<Object> (the approved pairing object)

Throws: Error if pairing expires or times out.

Example:

const { pairing, pairing_url } = await claw.createPairing({
  publicKeyPem: myPublicKeyPem,
});
console.log('Approve pairing at:', pairing_url);

const approved = await claw.waitForPairing(pairing.id);
console.log('Pairing approved!', approved.status);

Register and manage agent public keys for cryptographic identity verification.

Register or update an agent's public key for identity verification. Requires admin API key.

Parameters:

Returns: Promise<{identity: Object}>

List all registered agent identities for this organization.

Returns: Promise<{identities: Object[]}>

Manage organizations and API keys. All methods require admin API key.

Get the current organization's details.

Returns: Promise<{organizations: Object[]}>

Create a new organization with an initial admin API key.

Parameters:

Returns: Promise<{organization: Object, api_key: Object}>

Get organization details by ID.

Parameters:

Returns: Promise<{organization: Object}>

Update organization details.

Parameters:

Returns: Promise<{organization: Object}>

List API keys for an organization.

Parameters:

Returns: Promise<{keys: Object[]}>

Get activity/audit logs for the organization.

Parameters:

Returns: Promise<{logs: Object[], stats: Object, pagination: Object}>

Subscribe to DashClaw events and receive real-time notifications.

List all webhooks for this organization.

Returns: Promise<{webhooks: Object[]}>

Create a new webhook subscription.

Parameters:

Returns: Promise<{webhook: Object}>

Delete a webhook.

Parameters:

Returns: Promise<{deleted: boolean}>

Send a test event to a webhook to verify connectivity.

Parameters:

Returns: Promise<{delivery: Object}>

Get delivery history for a webhook.

Parameters:

Returns: Promise<{deliveries: Object[]}>

Push multiple data categories in a single request. Accepts connections, memory, goals, learning, content, inspiration, context_points, context_threads, handoffs, preferences, and snippets.

Returns: Promise<{results: Object, total_synced: number, total_errors: number, duration_ms: number}>

Run guardrails tests, generate compliance proof reports, and import policy packs.

Run guardrails tests against all active policies. Returns pass/fail results per policy.

Returns: Promise<{ results: Object[], total: number, passed: number, failed: number }>

Example:

const report = await claw.testPolicies();
console.log(`${report.passed}/${report.total} policies passed`);
for (const r of report.results.filter(r => !r.passed)) {
  console.log(`FAIL: ${r.policy}: ${r.reason}`);
}

Generate a compliance proof report summarizing guard decisions, policy evaluations, and audit evidence.

Parameters:

Returns: Promise<{ report: Object|string }>

Import a policy pack or raw YAML. Admin only. Replaces or merges into active policies.

Parameters:

Returns: Promise<{ imported: number, policies: Object[] }>

Map policies to regulatory frameworks, run gap analysis, and generate compliance reports.

Map active policies to framework controls. Returns a control-by-control coverage matrix.

Parameters:

Returns: Promise<{ framework: string, controls: Object[], coverage_pct: number }>

Example:

const { controls, coverage_pct } = await claw.mapCompliance('soc2');
console.log(`SOC 2 coverage: ${coverage_pct}%`);
for (const ctrl of controls.filter(c => !c.covered)) {
  console.log(`Gap: ${ctrl.id}: ${ctrl.name}`);
}

Run gap analysis with remediation plan. Identifies missing controls and suggests policy changes.

Parameters:

Returns: Promise<{ framework: string, gaps: Object[], remediation_plan: Object[] }>

Generate a full compliance report and save a point-in-time snapshot.

Parameters:

Returns: Promise<{ report: Object|string, snapshot_id: string }>

List all available compliance frameworks with metadata.

Returns: Promise<{ frameworks: Object[] }>

Get live guard decision evidence for compliance audits. Returns timestamped decision records.

Parameters:

Returns: Promise<{ evidence: Object[], window: string, total: number }>

Route tasks to agents based on capabilities, availability, and workload. Manage the agent pool and monitor routing health.

List registered routing agents with optional status filter.

Parameters:

Returns: Promise<{ agents: Object[], total: number }>

Register a new agent in the routing pool.

Parameters:

Returns: Promise<{ agent: Object, agent_id: string }>

Get a single routing agent with current metrics.

Parameters:

Returns: Promise<{ agent: Object, metrics: Object }>

Update a routing agent's availability status.

Parameters:

Returns: Promise<{ agent: Object }>

Remove an agent from the routing pool.

Parameters:

Returns: Promise<{ deleted: boolean, id: string }>

List routing tasks with optional filters.

Parameters:

Returns: Promise<{ tasks: Object[], total: number }>

Submit a task for automatic routing to the best available agent.

Parameters:

Returns: Promise<{ task: Object, task_id: string, assigned_agent: Object|null }>

Example:

const { task_id, assigned_agent } = await claw.submitRoutingTask({
  title: 'Analyze quarterly metrics',
  description: 'Pull Q4 data and generate summary report',
  requiredSkills: ['data-analysis', 'reporting'],
  urgency: 'high',
  timeoutSeconds: 600,
  callbackUrl: 'https://hooks.example.com/task-done',
});
console.log(`Task ${task_id} assigned to ${assigned_agent?.name ?? 'queue'}`);

Mark a routing task as completed with optional result payload.

Parameters:

Returns: Promise<{ task: Object }>

Get aggregate routing statistics (throughput, latency, agent utilization).

Returns: Promise<{ stats: Object }>

Get routing system health status and diagnostics.

Returns: Promise<{ healthy: boolean, agents: Object, tasks: Object, latency: Object }>

Define recurring tasks and cron-based schedules for agents.

List agent schedules, optionally filtered by agent.

const { schedules } = await claw.listAgentSchedules({ agent_id: 'forge' });

Parameters:

Returns: Promise<{ schedules: Object[] }>

Create a new agent schedule entry.

const { schedule } = await claw.createAgentSchedule({
  agent_id: 'forge',
  name: 'Build projects',
  cron_expression: '0 */6 * * *',
  description: 'Check for pending builds every 6 hours'
});

Parameters:

Returns: Promise<{ schedule: Object }>

All SDK methods throw on non-2xx responses. Errors include status (HTTP code) and details (when available).

try {
  await claw.createAction({ ... });
} catch (err) {
  if (err.status === 401) {
    console.error('Invalid API key');
  } else {
    console.error(`Action failed: \${err.message}`);
  }
}