@apo-ai/sdk 0.3.0 → 0.4.0

package/README.md

@@ -286,6 +286,17 @@ with `runTask(dir, { judge: { model, apiKey?, baseURL? } })`, or set
 same recorder and result format as code assertions, including model, prompt,
 response, token usage, and latency metadata.
 
+A task can also set its own judge layer (`task("id", { judge: { model?, prompt? } })`)
+that overrides the run-level config and is itself overridden per `t.judge`
+call — resolution is `run-level ← task-level ← per-call`, field by field.
+`prompt` is a builder `(ctx) => ({ system?, user? })` that receives what the
+judge is grading (`taskId`, `taskDescription?`, `checkName`, `instruction`,
+`deliverableNames?`) so the briefing can say what a bare deliverable + rubric
+never revealed. The SDK appends its JSON response contract to any custom
+`system` — a builder customizes the briefing, never the response format. Keep
+`system` constant per task and vary only `user` to preserve the cached prompt
+prefix across a task's criteria (issue #161).
+
 **Testing agents not built on apo's adapter.** Build a `Flow` from the
 framework's own output with a normalizer, then run the same checks:
 

package/dist/agent-task/public.d.ts

@@ -3,20 +3,184 @@ export { CreateApoTracerOptions, createApoTracer } from './integrations/ai-sdk.j
 export { CreateApoOpenAIOptions, createApoOpenAI } from './integrations/openai.js';
 export { CreateApoAnthropicOptions, createApoAnthropic } from './integrations/anthropic.js';
 
