@openpond/evals 0.12.3 → 0.12.4

package/dist/tool-learning/installations.js

@@ -0,0 +1,151 @@
+import { z } from "zod";
+import { TOOL_LEARNING_LIMITS, ToolLearningClientSchema, ToolLearningHashSchema as Hash, ToolLearningIdSchema as Id, ToolLearningRefSchema as Ref, ToolLearningScopeSchema, ToolLearningTimestampSchema as Timestamp, boundedToolLearningSchema, } from "./primitives.js";
+export const ToolLearningCapturePolicySchema = z
+    .object({
+    revision: z.number().int().positive(),
+    permittedTools: z.array(z.string().min(1).max(200)).min(1).max(100),
+    workspaceRootHashes: z.array(Hash).min(1).max(32),
+    permittedFields: z
+        .array(z.enum(["action", "intent", "state", "result_excerpt", "artifact_reference"]))
+        .min(1)
+        .max(5),
+    unchangedControls: z
+        .object({
+        numerator: z.number().int().nonnegative(),
+        denominator: z.number().int().positive(),
+    })
+        .strict(),
+    maximumEventBytes: z.number().int().positive().max(TOOL_LEARNING_LIMITS.eventBytes),
+    maximumEpisodeBytes: z.number().int().positive().max(TOOL_LEARNING_LIMITS.episodeBytes),
+    maximumEpisodeEvents: z.number().int().positive().max(TOOL_LEARNING_LIMITS.eventsPerEpisode),
+    maximumQueueBytes: z.number().int().positive().max(TOOL_LEARNING_LIMITS.queueBytes),
+    maximumQueueEvents: z.number().int().positive().max(TOOL_LEARNING_LIMITS.queueEvents),
+    maximumQueueAgeSeconds: z.number().int().positive().max(TOOL_LEARNING_LIMITS.queueAgeSeconds),
+    rawRetentionDays: z.number().int().min(1).max(30),
+    purposes: z
+        .array(z.enum(["capture", "consultation"]))
+        .min(1)
+        .max(2),
+    modelUpdates: z.literal("requires_separate_review"),
+    variantGeneration: z.literal("disabled"),
+})
+    .strict()
+    .superRefine((policy, context) => {
+    if (policy.unchangedControls.numerator > policy.unchangedControls.denominator)
+        context.addIssue({
+            code: "custom",
+            path: ["unchangedControls"],
+            message: "Sampling probability cannot exceed one.",
+        });
+    for (const key of [
+        "permittedTools",
+        "workspaceRootHashes",
+        "permittedFields",
+        "purposes",
+    ])
+        if (new Set(policy[key]).size !== policy[key].length)
+            context.addIssue({
+                code: "custom",
+                path: [key],
+                message: "Policy entries must be unique.",
+            });
+    if (policy.maximumEpisodeBytes < policy.maximumEventBytes ||
+        policy.maximumQueueBytes < policy.maximumEventBytes)
+        context.addIssue({
+            code: "custom",
+            message: "Episode and queue capacities must fit one permitted event.",
+        });
+});
+export const ToolLearningCoverageSchema = z
+    .object({
+    receipt: Ref.nullable(),
+    start: z.enum(["observed", "documented", "unsupported", "unqualified"]),
+    resume: z.enum(["observed", "documented", "unsupported", "unqualified"]),
+    compaction: z.enum(["observed", "documented", "unsupported", "unqualified"]),
+    executionFailure: z.enum(["observed", "documented", "unsupported", "unqualified"]),
+    processFailure: z.enum(["observed", "documented", "unsupported", "unqualified"]),
+    validationFailure: z.enum(["observed", "documented", "unsupported", "unqualified"]),
+    nestedCalls: z.enum(["observed", "documented", "unsupported", "unqualified"]),
+    contextRefresh: z.enum([
+        "session_start",
+        "start_resume",
+        "start_resume_compaction",
+        "revision_aware_turn",
+        "unqualified",
+    ]),
+    gaps: z.array(z.string().min(1).max(500)).max(32),
+})
+    .strict()
+    .superRefine((coverage, context) => {
+    if (Object.values(coverage).includes("observed") && !coverage.receipt)
+        context.addIssue({
+            code: "custom",
+            path: ["receipt"],
+            message: "Observed coverage requires a qualification receipt.",
+        });
+});
+export const ToolLearningRegistrationSchema = boundedToolLearningSchema(z
+    .object({
+    schemaVersion: z.literal("openpond.toolLearningRegistration.v1"),
+    operationId: Id,
+    installationId: Id,
+    projectId: Id,
+    machineSourceId: Id,
+    client: ToolLearningClientSchema,
+    clientVersion: z.string().min(1).max(200),
+    adapterRelease: Ref,
+    collectionPolicy: ToolLearningCapturePolicySchema,
+})
+    .strict(), TOOL_LEARNING_LIMITS.eventBytes);
+/** Status deliberately exposes capability/expiry metadata, never the credential. */
+export const ToolLearningInstallationSchema = z
+    .object({
+    schemaVersion: z.literal("openpond.toolLearningInstallation.v1"),
+    id: Id,
+    revision: z.number().int().positive(),
+    scope: ToolLearningScopeSchema,
+    ownerUserId: Id,
+    machineSourceId: Id,
+    client: ToolLearningClientSchema,
+    clientVersion: z.string().min(1).max(200),
+    adapterRelease: Ref,
+    state: z.enum(["pending_client_trust", "enabled", "disabled", "revoked"]),
+    collectionPolicy: ToolLearningCapturePolicySchema,
+    collectionPolicyHash: Hash,
+    coverage: ToolLearningCoverageSchema,
+    credential: z
+        .object({
+        id: Id,
+        expiresAt: Timestamp,
+        revokedAt: Timestamp.nullable(),
+        capabilities: z
+            .array(z.enum(["episode_append", "manifest_read", "consultation_submit", "consultation_read"]))
+            .min(1)
+            .max(4),
+    })
+        .strict()
+        .nullable(),
+    createdAt: Timestamp,
+    updatedAt: Timestamp,
+})
+    .strict();
+export const ToolLearningInstallationUpdateSchema = z
+    .object({
+    operationId: Id,
+    expectedRevision: z.number().int().positive(),
+    state: z.enum(["enabled", "disabled", "revoked"]),
+})
+    .strict();
+export const ToolEpisodeOriginSchema = z
+    .object({
+    schemaVersion: z.literal("openpond.toolEpisodeOrigin.v1"),
+    installationId: Id,
+    projectId: Id,
+    ownerUserId: Id,
+    episode: Ref,
+    event: Ref,
+    appendReceipt: Ref,
+    purpose: z.literal("private_dataset_evidence"),
+    trainingConsent: z.literal("not_granted"),
+})
+    .strict();

