@f-inverse/jammi-client 0.49.0 → 0.50.0

package/dist/gen/jammi/v1/job_pb.d.ts

@@ -0,0 +1,774 @@
+import type { GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv2";
+import type { CacheOutcome, CachePolicy } from "./inference_pb";
+import type { ContextPredictorSpec, FineTuneConfig, FineTuneSpec, GraphFineTuneSpec } from "./training_pb";
+import type { Message } from "@bufbuild/protobuf";
+/**
+ * Describes the file jammi/v1/job.proto.
+ */
+export declare const file_jammi_v1_job: GenFile;
+/**
+ * The training-kind spec `oneof` `SubmitJob` accepts, plus the client-supplied
+ * dedupe key. Mirrors the engine's `TrainingSpec` enum variant-for-variant,
+ * field-for-field: a decoded request reconstructs the identical engine spec,
+ * so a remote-submitted job is byte-identical to one submitted in-process.
+ *
+ * @generated from message jammi.v1.job.SubmitJobRequest
+ */
+export type SubmitJobRequest = Message<"jammi.v1.job.SubmitJobRequest"> & {
+    /**
+     * @generated from oneof jammi.v1.job.SubmitJobRequest.spec
+     */
+    spec: {
+        /**
+         * @generated from field: jammi.v1.training.FineTuneSpec fine_tune = 1;
+         */
+        value: FineTuneSpec;
+        case: "fineTune";
+    } | {
+        /**
+         * @generated from field: jammi.v1.training.GraphFineTuneSpec graph_fine_tune = 2;
+         */
+        value: GraphFineTuneSpec;
+        case: "graphFineTune";
+    } | {
+        /**
+         * @generated from field: jammi.v1.training.ContextPredictorSpec context_predictor = 3;
+         */
+        value: ContextPredictorSpec;
+        case: "contextPredictor";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+    /**
+     * Base encoder to adapt for the two LoRA fine-tune kinds (`local:<path>`, an
+     * HF repo id, or a fine-tuned id). Unused by the context-predictor kind (it
+     * names its source's embedding model implicitly), so it is empty there.
+     *
+     * @generated from field: string base_model = 4;
+     */
+    baseModel: string;
+    /**
+     * Optional fine-tune hyperparameters for the two LoRA fine-tune kinds; unset
+     * applies the engine's defaults. Unused by the context-predictor kind (its
+     * budget rides inside `predictor_spec`).
+     *
+     * @generated from field: optional jammi.v1.training.FineTuneConfig config = 5;
+     */
+    config?: FineTuneConfig | undefined;
+    /**
+     * Optional caller-supplied dedupe key, scoped to the session tenant. A
+     * second `SubmitJob` carrying the same non-empty key as a still-known prior
+     * submission returns that prior job's handle unchanged rather than
+     * submitting a duplicate row. Empty (the default) submits unconditionally,
+     * matching every pre-existing caller. DURABLE (migration 030): the key
+     * lives on the `jobs` row itself under a per-tenant unique index, so the
+     * guarantee survives a process restart and a concurrent retry racing the
+     * SAME key — the loser's insert is refused by the same compare-and-set
+     * that creates the row, never a separate lookup-then-insert window. A
+     * pruned row's key is gone with it (nothing resurrects an identity for a
+     * key whose row has been deleted); different tenants may reuse the same
+     * key freely. Bounded to MAX_IDEMPOTENCY_KEY_BYTES (256 bytes,
+     * `jammi_db::catalog::jobs_repo::MAX_IDEMPOTENCY_KEY_BYTES`); a longer key
+     * is refused with `INVALID_ARGUMENT` naming the bound, never the key's own
+     * value -- Postgres's btree index has a hard row-size ceiling an oversize
+     * key can exceed (SQLite has none, so the two backends would otherwise
+     * silently diverge on the exact same input).
+     *
+     * @generated from field: string idempotency_key = 6;
+     */
+    idempotencyKey: string;
+    /**
+     * Data-parallel rank count for the two LoRA fine-tune kinds: the wire form of
+     * the engine's `TrainingCommon.world_size`, which is why it sits beside
+     * `base_model`/`config` rather than inside a per-kind spec — both LoRA kinds
+     * fold the same common block, so one field serves both and the two kinds
+     * cannot diverge on it. Unused by the context-predictor kind (it carries no
+     * common block).
+     *
+     * `0` means UNSET and resolves to the engine's default of `1` (a single
+     * rank), so a caller that never sets it submits exactly the single-rank job
+     * it always did and a request encoded without the field decodes identically
+     * to one encoded with `0`. Identity-relevant, not a scheduling hint: the rank
+     * count fixes the batch layout and the summation order, so it is part of the
+     * trained model's producing identity. A count the deployment cannot serve is
+     * refused at submit with a typed error rather than silently clamped.
+     *
+     * @generated from field: uint32 world_size = 9;
+     */
+    worldSize: number;
+    /**
+     * Mirrors the engine's `TrainingSpec::FineTune.cache` field for field, the
+     * same shared `CachePolicy` enum every other result-table producer verb carries
+     * (`jammi.v1.inference.CachePolicy` — imported rather than redeclared, so
+     * this and every other producer's cache dial share one wire vocabulary).
+     * UNSPECIFIED maps to the engine default (`Bypass`, always train), matching
+     * how every other `*_UNSPECIFIED` arm resolves to its engine default; an
+     * absent field and an explicit `CACHE_POLICY_BYPASS` are the identical
+     * engine outcome. `USE` is REFUSED, typed (`InvalidArgument`), for BOTH LoRA
+     * fine-tune kinds: `graph_fine_tune`'s model carries no materialization to
+     * probe or record, and model-level cache reuse for the column-source
+     * `fine_tune` kind is not supported. `BYPASS`/unset always
+     * trains, on either kind. Unused by
+     * the context-predictor kind (it carries no `TrainingCommon`, so it has
+     * nothing to probe by).
+     *
+     * @generated from field: jammi.v1.inference.CachePolicy cache = 10;
+     */
+    cache: CachePolicy;
+};
+/**
+ * Describes the message jammi.v1.job.SubmitJobRequest.
+ * Use `create(SubmitJobRequestSchema)` to create a new message.
+ */
+export declare const SubmitJobRequestSchema: GenMessage<SubmitJobRequest>;
+/**
+ * @generated from message jammi.v1.job.SubmitJobResponse
+ */
+export type SubmitJobResponse = Message<"jammi.v1.job.SubmitJobResponse"> & {
+    /**
+     * Server-assigned job id. Read status with `JobStatus`/`WaitJob`.
+     *
+     * @generated from field: string job_id = 1;
+     */
+    jobId: string;
+    /**
+     * The `jobs.kind` tag this job submitted under (e.g. `"fine_tune"`).
+     *
+     * @generated from field: string kind = 2;
+     */
+    kind: string;
+    /**
+     * The deterministic output model id the trained artifact registers under —
+     * resolved via the same rule the embedded `TrainingJob::model_id` uses.
+     * Empty for a compute kind (no training kinds ever compute this).
+     *
+     * @generated from field: string output_model_id = 3;
+     */
+    outputModelId: string;
+};
+/**
+ * Describes the message jammi.v1.job.SubmitJobResponse.
+ * Use `create(SubmitJobResponseSchema)` to create a new message.
+ */
+export declare const SubmitJobResponseSchema: GenMessage<SubmitJobResponse>;
+/**
+ * A job's identity, for `WaitJob` and `CancelJob`.
+ *
+ * @generated from message jammi.v1.job.JobHandle
+ */
+export type JobHandle = Message<"jammi.v1.job.JobHandle"> & {
+    /**
+     * @generated from field: string job_id = 1;
+     */
+    jobId: string;
+};
+/**
+ * Describes the message jammi.v1.job.JobHandle.
+ * Use `create(JobHandleSchema)` to create a new message.
+ */
+export declare const JobHandleSchema: GenMessage<JobHandle>;
+/**
+ * @generated from message jammi.v1.job.JobStatusRequest
+ */
+export type JobStatusRequest = Message<"jammi.v1.job.JobStatusRequest"> & {
+    /**
+     * @generated from field: string job_id = 1;
+     */
+    jobId: string;
+};
+/**
+ * Describes the message jammi.v1.job.JobStatusRequest.
+ * Use `create(JobStatusRequestSchema)` to create a new message.
+ */
+export declare const JobStatusRequestSchema: GenMessage<JobStatusRequest>;
+/**
+ * A job's progress, updated at producer checkpoint boundaries. Field presence
+ * distinguishes "no progress recorded yet" from a legal `0`.
+ *
+ * @generated from message jammi.v1.job.JobProgress
+ */
+export type JobProgress = Message<"jammi.v1.job.JobProgress"> & {
+    /**
+     * @generated from field: optional uint64 rows_done = 1;
+     */
+    rowsDone?: bigint | undefined;
+    /**
+     * @generated from field: optional uint64 rows_total = 2;
+     */
+    rowsTotal?: bigint | undefined;
+    /**
+     * @generated from field: string phase = 3;
+     */
+    phase: string;
+};
+/**
+ * Describes the message jammi.v1.job.JobProgress.
+ * Use `create(JobProgressSchema)` to create a new message.
+ */
+export declare const JobProgressSchema: GenMessage<JobProgress>;
+/**
+ * A training kind's terminal model result.
+ *
+ * @generated from message jammi.v1.job.ModelResult
+ */
+export type ModelResult = Message<"jammi.v1.job.ModelResult"> & {
+    /**
+     * @generated from field: string model_id = 1;
+     */
+    modelId: string;
+    /**
+     * @generated from field: string artifact_path = 2;
+     */
+    artifactPath: string;
+    /**
+     * Run-metrics JSON, present once the run recorded any.
+     *
+     * @generated from field: optional string metrics_json = 3;
+     */
+    metricsJson?: string | undefined;
+    /**
+     * `computed` for a run that trained; `reused_model_artifact` — naming the
+     * artifact `artifact_path` also names — for a `CACHE_POLICY_USE` job that
+     * completed against an already-published model of the same definition.
+     * Observable on the terminal result, never merely inferred from an absent
+     * `metrics_json`.
+     *
+     * @generated from field: jammi.v1.inference.CacheOutcome cache_outcome = 4;
+     */
+    cacheOutcome?: CacheOutcome | undefined;
+};
+/**
+ * Describes the message jammi.v1.job.ModelResult.
+ * Use `create(ModelResultSchema)` to create a new message.
+ */
+export declare const ModelResultSchema: GenMessage<ModelResult>;
+/**
+ * A compute kind's terminal result-table result.
+ *
+ * @generated from message jammi.v1.job.TableResult
+ */
+export type TableResult = Message<"jammi.v1.job.TableResult"> & {
+    /**
+     * @generated from field: string table = 1;
+     */
+    table: string;
+    /**
+     * `computed`, or `reused_table` naming the table for an exact cache hit.
+     *
+     * @generated from field: jammi.v1.inference.CacheOutcome cache_outcome = 2;
+     */
+    cacheOutcome?: CacheOutcome | undefined;
+};
+/**
+ * Describes the message jammi.v1.job.TableResult.
+ * Use `create(TableResultSchema)` to create a new message.
+ */
+export declare const TableResultSchema: GenMessage<TableResult>;
+/**
+ * @generated from message jammi.v1.job.JobStatusResponse
+ */
+export type JobStatusResponse = Message<"jammi.v1.job.JobStatusResponse"> & {
+    /**
+     * Current lifecycle status: "queued", "running", "completed", or "failed".
+     *
+     * @generated from field: string status = 1;
+     */
+    status: string;
+    /**
+     * The `jobs.kind` tag this job submitted under.
+     *
+     * @generated from field: string kind = 2;
+     */
+    kind: string;
+    /**
+     * @generated from field: jammi.v1.job.JobProgress progress = 3;
+     */
+    progress?: JobProgress | undefined;
+    /**
+     * The failure message when `status` is "failed"; empty otherwise.
+     *
+     * @generated from field: string error = 4;
+     */
+    error: string;
+    /**
+     * The output model id the trained artifact registers under, resolved the
+     * same way `SubmitJobResponse.output_model_id` is; empty for a compute
+     * kind (never populated).
+     *
+     * @generated from field: string output_model_id = 5;
+     */
+    outputModelId: string;
+    /**
+     * The tagged terminal result. Unset until `status` is "completed".
+     *
+     * @generated from oneof jammi.v1.job.JobStatusResponse.result
+     */
+    result: {
+        /**
+         * @generated from field: jammi.v1.job.ModelResult model = 6;
+         */
+        value: ModelResult;
+        case: "model";
+    } | {
+        /**
+         * @generated from field: jammi.v1.job.TableResult table = 7;
+         */
+        value: TableResult;
+        case: "table";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+    /**
+     * GPU-acceleration determination for this job, as an opaque, self-describing
+     * JSON object — the SAME blob the catalog's `jobs.acceleration_report`
+     * column carries. Field presence (not the empty string)
+     * distinguishes "no column value" from an already-recorded blob.
+     *
+     * @generated from field: optional string acceleration_report_json = 8;
+     */
+    accelerationReportJson?: string | undefined;
+};
+/**
+ * Describes the message jammi.v1.job.JobStatusResponse.
+ * Use `create(JobStatusResponseSchema)` to create a new message.
+ */
+export declare const JobStatusResponseSchema: GenMessage<JobStatusResponse>;
+/**
+ * One frame of a `WaitJob` stream: either an in-flight progress update or the
+ * terminal `JobStatusResponse` — after which the stream ends.
+ *
+ * @generated from message jammi.v1.job.JobEvent
+ */
+export type JobEvent = Message<"jammi.v1.job.JobEvent"> & {
+    /**
+     * @generated from oneof jammi.v1.job.JobEvent.event
+     */
+    event: {
+        /**
+         * @generated from field: jammi.v1.job.JobProgress progress = 1;
+         */
+        value: JobProgress;
+        case: "progress";
+    } | {
+        /**
+         * @generated from field: jammi.v1.job.JobStatusResponse done = 2;
+         */
+        value: JobStatusResponse;
+        case: "done";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message jammi.v1.job.JobEvent.
+ * Use `create(JobEventSchema)` to create a new message.
+ */
+export declare const JobEventSchema: GenMessage<JobEvent>;
+/**
+ * @generated from message jammi.v1.job.ListJobsRequest
+ */
+export type ListJobsRequest = Message<"jammi.v1.job.ListJobsRequest"> & {};
+/**
+ * Describes the message jammi.v1.job.ListJobsRequest.
+ * Use `create(ListJobsRequestSchema)` to create a new message.
+ */
+export declare const ListJobsRequestSchema: GenMessage<ListJobsRequest>;
+/**
+ * @generated from message jammi.v1.job.ListJobsResponse
+ */
+export type ListJobsResponse = Message<"jammi.v1.job.ListJobsResponse"> & {
+    /**
+     * @generated from field: repeated jammi.v1.job.JobSummary jobs = 1;
+     */
+    jobs: JobSummary[];
+};
+/**
+ * Describes the message jammi.v1.job.ListJobsResponse.
+ * Use `create(ListJobsResponseSchema)` to create a new message.
+ */
+export declare const ListJobsResponseSchema: GenMessage<ListJobsResponse>;
+/**
+ * One job's lifecycle summary: the `JobStatus` projection plus the
+ * submit-time identity fields a listing needs to tell jobs apart.
+ *
+ * @generated from message jammi.v1.job.JobSummary
+ */
+export type JobSummary = Message<"jammi.v1.job.JobSummary"> & {
+    /**
+     * @generated from field: string job_id = 1;
+     */
+    jobId: string;
+    /**
+     * The `jobs.kind` tag this job submitted under.
+     *
+     * @generated from field: string kind = 2;
+     */
+    kind: string;
+    /**
+     * @generated from field: string status = 3;
+     */
+    status: string;
+    /**
+     * The base model a training kind trains from — the catalog's registered
+     * model id (PK-keyed). Empty for a compute kind.
+     *
+     * @generated from field: string base_model_id = 4;
+     */
+    baseModelId: string;
+    /**
+     * The output model id the trained artifact registers under, stamped at
+     * submission for a training kind; always empty for a compute kind.
+     *
+     * @generated from field: string output_model_id = 5;
+     */
+    outputModelId: string;
+    /**
+     * Job creation time, as recorded by the catalog (UTC text timestamp).
+     *
+     * @generated from field: string created_at = 6;
+     */
+    createdAt: string;
+    /**
+     * @generated from field: string error = 7;
+     */
+    error: string;
+    /**
+     * The instance holding (or, on a terminal job, last holding) the job's
+     * claim — for a placed training attempt, the executor the claim moved to.
+     * Empty while the job is queued and unclaimed.
+     *
+     * @generated from field: string claimed_by = 8;
+     */
+    claimedBy: string;
+    /**
+     * The instance that ran each rank of the latest training attempt, in rank
+     * order (the same id `ListWorkers` reports). Empty for a compute job and
+     * until a training attempt records its ranks.
+     *
+     * @generated from field: repeated string ranks = 9;
+     */
+    ranks: string[];
+};
+/**
+ * Describes the message jammi.v1.job.JobSummary.
+ * Use `create(JobSummarySchema)` to create a new message.
+ */
+export declare const JobSummarySchema: GenMessage<JobSummary>;
+/**
+ * @generated from message jammi.v1.job.CancelJobRequest
+ */
+export type CancelJobRequest = Message<"jammi.v1.job.CancelJobRequest"> & {
+    /**
+     * @generated from field: string job_id = 1;
+     */
+    jobId: string;
+};
+/**
+ * Describes the message jammi.v1.job.CancelJobRequest.
+ * Use `create(CancelJobRequestSchema)` to create a new message.
+ */
+export declare const CancelJobRequestSchema: GenMessage<CancelJobRequest>;
+/**
+ * @generated from message jammi.v1.job.CancelJobResponse
+ */
+export type CancelJobResponse = Message<"jammi.v1.job.CancelJobResponse"> & {
+    /**
+     * `false` when the job was already terminal or absent — cancellation had
+     * no effect.
+     *
+     * @generated from field: bool cancelled = 1;
+     */
+    cancelled: boolean;
+};
+/**
+ * Describes the message jammi.v1.job.CancelJobResponse.
+ * Use `create(CancelJobResponseSchema)` to create a new message.
+ */
+export declare const CancelJobResponseSchema: GenMessage<CancelJobResponse>;
+/**
+ * @generated from message jammi.v1.job.ListWorkersRequest
+ */
+export type ListWorkersRequest = Message<"jammi.v1.job.ListWorkersRequest"> & {};
+/**
+ * Describes the message jammi.v1.job.ListWorkersRequest.
+ * Use `create(ListWorkersRequestSchema)` to create a new message.
+ */
+export declare const ListWorkersRequestSchema: GenMessage<ListWorkersRequest>;
+/**
+ * @generated from message jammi.v1.job.ListWorkersResponse
+ */
+export type ListWorkersResponse = Message<"jammi.v1.job.ListWorkersResponse"> & {
+    /**
+     * @generated from field: repeated jammi.v1.job.WorkerSummary workers = 1;
+     */
+    workers: WorkerSummary[];
+};
+/**
+ * Describes the message jammi.v1.job.ListWorkersResponse.
+ * Use `create(ListWorkersResponseSchema)` to create a new message.
+ */
+export declare const ListWorkersResponseSchema: GenMessage<ListWorkersResponse>;
+/**
+ * One process currently running the claim loop, joined from `instances` +
+ * `workers` (migration 029).
+ *
+ * @generated from message jammi.v1.job.WorkerSummary
+ */
+export type WorkerSummary = Message<"jammi.v1.job.WorkerSummary"> & {
+    /**
+     * The process's minted-at-construction uuid.
+     *
+     * @generated from field: string instance_id = 1;
+     */
+    instanceId: string;
+    /**
+     * `JAMMI_WORKER_ID`, non-unique — an operator-chosen label, empty when
+     * unset.
+     *
+     * @generated from field: string label = 2;
+     */
+    label: string;
+    /**
+     * The machine the process runs on, as its OS names it; empty when the OS
+     * reports none.
+     *
+     * @generated from field: string host = 3;
+     */
+    host: string;
+    /**
+     * The `[worker] kinds` configuration this process claims: `"all"` or a
+     * comma-joined kind list.
+     *
+     * @generated from field: string kinds = 4;
+     */
+    kinds: string;
+    /**
+     * @generated from field: string started_at = 5;
+     */
+    startedAt: string;
+    /**
+     * @generated from field: string last_seen_at = 6;
+     */
+    lastSeenAt: string;
+    /**
+     * The claim loop's lifecycle state, exactly as the `workers.state` row
+     * carries it: `warming` (the process is preloading; nothing claimed yet),
+     * `claiming` (the loop is live), `draining` (a DRAIN is finishing the
+     * in-flight job). The row is deleted once the loop has exited.
+     *
+     * @generated from field: string state = 7;
+     */
+    state: string;
+    /**
+     * This worker's device inventory, as `workers.devices` carries it
+     * (`jammi_db::catalog::jobs_repo::WorkerRecord::devices`) — a MIRROR of
+     * the process's own registration, informational only (never the
+     * placement policy's authority).
+     *
+     * @generated from field: repeated jammi.v1.job.DeviceFact devices = 8;
+     */
+    devices: DeviceFact[];
+};
+/**
+ * Describes the message jammi.v1.job.WorkerSummary.
+ * Use `create(WorkerSummarySchema)` to create a new message.
+ */
+export declare const WorkerSummarySchema: GenMessage<WorkerSummary>;
+/**
+ * One device a worker process names as its own: a KIND (`"cpu"` / `"cuda"`
+ * / `"metal"`, opaque here) and its ORDINAL within that kind. Mirrors
+ * `jammi_db::catalog::instance::DeviceFact` field for field.
+ *
+ * @generated from message jammi.v1.job.DeviceFact
+ */
+export type DeviceFact = Message<"jammi.v1.job.DeviceFact"> & {
+    /**
+     * @generated from field: string kind = 1;
+     */
+    kind: string;
+    /**
+     * @generated from field: uint32 ordinal = 2;
+     */
+    ordinal: number;
+};
+/**
+ * Describes the message jammi.v1.job.DeviceFact.
+ * Use `create(DeviceFactSchema)` to create a new message.
+ */
+export declare const DeviceFactSchema: GenMessage<DeviceFact>;
+/**
+ * @generated from message jammi.v1.job.PruneJobsRequest
+ */
+export type PruneJobsRequest = Message<"jammi.v1.job.PruneJobsRequest"> & {};
+/**
+ * Describes the message jammi.v1.job.PruneJobsRequest.
+ * Use `create(PruneJobsRequestSchema)` to create a new message.
+ */
+export declare const PruneJobsRequestSchema: GenMessage<PruneJobsRequest>;
+/**
+ * @generated from message jammi.v1.job.PruneJobsResponse
+ */
+export type PruneJobsResponse = Message<"jammi.v1.job.PruneJobsResponse"> & {
+    /**
+     * Count of terminal job rows deleted by this call.
+     *
+     * @generated from field: uint64 jobs_deleted = 1;
+     */
+    jobsDeleted: bigint;
+};
+/**
+ * Describes the message jammi.v1.job.PruneJobsResponse.
+ * Use `create(PruneJobsResponseSchema)` to create a new message.
+ */
+export declare const PruneJobsResponseSchema: GenMessage<PruneJobsResponse>;
+/**
+ * JobService — the wire surface over the engine's durable job queue
+ * (`jobs`/`instances`/`workers`, migration 029; `jammi_ai::jobs`).
+ *
+ * `SubmitJob`, `JobStatus`, `WaitJob`, `ListJobs`, `CancelJob`, and
+ * `ListWorkers` are imperative session methods, not SQL queries, so they live
+ * as typed gRPC RPCs alongside CatalogService / EmbeddingService /
+ * InferenceService / PipelineService / EvalService rather than on the Flight
+ * SQL surface (which carries query/result only).
+ *
+ * `JobService` is the kind-agnostic durable job abstraction every compute
+ * verb submits through INTERNALLY
+ * (`jammi_ai::jobs`, `InferenceSession::run_now`) — but `SubmitJob` itself
+ * carries only the three training-kind spec variants (the `oneof`): every
+ * other compute verb is SYNCHRONOUS on the wire today. Each keeps its own
+ * dedicated request AND response message on its own service (e.g.
+ * `PipelineService.BuildNeighborGraph` returns `jammi.v1.embedding.ResultTable`
+ * directly) rather than going through `SubmitJobResponse`, so this service's
+ * `JobStatus`/`WaitJob` never has a compute-kind row to answer for over the
+ * wire (the terminal payload read back is byte-identical to what a `jobs`
+ * row of the same kind would resolve to, since both paths run through the
+ * same `execute_compute` dispatcher). The service reimplements no training,
+ * LoRA, sampling, scan, or compute-verb logic; it is purely a wire adapter
+ * over `jammi_ai::jobs`.
+ *
+ * Tenant scope is read from the request's `SessionTenant` extension, set by
+ * the single async tenant-binding layer driven by the engine's
+ * `TenantResolver` (default: the `jammi-session-id` header → shared session
+ * store) — the one mechanism every gRPC service and Flight SQL bind through.
+ * A job row carries the submitting tenant; a peer names an unresolvable job
+ * id — `JobStatus`/`WaitJob`/`CancelJob` answer `NOT_FOUND`, never
+ * `PERMISSION_DENIED` (matching every other tenant-scoped read in this
+ * codebase — a wrong tenant learns nothing about whether the id exists at
+ * all). `ListWorkers` reports process/fleet liveness, not a tenant-owned
+ * resource, so it carries no per-tenant filter (control-plane allowlisted in
+ * `tenant_isolation_oracle.rs`, alongside `GetServerInfo`). Every OTHER rpc on
+ * this service — including `PruneJobs` — IS tenant-scoped: there is no
+ * exemption for a maintenance verb — it is tenant-scoped like every other
+ * job RPC.
+ *
+ * @generated from service jammi.v1.job.JobService
+ */
+export declare const JobService: GenService<{
+    /**
+     * Submit a training job (`fine_tune` / `graph_fine_tune` /
+     * `context_predictor`) and return its durable handle. The job is always
+     * accepted and stays `queued` until a worker claims it (or, embedded-side,
+     * until `run_now` claims and executes it inline) — there is no `NoWorker`
+     * refusal. `output_model_id` is populated via the same `resolve_model_id`
+     * rule the embedded `TrainingJob` handle uses, so a remote caller reads the
+     * byte-identical deterministic id at submit time. A second `SubmitJob` call
+     * carrying the same `idempotency_key` (when non-empty) returns the handle
+     * of the job that key first created rather than submitting a duplicate.
+     *
+     * @generated from rpc jammi.v1.job.JobService.SubmitJob
+     */
+    submitJob: {
+        methodKind: "unary";
+        input: typeof SubmitJobRequestSchema;
+        output: typeof SubmitJobResponseSchema;
+    };
+    /**
+     * Read a job's current status by id: lifecycle status, kind, progress,
+     * failure message, and — once terminal — the tagged result and (for a
+     * training kind) the acceleration-report blob. Peer of reading back the
+     * embedded `JobHandle`.
+     *
+     * @generated from rpc jammi.v1.job.JobService.JobStatus
+     */
+    jobStatus: {
+        methodKind: "unary";
+        input: typeof JobStatusRequestSchema;
+        output: typeof JobStatusResponseSchema;
+    };
+    /**
+     * Stream status updates for one job until it reaches a terminal state, then
+     * end the stream after emitting the terminal frame. Polls the job row every
+     * 100ms server-side; a client disconnect ends only that wait (the job keeps
+     * running) — reconnecting with the same job id resumes the wait and, if the
+     * job has already gone terminal, immediately receives the same terminal
+     * frame `JobStatus` would report.
+     *
+     * @generated from rpc jammi.v1.job.JobService.WaitJob
+     */
+    waitJob: {
+        methodKind: "server_streaming";
+        input: typeof JobHandleSchema;
+        output: typeof JobEventSchema;
+    };
+    /**
+     * List jobs visible to the session tenant, most recent first. Each row is
+     * the same lifecycle projection `JobStatus` reads (status, kind, output
+     * model id, failure error) plus the submit-time identity (base model,
+     * creation time) — a listing of `JobStatus` answers, not a progress
+     * surface.
+     *
+     * @generated from rpc jammi.v1.job.JobService.ListJobs
+     */
+    listJobs: {
+        methodKind: "unary";
+        input: typeof ListJobsRequestSchema;
+        output: typeof ListJobsResponseSchema;
+    };
+    /**
+     * Request cancellation of a job by id. Idempotent: cancelling an
+     * already-terminal or already-cancel-requested job still returns
+     * successfully (`cancelled = false` when the request had no effect — the
+     * job was already terminal). The executor checks the flag at its next
+     * checkpoint; cancellation is therefore cooperative, not immediate.
+     *
+     * @generated from rpc jammi.v1.job.JobService.CancelJob
+     */
+    cancelJob: {
+        methodKind: "unary";
+        input: typeof CancelJobRequestSchema;
+        output: typeof CancelJobResponseSchema;
+    };
+    /**
+     * List the engine processes currently running the claim loop
+     * (`[worker] enabled = true`), most recently seen first. Fleet/liveness
+     * metadata, not a tenant-owned resource — see the service doc.
+     *
+     * @generated from rpc jammi.v1.job.JobService.ListWorkers
+     */
+    listWorkers: {
+        methodKind: "unary";
+        input: typeof ListWorkersRequestSchema;
+        output: typeof ListWorkersResponseSchema;
+    };
+    /**
+     * Eagerly delete the CALLER's own terminal (`completed`/`failed`) job rows
+     * older than the deployment's `[jobs] retention_days` — tenant-scoped like
+     * every other rpc here (never a peer tenant's terminal rows, however old);
+     * this RPC only makes that on-demand (e.g. `jammi jobs prune`). Distinct
+     * from the process's construction-time sweep, which is not an rpc: it runs
+     * once per process boot, before any request is tenant-scoped, and stays
+     * global by design (see `InferenceSession::wrap`'s doc) — there is no
+     * periodic background sweep besides that one-shot boot pass.
+     *
+     * @generated from rpc jammi.v1.job.JobService.PruneJobs
+     */
+    pruneJobs: {
+        methodKind: "unary";
+        input: typeof PruneJobsRequestSchema;
+        output: typeof PruneJobsResponseSchema;
+    };
+}>;
+//# sourceMappingURL=job_pb.d.ts.map