-type TaskDefinition<TAdapterName extends string = string, TDeliverable extends string = string> = {
-    id: string;
-    adapter: TAdapterName;
-    description?: string;
-    deliverables: TDeliverable[];
-    maxTurns?: number;
-    metadata?: Record<string, unknown>;
-    checks?: string | false;
-};
-type TaskConfig<TDeliverable extends string = string> = Omit<TaskDefinition<string, TDeliverable>, "adapter">;
-type FileEntry = {
-    relativePath: string;
-    absolutePath: string;
-};
+/**
+ * Trace Projection snapshot contract.
+ *
+ * This is the immutable transport/read snapshot of a Trace Projection — the
+ * query-optimized representation shared by the dashboard and agent-task
+ * assertions. It is NOT a new domain entity and never a source of truth; the
+ * canonical OpenTelemetry spans remain authoritative.
+ *
+ * Both the Python backend and the TypeScript SDK MUST serialize to this exact
+ * lower-camel-case JSON contract, so assertions read the same shape whether
+ * the snapshot came from the canonical repository, a local/offline recorder,
+ * or a legacy-Flow compatibility adapter.
+ *
+ * Rules:
+ * - `schemaVersion` versions the JSON contract.
+ * - `projectionVersion` identifies the normalizer/projector interpretation.
+ * - `source` is diagnostic; only `"canonical"` represents a durably projected
+ *   Trace.
+ * - `complete` means the task execution root ended and every span in the
+ *   acknowledged export was projected. It does not promise no unrelated
+ *   service will ever export a late span.
+ * - Missing evidence is represented through `capabilities`, never converted to
+ *   empty arrays, zero duration, or successful status.
+ * - Observations are immutable and sorted deterministically by invocation
+ *   time, then span ID. Missing timestamps sort after timestamped ones.
+ */
+/** Whether a category of evidence is present in the projection. */
+type EvidenceAvailability = "available" | "partial" | "unavailable";
+/** Lifecycle status of an observation. `unset` = the source had no status. */
+type ObservationStatus = "unset" | "ok" | "error";
+/** What kind of Span an Observation was derived from. */
+type ObservationType = "SPAN" | "GENERATION" | "TOOL" | "AGENT" | "SKILL" | "CHAIN" | "RETRIEVER" | "EMBEDDING" | "GUARDRAIL";
+/**
+ * Per-category evidence availability. Every category must declare honestly
+ * what it carries so assertions can fail closed when evidence is missing
+ * instead of vacuously passing.
+ */
+interface TraceProjectionCapabilities {
+    messages: EvidenceAvailability;
+    tools: EvidenceAvailability;
+    errors: EvidenceAvailability;
+    timing: EvidenceAvailability;
+    skills: EvidenceAvailability;
+    subagents: EvidenceAvailability;
+}
+/** One chat message reconstructed from a generation observation. */
+interface TraceProjectionMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string;
+}
+/**
+ * A derived interpretation of one Span, as shown by the dashboard and read by
+ * assertions. Unknown span kinds survive as `SPAN`; hierarchy is preserved via
+ * `parentSpanId`.
+ */
+interface TraceProjectionObservation {
+    spanId: string;
+    parentSpanId?: string;
+    type: ObservationType;
+    name: string;
+    startedAt?: string;
+    endedAt?: string;
+    durationMs?: number;
+    status: ObservationStatus;
+    errorMessage?: string;
+    input?: unknown;
+    output?: unknown;
+    model?: string;
+    toolName?: string;
+    toolParameters?: unknown;
+    toolResult?: unknown;
+    messages?: readonly TraceProjectionMessage[];
+    metadata?: Readonly<Record<string, unknown>>;
+}
+/** Trace-level facts. All timing is optional; absence is honest. */
+interface TraceProjectionTrace {
+    traceId: string;
+    taskRunId?: string;
+    name?: string;
+    startedAt?: string;
+    endedAt?: string;
+    durationMs?: number;
+    complete: boolean;
+}
+/**
+ * The immutable read snapshot. Identical JSON shape across canonical, local,
+ * and legacy-flow sources — only `source` and `capabilities` differ.
+ */
+interface TraceProjectionSnapshot {
+    schemaVersion: 1;
+    projectionVersion: number;
+    source: "canonical" | "local" | "legacy-flow";
+    trace: TraceProjectionTrace;
+    capabilities: TraceProjectionCapabilities;
+    observations: readonly TraceProjectionObservation[];
+}
+
+/**
+ * TraceView — typed, capability-gated, derived access over a
+ * {@link TraceProjectionSnapshot}. This is the read model the projection-first
+ * assertion surface queries. It is the projection analogue of `FlowView`.
+ *
+ * The defining difference from `FlowView` is **capability honesty**: when the
+ * snapshot declares a category of evidence `unavailable`, the derived numeric
+ * facts (`durationMs`, `failedActions`, `turnCount`) return `undefined` rather
+ * than zero — so an assertion like `t.maxDurationMs` can record an explicit
+ * `unsupported` outcome instead of vacuously passing against a fabricated 0ms.
+ *
+ * `toolNamesInOrder` sorts by observation invocation time (`startedAt`) with a
+ * deterministic span-ID tie-breaker — NOT array/completion order. This fixes
+ * the drift where concurrent tools appeared in completion order.
+ */
+
+/** A tool call derived from a `TOOL` observation. */
+interface TraceToolCall {
+    spanId: string;
+    name: string;
+    input?: unknown;
+    output?: unknown;
+    status: ObservationStatus;
+    startedAt?: string;
+}
+/** A skill load derived from a `SKILL` observation. */
+interface TraceSkillLoad {
+    spanId: string;
+    skill: string;
+    startedAt?: string;
+}
+/** A subagent delegation derived from an `AGENT` observation. */
+interface TraceSubagentCall {
+    spanId: string;
+    agent: string;
+    output?: unknown;
+    status: ObservationStatus;
+    startedAt?: string;
+}
+declare class TraceView {
+    readonly snapshot: TraceProjectionSnapshot;
+    constructor(snapshot: TraceProjectionSnapshot);
+    /** Evidence availability for a capability. */
+    requireCapability(capability: keyof TraceProjectionCapabilities): EvidenceAvailability;
+    /** Whether a capability is reported as available (not partial/unavailable). */
+    private isAvailable;
+    /** All chat messages flattened across generation observations, in order. */
+    get messages(): readonly TraceProjectionMessage[];
+    /** Tool calls derived from `TOOL` observations, in invocation order. */
+    get toolCalls(): readonly TraceToolCall[];
+    /** Tool names in invocation order with deterministic span-ID tie-breaking. */
+    get toolNamesInOrder(): readonly string[];
+    /** Skill loads derived from `SKILL` observations, in invocation order. */
+    get skillLoads(): readonly TraceSkillLoad[];
+    /** Subagent delegations derived from `AGENT` observations, in invocation order. */
+    get subagentCalls(): readonly TraceSubagentCall[];
+    /** Last assistant message content — the agent's "reply". Empty if none. */
+    get reply(): string;
+    /**
+     * Number of completed assistant turns, or `undefined` when message evidence
+     * is unavailable (capability honesty).
+     */
+    get turnCount(): number | undefined;
+    /**
+     * Number of tool/subagent observations that reported an error, or `undefined`
+     * when error evidence is unavailable (capability honesty).
+     */
+    get failedActions(): number | undefined;
+    /**
+     * Total execution duration in milliseconds, or `undefined` when timing
+     * evidence is unavailable (capability honesty). Uses trace-level
+     * startedAt/endedAt when present.
+     */
+    get durationMs(): number | undefined;
+    /**
+     * Observations sorted deterministically by invocation time then span ID.
+     * Memoized per TraceView instance since the snapshot is immutable.
+     */
+    private get sortedObservations();
+    private _sorted;
+}
 
 declare class TaskFiles {
     private entries;
@@ -138,103 +302,6 @@ type TypedAdapterDefinition<TName extends string, TDeliverables extends Record<s
     collectDeliverables: (ctx: CollectDeliverablesContext) => Promise<TCollected>;
 };
 