package/dist/tool-learning/policy.js

@@ -0,0 +1,38 @@
+import { ToolEpisodeEventSchema } from "./episodes.js";
+import { ToolLearningCapturePolicySchema } from "./installations.js";
+import { toolLearningContentHash } from "./primitives.js";
+/** Shared local-persistence/intake boundary. A hash alone does not grant consent. */
+export function assertToolEpisodeCapturePolicy(eventValue, policyValue) {
+    const event = ToolEpisodeEventSchema.parse(eventValue);
+    const policy = ToolLearningCapturePolicySchema.parse(policyValue);
+    if (!policy.purposes.includes("capture"))
+        throw new Error("tool_learning_capture_not_enabled");
+    if (event.sanitization.policyRevision !== policy.revision ||
+        event.sanitization.policyHash !== toolLearningContentHash(policy))
+        throw new Error("tool_learning_capture_policy_changed");
+    if (new TextEncoder().encode(JSON.stringify(event)).byteLength > policy.maximumEventBytes)
+        throw new Error("tool_learning_event_policy_limit");
+    const permits = (field) => policy.permittedFields.includes(field);
+    if (event.eventKind === "attempt") {
+        if (!policy.permittedTools.includes(event.payload.tool.name))
+            throw new Error("tool_learning_tool_outside_collection_policy");
+        if (!permits("action") ||
+            (!permits("intent") && event.payload.intent !== "") ||
+            (!permits("state") && Object.keys(event.payload.environment.state).length > 0) ||
+            (!permits("artifact_reference") && event.payload.contextAssets.length > 0))
+            throw new Error("tool_learning_attempt_field_outside_collection_policy");
+    }
+    if (event.eventKind === "observation") {
+        if ((!permits("result_excerpt") &&
+            (event.payload.resultExcerpt !== "" ||
+                (event.payload.outcome === "failed" && event.payload.message !== ""))) ||
+            (!permits("artifact_reference") && event.payload.assets.length > 0))
+            throw new Error("tool_learning_result_field_outside_collection_policy");
+    }
+    if (event.eventKind === "verification" &&
+        ((!permits("result_excerpt") && event.payload.reason !== "") ||
+            (!permits("artifact_reference") && event.payload.outputArtifacts.length > 0)))
+        throw new Error("tool_learning_verification_field_outside_collection_policy");
+    if (event.eventKind === "lineage" && !permits("intent") && event.payload.reason !== "")
+        throw new Error("tool_learning_lineage_field_outside_collection_policy");
+}

