@camstack/types 1.2.331 → 1.2.333

package/dist/capabilities/snapshot.cap.d.ts

@@ -101,9 +101,9 @@ export declare const snapshotCapability: {
             state: z.ZodObject<{
                 isBattery: z.ZodBoolean;
                 reason: z.ZodNullable<z.ZodEnum<{
+                    unreachable: "unreachable";
                     offline: "offline";
                     disabled: "disabled";
-                    unreachable: "unreachable";
                     sleeping: "sleeping";
                     waking: "waking";
                 }>>;
@@ -174,9 +174,9 @@ export declare const snapshotCapability: {
             neverCaptured: z.ZodBoolean;
             sleeping: z.ZodBoolean;
             stateReason: z.ZodNullable<z.ZodEnum<{
+                unreachable: "unreachable";
                 offline: "offline";
                 disabled: "disabled";
-                unreachable: "unreachable";
                 sleeping: "sleeping";
                 waking: "waking";
             }>>;

package/dist/capabilities/sso-bridge.cap.d.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { type InferProvider } from './capability-definition.js';
 /**
  * `sso-bridge` — internal hub-only cap that lets SSO-style auth
- * providers (OIDC, SAML, magic-link, …) mint an HMAC-signed token
+ * providers (OIDC, SAML, …) mint an HMAC-signed token
  * carrying the post-callback claims before redirecting back to
  * `/api/auth/sso/finish`.
  *
@@ -78,6 +78,7 @@ declare const SsoBridgeClaimsSchema: z.ZodObject<{
     refreshTtl: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"never">]>>;
     linkIntent: z.ZodOptional<z.ZodString>;
     issuer: z.ZodOptional<z.ZodString>;
+    browserBinding: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const ssoBridgeCapability: {
     readonly name: "sso-bridge";
@@ -95,7 +96,7 @@ export declare const ssoBridgeCapability: {
          * `/api/auth/sso/finish` to become admin — a full privilege escalation
          * through the exact surface this cap exists to close (see the module
          * docblock). Every real caller (`oauth-grants.ts`, `main.ts`
-         * registration, the OIDC/magic-link addons) reaches this through
+         * registration, the OIDC addon) reaches this through
          * `ctx.api` / the in-process registry — never through tRPC — so
          * `auth: 'admin'` costs those callers nothing.
          */
@@ -164,6 +165,7 @@ export declare const ssoBridgeCapability: {
                 refreshTtl: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"never">]>>;
                 linkIntent: z.ZodOptional<z.ZodString>;
                 issuer: z.ZodOptional<z.ZodString>;
+                browserBinding: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>;
             ttlSec: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"never">]>>;
         }, z.core.$strip>, z.ZodObject<{
@@ -235,6 +237,7 @@ export declare const ssoBridgeCapability: {
             refreshTtl: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"never">]>>;
             linkIntent: z.ZodOptional<z.ZodString>;
             issuer: z.ZodOptional<z.ZodString>;
+            browserBinding: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
     };
 };

package/dist/capabilities/training-provider.cap.d.ts