-/**
- * Trace Projection snapshot contract.
- *
- * This is the immutable transport/read snapshot of a Trace Projection — the
- * query-optimized representation shared by the dashboard and agent-task
- * assertions. It is NOT a new domain entity and never a source of truth; the
- * canonical OpenTelemetry spans remain authoritative.
- *
- * Both the Python backend and the TypeScript SDK MUST serialize to this exact
- * lower-camel-case JSON contract, so assertions read the same shape whether
- * the snapshot came from the canonical repository, a local/offline recorder,
- * or a legacy-Flow compatibility adapter.
- *
- * Rules:
- * - `schemaVersion` versions the JSON contract.
- * - `projectionVersion` identifies the normalizer/projector interpretation.
- * - `source` is diagnostic; only `"canonical"` represents a durably projected
- *   Trace.
- * - `complete` means the task execution root ended and every span in the
- *   acknowledged export was projected. It does not promise no unrelated
- *   service will ever export a late span.
- * - Missing evidence is represented through `capabilities`, never converted to
- *   empty arrays, zero duration, or successful status.
- * - Observations are immutable and sorted deterministically by invocation
- *   time, then span ID. Missing timestamps sort after timestamped ones.
- */
-/** Whether a category of evidence is present in the projection. */
-type EvidenceAvailability = "available" | "partial" | "unavailable";
-/** Lifecycle status of an observation. `unset` = the source had no status. */
-type ObservationStatus = "unset" | "ok" | "error";
-/** What kind of Span an Observation was derived from. */
-type ObservationType = "SPAN" | "GENERATION" | "TOOL" | "AGENT" | "SKILL" | "CHAIN" | "RETRIEVER" | "EMBEDDING" | "GUARDRAIL";
-/**
- * Per-category evidence availability. Every category must declare honestly
- * what it carries so assertions can fail closed when evidence is missing
- * instead of vacuously passing.
- */
-interface TraceProjectionCapabilities {
-    messages: EvidenceAvailability;
-    tools: EvidenceAvailability;
-    errors: EvidenceAvailability;
-    timing: EvidenceAvailability;
-    skills: EvidenceAvailability;
-    subagents: EvidenceAvailability;
-}
-/** One chat message reconstructed from a generation observation. */
-interface TraceProjectionMessage {
-    role: "system" | "user" | "assistant" | "tool";
-    content: string;
-}
-/**
- * A derived interpretation of one Span, as shown by the dashboard and read by
- * assertions. Unknown span kinds survive as `SPAN`; hierarchy is preserved via
- * `parentSpanId`.
- */
-interface TraceProjectionObservation {
-    spanId: string;
-    parentSpanId?: string;
-    type: ObservationType;
-    name: string;
-    startedAt?: string;
-    endedAt?: string;
-    durationMs?: number;
-    status: ObservationStatus;
-    errorMessage?: string;
-    input?: unknown;
-    output?: unknown;
-    model?: string;
-    toolName?: string;
-    toolParameters?: unknown;
-    toolResult?: unknown;
-    messages?: readonly TraceProjectionMessage[];
-    metadata?: Readonly<Record<string, unknown>>;
-}
-/** Trace-level facts. All timing is optional; absence is honest. */
-interface TraceProjectionTrace {
-    traceId: string;
-    taskRunId?: string;
-    name?: string;
-    startedAt?: string;
-    endedAt?: string;
-    durationMs?: number;
-    complete: boolean;
-}
-/**
- * The immutable read snapshot. Identical JSON shape across canonical, local,
- * and legacy-flow sources — only `source` and `capabilities` differ.
- */
-interface TraceProjectionSnapshot {
-    schemaVersion: 1;
-    projectionVersion: number;
-    source: "canonical" | "local" | "legacy-flow";
-    trace: TraceProjectionTrace;
-    capabilities: TraceProjectionCapabilities;
-    observations: readonly TraceProjectionObservation[];
-}
-
 /**
  * The outcome of a single assertion.
  *
@@ -423,88 +490,6 @@ type TaskRunResult = {
     runConfiguration?: AgentTaskRunConfiguration;
 };
 
-/**
- * TraceView — typed, capability-gated, derived access over a
- * {@link TraceProjectionSnapshot}. This is the read model the projection-first
- * assertion surface queries. It is the projection analogue of `FlowView`.
- *
- * The defining difference from `FlowView` is **capability honesty**: when the
- * snapshot declares a category of evidence `unavailable`, the derived numeric
- * facts (`durationMs`, `failedActions`, `turnCount`) return `undefined` rather
- * than zero — so an assertion like `t.maxDurationMs` can record an explicit
- * `unsupported` outcome instead of vacuously passing against a fabricated 0ms.
- *
- * `toolNamesInOrder` sorts by observation invocation time (`startedAt`) with a
- * deterministic span-ID tie-breaker — NOT array/completion order. This fixes
- * the drift where concurrent tools appeared in completion order.
- */
-
-/** A tool call derived from a `TOOL` observation. */
-interface TraceToolCall {
-    spanId: string;
-    name: string;
-    input?: unknown;
-    output?: unknown;
-    status: ObservationStatus;
-    startedAt?: string;
-}
-/** A skill load derived from a `SKILL` observation. */
-interface TraceSkillLoad {
-    spanId: string;
-    skill: string;
-    startedAt?: string;
-}
-/** A subagent delegation derived from an `AGENT` observation. */
-interface TraceSubagentCall {
-    spanId: string;
-    agent: string;
-    output?: unknown;
-    status: ObservationStatus;
-    startedAt?: string;
-}
-declare class TraceView {
-    readonly snapshot: TraceProjectionSnapshot;
-    constructor(snapshot: TraceProjectionSnapshot);
-    /** Evidence availability for a capability. */
-    requireCapability(capability: keyof TraceProjectionCapabilities): EvidenceAvailability;
-    /** Whether a capability is reported as available (not partial/unavailable). */
-    private isAvailable;
-    /** All chat messages flattened across generation observations, in order. */
-    get messages(): readonly TraceProjectionMessage[];
-    /** Tool calls derived from `TOOL` observations, in invocation order. */
-    get toolCalls(): readonly TraceToolCall[];
-    /** Tool names in invocation order with deterministic span-ID tie-breaking. */
-    get toolNamesInOrder(): readonly string[];
-    /** Skill loads derived from `SKILL` observations, in invocation order. */
-    get skillLoads(): readonly TraceSkillLoad[];
-    /** Subagent delegations derived from `AGENT` observations, in invocation order. */
-    get subagentCalls(): readonly TraceSubagentCall[];
-    /** Last assistant message content — the agent's "reply". Empty if none. */
-    get reply(): string;
-    /**
-     * Number of completed assistant turns, or `undefined` when message evidence
-     * is unavailable (capability honesty).
-     */
-    get turnCount(): number | undefined;
-    /**
-     * Number of tool/subagent observations that reported an error, or `undefined`
-     * when error evidence is unavailable (capability honesty).
-     */
-    get failedActions(): number | undefined;
-    /**
-     * Total execution duration in milliseconds, or `undefined` when timing
-     * evidence is unavailable (capability honesty). Uses trace-level
-     * startedAt/endedAt when present.
-     */
-    get durationMs(): number | undefined;
-    /**
-     * Observations sorted deterministically by invocation time then span ID.
-     * Memoized per TraceView instance since the snapshot is immutable.
-     */
-    private get sortedObservations();
-    private _sorted;
-}
-
 /**
  * Value matchers for `t.check(value, matcher)`. Small, composable, and the
  * single way to assert on deliverables/values (replaces the old `expect`).
@@ -536,6 +521,42 @@ declare function matchValue<T>(actual: T, matcher: ValueMatcher<T>): boolean;
 /** Normalized Levenshtein similarity. Pass when score ≥ threshold (default 0.8). */
 declare function similarity(expected: string, threshold?: number): Matcher<unknown>;
 
