@deksden-com/cpa-kit 0.0.0-stage → 0.1.4

package/dist/contracts/index.d.ts

@@ -0,0 +1,571 @@
+import { z } from 'zod';
+
+declare const idSchema: z.ZodString;
+declare const errorCodes: readonly ["INVALID_INPUT", "UNSUPPORTED_CAPABILITY", "NOT_AUTHORIZED", "REVISION_CONFLICT", "IDEMPOTENCY_CONFLICT", "KEY_EXPIRED", "INSTANCE_BUSY", "UPLOAD_LIMIT", "ARCHIVE_UNSAFE", "CREDENTIAL_INVALID", "MANAGEMENT_UNAVAILABLE", "DRAIN_TIMEOUT", "PROBE_QUOTA_LIMITED", "PROBE_FAILED", "APPLY_PARTIAL", "OUTCOME_UNKNOWN", "RECOVERY_REQUIRED", "CANCELLED", "INTERNAL"];
+type ErrorCode = (typeof errorCodes)[number];
+interface ErrorDto {
+    code: ErrorCode;
+    message: string;
+    retryable: boolean;
+    retryAt: string | null;
+    operationId: string | null;
+}
+declare const states: readonly ["queued", "running", "succeeded", "failed", "cancelled", "partially_applied", "recovery_required"];
+type OperationState = (typeof states)[number];
+type Phase = "validate" | "preview" | "drain" | "prepare" | "switch" | "verify" | "commit" | "cleanup";
+declare const payloadSchemas: {
+    readonly "import.stage": z.ZodObject<{
+        uploadId: z.ZodString;
+        format: z.ZodDefault<z.ZodLiteral<"auto">>;
+    }, z.core.$strict>;
+    readonly "import.apply": z.ZodObject<{
+        candidateId: z.ZodString;
+        previewRevision: z.ZodString;
+        mode: z.ZodEnum<{
+            merge: "merge";
+            replace: "replace";
+        }>;
+        overwriteIds: z.ZodArray<z.ZodString>;
+        confirmedRemovals: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    readonly "import.cancel": z.ZodObject<{
+        candidateId: z.ZodString;
+    }, z.core.$strict>;
+    readonly "credential.delete": z.ZodObject<{
+        credentialId: z.ZodString;
+        confirmed: z.ZodLiteral<true>;
+    }, z.core.$strict>;
+    readonly "catalog.refresh": z.ZodObject<{}, z.core.$strict>;
+    readonly "release.discover": z.ZodObject<{}, z.core.$strict>;
+    readonly "release.install": z.ZodObject<{
+        releaseId: z.ZodString;
+    }, z.core.$strict>;
+    readonly "release.activate": z.ZodObject<{
+        installedReleaseId: z.ZodString;
+        confirmed: z.ZodLiteral<true>;
+    }, z.core.$strict>;
+    readonly "release.delete": z.ZodObject<{
+        installedReleaseId: z.ZodString;
+        confirmed: z.ZodLiteral<true>;
+    }, z.core.$strict>;
+    readonly "release.rollback": z.ZodObject<{
+        lastKnownGoodReleaseId: z.ZodString;
+        confirmed: z.ZodLiteral<true>;
+    }, z.core.$strict>;
+    readonly "model.probe": z.ZodObject<{
+        modelId: z.ZodString;
+        protocol: z.ZodString;
+        reasoningProfile: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    readonly "operation.cancel": z.ZodObject<{
+        operationId: z.ZodString;
+    }, z.core.$strict>;
+};
+type CommandKind = keyof typeof payloadSchemas;
+type Command = {
+    [K in CommandKind]: {
+        apiVersion: 1;
+        instanceId: string;
+        kind: K;
+        payload: z.infer<(typeof payloadSchemas)[K]>;
+        idempotencyKey: string;
+        expectedRevision: string | null;
+    };
+}[CommandKind];
+declare const commandSchema: z.ZodPipe<z.ZodObject<{
+    apiVersion: z.ZodLiteral<1>;
+    instanceId: z.ZodString;
+    kind: z.ZodEnum<{
+        "import.stage": "import.stage";
+        "import.apply": "import.apply";
+        "import.cancel": "import.cancel";
+        "credential.delete": "credential.delete";
+        "catalog.refresh": "catalog.refresh";
+        "release.discover": "release.discover";
+        "release.install": "release.install";
+        "release.activate": "release.activate";
+        "release.delete": "release.delete";
+        "release.rollback": "release.rollback";
+        "model.probe": "model.probe";
+        "operation.cancel": "operation.cancel";
+    }>;
+    payload: z.ZodUnknown;
+    idempotencyKey: z.ZodString;
+    expectedRevision: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodTransform<{
+    apiVersion: 1;
+    instanceId: string;
+    kind: "import.stage";
+    payload: {
+        uploadId: string;
+        format: "auto";
+    };
+    idempotencyKey: string;
+    expectedRevision: string | null;
+} | {
+    apiVersion: 1;
+    instanceId: string;
+    kind: "import.apply";
+    payload: {
+        candidateId: string;
+        previewRevision: string;
+        mode: "merge" | "replace";
+        overwriteIds: string[];
+        confirmedRemovals: string[];
+    };
+    idempotencyKey: string;
+    expectedRevision: string | null;
+} | {
+    apiVersion: 1;
+    instanceId: string;
+    kind: "import.cancel";
+    payload: {
+        candidateId: string;
+    };
+    idempotencyKey: string;
+    expectedRevision: string | null;
+} | {
+    apiVersion: 1;
+    instanceId: string;
+    kind: "credential.delete";
+    payload: {
+        credentialId: string;
+        confirmed: true;
+    };
+    idempotencyKey: string;
+    expectedRevision: string | null;
+} | {
+    apiVersion: 1;
+    instanceId: string;
+    kind: "catalog.refresh";
+    payload: Record<string, never>;
+    idempotencyKey: string;
+    expectedRevision: string | null;
+} | {
+    apiVersion: 1;
+    instanceId: string;
+    kind: "release.discover";
+    payload: Record<string, never>;
+    idempotencyKey: string;
+    expectedRevision: string | null;
+} | {
+    apiVersion: 1;
+    instanceId: string;
+    kind: "release.install";
+    payload: {
+        releaseId: string;
+    };
+    idempotencyKey: string;
+    expectedRevision: string | null;
+} | {
+    apiVersion: 1;
+    instanceId: string;
+    kind: "release.activate";
+    payload: {
+        installedReleaseId: string;
+        confirmed: true;
+    };
+    idempotencyKey: string;
+    expectedRevision: string | null;
+} | {
+    apiVersion: 1;
+    instanceId: string;
+    kind: "release.delete";
+    payload: {
+        installedReleaseId: string;
+        confirmed: true;
+    };
+    idempotencyKey: string;
+    expectedRevision: string | null;
+} | {
+    apiVersion: 1;
+    instanceId: string;
+    kind: "release.rollback";
+    payload: {
+        lastKnownGoodReleaseId: string;
+        confirmed: true;
+    };
+    idempotencyKey: string;
+    expectedRevision: string | null;
+} | {
+    apiVersion: 1;
+    instanceId: string;
+    kind: "model.probe";
+    payload: {
+        modelId: string;
+        protocol: string;
+        reasoningProfile: string | null;
+    };
+    idempotencyKey: string;
+    expectedRevision: string | null;
+} | {
+    apiVersion: 1;
+    instanceId: string;
+    kind: "operation.cancel";
+    payload: {
+        operationId: string;
+    };
+    idempotencyKey: string;
+    expectedRevision: string | null;
+}, {
+    apiVersion: 1;
+    instanceId: string;
+    kind: "import.stage" | "import.apply" | "import.cancel" | "credential.delete" | "catalog.refresh" | "release.discover" | "release.install" | "release.activate" | "release.delete" | "release.rollback" | "model.probe" | "operation.cancel";
+    payload: unknown;
+    idempotencyKey: string;
+    expectedRevision: string | null;
+}>>;
+interface Actor {
+    id: string;
+    admin?: boolean;
+}
+interface Capability {
+    enabled: boolean;
+    reasonCode: string | null;
+    modes?: ("merge" | "replace")[];
+    overwrite?: boolean;
+}
+type Capabilities = Partial<Record<CommandKind | "credentials.list" | "models.get" | "releases.list", Capability>>;
+interface CredentialDto {
+    id: string;
+    provider: string;
+    fingerprint: string;
+    usability: "usable" | "unknown" | "disabled";
+    updatedAt: string | null;
+}
+interface ModelDto {
+    id: string;
+    capabilities: string[];
+}
+interface ModelsDto {
+    apiVersion: 1;
+    instanceId: string;
+    models: ModelDto[];
+    fetchedAt: string | null;
+    expiresAt: string | null;
+    stale: boolean;
+    revision: string;
+}
+interface ReleaseDto {
+    id: string;
+    version: string;
+    installed: boolean;
+    active: boolean;
+    lastKnownGood: boolean;
+    installedAt: string | null;
+}
+interface StatusDto {
+    apiVersion: 1;
+    instanceId: string;
+    revision: string;
+    runtime: {
+        mode: "managed" | "remote";
+        version: string | null;
+        state: "running" | "stopped" | "unknown";
+    };
+    management: {
+        protocol: string | null;
+        availability: "available" | "unavailable" | "unknown";
+    };
+    inference: {
+        reachable: boolean | null;
+        catalogState: "fresh" | "stale" | "unknown";
+        probeState: "passed" | "failed" | "unknown";
+        checkedAt: string | null;
+    };
+    capabilities: Capabilities;
+    busyOperationId: string | null;
+}
+interface OperationDto {
+    apiVersion: 1;
+    instanceId: string;
+    id: string;
+    kind: CommandKind;
+    actorId: string;
+    state: OperationState;
+    phase: Phase;
+    progress: {
+        completed: number;
+        total: number | null;
+    };
+    createdAt: string;
+    startedAt: string | null;
+    updatedAt: string;
+    finishedAt: string | null;
+    revision: number;
+    error: ErrorDto | null;
+    result: Record<string, unknown> | null;
+    recoveryDisposition: string | null;
+    cancelRequested: boolean;
+}
+interface AcceptResult {
+    apiVersion: 1;
+    operationId: string;
+    state: OperationState;
+    reused: boolean;
+}
+interface ImportPreviewDto {
+    apiVersion: 1;
+    instanceId: string;
+    candidateId: string;
+    revision: string;
+    expiresAt: string;
+    previewExpiresAt: string;
+    accepted: number;
+    skipped: number;
+    additions: string[];
+    preserved: string[];
+    replacements: string[];
+    removals: string[];
+    reasons: Record<string, number>;
+}
+interface ListDto<T> {
+    apiVersion: 1;
+    instanceId: string;
+    items: T[];
+    nextCursor: string | null;
+}
+interface UploadResult {
+    apiVersion: 1;
+    uploadId: string;
+}
+declare const errorSchema: z.ZodObject<{
+    code: z.ZodEnum<{
+        INVALID_INPUT: "INVALID_INPUT";
+        UNSUPPORTED_CAPABILITY: "UNSUPPORTED_CAPABILITY";
+        NOT_AUTHORIZED: "NOT_AUTHORIZED";
+        REVISION_CONFLICT: "REVISION_CONFLICT";
+        IDEMPOTENCY_CONFLICT: "IDEMPOTENCY_CONFLICT";
+        KEY_EXPIRED: "KEY_EXPIRED";
+        INSTANCE_BUSY: "INSTANCE_BUSY";
+        UPLOAD_LIMIT: "UPLOAD_LIMIT";
+        ARCHIVE_UNSAFE: "ARCHIVE_UNSAFE";
+        CREDENTIAL_INVALID: "CREDENTIAL_INVALID";
+        MANAGEMENT_UNAVAILABLE: "MANAGEMENT_UNAVAILABLE";
+        DRAIN_TIMEOUT: "DRAIN_TIMEOUT";
+        PROBE_QUOTA_LIMITED: "PROBE_QUOTA_LIMITED";
+        PROBE_FAILED: "PROBE_FAILED";
+        APPLY_PARTIAL: "APPLY_PARTIAL";
+        OUTCOME_UNKNOWN: "OUTCOME_UNKNOWN";
+        RECOVERY_REQUIRED: "RECOVERY_REQUIRED";
+        CANCELLED: "CANCELLED";
+        INTERNAL: "INTERNAL";
+    }>;
+    message: z.ZodString;
+    retryable: z.ZodBoolean;
+    retryAt: z.ZodNullable<z.ZodString>;
+    operationId: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+declare const acceptSchema: z.ZodObject<{
+    apiVersion: z.ZodLiteral<1>;
+    operationId: z.ZodString;
+    state: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+        cancelled: "cancelled";
+        partially_applied: "partially_applied";
+        recovery_required: "recovery_required";
+    }>;
+    reused: z.ZodBoolean;
+}, z.core.$strict>;
+declare const operationSchema: z.ZodObject<{
+    apiVersion: z.ZodLiteral<1>;
+    instanceId: z.ZodString;
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        "import.stage": "import.stage";
+        "import.apply": "import.apply";
+        "import.cancel": "import.cancel";
+        "credential.delete": "credential.delete";
+        "catalog.refresh": "catalog.refresh";
+        "release.discover": "release.discover";
+        "release.install": "release.install";
+        "release.activate": "release.activate";
+        "release.delete": "release.delete";
+        "release.rollback": "release.rollback";
+        "model.probe": "model.probe";
+        "operation.cancel": "operation.cancel";
+    }>;
+    actorId: z.ZodString;
+    state: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+        cancelled: "cancelled";
+        partially_applied: "partially_applied";
+        recovery_required: "recovery_required";
+    }>;
+    phase: z.ZodEnum<{
+        validate: "validate";
+        preview: "preview";
+        drain: "drain";
+        prepare: "prepare";
+        switch: "switch";
+        verify: "verify";
+        commit: "commit";
+        cleanup: "cleanup";
+    }>;
+    progress: z.ZodObject<{
+        completed: z.ZodNumber;
+        total: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>;
+    createdAt: z.ZodString;
+    startedAt: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodString;
+    finishedAt: z.ZodNullable<z.ZodString>;
+    revision: z.ZodNumber;
+    error: z.ZodNullable<z.ZodObject<{
+        code: z.ZodEnum<{
+            INVALID_INPUT: "INVALID_INPUT";
+            UNSUPPORTED_CAPABILITY: "UNSUPPORTED_CAPABILITY";
+            NOT_AUTHORIZED: "NOT_AUTHORIZED";
+            REVISION_CONFLICT: "REVISION_CONFLICT";
+            IDEMPOTENCY_CONFLICT: "IDEMPOTENCY_CONFLICT";
+            KEY_EXPIRED: "KEY_EXPIRED";
+            INSTANCE_BUSY: "INSTANCE_BUSY";
+            UPLOAD_LIMIT: "UPLOAD_LIMIT";
+            ARCHIVE_UNSAFE: "ARCHIVE_UNSAFE";
+            CREDENTIAL_INVALID: "CREDENTIAL_INVALID";
+            MANAGEMENT_UNAVAILABLE: "MANAGEMENT_UNAVAILABLE";
+            DRAIN_TIMEOUT: "DRAIN_TIMEOUT";
+            PROBE_QUOTA_LIMITED: "PROBE_QUOTA_LIMITED";
+            PROBE_FAILED: "PROBE_FAILED";
+            APPLY_PARTIAL: "APPLY_PARTIAL";
+            OUTCOME_UNKNOWN: "OUTCOME_UNKNOWN";
+            RECOVERY_REQUIRED: "RECOVERY_REQUIRED";
+            CANCELLED: "CANCELLED";
+            INTERNAL: "INTERNAL";
+        }>;
+        message: z.ZodString;
+        retryable: z.ZodBoolean;
+        retryAt: z.ZodNullable<z.ZodString>;
+        operationId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    result: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    recoveryDisposition: z.ZodNullable<z.ZodString>;
+    cancelRequested: z.ZodBoolean;
+}, z.core.$strict>;
+declare function isTerminal(state: OperationState): boolean;
+declare const capabilitySchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    reasonCode: z.ZodNullable<z.ZodString>;
+    modes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        merge: "merge";
+        replace: "replace";
+    }>>>;
+    overwrite: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+declare const credentialSchema: z.ZodObject<{
+    id: z.ZodString;
+    provider: z.ZodString;
+    fingerprint: z.ZodString;
+    usability: z.ZodEnum<{
+        unknown: "unknown";
+        usable: "usable";
+        disabled: "disabled";
+    }>;
+    updatedAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+declare const modelSchema: z.ZodObject<{
+    id: z.ZodString;
+    capabilities: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+declare const modelsSchema: z.ZodObject<{
+    apiVersion: z.ZodLiteral<1>;
+    instanceId: z.ZodString;
+    models: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        capabilities: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    fetchedAt: z.ZodNullable<z.ZodISODateTime>;
+    expiresAt: z.ZodNullable<z.ZodISODateTime>;
+    stale: z.ZodBoolean;
+    revision: z.ZodString;
+}, z.core.$strict>;
+declare const releaseSchema: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodString;
+    installed: z.ZodBoolean;
+    active: z.ZodBoolean;
+    lastKnownGood: z.ZodBoolean;
+    installedAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+declare const statusSchema: z.ZodObject<{
+    apiVersion: z.ZodLiteral<1>;
+    instanceId: z.ZodString;
+    revision: z.ZodString;
+    runtime: z.ZodObject<{
+        mode: z.ZodEnum<{
+            managed: "managed";
+            remote: "remote";
+        }>;
+        version: z.ZodNullable<z.ZodString>;
+        state: z.ZodEnum<{
+            running: "running";
+            unknown: "unknown";
+            stopped: "stopped";
+        }>;
+    }, z.core.$strict>;
+    management: z.ZodObject<{
+        protocol: z.ZodNullable<z.ZodString>;
+        availability: z.ZodEnum<{
+            unknown: "unknown";
+            available: "available";
+            unavailable: "unavailable";
+        }>;
+    }, z.core.$strict>;
+    inference: z.ZodObject<{
+        reachable: z.ZodNullable<z.ZodBoolean>;
+        catalogState: z.ZodEnum<{
+            unknown: "unknown";
+            fresh: "fresh";
+            stale: "stale";
+        }>;
+        probeState: z.ZodEnum<{
+            failed: "failed";
+            unknown: "unknown";
+            passed: "passed";
+        }>;
+        checkedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>;
+    capabilities: z.ZodRecord<z.ZodString, z.ZodObject<{
+        enabled: z.ZodBoolean;
+        reasonCode: z.ZodNullable<z.ZodString>;
+        modes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            merge: "merge";
+            replace: "replace";
+        }>>>;
+        overwrite: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    busyOperationId: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+declare const importPreviewSchema: z.ZodObject<{
+    apiVersion: z.ZodLiteral<1>;
+    instanceId: z.ZodString;
+    candidateId: z.ZodString;
+    revision: z.ZodString;
+    expiresAt: z.ZodISODateTime;
+    previewExpiresAt: z.ZodISODateTime;
+    accepted: z.ZodNumber;
+    skipped: z.ZodNumber;
+    additions: z.ZodArray<z.ZodString>;
+    preserved: z.ZodArray<z.ZodString>;
+    replacements: z.ZodArray<z.ZodString>;
+    removals: z.ZodArray<z.ZodString>;
+    reasons: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strict>;
+declare const uploadResultSchema: z.ZodObject<{
+    apiVersion: z.ZodLiteral<1>;
+    uploadId: z.ZodString;
+}, z.core.$strict>;
+declare const listSchema: <T extends z.ZodType>(item: T) => z.ZodObject<{
+    apiVersion: z.ZodLiteral<1>;
+    instanceId: z.ZodString;
+    items: z.ZodArray<T>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+
+export { type AcceptResult, type Actor, type Capabilities, type Capability, type Command, type CommandKind, type CredentialDto, type ErrorCode, type ErrorDto, type ImportPreviewDto, type ListDto, type ModelDto, type ModelsDto, type OperationDto, type OperationState, type Phase, type ReleaseDto, type StatusDto, type UploadResult, acceptSchema, capabilitySchema, commandSchema, credentialSchema, errorCodes, errorSchema, idSchema, importPreviewSchema, isTerminal, listSchema, modelSchema, modelsSchema, operationSchema, payloadSchemas, releaseSchema, states, statusSchema, uploadResultSchema };

package/dist/contracts/index.js

@@ -0,0 +1,41 @@
+import {
+  acceptSchema,
+  capabilitySchema,
+  commandSchema,
+  credentialSchema,
+  errorCodes,
+  errorSchema,
+  idSchema,
+  importPreviewSchema,
+  isTerminal,
+  listSchema,
+  modelSchema,
+  modelsSchema,
+  operationSchema,
+  payloadSchemas,
+  releaseSchema,
+  states,
+  statusSchema,
+  uploadResultSchema
+} from "../chunk-T47QB7AC.js";
+export {
+  acceptSchema,
+  capabilitySchema,
+  commandSchema,
+  credentialSchema,
+  errorCodes,
+  errorSchema,
+  idSchema,
+  importPreviewSchema,
+  isTerminal,
+  listSchema,
+  modelSchema,
+  modelsSchema,
+  operationSchema,
+  payloadSchemas,
+  releaseSchema,
+  states,
+  statusSchema,
+  uploadResultSchema
+};
+//# sourceMappingURL=index.js.map

package/dist/contracts/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}