@treeseed/sdk 0.13.0-rc.11 → 0.13.0-rc.111

package/dist/capacity-provider/sandbox-contracts.d.ts

@@ -0,0 +1,548 @@
+import { z } from 'zod';
+declare const sandboxProfile: z.ZodString;
+export declare const sandboxAssignmentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.sandbox-assignment/v1">;
+    assignmentId: z.ZodString;
+    attempt: z.ZodNumber;
+    runnerId: z.ZodString;
+    providerId: z.ZodString;
+    teamId: z.ZodString;
+    projectId: z.ZodString;
+    profile: z.ZodString;
+    environmentContract: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        digest: z.ZodString;
+        capabilities: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        version: string;
+        digest: string;
+        capabilities: string[];
+    }, {
+        id: string;
+        version: string;
+        digest: string;
+        capabilities: string[];
+    }>>;
+    guestImage: z.ZodString;
+    guestImageDigest: z.ZodString;
+    identityManifestDigest: z.ZodString;
+    contextManifestDigest: z.ZodString;
+    resources: z.ZodObject<{
+        cpuCores: z.ZodNumber;
+        memoryBytes: z.ZodNumber;
+        diskBytes: z.ZodNumber;
+        durationSeconds: z.ZodNumber;
+        processLimit: z.ZodNumber;
+        outputBytes: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        cpuCores: number;
+        memoryBytes: number;
+        diskBytes: number;
+        durationSeconds: number;
+        processLimit: number;
+        outputBytes: number;
+    }, {
+        cpuCores: number;
+        memoryBytes: number;
+        diskBytes: number;
+        durationSeconds: number;
+        processLimit: number;
+        outputBytes: number;
+    }>;
+    inputs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        digest: z.ZodString;
+        bytes: z.ZodNumber;
+        disposition: z.ZodEnum<["read-only", "copy-on-write"]>;
+        mediaType: z.ZodString;
+        targetPath: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        digest: string;
+        mediaType: string;
+        bytes: number;
+        disposition: "read-only" | "copy-on-write";
+        targetPath: string;
+    }, {
+        id: string;
+        digest: string;
+        mediaType: string;
+        bytes: number;
+        disposition: "read-only" | "copy-on-write";
+        targetPath: string;
+    }>, "many">;
+    outputs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+        mediaType: z.ZodString;
+        maxBytes: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+        id: string;
+        mediaType: string;
+        maxBytes: number;
+    }, {
+        path: string;
+        id: string;
+        mediaType: string;
+        maxBytes: number;
+    }>, "many">;
+    network: z.ZodObject<{
+        defaultDeny: z.ZodLiteral<true>;
+        relayUrl: z.ZodString;
+        allowedServices: z.ZodArray<z.ZodString, "many">;
+        connectedDevelopmentSessionId: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        defaultDeny: true;
+        relayUrl: string;
+        allowedServices: string[];
+        connectedDevelopmentSessionId?: string | undefined;
+    }, {
+        defaultDeny: true;
+        relayUrl: string;
+        allowedServices: string[];
+        connectedDevelopmentSessionId?: string | undefined;
+    }>;
+    modelPolicy: z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+        reasoningEffort: z.ZodOptional<z.ZodEnum<["minimal", "low", "medium", "high", "xhigh"]>>;
+        capabilities: z.ZodArray<z.ZodString, "many">;
+        maxInputTokens: z.ZodOptional<z.ZodNumber>;
+        maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+        maxCost: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        provider: string;
+        capabilities: string[];
+        model: string;
+        reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
+        maxInputTokens?: number | undefined;
+        maxOutputTokens?: number | undefined;
+        maxCost?: number | undefined;
+    }, {
+        provider: string;
+        capabilities: string[];
+        model: string;
+        reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
+        maxInputTokens?: number | undefined;
+        maxOutputTokens?: number | undefined;
+        maxCost?: number | undefined;
+    }>;
+    credentialHandles: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        profileId: z.ZodString;
+        revealAllowed: z.ZodLiteral<false>;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        profileId: string;
+        revealAllowed: false;
+    }, {
+        id: string;
+        profileId: string;
+        revealAllowed: false;
+    }>, "many">;
+    treeDxHandleIds: z.ZodArray<z.ZodString, "many">;
+    leaseExpiresAt: z.ZodString;
+    signature: z.ZodObject<{
+        keyId: z.ZodString;
+        algorithm: z.ZodLiteral<"Ed25519">;
+        value: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        value: string;
+        algorithm: "Ed25519";
+        keyId: string;
+    }, {
+        value: string;
+        algorithm: "Ed25519";
+        keyId: string;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    schemaVersion: "treeseed.sandbox-assignment/v1";
+    resources: {
+        cpuCores: number;
+        memoryBytes: number;
+        diskBytes: number;
+        durationSeconds: number;
+        processLimit: number;
+        outputBytes: number;
+    };
+    inputs: {
+        id: string;
+        digest: string;
+        mediaType: string;
+        bytes: number;
+        disposition: "read-only" | "copy-on-write";
+        targetPath: string;
+    }[];
+    projectId: string;
+    teamId: string;
+    providerId: string;
+    assignmentId: string;
+    network: {
+        defaultDeny: true;
+        relayUrl: string;
+        allowedServices: string[];
+        connectedDevelopmentSessionId?: string | undefined;
+    };
+    profile: string;
+    outputs: {
+        path: string;
+        id: string;
+        mediaType: string;
+        maxBytes: number;
+    }[];
+    guestImage: string;
+    guestImageDigest: string;
+    signature: {
+        value: string;
+        algorithm: "Ed25519";
+        keyId: string;
+    };
+    runnerId: string;
+    leaseExpiresAt: string;
+    attempt: number;
+    identityManifestDigest: string;
+    contextManifestDigest: string;
+    modelPolicy: {
+        provider: string;
+        capabilities: string[];
+        model: string;
+        reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
+        maxInputTokens?: number | undefined;
+        maxOutputTokens?: number | undefined;
+        maxCost?: number | undefined;
+    };
+    credentialHandles: {
+        id: string;
+        profileId: string;
+        revealAllowed: false;
+    }[];
+    treeDxHandleIds: string[];
+    environmentContract?: {
+        id: string;
+        version: string;
+        digest: string;
+        capabilities: string[];
+    } | undefined;
+}, {
+    schemaVersion: "treeseed.sandbox-assignment/v1";
+    resources: {
+        cpuCores: number;
+        memoryBytes: number;
+        diskBytes: number;
+        durationSeconds: number;
+        processLimit: number;
+        outputBytes: number;
+    };
+    inputs: {
+        id: string;
+        digest: string;
+        mediaType: string;
+        bytes: number;
+        disposition: "read-only" | "copy-on-write";
+        targetPath: string;
+    }[];
+    projectId: string;
+    teamId: string;
+    providerId: string;
+    assignmentId: string;
+    network: {
+        defaultDeny: true;
+        relayUrl: string;
+        allowedServices: string[];
+        connectedDevelopmentSessionId?: string | undefined;
+    };
+    profile: string;
+    outputs: {
+        path: string;
+        id: string;
+        mediaType: string;
+        maxBytes: number;
+    }[];
+    guestImage: string;
+    guestImageDigest: string;
+    signature: {
+        value: string;
+        algorithm: "Ed25519";
+        keyId: string;
+    };
+    runnerId: string;
+    leaseExpiresAt: string;
+    attempt: number;
+    identityManifestDigest: string;
+    contextManifestDigest: string;
+    modelPolicy: {
+        provider: string;
+        capabilities: string[];
+        model: string;
+        reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
+        maxInputTokens?: number | undefined;
+        maxOutputTokens?: number | undefined;
+        maxCost?: number | undefined;
+    };
+    credentialHandles: {
+        id: string;
+        profileId: string;
+        revealAllowed: false;
+    }[];
+    treeDxHandleIds: string[];
+    environmentContract?: {
+        id: string;
+        version: string;
+        digest: string;
+        capabilities: string[];
+    } | undefined;
+}>;
+export declare const sandboxEventSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.sandbox-event/v1">;
+    sandboxId: z.ZodString;
+    assignmentId: z.ZodString;
+    sequence: z.ZodNumber;
+    occurredAt: z.ZodString;
+    type: z.ZodEnum<["sandbox.created", "sandbox.ready", "execution.started", "execution.progress", "tool.requested", "tool.completed", "execution.completed", "execution.failed", "sandbox.destroyed"]>;
+    payload: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strict", z.ZodTypeAny, {
+    type: "sandbox.created" | "sandbox.ready" | "execution.started" | "execution.progress" | "tool.requested" | "tool.completed" | "execution.completed" | "execution.failed" | "sandbox.destroyed";
+    schemaVersion: "treeseed.sandbox-event/v1";
+    assignmentId: string;
+    sequence: number;
+    payload: Record<string, unknown>;
+    occurredAt: string;
+    sandboxId: string;
+}, {
+    type: "sandbox.created" | "sandbox.ready" | "execution.started" | "execution.progress" | "tool.requested" | "tool.completed" | "execution.completed" | "execution.failed" | "sandbox.destroyed";
+    schemaVersion: "treeseed.sandbox-event/v1";
+    assignmentId: string;
+    sequence: number;
+    occurredAt: string;
+    sandboxId: string;
+    payload?: Record<string, unknown> | undefined;
+}>;
+export declare const sandboxLeaseRenewalSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.sandbox-lease-renewal/v1">;
+    sandboxId: z.ZodString;
+    assignmentId: z.ZodString;
+    providerId: z.ZodString;
+    teamId: z.ZodString;
+    leaseExpiresAt: z.ZodString;
+    issuedAt: z.ZodString;
+    signature: z.ZodObject<{
+        keyId: z.ZodString;
+        algorithm: z.ZodLiteral<"Ed25519">;
+        value: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        value: string;
+        algorithm: "Ed25519";
+        keyId: string;
+    }, {
+        value: string;
+        algorithm: "Ed25519";
+        keyId: string;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    schemaVersion: "treeseed.sandbox-lease-renewal/v1";
+    teamId: string;
+    providerId: string;
+    issuedAt: string;
+    assignmentId: string;
+    signature: {
+        value: string;
+        algorithm: "Ed25519";
+        keyId: string;
+    };
+    leaseExpiresAt: string;
+    sandboxId: string;
+}, {
+    schemaVersion: "treeseed.sandbox-lease-renewal/v1";
+    teamId: string;
+    providerId: string;
+    issuedAt: string;
+    assignmentId: string;
+    signature: {
+        value: string;
+        algorithm: "Ed25519";
+        keyId: string;
+    };
+    leaseExpiresAt: string;
+    sandboxId: string;
+}>;
+export declare const sandboxResultSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.sandbox-result/v1">;
+    sandboxId: z.ZodString;
+    assignmentId: z.ZodString;
+    status: z.ZodEnum<["completed", "failed", "cancelled", "expired"]>;
+    summary: z.ZodString;
+    responseMarkdown: z.ZodOptional<z.ZodString>;
+    artifacts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+        digest: z.ZodString;
+        mediaType: z.ZodString;
+        bytes: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+        id: string;
+        digest: string;
+        mediaType: string;
+        bytes: number;
+    }, {
+        path: string;
+        id: string;
+        digest: string;
+        mediaType: string;
+        bytes: number;
+    }>, "many">;
+    usage: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    diagnostics: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    teardown: z.ZodObject<{
+        verified: z.ZodBoolean;
+        completedAt: z.ZodNullable<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        completedAt: string | null;
+        verified: boolean;
+    }, {
+        completedAt: string | null;
+        verified: boolean;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    status: "expired" | "failed" | "completed" | "cancelled";
+    schemaVersion: "treeseed.sandbox-result/v1";
+    assignmentId: string;
+    artifacts: {
+        path: string;
+        id: string;
+        digest: string;
+        mediaType: string;
+        bytes: number;
+    }[];
+    summary: string;
+    usage: Record<string, unknown>;
+    diagnostics: Record<string, unknown>;
+    sandboxId: string;
+    teardown: {
+        completedAt: string | null;
+        verified: boolean;
+    };
+    responseMarkdown?: string | undefined;
+}, {
+    status: "expired" | "failed" | "completed" | "cancelled";
+    schemaVersion: "treeseed.sandbox-result/v1";
+    assignmentId: string;
+    artifacts: {
+        path: string;
+        id: string;
+        digest: string;
+        mediaType: string;
+        bytes: number;
+    }[];
+    summary: string;
+    sandboxId: string;
+    teardown: {
+        completedAt: string | null;
+        verified: boolean;
+    };
+    usage?: Record<string, unknown> | undefined;
+    diagnostics?: Record<string, unknown> | undefined;
+    responseMarkdown?: string | undefined;
+}>;
+export declare const providerEnvironmentReceiptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.provider-environment-receipt/v1">;
+    assignmentId: z.ZodString;
+    offerId: z.ZodString;
+    providerId: z.ZodString;
+    imageDigest: z.ZodString;
+    baseLineage: z.ZodObject<{
+        baseImageDigest: z.ZodString;
+        provenanceDigest: z.ZodString;
+        architectures: z.ZodArray<z.ZodEnum<["amd64", "arm64"]>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        baseImageDigest: string;
+        provenanceDigest: string;
+        architectures: ("amd64" | "arm64")[];
+    }, {
+        baseImageDigest: string;
+        provenanceDigest: string;
+        architectures: ("amd64" | "arm64")[];
+    }>;
+    securityAttestationDigest: z.ZodString;
+    brokerVersion: z.ZodString;
+    teardown: z.ZodObject<{
+        verified: z.ZodBoolean;
+        completedAt: z.ZodNullable<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        completedAt: string | null;
+        verified: boolean;
+    }, {
+        completedAt: string | null;
+        verified: boolean;
+    }>;
+    createdAt: z.ZodString;
+    signature: z.ZodObject<{
+        keyId: z.ZodString;
+        algorithm: z.ZodLiteral<"Ed25519">;
+        value: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        value: string;
+        algorithm: "Ed25519";
+        keyId: string;
+    }, {
+        value: string;
+        algorithm: "Ed25519";
+        keyId: string;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    schemaVersion: "treeseed.provider-environment-receipt/v1";
+    createdAt: string;
+    providerId: string;
+    assignmentId: string;
+    signature: {
+        value: string;
+        algorithm: "Ed25519";
+        keyId: string;
+    };
+    offerId: string;
+    teardown: {
+        completedAt: string | null;
+        verified: boolean;
+    };
+    imageDigest: string;
+    baseLineage: {
+        baseImageDigest: string;
+        provenanceDigest: string;
+        architectures: ("amd64" | "arm64")[];
+    };
+    securityAttestationDigest: string;
+    brokerVersion: string;
+}, {
+    schemaVersion: "treeseed.provider-environment-receipt/v1";
+    createdAt: string;
+    providerId: string;
+    assignmentId: string;
+    signature: {
+        value: string;
+        algorithm: "Ed25519";
+        keyId: string;
+    };
+    offerId: string;
+    teardown: {
+        completedAt: string | null;
+        verified: boolean;
+    };
+    imageDigest: string;
+    baseLineage: {
+        baseImageDigest: string;
+        provenanceDigest: string;
+        architectures: ("amd64" | "arm64")[];
+    };
+    securityAttestationDigest: string;
+    brokerVersion: string;
+}>;
+export type SandboxAssignment = z.infer<typeof sandboxAssignmentSchema>;
+export type SandboxEvent = z.infer<typeof sandboxEventSchema>;
+export type SandboxLeaseRenewal = z.infer<typeof sandboxLeaseRenewalSchema>;
+export type SandboxResult = z.infer<typeof sandboxResultSchema>;
+export type ProviderEnvironmentReceipt = z.infer<typeof providerEnvironmentReceiptSchema>;
+export type SandboxEnvironmentProfile = z.infer<typeof sandboxProfile>;
+export {};