@@ -0,0 +1,373 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+/**
+ * `training-provider` — ONE cloud that can run the CamStack trainer.
+ *
+ * A thin, mockable translation layer: it knows how to run a container with a
+ * GPU, move a dataset in, read the job's stdout and hand artefacts back. It
+ * knows nothing about datasets, splits, floors, cost policy or Model Studio —
+ * those are the `training` orchestrator's (D805). Every rule written there
+ * once is what makes a second provider (RunPod, a local NVIDIA node) a new
+ * manifest entry and nothing else.
+ *
+ * Collection, routed by the `addonId` in every single-row input (the `llm` /
+ * `notification-output` posture); `describe` concat-fans across providers.
+ * Every method is `admin`: these spend money.
+ *
+ * Every cloud object a provider creates is tagged with the orchestrator's
+ * `jobKey`, so a retried submit finds the job it already started instead of
+ * starting a second GPU, and `listJobs` can find orphans.
+ *
+ * Bytes never ride a cap field: the dataset arrives as a `ctx.peerBytes`
+ * ticket the producer (pipeline-analytics) minted, and artefacts leave as a
+ * ticket the provider mints (D613).
+ */
+export declare const TrainingGpuOptionSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    usdPerHour: z.ZodNumber;
+    vramGb: z.ZodNumber;
+}, z.core.$strip>;
+export type TrainingGpuOption = z.infer<typeof TrainingGpuOptionSchema>;
+export declare const TrainingRegionOptionSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    priceMultiplier: z.ZodNumber;
+}, z.core.$strip>;
+export type TrainingRegionOption = z.infer<typeof TrainingRegionOptionSchema>;
+/**
+ * The provider's per-account settings, as the orchestrator reads them. They
+ * live in the PROVIDER addon's settings (operator decision 2026-10-08: they
+ * depend on the user's account), never hard-coded in the orchestrator.
+ */
+export declare const TrainingProviderDefaultsSchema: z.ZodObject<{
+    gpuType: z.ZodString;
+    region: z.ZodString;
+    costCapUsd: z.ZodNumber;
+    maxRuntimeSec: z.ZodNumber;
+    failedDatasetGraceHours: z.ZodNumber;
+}, z.core.$strip>;
+export type TrainingProviderDefaults = z.infer<typeof TrainingProviderDefaultsSchema>;
+export declare const TrainingProviderDescriptorSchema: z.ZodObject<{
+    addonId: z.ZodString;
+    kind: z.ZodString;
+    label: z.ZodString;
+    gpuTypes: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        usdPerHour: z.ZodNumber;
+        vramGb: z.ZodNumber;
+    }, z.core.$strip>>>;
+    regions: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        priceMultiplier: z.ZodNumber;
+    }, z.core.$strip>>>;
+    maxDatasetBytes: z.ZodNumber;
+    maxRuntimeSec: z.ZodNumber;
+    freeTierNote: z.ZodOptional<z.ZodString>;
+    dataResidencyNote: z.ZodString;
+    configured: z.ZodBoolean;
+    defaults: z.ZodObject<{
+        gpuType: z.ZodString;
+        region: z.ZodString;
+        costCapUsd: z.ZodNumber;
+        maxRuntimeSec: z.ZodNumber;
+        failedDatasetGraceHours: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type TrainingProviderDescriptor = z.infer<typeof TrainingProviderDescriptorSchema>;
+export declare const TrainingCredentialCheckSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    account: z.ZodOptional<z.ZodString>;
+    reason: z.ZodOptional<z.ZodEnum<{
+        invalid: "invalid";
+        quota: "quota";
+        missing: "missing";
+        forbidden: "forbidden";
+        network: "network";
+    }>>;
+    detail: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type TrainingCredentialCheck = z.infer<typeof TrainingCredentialCheckSchema>;
+export declare const ProviderJobStateSchema: z.ZodEnum<{
+    running: "running";
+    failed: "failed";
+    cancelled: "cancelled";
+    pending: "pending";
+    succeeded: "succeeded";
+    starting: "starting";
+    lost: "lost";
+}>;
+export type ProviderJobState = z.infer<typeof ProviderJobStateSchema>;
+export declare const ProviderJobStatusSchema: z.ZodObject<{
+    jobKey: z.ZodString;
+    providerJobId: z.ZodOptional<z.ZodString>;
+    state: z.ZodEnum<{
+        running: "running";
+        failed: "failed";
+        cancelled: "cancelled";
+        pending: "pending";
+        succeeded: "succeeded";
+        starting: "starting";
+        lost: "lost";
+    }>;
+    startedAt: z.ZodOptional<z.ZodNumber>;
+    endedAt: z.ZodOptional<z.ZodNumber>;
+    exitCode: z.ZodOptional<z.ZodNumber>;
+    failureReason: z.ZodOptional<z.ZodString>;
+    gpuType: z.ZodString;
+    region: z.ZodOptional<z.ZodString>;
+    billedSeconds: z.ZodNumber;
+    costUsd: z.ZodNumber;
+    costIsEstimate: z.ZodBoolean;
+    lastFetchedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type ProviderJobStatus = z.infer<typeof ProviderJobStatusSchema>;
+/**
+ * The trainer the job runs, by SOURCE revision: the provider turns it into an
+ * image its own way (Modal builds the published Dockerfile at that revision;
+ * a registry-pull provider maps it to a tag). Recorded on the job and echoed
+ * in `result.json`.
+ */
+export declare const TrainerSourceRefSchema: z.ZodObject<{
+    repo: z.ZodString;
+    revision: z.ZodString;
+}, z.core.$strip>;
+export type TrainerSourceRef = z.infer<typeof TrainerSourceRefSchema>;
+export declare const TrainingLogLineSchema: z.ZodObject<{
+    ts: z.ZodNumber;
+    text: z.ZodString;
+}, z.core.$strip>;
+export type TrainingLogLine = z.infer<typeof TrainingLogLineSchema>;
+export declare const trainingProviderCapability: {
+    readonly name: "training-provider";
+    readonly scope: "system";
+    readonly mode: "collection";
+    readonly internal: true;
+    readonly methods: {
+        /** Every provider's offer and settings. Concat-fans across providers. */
+        readonly describe: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            addonId: z.ZodString;
+            kind: z.ZodString;
+            label: z.ZodString;
+            gpuTypes: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                usdPerHour: z.ZodNumber;
+                vramGb: z.ZodNumber;
+            }, z.core.$strip>>>;
+            regions: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                priceMultiplier: z.ZodNumber;
+            }, z.core.$strip>>>;
+            maxDatasetBytes: z.ZodNumber;
+            maxRuntimeSec: z.ZodNumber;
+            freeTierNote: z.ZodOptional<z.ZodString>;
+            dataResidencyNote: z.ZodString;
+            configured: z.ZodBoolean;
+            defaults: z.ZodObject<{
+                gpuType: z.ZodString;
+                region: z.ZodString;
+                costCapUsd: z.ZodNumber;
+                maxRuntimeSec: z.ZodNumber;
+                failedDatasetGraceHours: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Call the provider with the stored credentials. Never returns them. */
+        readonly validateCredentials: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            addonId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            ok: z.ZodBoolean;
+            account: z.ZodOptional<z.ZodString>;
+            reason: z.ZodOptional<z.ZodEnum<{
+                invalid: "invalid";
+                quota: "quota";
+                missing: "missing";
+                forbidden: "forbidden";
+                network: "network";
+            }>>;
+            detail: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, "mutation">;
+        /** USD range for a run of `gpuSeconds` on `gpuType` in `region`. */
+        readonly estimateJob: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            addonId: z.ZodString;
+            gpuType: z.ZodString;
+            region: z.ZodString;
+            datasetBytes: z.ZodNumber;
+            gpuSecondsLow: z.ZodNumber;
+            gpuSecondsHigh: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            usdLow: z.ZodNumber;
+            usdHigh: z.ZodNumber;
+            notes: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Take the dataset archive behind `ticket` (minted by pipeline-analytics,
+         * same host) and land it as the job's dataset in the cloud, streamed —
+         * nothing is staged on the hub's disk. Idempotent per `jobKey`: a second
+         * call replaces a partial upload. Answers what actually landed.
+         */
+        readonly uploadDataset: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            ticket: z.ZodObject<{
+                url: z.ZodString;
+                hostNodeId: z.ZodString;
+                expiresAtMs: z.ZodNumber;
+                declaredBytes: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>;
+            addonId: z.ZodString;
+            jobKey: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            bytes: z.ZodNumber;
+            sha256: z.ZodString;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * Start the trainer on a GPU. Looks the job up by `jobKey` first, so a
+         * retried submit never starts a second GPU. `jobSpecJson` is written next
+         * to the dataset as `job.json`; `maxRuntimeSec` is enforced by the
+         * provider (a hard timeout), not by the hub.
+         */
+        readonly submitJob: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            trainer: z.ZodObject<{
+                repo: z.ZodString;
+                revision: z.ZodString;
+            }, z.core.$strip>;
+            jobSpecJson: z.ZodString;
+            gpuType: z.ZodString;
+            region: z.ZodString;
+            maxRuntimeSec: z.ZodNumber;
+            addonId: z.ZodString;
+            jobKey: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            jobKey: z.ZodString;
+            providerJobId: z.ZodOptional<z.ZodString>;
+            state: z.ZodEnum<{
+                running: "running";
+                failed: "failed";
+                cancelled: "cancelled";
+                pending: "pending";
+                succeeded: "succeeded";
+                starting: "starting";
+                lost: "lost";
+            }>;
+            startedAt: z.ZodOptional<z.ZodNumber>;
+            endedAt: z.ZodOptional<z.ZodNumber>;
+            exitCode: z.ZodOptional<z.ZodNumber>;
+            failureReason: z.ZodOptional<z.ZodString>;
+            gpuType: z.ZodString;
+            region: z.ZodOptional<z.ZodString>;
+            billedSeconds: z.ZodNumber;
+            costUsd: z.ZodNumber;
+            costIsEstimate: z.ZodBoolean;
+            lastFetchedAt: z.ZodNumber;
+        }, z.core.$strip>, "mutation">;
+        readonly getJob: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            addonId: z.ZodString;
+            jobKey: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            jobKey: z.ZodString;
+            providerJobId: z.ZodOptional<z.ZodString>;
+            state: z.ZodEnum<{
+                running: "running";
+                failed: "failed";
+                cancelled: "cancelled";
+                pending: "pending";
+                succeeded: "succeeded";
+                starting: "starting";
+                lost: "lost";
+            }>;
+            startedAt: z.ZodOptional<z.ZodNumber>;
+            endedAt: z.ZodOptional<z.ZodNumber>;
+            exitCode: z.ZodOptional<z.ZodNumber>;
+            failureReason: z.ZodOptional<z.ZodString>;
+            gpuType: z.ZodString;
+            region: z.ZodOptional<z.ZodString>;
+            billedSeconds: z.ZodNumber;
+            costUsd: z.ZodNumber;
+            costIsEstimate: z.ZodBoolean;
+            lastFetchedAt: z.ZodNumber;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Stdout/stderr since `cursor` (opaque), oldest first, at most `max` lines. */
+        readonly listJobEvents: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            cursor: z.ZodOptional<z.ZodString>;
+            max: z.ZodNumber;
+            addonId: z.ZodString;
+            jobKey: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            lines: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                ts: z.ZodNumber;
+                text: z.ZodString;
+            }, z.core.$strip>>>;
+            cursor: z.ZodString;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Stop the job. Idempotent: an unknown or finished job is a no-op. */
+        readonly cancelJob: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            addonId: z.ZodString;
+            jobKey: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+        /** The job's `result.json`, as text (small, JSON). `found: false` before it exists. */
+        readonly readResult: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            addonId: z.ZodString;
+            jobKey: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            found: z.ZodBoolean;
+            text: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * Offer one output file of the job (`bundle.tar`) to the caller as a
+         * one-shot `ctx.peerBytes` ticket, streamed from the cloud — the provider
+         * stages nothing on disk. The caller dials it at once.
+         */
+        readonly offerArtifact: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            path: z.ZodEnum<{
+                "bundle.tar": "bundle.tar";
+            }>;
+            addonId: z.ZodString;
+            jobKey: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            ticket: z.ZodObject<{
+                url: z.ZodString;
+                hostNodeId: z.ZodString;
+                expiresAtMs: z.ZodNumber;
+                declaredBytes: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, "mutation">;
+        /** Delete every cloud object tagged with `jobKey` (the dataset first). Idempotent. */
+        readonly cleanupJob: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            addonId: z.ZodString;
+            jobKey: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            deleted: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>, "mutation">;
+        /** Every job the provider can still see — the orphan sweep diffs it against our records. */
+        readonly listJobs: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            addonId: z.ZodString;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            jobKey: z.ZodString;
+            providerJobId: z.ZodOptional<z.ZodString>;
+            state: z.ZodEnum<{
+                running: "running";
+                failed: "failed";
+                cancelled: "cancelled";
+                pending: "pending";
+                succeeded: "succeeded";
+                starting: "starting";
+                lost: "lost";
+            }>;
+            startedAt: z.ZodOptional<z.ZodNumber>;
+            endedAt: z.ZodOptional<z.ZodNumber>;
+            exitCode: z.ZodOptional<z.ZodNumber>;
+            failureReason: z.ZodOptional<z.ZodString>;
+            gpuType: z.ZodString;
+            region: z.ZodOptional<z.ZodString>;
+            billedSeconds: z.ZodNumber;
+            costUsd: z.ZodNumber;
+            costIsEstimate: z.ZodBoolean;
+            lastFetchedAt: z.ZodNumber;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type ITrainingCloudProvider = InferProvider<typeof trainingProviderCapability>;