@sanity/ailf 4.0.7 → 4.1.0

package/bin/ailf.js

@@ -28,10 +28,15 @@ const args = process.argv.slice(2)
 // operate on the user's cwd, not the eval package root.
 const callerCwd = process.cwd()
 
+// Test harnesses (and any caller that knows the dist is fresh) can opt out
+// of the tsx dev path with AILF_PREFER_DIST=1. This avoids the npx + tsx
+// cold-start cost (~1–2s per invocation) on every `spawnCli(...)` call.
+const preferDist = process.env.AILF_PREFER_DIST === "1" && existsSync(jsDist)
+
 // ---------------------------------------------------------------------------
 // Mode 1: Development — tsx + TypeScript source (no build step needed)
 // ---------------------------------------------------------------------------
-if (existsSync(tsSrc)) {
+if (existsSync(tsSrc) && !preferDist) {
   try {
     // Enable the `ailf-source` export condition so @sanity/ailf-shared and
     // @sanity/ailf-core resolve to their `src/index.ts` entrypoints rather

package/dist/_vendor/ailf-core/schemas/external-providers.d.ts

@@ -0,0 +1,136 @@
+/**
+ * @sanity/ailf-core — External provider response schemas
+ *
+ * Zod schemas for HTTP responses from third-party AI providers and search
+ * APIs that the agent-observer providers parse. Replaces inline `as`
+ * casts on `await response.json()` with parse-don't-validate boundaries.
+ *
+ * Schemas are intentionally permissive on optional fields (real APIs add
+ * fields over time) but strict on shape — a malformed payload surfaces
+ * as a clear ZodError at the call site instead of a cryptic
+ * `Cannot read properties of undefined` later.
+ *
+ * @see docs/design-docs/parse-dont-validate.md
+ * @see docs/work-items/W0004.json
+ */
+import { z } from "zod";
+export declare const OpenAIChatResponseSchema: z.ZodObject<{
+    choices: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        finish_reason: z.ZodOptional<z.ZodString>;
+        message: z.ZodOptional<z.ZodObject<{
+            content: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+            role: z.ZodEnum<{
+                user: "user";
+                assistant: "assistant";
+                system: "system";
+                tool: "tool";
+            }>;
+            tool_call_id: z.ZodOptional<z.ZodString>;
+            tool_calls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                function: z.ZodObject<{
+                    arguments: z.ZodString;
+                    name: z.ZodString;
+                }, z.core.$strip>;
+                id: z.ZodString;
+                type: z.ZodLiteral<"function">;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    error: z.ZodOptional<z.ZodObject<{
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    usage: z.ZodOptional<z.ZodObject<{
+        completion_tokens: z.ZodOptional<z.ZodNumber>;
+        prompt_tokens: z.ZodOptional<z.ZodNumber>;
+        total_tokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type OpenAIChatResponse = z.infer<typeof OpenAIChatResponseSchema>;
+export declare const OpenAIResponsesResponseSchema: z.ZodObject<{
+    error: z.ZodOptional<z.ZodObject<{
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    output: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        content: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            text: z.ZodOptional<z.ZodString>;
+            type: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        role: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    usage: z.ZodOptional<z.ZodObject<{
+        input_tokens: z.ZodOptional<z.ZodNumber>;
+        output_tokens: z.ZodOptional<z.ZodNumber>;
+        total_tokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type OpenAIResponsesResponse = z.infer<typeof OpenAIResponsesResponseSchema>;
+declare const AnthropicTextBlockSchema: z.ZodObject<{
+    text: z.ZodString;
+    type: z.ZodLiteral<"text">;
+}, z.core.$strip>;
+declare const AnthropicToolUseBlockSchema: z.ZodObject<{
+    id: z.ZodString;
+    input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    name: z.ZodString;
+    type: z.ZodLiteral<"tool_use">;
+}, z.core.$strip>;
+declare const AnthropicContentBlockSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    text: z.ZodString;
+    type: z.ZodLiteral<"text">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    name: z.ZodString;
+    type: z.ZodLiteral<"tool_use">;
+}, z.core.$strip>], "type">;
+export declare const AnthropicResponseSchema: z.ZodObject<{
+    content: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        text: z.ZodString;
+        type: z.ZodLiteral<"text">;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        name: z.ZodString;
+        type: z.ZodLiteral<"tool_use">;
+    }, z.core.$strip>], "type">>>;
+    error: z.ZodOptional<z.ZodObject<{
+        message: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    model: z.ZodOptional<z.ZodString>;
+    stop_reason: z.ZodOptional<z.ZodEnum<{
+        tool_use: "tool_use";
+        end_turn: "end_turn";
+        max_tokens: "max_tokens";
+    }>>;
+    usage: z.ZodOptional<z.ZodObject<{
+        input_tokens: z.ZodOptional<z.ZodNumber>;
+        output_tokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AnthropicResponse = z.infer<typeof AnthropicResponseSchema>;
+export type AnthropicTextBlock = z.infer<typeof AnthropicTextBlockSchema>;
+export type AnthropicToolUseBlock = z.infer<typeof AnthropicToolUseBlockSchema>;
+export type AnthropicContentBlock = z.infer<typeof AnthropicContentBlockSchema>;
+export declare const GoogleSearchResponseSchema: z.ZodObject<{
+    items: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        link: z.ZodString;
+        snippet: z.ZodString;
+        title: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type GoogleSearchResponse = z.infer<typeof GoogleSearchResponseSchema>;
+export declare const FetchPageToolArgsSchema: z.ZodObject<{
+    url: z.ZodString;
+}, z.core.$strip>;
+export declare const ListDocsToolArgsSchema: z.ZodObject<{
+    site: z.ZodString;
+}, z.core.$strip>;
+export declare const WebSearchToolArgsSchema: z.ZodObject<{
+    query: z.ZodString;
+}, z.core.$strip>;
+export type FetchPageToolArgs = z.infer<typeof FetchPageToolArgsSchema>;
+export type ListDocsToolArgs = z.infer<typeof ListDocsToolArgsSchema>;
+export type WebSearchToolArgs = z.infer<typeof WebSearchToolArgsSchema>;
+export {};

package/dist/_vendor/ailf-core/schemas/external-providers.js

@@ -0,0 +1,136 @@
+/**
+ * @sanity/ailf-core — External provider response schemas
+ *
+ * Zod schemas for HTTP responses from third-party AI providers and search
+ * APIs that the agent-observer providers parse. Replaces inline `as`
+ * casts on `await response.json()` with parse-don't-validate boundaries.
+ *
+ * Schemas are intentionally permissive on optional fields (real APIs add
+ * fields over time) but strict on shape — a malformed payload surfaces
+ * as a clear ZodError at the call site instead of a cryptic
+ * `Cannot read properties of undefined` later.
+ *
+ * @see docs/design-docs/parse-dont-validate.md
+ * @see docs/work-items/W0004.json
+ */
+import { z } from "zod";
+// ---------------------------------------------------------------------------
+// OpenAI Chat Completions response
+//
+// Covers both the minimal shape used by the InstrumentedObserverProvider
+// (`provider.ts`) and the richer tool-calling shape used by
+// `AgenticObserverProvider` (`agentic-provider.ts`).
+// ---------------------------------------------------------------------------
+const OpenAIToolCallSchema = z.object({
+    function: z.object({
+        arguments: z.string(),
+        name: z.string(),
+    }),
+    id: z.string(),
+    type: z.literal("function"),
+});
+const OpenAIChatMessageSchema = z.object({
+    content: z.union([z.string(), z.null()]),
+    role: z.enum(["assistant", "system", "tool", "user"]),
+    tool_call_id: z.string().optional(),
+    tool_calls: z.array(OpenAIToolCallSchema).optional(),
+});
+const OpenAIUsageSchema = z.object({
+    completion_tokens: z.number().optional(),
+    prompt_tokens: z.number().optional(),
+    total_tokens: z.number().optional(),
+});
+const OpenAIErrorSchema = z.object({
+    message: z.string().optional(),
+});
+export const OpenAIChatResponseSchema = z.object({
+    choices: z
+        .array(z.object({
+        finish_reason: z.string().optional(),
+        message: OpenAIChatMessageSchema.optional(),
+    }))
+        .optional(),
+    error: OpenAIErrorSchema.optional(),
+    usage: OpenAIUsageSchema.optional(),
+});
+// ---------------------------------------------------------------------------
+// OpenAI Responses API response (reasoning models)
+// ---------------------------------------------------------------------------
+const OpenAIResponsesUsageSchema = z.object({
+    input_tokens: z.number().optional(),
+    output_tokens: z.number().optional(),
+    total_tokens: z.number().optional(),
+});
+const OpenAIResponsesContentSchema = z.object({
+    text: z.string().optional(),
+    type: z.string().optional(),
+});
+const OpenAIResponsesOutputItemSchema = z.object({
+    content: z.array(OpenAIResponsesContentSchema).optional(),
+    role: z.string().optional(),
+    type: z.string().optional(),
+});
+export const OpenAIResponsesResponseSchema = z.object({
+    error: OpenAIErrorSchema.optional(),
+    output: z.array(OpenAIResponsesOutputItemSchema).optional(),
+    usage: OpenAIResponsesUsageSchema.optional(),
+});
+// ---------------------------------------------------------------------------
+// Anthropic Messages API response
+// ---------------------------------------------------------------------------
+const AnthropicTextBlockSchema = z.object({
+    text: z.string(),
+    type: z.literal("text"),
+});
+const AnthropicToolUseBlockSchema = z.object({
+    id: z.string(),
+    input: z.record(z.string(), z.unknown()),
+    name: z.string(),
+    type: z.literal("tool_use"),
+});
+const AnthropicContentBlockSchema = z.discriminatedUnion("type", [
+    AnthropicTextBlockSchema,
+    AnthropicToolUseBlockSchema,
+]);
+const AnthropicUsageSchema = z.object({
+    input_tokens: z.number().optional(),
+    output_tokens: z.number().optional(),
+});
+const AnthropicErrorSchema = z.object({
+    message: z.string().optional(),
+    type: z.string().optional(),
+});
+export const AnthropicResponseSchema = z.object({
+    content: z.array(AnthropicContentBlockSchema).optional(),
+    error: AnthropicErrorSchema.optional(),
+    model: z.string().optional(),
+    stop_reason: z.enum(["end_turn", "max_tokens", "tool_use"]).optional(),
+    usage: AnthropicUsageSchema.optional(),
+});
+// ---------------------------------------------------------------------------
+// Google Custom Search API response
+// ---------------------------------------------------------------------------
+export const GoogleSearchResponseSchema = z.object({
+    items: z
+        .array(z.object({
+        link: z.string(),
+        snippet: z.string(),
+        title: z.string(),
+    }))
+        .optional(),
+});
+// ---------------------------------------------------------------------------
+// Agent tool-call arguments
+//
+// The model emits these as JSON strings via tool-calling; we parse them
+// before dispatching. Per-tool schemas keep the contract explicit.
+// ---------------------------------------------------------------------------
+export const FetchPageToolArgsSchema = z.object({
+    url: z.string(),
+});
+export const ListDocsToolArgsSchema = z.object({
+    site: z.string(),
+});
+export const WebSearchToolArgsSchema = z.object({
+    query: z.string(),
+});

package/dist/_vendor/ailf-core/schemas/index.d.ts

@@ -11,8 +11,10 @@
 export * from "./callback-payload.js";
 export * from "./canary-tasks.js";
 export * from "./eval-config.js";
+export * from "./external-providers.js";
 export * from "./pipeline-request.js";
 export * from "./pipeline.js";
+export * from "./report.js";
 export * from "./schedules.js";
 export * from "./sinks.js";
 export * from "./test-budgets.js";

package/dist/_vendor/ailf-core/schemas/index.js

@@ -11,8 +11,10 @@
 export * from "./callback-payload.js";
 export * from "./canary-tasks.js";
 export * from "./eval-config.js";
+export * from "./external-providers.js";
 export * from "./pipeline-request.js";
 export * from "./pipeline.js";
+export * from "./report.js";
 export * from "./schedules.js";
 export * from "./sinks.js";
 export * from "./test-budgets.js";

package/dist/_vendor/ailf-core/schemas/pipeline-request.d.ts

@@ -16,8 +16,8 @@ import { z } from "zod";
 export declare const PipelineRequestSchema: z.ZodObject<{
     allowedOrigins: z.ZodOptional<z.ZodArray<z.ZodString>>;
     backend: z.ZodOptional<z.ZodEnum<{
-        "github-actions": "github-actions";
         "cloud-run": "cloud-run";
+        "github-actions": "github-actions";
     }>>;
     areas: z.ZodOptional<z.ZodArray<z.ZodString>>;
     callerGit: z.ZodOptional<z.ZodObject<{
@@ -116,5 +116,4 @@ export declare const PipelineRequestSchema: z.ZodObject<{
     purpose: z.ZodOptional<z.ZodString>;
     labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
-/** Inferred TypeScript type for a pipeline request payload. */
-export type PipelineRequest = z.infer<typeof PipelineRequestSchema>;
+export type { PipelineRequest } from "../types/pipeline-request.js";

package/dist/_vendor/ailf-core/schemas/report.d.ts

@@ -0,0 +1,251 @@
+/**
+ * @sanity/ailf-core — Report schema (W0191)
+ *
+ * Runtime Zod gate for `ailf.report` documents at the ReportStore
+ * read/write boundary. Mirrors the W0073 pattern that
+ * `ContentLakeAuthorableTaskSchema` applies to `ailf.task` — turn silent
+ * shape drift into a loud parse failure at the Content Lake boundary.
+ *
+ * **Scope A** (this file): top-level shape is `passthrough()` so that
+ * adding a new top-level Report field on the TS side does not silently
+ * fail validation before the schema author updates this mirror.
+ * `provenance` (and nested `provenance.lineage`) are `strict()` because
+ * they are fully mirrored — unknown keys there signal real drift.
+ * `summary`, `comparison`, and `artifactManifest` are modeled as
+ * non-empty objects with passthrough; their deep contents
+ * (`ScoreSummary`, `FeatureScore`, the W0051 slim shapes, etc.) are
+ * intentionally out of scope and may grow into a Scope B follow-up.
+ *
+ * @see packages/eval/src/adapters/task-sources/content-lake-task-source.ts
+ *      — sibling W0073 gate
+ * @see packages/core/src/types/index.ts — `Report`, `ReportProvenance`,
+ *      `ReportLineage`
+ * @see packages/shared/src/run-context.ts — `RunContext`
+ * @see docs/work-items/W0191-report-store-schema-gate.json
+ */
+import { z } from "zod";
+export declare const ReportLineageSchema: z.ZodObject<{
+    rerunOf: z.ZodOptional<z.ZodString>;
+    comparedAgainst: z.ZodOptional<z.ZodString>;
+    parentJobId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const ReportProvenanceSchema: z.ZodObject<{
+    areas: z.ZodArray<z.ZodString>;
+    classification: z.ZodEnum<{
+        external: "external";
+        official: "official";
+        adhoc: "adhoc";
+        experimental: "experimental";
+        test: "test";
+    }>;
+    evalFingerprint: z.ZodOptional<z.ZodString>;
+    executor: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"user">;
+        name: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodString>;
+        surface: z.ZodEnum<{
+            cli: "cli";
+            studio: "studio";
+            api: "api";
+        }>;
+        githubActor: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"system">;
+        name: z.ZodString;
+        workflow: z.ZodOptional<z.ZodString>;
+        runId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>], "type">;
+    git: z.ZodOptional<z.ZodObject<{
+        branch: z.ZodString;
+        prNumber: z.ZodOptional<z.ZodNumber>;
+        repo: z.ZodString;
+        sha: z.ZodString;
+    }, z.core.$strict>>;
+    graderModel: z.ZodString;
+    host: z.ZodOptional<z.ZodObject<{
+        platform: z.ZodString;
+        arch: z.ZodString;
+        ci: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    lineage: z.ZodOptional<z.ZodObject<{
+        rerunOf: z.ZodOptional<z.ZodString>;
+        comparedAgainst: z.ZodOptional<z.ZodString>;
+        parentJobId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    mode: z.ZodString;
+    models: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strict>>;
+    owner: z.ZodObject<{
+        team: z.ZodString;
+        individual: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    purpose: z.ZodOptional<z.ZodString>;
+    source: z.ZodObject<{
+        baseUrl: z.ZodString;
+        dataset: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        perspective: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tool: z.ZodOptional<z.ZodObject<{
+        ailfVersion: z.ZodString;
+        nodeVersion: z.ZodString;
+    }, z.core.$strict>>;
+    trigger: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"ci">;
+        runId: z.ZodString;
+        workflow: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"cross-repo">;
+        callerRef: z.ZodOptional<z.ZodString>;
+        callerRepo: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"manual">;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"scheduled">;
+        schedule: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"webhook">;
+        documentId: z.ZodOptional<z.ZodString>;
+        source: z.ZodString;
+    }, z.core.$strict>], "type">;
+    autoScope: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        affectedTaskIds: z.ZodArray<z.ZodString>;
+        skippedTaskIds: z.ZodArray<z.ZodString>;
+        perspective: z.ZodString;
+        impactSummary: z.ZodObject<{
+            added: z.ZodNumber;
+            modified: z.ZodNumber;
+            removed: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    contextHash: z.ZodOptional<z.ZodString>;
+    promptfooUrl: z.ZodOptional<z.ZodString>;
+    promptfooUrls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        mode: z.ZodString;
+        url: z.ZodString;
+    }, z.core.$strict>>>;
+    runId: z.ZodString;
+    targetDocuments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const ReportSchema: z.ZodObject<{
+    id: z.ZodString;
+    completedAt: z.ZodISODateTime;
+    durationMs: z.ZodNumber;
+    summary: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    provenance: z.ZodObject<{
+        areas: z.ZodArray<z.ZodString>;
+        classification: z.ZodEnum<{
+            external: "external";
+            official: "official";
+            adhoc: "adhoc";
+            experimental: "experimental";
+            test: "test";
+        }>;
+        evalFingerprint: z.ZodOptional<z.ZodString>;
+        executor: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"user">;
+            name: z.ZodOptional<z.ZodString>;
+            email: z.ZodOptional<z.ZodString>;
+            surface: z.ZodEnum<{
+                cli: "cli";
+                studio: "studio";
+                api: "api";
+            }>;
+            githubActor: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"system">;
+            name: z.ZodString;
+            workflow: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], "type">;
+        git: z.ZodOptional<z.ZodObject<{
+            branch: z.ZodString;
+            prNumber: z.ZodOptional<z.ZodNumber>;
+            repo: z.ZodString;
+            sha: z.ZodString;
+        }, z.core.$strict>>;
+        graderModel: z.ZodString;
+        host: z.ZodOptional<z.ZodObject<{
+            platform: z.ZodString;
+            arch: z.ZodString;
+            ci: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        lineage: z.ZodOptional<z.ZodObject<{
+            rerunOf: z.ZodOptional<z.ZodString>;
+            comparedAgainst: z.ZodOptional<z.ZodString>;
+            parentJobId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        mode: z.ZodString;
+        models: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strict>>;
+        owner: z.ZodObject<{
+            team: z.ZodString;
+            individual: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        purpose: z.ZodOptional<z.ZodString>;
+        source: z.ZodObject<{
+            baseUrl: z.ZodString;
+            dataset: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
+            perspective: z.ZodOptional<z.ZodString>;
+            projectId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        tool: z.ZodOptional<z.ZodObject<{
+            ailfVersion: z.ZodString;
+            nodeVersion: z.ZodString;
+        }, z.core.$strict>>;
+        trigger: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"ci">;
+            runId: z.ZodString;
+            workflow: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"cross-repo">;
+            callerRef: z.ZodOptional<z.ZodString>;
+            callerRepo: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"manual">;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"scheduled">;
+            schedule: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"webhook">;
+            documentId: z.ZodOptional<z.ZodString>;
+            source: z.ZodString;
+        }, z.core.$strict>], "type">;
+        autoScope: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            affectedTaskIds: z.ZodArray<z.ZodString>;
+            skippedTaskIds: z.ZodArray<z.ZodString>;
+            perspective: z.ZodString;
+            impactSummary: z.ZodObject<{
+                added: z.ZodNumber;
+                modified: z.ZodNumber;
+                removed: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        contextHash: z.ZodOptional<z.ZodString>;
+        promptfooUrl: z.ZodOptional<z.ZodString>;
+        promptfooUrls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            mode: z.ZodString;
+            url: z.ZodString;
+        }, z.core.$strict>>>;
+        runId: z.ZodString;
+        targetDocuments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+    comparison: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    artifactManifest: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    tag: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$loose>;
+export type ReportSchemaInput = z.input<typeof ReportSchema>;
+export type ReportSchemaOutput = z.infer<typeof ReportSchema>;