+/**
+ * LLM-as-judge call. Used by `t.judge(values, instruction)` to evaluate
+ * deliverables against a natural-language rubric. Calls an OpenAI-compatible
+ * endpoint (OpenRouter, OpenAI, etc.) via fetch and parses the verdict.
+ */
+
+/**
+ * What a judge call is grading — everything the SDK knows that a bare
+ * (deliverable, instruction) pair withholds (#161). Threaded automatically
+ * from the task definition and the check registry; consumed by
+ * {@link JudgePromptBuilder}.
+ */
+type JudgeContext = {
+    /** The task being graded (`TaskDefinition.id`). */
+    taskId: string;
+    /** `TaskDefinition.description`, when the task sets one. */
+    taskDescription?: string;
+    /** The name of the check invoking the judge (the `test(...)` id). */
+    checkName: string;
+    /** The rubric instruction for this call. */
+    instruction: string;
+    /** Deliverable keys the check read before judging, in read order. */
+    deliverableNames?: string[];
+};
+/**
+ * Builds the judge *briefing* — not the whole prompt. The SDK appends its
+ * own response contract to whatever `system` comes back and keeps
+ * `response_format`, so a builder cannot break verdict parsing. Keep the
+ * returned `system` constant per task (vary only `user`) to preserve the
+ * cached prompt prefix across a task's criteria.
+ */
+type JudgePromptBuilder = (ctx: JudgeContext) => {
+    system?: string;
+    user?: string;
+};
+
 /**
  * The assertion surface — `t`. Flat and eve-style: reads the trace (via
  * {@link TraceView}) for behavioural checks and grades explicit values via
@@ -559,7 +580,8 @@ type ToolCallOptions = {
 /**
  * LLM judge model config for `t.judge(...)` calls in checks.ts. Threaded
  * through `runTask({ judge })` from the caller — the runner has no opinion
- * about which model grades a deliverable.
+ * about which model grades a deliverable. A task definition may also set a
+ * `judge` layer of its own; see {@link resolveJudgeConfig} for precedence.
  */
 type JudgeConfig = {
     /** Model id, e.g. ``"google/gemini-2.5-flash-lite"``. */
@@ -568,6 +590,24 @@ type JudgeConfig = {
     baseURL?: string;
     /** Override the API key (defaults to env). */
     apiKey?: string;
+    /**
+     * Build a custom judge briefing from the threaded context (#161). The SDK
+     * keeps ownership of the JSON response contract — see
+     * {@link JudgePromptBuilder}.
+     */
+    prompt?: JudgePromptBuilder;
+};
+/**
+ * What a check knows about its scope when it invokes the judge — the
+ * task-level frame threaded from the runner plus the deliverables the check
+ * has read so far.
+ */
+type JudgeScope = {
+    taskId: string;
+    taskDescription?: string;
+    checkName: string;
+    /** Deliverable keys read so far, recorded by the check runner. */
+    readDeliverableNames?: () => string[];
 };
 interface TestContext {
     /** Asserts a matching tool was called. Pass `{ count }` for an exact count. */
@@ -627,6 +667,28 @@ interface TestContext {
  */
 declare const TEST_METHOD_NAMES: readonly ["calledTool", "notCalledTool", "toolOrder", "usedNoTools", "maxToolCalls", "noFailedActions", "loadedSkill", "calledSubagent", "messageIncludes", "maxTurns", "maxDurationMs", "assert", "check", "judge"];
 
+type TaskDefinition<TAdapterName extends string = string, TDeliverable extends string = string> = {
+    id: string;
+    adapter: TAdapterName;
+    description?: string;
+    deliverables: TDeliverable[];
+    maxTurns?: number;
+    metadata?: Record<string, unknown>;
+    checks?: string | false;
+    /**
+     * Task-level judge layer (#161): overrides the run-level `runTask({ judge })`
+     * config and is itself overridden per `t.judge` call. Lets a task grade
+     * differently from its suite — a stronger model, or a custom briefing via
+     * `prompt` that tells the judge what it is grading.
+     */
+    judge?: Partial<JudgeConfig>;
+};
+type TaskConfig<TDeliverable extends string = string> = Omit<TaskDefinition<string, TDeliverable>, "adapter">;
+type FileEntry = {
+    relativePath: string;
+    absolutePath: string;
+};
+
 /**
  * Check runner — builds a {@link TestContext} (`t`) per registered check from
  * a {@link TraceProjectionSnapshot}, runs it, and aggregates every recorded
@@ -1403,4 +1465,4 @@ declare function canonicalManifestJson(manifest: TaskRevisionManifestV1): string
 /** SHA-256 (lowercase hex) of the canonical manifest JSON's UTF-8 bytes. */
 declare function contentSha256(manifest: TaskRevisionManifestV1): string;
 
-export { type AISDKResult, type AdapterDefinition, type AdapterRuntimeState, type AdapterSession, type AgentTaskCliOptions, type AgentTaskRunConfiguration, AgentTaskRunError, type AgentTaskRunSummary, type AgentTaskRuntime, AgentTaskTraceContext, AgentTaskTraceOptions, type AgentTurnResult, type AnthropicMessage, type ApoRunContext, ApoSpanProcessor, type ArtifactUploadConfig, type CheckContext, type CheckGroup, type CleanupContext, type CollectDeliverablesContext, type CollectedDeliverables, type DeliverableDefinition, type DeliverableSummary, type DeliverableValidationResult, type DescribeRegistration, type FileArtifact, type FileArtifactOptions, type FileEntry, type Flow, type FlowEvent, FlowView, type InitializeContext, type JudgeConfig, type LoadedTask, type ManifestFile, type ManifestFileInput, type Matcher, type ModeClass, type NameMatcher, type OpenAIMessage, type PreparedTaskResult, type RegisterApoTracingOptions, type RejudgeCheckStability, type RejudgeEndpoints, RejudgeError, type RejudgeOptions, type RejudgeOutcome, type RunTaskOptions, type StartSessionContext, TEST_METHOD_NAMES, type TaskConfig, type TaskDefinition, type TaskEvaluationResult, TaskFiles, type TaskRevisionManifestV1, type TaskRunResult, type TaskScope, type TaskTranscript, type TaskTranscriptTurn, type TestContext, type TestRegistration, type ToolCallOptions, type ToolCallStatus, type TurnContext, type TurnFn, type TurnRecord, type TypedAdapterDefinition, type ValueMatcher, buildManifest, canonicalManifestJson, contentSha256, defineAdapter, defineTask, describe, discoverAgentTaskDirs, equals, fileArtifact, filePaths, fromAISDK, fromAnthropicMessages, fromOpenAIMessages, getActiveApoRun, getTaskTurn, includes, isFileArtifact, loadTask, loadTaskRuntime, matchValue, matches, normalizeManifestPath, parseAgentTaskCliArgs, persistFileArtifacts, registerApoTracing, rejudgeTaskRun, resetApoTracing, resetFlowChecks, resetTaskRegistry, resetTaskTurn, resolveTurn, runAgentTaskCli, runTask, runTaskDir, satisfies, sha256Hex, similarity, task, defineCheck as test, turn, withApoRun, withApoRunSync };
+export { type AISDKResult, type AdapterDefinition, type AdapterRuntimeState, type AdapterSession, type AgentTaskCliOptions, type AgentTaskRunConfiguration, AgentTaskRunError, type AgentTaskRunSummary, type AgentTaskRuntime, AgentTaskTraceContext, AgentTaskTraceOptions, type AgentTurnResult, type AnthropicMessage, type ApoRunContext, ApoSpanProcessor, type ArtifactUploadConfig, type CheckContext, type CheckGroup, type CleanupContext, type CollectDeliverablesContext, type CollectedDeliverables, type DeliverableDefinition, type DeliverableSummary, type DeliverableValidationResult, type DescribeRegistration, type FileArtifact, type FileArtifactOptions, type FileEntry, type Flow, type FlowEvent, FlowView, type InitializeContext, type JudgeConfig, type JudgeContext, type JudgePromptBuilder, type JudgeScope, type LoadedTask, type ManifestFile, type ManifestFileInput, type Matcher, type ModeClass, type NameMatcher, type OpenAIMessage, type PreparedTaskResult, type RegisterApoTracingOptions, type RejudgeCheckStability, type RejudgeEndpoints, RejudgeError, type RejudgeOptions, type RejudgeOutcome, type RunTaskOptions, type StartSessionContext, TEST_METHOD_NAMES, type TaskConfig, type TaskDefinition, type TaskEvaluationResult, TaskFiles, type TaskRevisionManifestV1, type TaskRunResult, type TaskScope, type TaskTranscript, type TaskTranscriptTurn, type TestContext, type TestRegistration, type ToolCallOptions, type ToolCallStatus, type TurnContext, type TurnFn, type TurnRecord, type TypedAdapterDefinition, type ValueMatcher, buildManifest, canonicalManifestJson, contentSha256, defineAdapter, defineTask, describe, discoverAgentTaskDirs, equals, fileArtifact, filePaths, fromAISDK, fromAnthropicMessages, fromOpenAIMessages, getActiveApoRun, getTaskTurn, includes, isFileArtifact, loadTask, loadTaskRuntime, matchValue, matches, normalizeManifestPath, parseAgentTaskCliArgs, persistFileArtifacts, registerApoTracing, rejudgeTaskRun, resetApoTracing, resetFlowChecks, resetTaskRegistry, resetTaskTurn, resolveTurn, runAgentTaskCli, runTask, runTaskDir, satisfies, sha256Hex, similarity, task, defineCheck as test, turn, withApoRun, withApoRunSync };