@assemble-dev/sdk 0.0.1

package/dist/index.d.cts

@@ -0,0 +1,588 @@
+import { ModelAdapter } from '@assemble-dev/providers';
+import { JsonValue } from '@assemble-dev/shared-types/json';
+import { AppError } from '@assemble-dev/shared-utils/errors';
+import { z } from 'zod';
+import { RunMessage, RunState, TokenUsage, PolicyAction, PolicyDecision, RunArtifact, RunStatus } from '@assemble-dev/shared-types/runs';
+import { TraceEvent } from '@assemble-dev/shared-types/trace-events';
+import { RedactionMode } from '@assemble-dev/shared-utils/redaction';
+
+type AgentStartHookContext = {
+    agentName: string;
+    input: JsonValue;
+};
+type AgentCompleteHookContext<TOutput> = {
+    agentName: string;
+    output: TOutput;
+};
+type AgentErrorHookContext = {
+    agentName: string;
+    error: AppError;
+};
+type AgentConfig<TOutput = string> = {
+    name: string;
+    role: string;
+    model: ModelAdapter;
+    instructions: string;
+    allowedToolNames?: string[];
+    inputSchema?: z.ZodType<JsonValue>;
+    outputSchema?: z.ZodType<TOutput>;
+    maxSteps?: number;
+    timeoutMs?: number;
+    costBudgetUsd?: number;
+    fallbackModelName?: string;
+    onAgentStart?: (context: AgentStartHookContext) => void;
+    onAgentComplete?: (context: AgentCompleteHookContext<TOutput>) => void;
+    onAgentError?: (context: AgentErrorHookContext) => void;
+};
+type AgentDefinition<TOutput = string> = Readonly<Omit<AgentConfig<TOutput>, "maxSteps"> & {
+    maxSteps: number;
+}>;
+declare function agent<TOutput = string>(config: AgentConfig<TOutput>): AgentDefinition<TOutput>;
+
+type MemoryProvider = {
+    getMemoryValue(key: string): Promise<JsonValue | null>;
+    setMemoryValue(key: string, value: JsonValue): Promise<void>;
+    appendMemoryValue(key: string, value: JsonValue): Promise<void>;
+    listMemoryKeys(): Promise<string[]>;
+};
+
+type ThreadMemoryOptions = {
+    provider: MemoryProvider;
+    threadKey: string;
+};
+type ThreadMemory = {
+    appendThreadMessage(message: RunMessage): Promise<void>;
+    listThreadMessages(): Promise<RunMessage[]>;
+};
+declare function createThreadMemory(options: ThreadMemoryOptions): ThreadMemory;
+
+type TraceSink = {
+    name: string;
+    writeTraceEvent(event: TraceEvent): void | Promise<void>;
+    flush?(): Promise<void>;
+    close?(): void;
+};
+
+type TraceSinkFailure = {
+    sinkName: string;
+    operation: "write" | "flush";
+    error: Error;
+};
+type TraceSinkErrorHandler = (failure: TraceSinkFailure) => void;
+type CreateTraceBusInput = {
+    runId: string;
+    workflowName: string;
+    input: JsonValue;
+    sinks: TraceSink[];
+    now?: () => Date;
+    initialRunState?: RunState;
+    onSinkError?: TraceSinkErrorHandler;
+};
+type TraceBus = {
+    emitTraceEvent(event: TraceEvent): TraceEvent;
+    getRunState(): RunState;
+    listTraceEvents(): readonly TraceEvent[];
+    flushSinks(): Promise<void>;
+    closeSinks(): void;
+};
+declare function createTraceBus(busInput: CreateTraceBusInput): TraceBus;
+
+type AgentRunResult<TOutput = string> = {
+    output: TOutput;
+    rawText: string;
+    tokenUsage: TokenUsage;
+    latencyMs: number;
+    agentCallEventId: string;
+};
+
+type RunAgentInput<TOutput = string> = {
+    definition: AgentDefinition<TOutput>;
+    input: JsonValue;
+    traceBus: TraceBus;
+    parentEventId?: string;
+    threadMemory?: ThreadMemory;
+    now?: () => Date;
+};
+declare function runAgent<TOutput = string>(runInput: RunAgentInput<TOutput>): Promise<AgentRunResult<TOutput>>;
+
+declare const ToolRetryConfigSchema: z.ZodObject<{
+    maxAttempts: z.ZodNumber;
+}, z.core.$strip>;
+type ToolRetryConfig = z.infer<typeof ToolRetryConfigSchema>;
+declare const ToolDefinitionOptionsSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    allowedAgentNames: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    requiresApproval: z.ZodOptional<z.ZodBoolean>;
+    retry: z.ZodOptional<z.ZodObject<{
+        maxAttempts: z.ZodNumber;
+    }, z.core.$strip>>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    sensitiveFieldNames: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    dryRun: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type ToolDefinitionOptions = z.infer<typeof ToolDefinitionOptionsSchema>;
+type ToolDefinitionConfig<TInput extends JsonValue, TOutput extends JsonValue> = ToolDefinitionOptions & {
+    inputSchema: z.ZodType<TInput>;
+    outputSchema?: z.ZodType<TOutput>;
+    execute: (input: TInput) => Promise<TOutput>;
+};
+type ToolDefinition<TInput extends JsonValue, TOutput extends JsonValue> = {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: z.ZodType<TInput>;
+    readonly outputSchema: z.ZodType<TOutput> | null;
+    readonly execute: (input: TInput) => Promise<TOutput>;
+    readonly allowedAgentNames: string[] | null;
+    readonly requiresApproval: boolean;
+    readonly retry: ToolRetryConfig;
+    readonly timeoutMs: number | null;
+    readonly sensitiveFieldNames: string[];
+    readonly dryRun: boolean;
+};
+declare function tool<TInput extends JsonValue, TOutput extends JsonValue>(config: ToolDefinitionConfig<TInput, TOutput>): ToolDefinition<TInput, TOutput>;
+
+type ToolPolicyContext = {
+    toolName: string;
+    agentName: string;
+    input: JsonValue;
+};
+type ToolPolicyRuleResult = boolean | string;
+type ToolPolicyRule = (context: ToolPolicyContext) => ToolPolicyRuleResult;
+type ToolPolicy = {
+    name: string;
+    appliesToToolNames?: string[];
+    block?: ToolPolicyRule;
+    requireApproval?: ToolPolicyRule;
+    redact?: ToolPolicyRule;
+    logOnly?: ToolPolicyRule;
+};
+
+type ToolCallErrorCode = "VALIDATION_FAILED" | "EXECUTION_FAILED";
+type ToolCallError = {
+    code: ToolCallErrorCode;
+    message: string;
+};
+type ToolCallCompletedOutcome = {
+    status: "completed";
+    output: JsonValue;
+    toolRequestEventId: string;
+    latencyMs: number;
+};
+type ToolCallFailedOutcome = {
+    status: "failed";
+    error: ToolCallError;
+};
+type ToolCallBlockedOutcome = {
+    status: "blocked";
+    reason: string;
+};
+type ToolCallAwaitingApprovalOutcome = {
+    status: "awaiting_approval";
+    approvalId: string;
+    toolRequestEventId: string;
+};
+type ToolCallOutcome = ToolCallCompletedOutcome | ToolCallFailedOutcome | ToolCallBlockedOutcome | ToolCallAwaitingApprovalOutcome;
+
+type GrantedToolApproval = {
+    approvalId: string;
+    toolRequestEventId: string | null;
+};
+type ExecuteToolCallInput<TInput extends JsonValue, TOutput extends JsonValue> = {
+    tool: ToolDefinition<TInput, TOutput>;
+    agentName: string;
+    input: JsonValue;
+    policies?: ToolPolicy[];
+    traceBus: TraceBus;
+    redactionMode?: RedactionMode;
+    parentEventId?: string;
+    now?: () => Date;
+    mockExecution?: (input: TInput) => JsonValue;
+    grantedApproval?: GrantedToolApproval;
+};
+declare function executeToolCall<TInput extends JsonValue, TOutput extends JsonValue>(callInput: ExecuteToolCallInput<TInput, TOutput>): Promise<ToolCallOutcome>;
+
+type WorkflowMemoryConfig = {
+    provider: MemoryProvider;
+};
+declare function resolveWorkflowMemoryConfig(config?: WorkflowMemoryConfig): WorkflowMemoryConfig;
+
+type RunWorkflowOptions = {
+    sinks?: TraceSink[];
+    runId?: string;
+    now?: () => Date;
+    runStateDirectory?: string;
+    persistRunState?: boolean;
+};
+type WorkflowRunCompletedResult<TOutput extends JsonValue = JsonValue> = {
+    status: "completed";
+    runId: string;
+    output: TOutput;
+    state: RunState;
+    events: readonly TraceEvent[];
+};
+type WorkflowRunAwaitingApprovalResult = {
+    status: "awaiting_approval";
+    runId: string;
+    approvalId: string;
+    state: RunState;
+    events: readonly TraceEvent[];
+};
+type WorkflowRunResult<TOutput extends JsonValue = JsonValue> = WorkflowRunCompletedResult<TOutput> | WorkflowRunAwaitingApprovalResult;
+type WorkflowResumeRejectedResult = {
+    status: "rejected";
+    runId: string;
+    state: RunState;
+    events: readonly TraceEvent[];
+};
+type WorkflowResumeResult<TOutput extends JsonValue = JsonValue> = WorkflowRunResult<TOutput> | WorkflowResumeRejectedResult;
+
+declare const finishWorkflow = "__finish__";
+declare const defaultSupervisorMaxSteps = 10;
+declare const defaultParallelMergedArtifactKey = "parallel:merged";
+type WorkflowRouteContext = {
+    state: RunState;
+    stepIndex: number;
+    lastAgentName: string | null;
+    lastOutput: JsonValue | null;
+};
+type WorkflowRouteDecision = {
+    agentName: string;
+    reason: string;
+};
+type WorkflowRouteTarget = string | WorkflowRouteDecision;
+type WorkflowRouteFunction = (context: WorkflowRouteContext) => Promise<WorkflowRouteTarget> | WorkflowRouteTarget;
+type WorkflowSupervisorStopWhen = (context: WorkflowRouteContext) => boolean;
+declare const PipelineTopologySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"pipeline">;
+}, z.core.$strip>;
+type PipelineTopology = z.infer<typeof PipelineTopologySchema>;
+declare const SupervisorTopologySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"supervisor">;
+    supervisorName: z.ZodString;
+    route: z.ZodCustom<WorkflowRouteFunction, WorkflowRouteFunction>;
+    maxSteps: z.ZodOptional<z.ZodNumber>;
+    stopWhen: z.ZodOptional<z.ZodCustom<WorkflowSupervisorStopWhen, WorkflowSupervisorStopWhen>>;
+}, z.core.$strip>;
+type SupervisorTopology = z.infer<typeof SupervisorTopologySchema>;
+declare const ParallelTopologySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"parallel">;
+    agentNames: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    mergedArtifactKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ParallelTopology = z.infer<typeof ParallelTopologySchema>;
+declare const WorkflowTopologySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"pipeline">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"supervisor">;
+    supervisorName: z.ZodString;
+    route: z.ZodCustom<WorkflowRouteFunction, WorkflowRouteFunction>;
+    maxSteps: z.ZodOptional<z.ZodNumber>;
+    stopWhen: z.ZodOptional<z.ZodCustom<WorkflowSupervisorStopWhen, WorkflowSupervisorStopWhen>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"parallel">;
+    agentNames: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    mergedArtifactKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "kind">;
+type WorkflowTopology = z.infer<typeof WorkflowTopologySchema>;
+declare const defaultWorkflowTopology: WorkflowTopology;
+
+type WorkflowAgentDefinition = Omit<AgentDefinition<JsonValue>, "onAgentComplete"> & {
+    onAgentComplete?(context: AgentCompleteHookContext<JsonValue>): void;
+};
+type WorkflowToolDefinition = Omit<ToolDefinition<JsonValue, JsonValue>, "execute"> & {
+    execute(input: JsonValue): Promise<JsonValue>;
+};
+type WorkflowAgentToolBindingContext = {
+    state: RunState;
+    stepIndex: number;
+    agentOutput: JsonValue;
+};
+type WorkflowAgentToolBinding = {
+    agentName: string;
+    toolName: string;
+    buildToolInput(context: WorkflowAgentToolBindingContext): JsonValue;
+};
+type WorkflowStopConditionContext = {
+    state: RunState;
+    stepIndex: number;
+};
+type WorkflowStopCondition = (context: WorkflowStopConditionContext) => boolean;
+type WorkflowConfig<TInput extends JsonValue, TOutput extends JsonValue> = {
+    name: string;
+    inputSchema: z.ZodType<TInput>;
+    outputSchema?: z.ZodType<TOutput>;
+    agents: WorkflowAgentDefinition[];
+    tools?: WorkflowToolDefinition[];
+    agentToolBindings?: WorkflowAgentToolBinding[];
+    topology?: WorkflowTopology;
+    policies?: ToolPolicy[];
+    memory?: WorkflowMemoryConfig;
+    stopCondition?: WorkflowStopCondition;
+    continueOnAgentFailure?: boolean;
+};
+type WorkflowDefinition<TInput extends JsonValue, TOutput extends JsonValue> = {
+    readonly name: string;
+    readonly inputSchema: z.ZodType<TInput>;
+    readonly outputSchema: z.ZodType<TOutput> | null;
+    readonly agents: readonly WorkflowAgentDefinition[];
+    readonly tools: readonly WorkflowToolDefinition[];
+    readonly agentToolBindings: readonly WorkflowAgentToolBinding[];
+    readonly topology: WorkflowTopology;
+    readonly policies: readonly ToolPolicy[];
+    readonly memory: WorkflowMemoryConfig | null;
+    readonly stopCondition: WorkflowStopCondition | null;
+    readonly continueOnAgentFailure: boolean;
+    run(input: TInput, options?: RunWorkflowOptions): Promise<WorkflowRunResult<TOutput>>;
+};
+declare function workflow<TInput extends JsonValue, TOutput extends JsonValue = JsonValue>(config: WorkflowConfig<TInput, TOutput>): WorkflowDefinition<TInput, TOutput>;
+
+type TeamConfig = {
+    name: string;
+    description?: string;
+    agents: WorkflowAgentDefinition[];
+};
+type TeamDefinition = {
+    readonly name: string;
+    readonly description: string;
+    readonly agents: readonly WorkflowAgentDefinition[];
+    readonly agentNames: readonly string[];
+};
+declare function team(config: TeamConfig): TeamDefinition;
+
+type BuildPipelineTeamWorkflowConfigInput<TInput extends JsonValue, TOutput extends JsonValue> = {
+    team: TeamDefinition;
+    name: string;
+    inputSchema: z.ZodType<TInput>;
+    outputSchema?: z.ZodType<TOutput>;
+};
+declare function buildPipelineTeamWorkflowConfig<TInput extends JsonValue, TOutput extends JsonValue = JsonValue>(input: BuildPipelineTeamWorkflowConfigInput<TInput, TOutput>): WorkflowConfig<TInput, TOutput>;
+type BuildSupervisorTeamWorkflowConfigInput<TInput extends JsonValue, TOutput extends JsonValue> = {
+    team: TeamDefinition;
+    name: string;
+    supervisorName: string;
+    route: WorkflowRouteFunction;
+    inputSchema: z.ZodType<TInput>;
+    outputSchema?: z.ZodType<TOutput>;
+    maxSteps?: number;
+};
+declare function buildSupervisorTeamWorkflowConfig<TInput extends JsonValue, TOutput extends JsonValue = JsonValue>(input: BuildSupervisorTeamWorkflowConfigInput<TInput, TOutput>): WorkflowConfig<TInput, TOutput>;
+type BuildReviewPanelWorkflowConfigInput<TInput extends JsonValue> = {
+    team: TeamDefinition;
+    name: string;
+    inputSchema: z.ZodType<TInput>;
+};
+declare function buildReviewPanelWorkflowConfig<TInput extends JsonValue>(input: BuildReviewPanelWorkflowConfigInput<TInput>): WorkflowConfig<TInput, JsonValue>;
+
+declare function policy(config: ToolPolicy): ToolPolicy;
+
+type EvaluateToolPoliciesInput = {
+    policies: ToolPolicy[];
+    context: ToolPolicyContext;
+    timestamp: string;
+};
+type ToolPolicyEvaluation = {
+    action: PolicyAction;
+    reason: string;
+    policyName: string;
+    decisions: PolicyDecision[];
+};
+declare function evaluateToolPolicies(input: EvaluateToolPoliciesInput): ToolPolicyEvaluation;
+
+type ArtifactStoreOptions = {
+    provider: MemoryProvider;
+    runId: string;
+};
+type ArtifactStore = {
+    saveRunArtifact(artifact: RunArtifact): Promise<void>;
+    getRunArtifact(key: string): Promise<RunArtifact | null>;
+    listRunArtifacts(): Promise<RunArtifact[]>;
+};
+declare function createArtifactStore(options: ArtifactStoreOptions): ArtifactStore;
+
+type RunWorkflowInput<TInput extends JsonValue, TOutput extends JsonValue> = {
+    definition: WorkflowDefinition<TInput, TOutput>;
+    input: TInput;
+    options?: RunWorkflowOptions;
+};
+
+declare function runWorkflow<TInput extends JsonValue, TOutput extends JsonValue>(runInput: RunWorkflowInput<TInput, TOutput>): Promise<WorkflowRunResult<TOutput>>;
+
+type ResumeRunDecision = {
+    approved: boolean;
+    approvedBy: string;
+    reason?: string;
+};
+type ResumeRunInput<TInput extends JsonValue, TOutput extends JsonValue> = {
+    definition: WorkflowDefinition<TInput, TOutput>;
+    runId: string;
+    decision: ResumeRunDecision;
+    options?: RunWorkflowOptions;
+};
+declare function resumeRun<TInput extends JsonValue, TOutput extends JsonValue>(resumeInput: ResumeRunInput<TInput, TOutput>): Promise<WorkflowResumeResult<TOutput>>;
+
+declare const defaultRunStateDirectory: string;
+declare function resolveRunStateFilePath(runId: string, directory?: string): string;
+type LoadRunStateFileInput = {
+    runId: string;
+    directory?: string;
+};
+declare function loadRunStateFile(input: LoadRunStateFileInput): RunState;
+
+declare function createInMemoryMemoryProvider(): MemoryProvider;
+
+type JsonFileMemoryProviderOptions = {
+    filePath: string;
+};
+declare function createJsonFileMemoryProvider(options: JsonFileMemoryProviderOptions): MemoryProvider;
+
+type ConsoleSinkOptions = {
+    writeLine?: (line: string) => void;
+    useColor?: boolean;
+};
+declare function createConsoleSink(options?: ConsoleSinkOptions): TraceSink;
+declare function formatTraceEventLine(event: TraceEvent, useColor: boolean): string;
+
+type JsonlSinkOptions = {
+    runId: string;
+    directory?: string;
+};
+declare const defaultTraceDirectory: string;
+declare function resolveTraceFilePath(runId: string, directory?: string): string;
+declare function createJsonlSink(options: JsonlSinkOptions): TraceSink;
+
+type CreateInitialRunStateInput = {
+    runId: string;
+    workflowName: string;
+    input: JsonValue;
+    createdAt: string;
+};
+declare function createInitialRunState(input: CreateInitialRunStateInput): RunState;
+declare function applyTraceEventToRunState(state: RunState, event: TraceEvent): RunState;
+
+type PlatformFetchResponse = {
+    ok: boolean;
+    status: number;
+};
+type PlatformFetchRequest = {
+    method: string;
+    headers: {
+        [headerName: string]: string;
+    };
+    body: string;
+};
+type PlatformFetchImplementation = (url: string, request: PlatformFetchRequest) => Promise<PlatformFetchResponse>;
+type PlatformUploadStats = {
+    uploadedEventCount: number;
+    droppedEventCount: number;
+    failedBatchCount: number;
+};
+type CreatePlatformTraceSinkOptions = {
+    apiKey: string;
+    baseUrl?: string;
+    runId: string;
+    workflowName: string;
+    redactionMode?: RedactionMode;
+    sensitiveFieldNames?: string[];
+    batchSize?: number;
+    maxQueueSize?: number;
+    fetchImplementation?: PlatformFetchImplementation;
+    onUploadError?: (error: Error) => void;
+};
+type PlatformTraceSink = TraceSink & {
+    flush(): Promise<void>;
+    close(): void;
+    getUploadStats(): PlatformUploadStats;
+};
+declare function createPlatformTraceSink(options: CreatePlatformTraceSinkOptions): PlatformTraceSink;
+
+declare const PlatformConfigSchema: z.ZodObject<{
+    apiKey: z.ZodNullable<z.ZodString>;
+    baseUrl: z.ZodString;
+    dashboardUrl: z.ZodString;
+}, z.core.$strip>;
+type PlatformConfig = z.infer<typeof PlatformConfigSchema>;
+type ResolvePlatformConfigOptions = {
+    apiKey?: string;
+    baseUrl?: string;
+    dashboardUrl?: string;
+    homeDirectory?: string;
+    environmentVariables?: Record<string, string | undefined>;
+};
+declare function resolvePlatformConfig(options?: ResolvePlatformConfigOptions): PlatformConfig;
+
+type BuildHostedTraceUrlInput = {
+    dashboardUrl: string;
+    runId: string;
+};
+declare function buildMissingKeyMessage(): string;
+declare function buildHostedTraceUrl(input: BuildHostedTraceUrlInput): string;
+
+type ReplayRunOptions = {
+    fromStepIndex?: number;
+    mockTools?: boolean;
+    sinks?: TraceSink[];
+    runStateDirectory?: string;
+    traceDirectory?: string;
+    now?: () => Date;
+    replayRunId?: string;
+};
+type ReplayRunInput<TInput extends JsonValue, TOutput extends JsonValue> = {
+    definition: WorkflowDefinition<TInput, TOutput>;
+    sourceRunId: string;
+    options?: ReplayRunOptions;
+};
+type ReplayRunResult = {
+    status: "completed" | "awaiting_approval";
+    runId: string;
+    sourceRunId: string;
+    output: JsonValue | null;
+    approvalId: string | null;
+    state: RunState;
+    events: readonly TraceEvent[];
+};
+declare function replayRun<TInput extends JsonValue, TOutput extends JsonValue>(replayInput: ReplayRunInput<TInput, TOutput>): Promise<ReplayRunResult>;
+
+declare const maxReplayOutputDiffCount = 50;
+type CompareRunToReplayInput = {
+    original: RunState;
+    replay: RunState;
+};
+type ReplayOutputDiff = {
+    path: string;
+    original: JsonValue | null;
+    replay: JsonValue | null;
+};
+type ReplayLatencyComparison = {
+    originalMs: number | null;
+    replayMs: number | null;
+    deltaMs: number | null;
+};
+type ReplayTokenUsageComparison = {
+    original: TokenUsage | null;
+    replay: TokenUsage | null;
+};
+type ReplayRunComparison = {
+    statusMatches: boolean;
+    originalStatus: RunStatus;
+    replayStatus: RunStatus;
+    outputMatches: boolean;
+    outputDiff: ReplayOutputDiff[];
+    latency: ReplayLatencyComparison;
+    tokenUsage: ReplayTokenUsageComparison;
+    routingMatches: boolean;
+};
+declare function compareRunToReplay(input: CompareRunToReplayInput): ReplayRunComparison;
+
+type LoadReplaySourceInput = {
+    runId: string;
+    runStateDirectory?: string;
+    traceDirectory?: string;
+};
+type ReplaySource = {
+    state: RunState;
+    events: TraceEvent[];
+};
+declare function loadReplaySource(input: LoadReplaySourceInput): ReplaySource;
+
+export { type AgentCompleteHookContext, type AgentConfig, type AgentDefinition, type AgentErrorHookContext, type AgentRunResult, type AgentStartHookContext, type ArtifactStore, type BuildPipelineTeamWorkflowConfigInput, type BuildReviewPanelWorkflowConfigInput, type BuildSupervisorTeamWorkflowConfigInput, type CompareRunToReplayInput, type ConsoleSinkOptions, type CreateInitialRunStateInput, type CreatePlatformTraceSinkOptions, type CreateTraceBusInput, type ExecuteToolCallInput, type GrantedToolApproval, type JsonlSinkOptions, type LoadReplaySourceInput, type MemoryProvider, type ParallelTopology, type PipelineTopology, type PlatformConfig, type PlatformFetchImplementation, type PlatformFetchRequest, type PlatformFetchResponse, type PlatformTraceSink, type PlatformUploadStats, type ReplayLatencyComparison, type ReplayOutputDiff, type ReplayRunComparison, type ReplayRunInput, type ReplayRunOptions, type ReplayRunResult, type ReplaySource, type ReplayTokenUsageComparison, type ResolvePlatformConfigOptions, type ResumeRunDecision, type ResumeRunInput, type RunAgentInput, type RunWorkflowInput, type RunWorkflowOptions, type SupervisorTopology, type TeamConfig, type TeamDefinition, type ThreadMemory, type ToolCallAwaitingApprovalOutcome, type ToolCallBlockedOutcome, type ToolCallCompletedOutcome, type ToolCallError, type ToolCallFailedOutcome, type ToolCallOutcome, type ToolDefinition, type ToolDefinitionConfig, type ToolPolicy, type ToolPolicyContext, type ToolPolicyEvaluation, type ToolPolicyRule, type ToolPolicyRuleResult, type ToolRetryConfig, type TraceBus, type TraceSink, type WorkflowAgentDefinition, type WorkflowAgentToolBinding, type WorkflowAgentToolBindingContext, type WorkflowConfig, type WorkflowDefinition, type WorkflowMemoryConfig, type WorkflowResumeRejectedResult, type WorkflowResumeResult, type WorkflowRouteContext, type WorkflowRouteDecision, type WorkflowRouteFunction, type WorkflowRouteTarget, type WorkflowRunAwaitingApprovalResult, type WorkflowRunCompletedResult, type WorkflowRunResult, type WorkflowToolDefinition, type WorkflowTopology, agent, applyTraceEventToRunState, buildHostedTraceUrl, buildMissingKeyMessage, buildPipelineTeamWorkflowConfig, buildReviewPanelWorkflowConfig, buildSupervisorTeamWorkflowConfig, compareRunToReplay, createArtifactStore, createConsoleSink, createInMemoryMemoryProvider, createInitialRunState, createJsonFileMemoryProvider, createJsonlSink, createPlatformTraceSink, createThreadMemory, createTraceBus, defaultParallelMergedArtifactKey, defaultRunStateDirectory, defaultSupervisorMaxSteps, defaultTraceDirectory, defaultWorkflowTopology, evaluateToolPolicies, executeToolCall, finishWorkflow, formatTraceEventLine, loadReplaySource, loadRunStateFile, maxReplayOutputDiffCount, policy, replayRun, resolvePlatformConfig, resolveRunStateFilePath, resolveTraceFilePath, resolveWorkflowMemoryConfig, resumeRun, runAgent, runWorkflow, team, tool, workflow };