package/dist/tool-learning/primitives.js

@@ -0,0 +1,87 @@
+import { z } from "zod";
+import { contentHash, ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema, } from "@openpond/harness";
+import { assertBoundedTaskJson } from "../task-schema-validation.js";
+export const TOOL_LEARNING_LIMITS = Object.freeze({
+    eventBytes: 65_536,
+    actionBytes: 16_384,
+    resultBytes: 8_192,
+    stateBytes: 8_192,
+    eventsPerAppend: 32,
+    eventsPerEpisode: 256,
+    episodeBytes: 2_097_152,
+    assetBytes: 1_048_576,
+    assetsPerEpisode: 16,
+    queueBytes: 52_428_800,
+    queueEvents: 5_000,
+    queueAgeSeconds: 86_400,
+    capabilities: 32,
+    consultationRounds: 3,
+    consultationBytes: 65_536,
+    manifestSeconds: 300,
+});
+export const ToolLearningIdSchema = ReleaseIdSchema;
+export const ToolLearningHashSchema = ReleaseHashSchema;
+export const ToolLearningTimestampSchema = ReleaseTimestampSchema;
+export const ToolLearningClientSchema = z.enum(["codex", "claude_code", "opencode", "openpond"]);
+export const ToolLearningRefSchema = z
+    .object({ id: ReleaseIdSchema, contentHash: ReleaseHashSchema })
+    .strict();
+export const ToolLearningScopeSchema = z
+    .object({ teamId: ReleaseIdSchema, projectId: ReleaseIdSchema })
+    .strict();
+/** Run the existing non-recursive JSON bound before Zod traverses producer data. */
+export function boundedToolLearningSchema(schema, maximumBytes) {
+    return z.preprocess((value, context) => {
+        try {
+            assertBoundedTaskJson(value, maximumBytes);
+        }
+        catch {
+            context.addIssue({
+                code: "custom",
+                message: "Tool learning data exceeds its JSON boundary.",
+            });
+            return z.NEVER;
+        }
+        return value;
+    }, schema);
+}
+export function toolLearningText(maximumBytes) {
+    return z
+        .string()
+        .max(maximumBytes)
+        .refine((value) => new TextEncoder().encode(value).byteLength <= maximumBytes, "Tool learning text exceeds its UTF-8 byte limit.");
+}
+export const ToolLearningStateSchema = boundedToolLearningSchema(z
+    .record(z.string().min(1).max(120), z.union([toolLearningText(2_000), z.number().finite(), z.boolean(), z.null()]))
+    .refine((value) => Object.keys(value).length <= 32, "Use at most 32 explicit state fields."), TOOL_LEARNING_LIMITS.stateBytes);
+export const ToolLearningEnvironmentSchema = z
+    .object({
+    application: z.string().trim().min(1).max(200),
+    version: z.string().trim().min(1).max(200),
+    state: ToolLearningStateSchema,
+    fingerprint: ReleaseHashSchema,
+})
+    .strict();
+export const ToolLearningAssetSchema = z
+    .object({
+    id: ReleaseIdSchema,
+    contentHash: ReleaseHashSchema,
+    mediaType: z.enum(["text/plain", "application/json", "text/x-python", "text/x-diff"]),
+    sizeBytes: z.number().int().nonnegative().max(TOOL_LEARNING_LIMITS.assetBytes),
+    purpose: z.enum(["action", "result", "state", "verification"]),
+})
+    .strict();
+export const ToolLearningSanitizationSchema = z
+    .object({
+    policyRevision: z.number().int().positive(),
+    policyHash: ReleaseHashSchema,
+    redactedFields: z.number().int().nonnegative().max(10_000),
+    omittedFields: z.number().int().nonnegative().max(10_000),
+    truncated: z.boolean(),
+})
+    .strict();
+/** Hash only the validated public envelope; no raw hook/transcript data enters it. */
+export function toolLearningContentHash(value, maximumBytes = TOOL_LEARNING_LIMITS.eventBytes) {
+    assertBoundedTaskJson(value, maximumBytes);
+    return contentHash(value);
+}

