TypeScript SDK reference.

interface DendriteOptions {
  synapse:                Synapse;        // REQUIRED
  registryStore?:         RegistryStore;
  namespace?:             string;         // default "default"
  dendriteId?:            string;         // default "dendrite"
  heartbeatMs?:           number;         // default 30_000; 0 disables
  reregisterOnHeartbeat?: boolean;        // default true
  role?:                  DendriteRole;   // "orchestrator" (default) | "worker"
  autoBid?:               boolean;        // default true  -  default bidder for hosted Axons
  staleAfterMs?:          number;         // liveness sweep; default 3 heartbeat intervals
}

class Dendrite {
  constructor(opts: DendriteOptions);

  // ── Axon lifecycle ──────────────────────────────────────
  attachAxon(axon: Axon): void;
  addAxon(axon: Axon): Promise<void>;              // attach while running
  detachAxon(neuronId: string, opts?: { reason? }): Promise<void>;
  start(): Promise<void>;
  stop(reason?: string): Promise<void>;

  // ── Dispatch (orchestrator-role only) ────────────────────
  // Addressed (neuron) or capability-routed (capabilities); at least one required.
  dispatchTask(args: DispatchArgs & { finalize?: boolean }): Promise<Signal>;

  // Pathway-based dispatch. scope: "all" | "terminal".
  // finalize defaults true when scope is "terminal", so a stock worker's
  // AGENT_OUTPUT is promoted to FINAL (terminal-handler finalize).
  dispatch(args): Promise<Pathway>;
  dispatchAndWait(args & { timeoutMs?: number }): Promise<Signal>;
  dispatchAndSubscribe(args): Promise<Pathway>;
  dispatchOffer(args: {
    input; capabilities?; deadlineMs?;            // BID-collection window
    select?: "first_bid" | "lowest_cost" | "highest_confidence";
  }): Promise<Pathway>;
  observePathway(traceId: string): Promise<Pathway>;   // watch a peer's trace

  // ── Resilience & cancellation (orchestrator-role only) ──
  runWithRetry(args & { retry: RetryStrategy; timeoutMs? }): Promise<Signal>;
  emitStop(args: { traceId; rollback?; reason? }): Promise<Signal>;
  stopTrace(traceId: string, opts?: {
    rollback?; reason?; collectAcks?; timeoutMs?;
  }): Promise<Signal[]>;

  // Worker side: register your own bidder (suppresses the auto-bidder).
  onTaskOffer(fn: SignalHandler, filter?: HandlerFilter): SignalHandler;
  bid(offer: Signal, args: { neuron; cost; etaMs?; confidence? }): Promise<Signal>;

  // ── Interactive cognition (CLARIFICATION / PERMISSION) ───
  awaitDecision(request: Signal, opts?: { timeoutMs? }): Promise<Signal>;
  answerClarification(request: Signal, opts: { answer; meta? }): Promise<Signal>;

  // ── Engram  -  shared memory (RECALL / IMPRINT) ──────────
  attachEngram(engram: Engram): Promise<void>;
  recall(args: { engramId?; engramKind?; query; ... }): Promise<RecallResult>;
  imprint(args: { engramId?; engramKind?; op; entry; ... }): Promise<ImprintReceipt | null>;

  // ── Inbound handlers  -  method calls, NOT decorators ─────
  // One per SignalType, all accepting an optional filter:
  //   { neuron?, capability?, traceId? }

  // Lifecycle
  onTaskSignal(fn, filter?): SignalHandler;
  onAgentOutput(fn, filter?): SignalHandler;
  onFinal(fn, filter?): SignalHandler;
  onErrorSignal(fn, filter?): SignalHandler;

  // Routing / bidding
  onTaskOffer(fn, filter?): SignalHandler;   // suppresses the auto-bidder
  onBid(fn, filter?): SignalHandler;
  onTaskAwarded(fn, filter?): SignalHandler;
  onTaskDeclined(fn, filter?): SignalHandler;

  // Cognition
  onPlan / onThoughtDelta / onToolCall / onToolResult(fn, filter?);
  onMemoryAppend / onCritique / onEscalation / onConsensus / onContextSync(fn, filter?);

  // Interactive cognition (see awaitDecision)
  onClarification(fn, filter?): SignalHandler;
  onPermission(fn, filter?): SignalHandler;
  onClarificationAnswer(fn, filter?): SignalHandler;
  onPermissionDecision(fn, filter?): SignalHandler;

  // Engram
  onRecallSignal / onImprintSignal(fn, filter?);    // requests on the bus
  onRecalled / onImprinted(fn, filter?);            // responses (observability)

  // Agent management + discovery
  onRegister / onDeregister / onHeartbeat(fn, filter?);
  onDiscover(fn): SignalHandler;

  // Generic escape hatches
  onSignal(type: SignalType, fn, filter?): SignalHandler;
  onTrace(traceId: string, ...types: SignalType[]): (fn) => SignalHandler;
  subscribe(type: SignalType, handler: MessageHandler, opts?): Promise<Subscription>;

  // Lifecycle hooks (inherited)
  onConnect(fn): ConnectHook;    // after this Dendrite registers
  onRefresh(fn): RefreshHook;    // heartbeat / register / deregister
  onSchedule(everyMs, fn): ScheduleHook;

  // ── Cognition emitters ────────────────────────────────────
  emitFinal(args: { traceId; parentId; result; meta? }): Promise<Signal>;
  emitError(args: { traceId; parentId?; code; message; recoverable?; meta? }): Promise<Signal>;
  // + emitPlan / emitThoughtDelta / emitToolCall / emitToolResult /
  //   emitMemoryAppend / emitCritique / emitEscalation / emitConsensus / emitContextSync
  emit(signal: Signal): Promise<void>;   // throws DendriteProtocolError off-list

  // ── Registry reads (require registryStore) ──────────────
  findNeurons(opts?: { capability?: string }): Promise<NeuronRecord[]>;
  registrySnapshot(opts?: ListOptions): Promise<NeuronRecord[]>;
}