package/dist/capacity-provider/sandbox-contracts.js

@@ -0,0 +1,86 @@
+import { z } from "zod";
+const identifier = z.string().regex(/^[a-z][a-z0-9._-]{0,127}$/u);
+const digest = z.string().regex(/^sha256:[a-f0-9]{64}$/u);
+const sandboxProfile = identifier;
+const sandboxAssignmentSchema = z.object({
+  schemaVersion: z.literal("treeseed.sandbox-assignment/v1"),
+  assignmentId: z.string().min(1),
+  attempt: z.number().int().positive(),
+  runnerId: z.string().min(1),
+  providerId: z.string().min(1),
+  teamId: z.string().min(1),
+  projectId: z.string().min(1),
+  profile: sandboxProfile,
+  environmentContract: z.object({ id: identifier, version: z.string().regex(/^\d+\.\d+\.\d+$/u), digest, capabilities: z.array(identifier) }).strict().optional(),
+  guestImage: z.string().min(1),
+  guestImageDigest: digest,
+  identityManifestDigest: digest,
+  contextManifestDigest: digest,
+  resources: z.object({
+    cpuCores: z.number().positive(),
+    memoryBytes: z.number().int().positive(),
+    diskBytes: z.number().int().positive(),
+    durationSeconds: z.number().int().positive(),
+    processLimit: z.number().int().positive(),
+    outputBytes: z.number().int().positive()
+  }).strict(),
+  inputs: z.array(z.object({ id: identifier, digest, bytes: z.number().int().nonnegative(), disposition: z.enum(["read-only", "copy-on-write"]), mediaType: z.string().min(1), targetPath: z.string().startsWith("/workspace/") }).strict()),
+  outputs: z.array(z.object({ id: identifier, path: z.string().startsWith("/run/treeseed-output/"), mediaType: z.string().min(1), maxBytes: z.number().int().positive() }).strict()),
+  network: z.object({ defaultDeny: z.literal(true), relayUrl: z.string().url().startsWith("https://"), allowedServices: z.array(identifier), connectedDevelopmentSessionId: z.string().min(1).optional() }).strict(),
+  modelPolicy: z.object({ provider: identifier, model: z.string().min(1), reasoningEffort: z.enum(["minimal", "low", "medium", "high", "xhigh"]).optional(), capabilities: z.array(identifier), maxInputTokens: z.number().int().positive().optional(), maxOutputTokens: z.number().int().positive().optional(), maxCost: z.number().nonnegative().optional() }).strict(),
+  credentialHandles: z.array(z.object({ id: identifier, profileId: identifier, revealAllowed: z.literal(false) }).strict()),
+  treeDxHandleIds: z.array(z.string().min(1)),
+  leaseExpiresAt: z.string().datetime(),
+  signature: z.object({ keyId: identifier, algorithm: z.literal("Ed25519"), value: z.string().min(1) }).strict()
+}).strict();
+const sandboxEventSchema = z.object({
+  schemaVersion: z.literal("treeseed.sandbox-event/v1"),
+  sandboxId: z.string().min(1),
+  assignmentId: z.string().min(1),
+  sequence: z.number().int().nonnegative(),
+  occurredAt: z.string().datetime(),
+  type: z.enum(["sandbox.created", "sandbox.ready", "execution.started", "execution.progress", "tool.requested", "tool.completed", "execution.completed", "execution.failed", "sandbox.destroyed"]),
+  payload: z.record(z.unknown()).default({})
+}).strict();
+const sandboxLeaseRenewalSchema = z.object({
+  schemaVersion: z.literal("treeseed.sandbox-lease-renewal/v1"),
+  sandboxId: z.string().min(1),
+  assignmentId: z.string().min(1),
+  providerId: z.string().min(1),
+  teamId: z.string().min(1),
+  leaseExpiresAt: z.string().datetime(),
+  issuedAt: z.string().datetime(),
+  signature: z.object({ keyId: identifier, algorithm: z.literal("Ed25519"), value: z.string().min(1) }).strict()
+}).strict();
+const sandboxResultSchema = z.object({
+  schemaVersion: z.literal("treeseed.sandbox-result/v1"),
+  sandboxId: z.string().min(1),
+  assignmentId: z.string().min(1),
+  status: z.enum(["completed", "failed", "cancelled", "expired"]),
+  summary: z.string(),
+  responseMarkdown: z.string().optional(),
+  artifacts: z.array(z.object({ id: identifier, path: z.string().startsWith("/run/treeseed-output/"), digest, mediaType: z.string().min(1), bytes: z.number().int().nonnegative() }).strict()),
+  usage: z.record(z.unknown()).default({}),
+  diagnostics: z.record(z.unknown()).default({}),
+  teardown: z.object({ verified: z.boolean(), completedAt: z.string().datetime().nullable() }).strict()
+}).strict();
+const providerEnvironmentReceiptSchema = z.object({
+  schemaVersion: z.literal("treeseed.provider-environment-receipt/v1"),
+  assignmentId: z.string().min(1),
+  offerId: identifier,
+  providerId: z.string().min(1),
+  imageDigest: digest,
+  baseLineage: z.object({ baseImageDigest: digest, provenanceDigest: digest, architectures: z.array(z.enum(["amd64", "arm64"])).min(1) }).strict(),
+  securityAttestationDigest: digest,
+  brokerVersion: z.string().min(1),
+  teardown: z.object({ verified: z.boolean(), completedAt: z.string().datetime().nullable() }).strict(),
+  createdAt: z.string().datetime(),
+  signature: z.object({ keyId: identifier, algorithm: z.literal("Ed25519"), value: z.string().min(1) }).strict()
+}).strict();
+export {
+  providerEnvironmentReceiptSchema,
+  sandboxAssignmentSchema,
+  sandboxEventSchema,
+  sandboxLeaseRenewalSchema,
+  sandboxResultSchema
+};