package/dist/types/tool-learning/actions.d.ts

@@ -0,0 +1,54 @@
+import { z } from "zod";
+export declare const ToolLearningActionSchema: z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"python">;
+    code: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"shell">;
+    command: z.ZodString;
+    shell: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"tool_arguments">;
+    arguments: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"edit">;
+    patch: z.ZodString;
+    baseFiles: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        contentHash: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>], "kind">>;
+export type ToolLearningAction = z.infer<typeof ToolLearningActionSchema>;
+export declare const ToolLearningRepairSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"replacement">;
+    expectedActionHash: z.ZodString;
+    environmentFingerprint: z.ZodString;
+    action: z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"python">;
+        code: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"shell">;
+        command: z.ZodString;
+        shell: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"tool_arguments">;
+        arguments: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"edit">;
+        patch: z.ZodString;
+        baseFiles: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            contentHash: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"patch">;
+    expectedActionHash: z.ZodString;
+    environmentFingerprint: z.ZodString;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        expectedContentHash: z.ZodString;
+        patch: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>], "kind">;
+export type ToolLearningRepair = z.infer<typeof ToolLearningRepairSchema>;
+//# sourceMappingURL=actions.d.ts.map

package/dist/types/tool-learning/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../src/tool-learning/actions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAsBxB,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;6BA4BpC,CAAC;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BA4BnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/types/tool-learning/consultation.d.ts

