Skip to content

RunContext

optional abortSignal?: AbortSignal;

optional autoRetrieve?: AutoRetrieveProvider;

optional bargeIn?: AbortSignal;

optional baseInstructions?: Instructions;

Agent base layer (ADR 0001), set when entering a flow. baseInstructions is composed as a prefix into every node turn’s system prompt (persona / safety / grounding floor); globalTools are safe tools made model-visible in every speaking turn.


controlModel: LanguageModel;

Control-path model (routing, decide, extraction) at temperature 0.


emit: (part) => void;
Parameter Type

part

HarnessStreamPart

void


optional fs?: FileSystem;

Agent workspace filesystem (same instance as AgentConfig.workspace).


optional globalTools?: Record<string, AnyTool>;

hookRunner: HookRunner;

inputProcessors: InputProcessor[];

optional lastRetrievalCitations?: SourceRef[];

Citations from the latest gather-phase retrieval on this turn.


optional limits?: Limits;

optional memoryService?: MemoryService;

model: LanguageModel;

outOfBandControl: boolean;

When true, flow reply nodes use the out-of-band control evaluator (ADR 0003 H1).


outputProcessors: OutputProcessor[];

refinementPolicies: RefinementCapability[];

runState: RunState;

runStore: RunStore;

session: Session;

optional skillPrompt?: string;

Level-1 skill metadata injected by SkillsCapability when AgentConfig.skills is set.


optional telemetry?: TelemetrySettings;

toolExecutor: EffectToolExecutor;

optional turnInputConsumed?: boolean;

Ephemeral, per-run-invocation flag: has the current turn’s user input been consumed yet by an input-node (collect/decide)? Input-nodes extract/decide from the turn’s fresh input; once it is consumed, later nodes in the same turn pause (present prompt, await next turn) instead of acting on stale context. Reset to false on every createRunContext (i.e. every turn).


validationPolicies: ValidationCapability[];

optional workingMemoryPrompt?: string;

Frozen persistent memory blocks loaded at session start (AgentMemory.workingMemory).


optional workingMemoryTools?: Record<string, AnyTool>;

Model-visible tools from working memory wiring (not in globalTools — mutating but scoped).

approve(req): Promise<{
approved: boolean;
by?: string;
}>;
Parameter Type

req

{ description?: string; title: string; }

req.description?

string

req.title

string

Promise<{ approved: boolean; by?: string; }>


now(): Promise<number>;

Promise<number>


resetCallsites(): void;

Rebase durable effect callsites to 0. The runtime calls this at flow entry so a flow’s durable callsites are anchored to the flow — identical on fresh entry (after an answering turn) and on resume (where that turn does not re-run).

void


signal(name, opts?): Promise<unknown>;
Parameter Type

name

string

opts?

{ deadline?: number; meta?: Record<string, unknown>; }

opts.deadline?

number

opts.meta?

Record<string, unknown>

Promise<unknown>


tool(
name,
args,
options?): Promise<unknown>;
Parameter Type

name

string

args

unknown

options?

{ def?: AnyTool; toolCallId?: string; toolCtx?: ToolContext; }

options.def?

AnyTool

options.toolCallId?

string

options.toolCtx?

ToolContext

Promise<unknown>


uuid(): Promise<string>;

Promise<string>