package/dist/capacity-provider/sandbox.d.ts

@@ -0,0 +1 @@
+export * from './sandbox-contracts.js';

package/dist/capacity-provider/sandbox.js

@@ -0,0 +1 @@
+export * from "./sandbox-contracts.js";

package/dist/capacity-provider/validation.d.ts

@@ -1,4 +1,4 @@
-import { type CapacityProviderManifestV2, type CapacityProviderProofPayload, type CapacityProviderPublicJwk, type ProviderSupplyOffer } from './contracts/index.js';
+import { type CapacityProviderManifestV5, type CapacityProviderProofPayload, type CapacityProviderPublicJwk, type ProviderSupplyOffer } from './contracts/index.js';
 export interface CapacityProviderContractDiagnostic {
     code: string;
     path: string;
@@ -19,7 +19,7 @@ export declare function validateCapacityProviderProofPayload(payload: CapacityPr
     expectedAudience?: string;
 }): CapacityProviderContractValidation;
 export declare function validateProviderSupplyOffer(offer: ProviderSupplyOffer, path?: string): CapacityProviderContractValidation;
-export declare function validateCapacityProviderManifestV2(manifest: CapacityProviderManifestV2): CapacityProviderContractValidation;
+export declare function validateCapacityProviderManifestV5(manifest: CapacityProviderManifestV5): CapacityProviderContractValidation;
 export declare function capacityProviderSecurityDefaults(): {
     proofTtlSeconds: number;
     accessTokenTtlSeconds: number;