@@ -0,0 +1,229 @@
+import { z } from "zod";
+export declare const ToolLearningCapabilitySchema: z.ZodObject<{
+    id: z.ZodString;
+    application: z.ZodString;
+    versions: z.ZodArray<z.ZodString>;
+    tools: z.ZodArray<z.ZodString>;
+    mode: z.ZodLiteral<"recovery">;
+    routingInstruction: z.ZodString;
+    qualification: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"integration">;
+        receipt: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"learned">;
+        receipt: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        trainingRun: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        adapter: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        evaluation: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        activation: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+export declare const ToolLearningManifestSchema: z.ZodPreprocess<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.toolLearningManifest.v1">;
+    installationId: z.ZodString;
+    scope: z.ZodObject<{
+        teamId: z.ZodString;
+        projectId: z.ZodString;
+    }, z.core.$strict>;
+    revision: z.ZodNumber;
+    contentHash: z.ZodString;
+    issuedAt: z.ZodString;
+    expiresAt: z.ZodString;
+    modelRelease: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    responseSchema: z.ZodLiteral<"openpond.toolLearningDecision.v1">;
+    capabilities: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        application: z.ZodString;
+        versions: z.ZodArray<z.ZodString>;
+        tools: z.ZodArray<z.ZodString>;
+        mode: z.ZodLiteral<"recovery">;
+        routingInstruction: z.ZodString;
+        qualification: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"integration">;
+            receipt: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"learned">;
+            receipt: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            trainingRun: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            adapter: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            evaluation: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            activation: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+export type ToolLearningManifest = z.infer<typeof ToolLearningManifestSchema>;
+export declare const ToolLearningConsultationRequestSchema: z.ZodPreprocess<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.toolLearningConsultation.v1">;
+    operationId: z.ZodString;
+    installationId: z.ZodString;
+    scope: z.ZodObject<{
+        teamId: z.ZodString;
+        projectId: z.ZodString;
+    }, z.core.$strict>;
+    sessionId: z.ZodString;
+    callId: z.ZodString;
+    capabilityId: z.ZodString;
+    manifestHash: z.ZodString;
+    modelRelease: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    mode: z.ZodLiteral<"recovery">;
+    intent: z.ZodString;
+    action: z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"python">;
+        code: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"shell">;
+        command: z.ZodString;
+        shell: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"tool_arguments">;
+        arguments: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"edit">;
+        patch: z.ZodString;
+        baseFiles: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            contentHash: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], "kind">>;
+    actionHash: z.ZodString;
+    environment: z.ZodObject<{
+        application: z.ZodString;
+        version: z.ZodString;
+        state: z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+        fingerprint: z.ZodString;
+    }, z.core.$strict>;
+    contextHash: z.ZodString;
+    failure: z.ZodObject<{
+        message: z.ZodString;
+        observation: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    round: z.ZodNumber;
+}, z.core.$strict>>;
+export type ToolLearningConsultationRequest = z.infer<typeof ToolLearningConsultationRequestSchema>;
+/** Only model-authored task content; transport failures never become proceed. */
+export declare const ToolLearningDecisionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    decision: z.ZodLiteral<"proceed">;
+}, z.core.$strict>, z.ZodObject<{
+    decision: z.ZodLiteral<"revise">;
+    issues: z.ZodArray<z.ZodObject<{
+        category: z.ZodString;
+        feedback: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    decision: z.ZodLiteral<"needs_context">;
+    missing: z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>], "decision">;
+export declare const ToolLearningConsultationResponseSchema: z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    operationId: z.ZodString;
+    installationId: z.ZodString;
+    capabilityId: z.ZodString;
+    manifestHash: z.ZodString;
+    modelRelease: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    actionHash: z.ZodString;
+    contextHash: z.ZodString;
+    schemaVersion: z.ZodLiteral<"openpond.toolLearningDecision.v1">;
+    state: z.ZodLiteral<"completed">;
+    decision: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        decision: z.ZodLiteral<"proceed">;
+    }, z.core.$strict>, z.ZodObject<{
+        decision: z.ZodLiteral<"revise">;
+        issues: z.ZodArray<z.ZodObject<{
+            category: z.ZodString;
+            feedback: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        decision: z.ZodLiteral<"needs_context">;
+        missing: z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], "decision">;
+    usageReceipt: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    completedAt: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    operationId: z.ZodString;
+    installationId: z.ZodString;
+    capabilityId: z.ZodString;
+    manifestHash: z.ZodString;
+    modelRelease: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    actionHash: z.ZodString;
+    contextHash: z.ZodString;
+    schemaVersion: z.ZodLiteral<"openpond.toolLearningDecision.v1">;
+    state: z.ZodLiteral<"unavailable">;
+    reason: z.ZodEnum<{
+        budget_exhausted: "budget_exhausted";
+        cancelled: "cancelled";
+        disabled: "disabled";
+        dispatch_uncertain: "dispatch_uncertain";
+        expired_manifest: "expired_manifest";
+        invalid_output: "invalid_output";
+        revoked: "revoked";
+        timeout: "timeout";
+        unsupported_scope: "unsupported_scope";
+    }>;
+    usageReceipt: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>], "state">>;
+export type ToolLearningConsultationResponse = z.infer<typeof ToolLearningConsultationResponseSchema>;
+/** Invoke before exposing a result to the agent; even valid JSON may be stale. */
+export declare function assertToolLearningConsultationResponse(requestValue: unknown, responseValue: unknown): ToolLearningConsultationResponse;
+//# sourceMappingURL=consultation.d.ts.map

package/dist/types/tool-learning/consultation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consultation.d.ts","sourceRoot":"","sources":["../../../src/tool-learning/consultation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAexB,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAsB9B,CAAC;AAwCZ,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAGtC,CAAC;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAgDjD,CAAC;AACF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAC;AAEpG,iFAAiF;AACjF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;gCAkCrC,CAAC;AAWH,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAiClD,CAAC;AACF,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CACpD,OAAO,sCAAsC,CAC9C,CAAC;AAEF,kFAAkF;AAClF,wBAAgB,sCAAsC,CACpD,YAAY,EAAE,OAAO,EACrB,aAAa,EAAE,OAAO,GACrB,gCAAgC,CAmBlC"}