daf-sdk

DAF (Defined Action Framework) is a single TypeScript package for defining, validating, and executing agentic, multi-step AI automations.

npm install daf-sdk

It ships two layers in one package:

• Protocol: DAF document/action types, Zod validation, builder utilities. No heavy dependencies, so it's safe to import in a frontend or any client.
• Runtime: the agentic execution engine (step loop, action handlers, token-cost calculation, variables, real-time updates). You embed it in your backend and supply a DAFStorageAdapter.

Import paths

import { executeProcess, validateDAFDocument } from 'daf-sdk';        // everything
import { validateDAFDocument, DAFDocumentBuilder } from 'daf-sdk/protocol'; // types only (lightweight)
import { executeProcess } from 'daf-sdk/runtime';                     // engine only

Use daf-sdk/protocol in browser or client code to avoid pulling the runtime's server dependencies (googleapis, nodemailer, firecrawl, and so on) into your bundle.

Build a DAF document (protocol)

import {
  DAFDocumentBuilder,
  ProcessBuilder,
  promptStep,
  validateDAFDocument,
} from 'daf-sdk/protocol';

const doc = new DAFDocumentBuilder()
  .variable('USER_EMAIL', '[email protected]')
  .process(
    new ProcessBuilder('Weekly Report', 'STATIC_DIALOGUE')
      .step(promptStep('Fetch data'))
      .build()
  )
  .build();

const { valid, errors } = validateDAFDocument(doc);

Execute it (runtime)

The runtime is an embedded library, not a service. Host concerns (database, HTTP routes, auth, billing, schedules) stay in your app; the runtime reaches them only through a DAFStorageAdapter you implement.

import { executeProcess, type DAFStorageAdapter } from 'daf-sdk';

const adapter: DAFStorageAdapter = {
  db: myDb,                                          // your persistence layer
  emitRunUpdate: (runId, event) => bus.publish(runId, event),
  log: console,
  // ...the rest of the DAFStorageAdapter interface
} as DAFStorageAdapter;

await executeProcess(processId, userId, adapter);

Pluggable host hooks

Some capabilities are host-coupled, so they're optional hooks on the adapter and the runtime calls back into your app:

const adapter: DAFStorageAdapter = {
  // ...core methods...
  executeCustomSkill: (skillName, params, userId) => myApp.runSkill(...),
  executeSkillScript: (skillName, scriptName, args, userId) => myApp.runScript(...),
  executeRunCode: (code, timeout, userId) => myApp.runCodeSandboxed(code, timeout),
};

runCode is delegated this way on purpose: the SDK never executes arbitrary code itself, so sandboxing and allowlisting are an explicit host responsibility. When a hook is absent, the corresponding action returns a graceful error instead of running.

Key exports

• executeProcess, executeProcessInRun, resumeProcessExecution: run and resume processes
• executeAction, processMessageActions, extractActionsFromMessage: action execution
• calculateTokenCost, getModelProvider, getProviderFromModel: pricing and providers
• substituteVariables, mergeVariables: variables
• DAFStorageAdapter, ExecutionContext, UserProviderSettings: runtime types
• validateDAFDocument, DAFDocumentBuilder, ProcessBuilder, all action types: protocol