@lostgradient/weft 0.17.0 → 0.19.0

package/dist/server/operations/get-worker-diagnostics.d.ts

@@ -0,0 +1,177 @@
+/**
+ * `weft.workers.diagnostics` operation + REST binding.
+ *
+ * Bounded diagnostic detail for one connected worker (WFT-29), split into
+ * two structurally distinct sub-objects: `instance` (this live socket —
+ * queue, health, connection timestamps) and `deploymentVersion` (what
+ * artifact it loaded — SDK/runtime identity, manifest digest, and every
+ * advertised workflow's version/revision/contract hash). Keeping these
+ * separate mirrors the manifest's own split between "which process" and
+ * "which build" questions.
+ *
+ * Deliberately excludes `capabilities` and the raw payload schemas backing
+ * each `contractHash` — this surfaces identity for drift detection, not a
+ * schema dump.
+ *
+ * @module server/operations/get-worker-diagnostics
+ */
+import { z } from 'zod';
+import type { WorkerHealth, WorkerRegistry } from '../../worker/registry.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const workerDiagnosticsEntrySchema: z.ZodObject<{
+    instance: z.ZodObject<{
+        workerId: z.ZodString;
+        queue: z.ZodString;
+        health: z.ZodType<WorkerHealth, unknown, z.core.$ZodTypeInternals<WorkerHealth, unknown>>;
+        connectedAt: z.ZodNumber;
+        startedAt: z.ZodNumber;
+        lastHeartbeatAt: z.ZodNumber;
+        heartbeatAgeMs: z.ZodNumber;
+    }, z.core.$strict>;
+    deploymentVersion: z.ZodObject<{
+        deploymentName: z.ZodString;
+        buildId: z.ZodString;
+        artifactDigest: z.ZodString;
+        runtimeName: z.ZodString;
+        runtimeVersion: z.ZodString;
+        sdkVersion: z.ZodString;
+        manifestVersion: z.ZodNumber;
+        protocolVersion: z.ZodNumber;
+        manifestDigest: z.ZodString;
+        workflows: z.ZodRecord<z.ZodString, z.ZodObject<{
+            workflowVersion: z.ZodString;
+            workflowRevision: z.ZodString;
+            contractHash: z.ZodString;
+            activities: z.ZodRecord<z.ZodString, z.ZodObject<{
+                contractHash: z.ZodString;
+                implementationRevision: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+declare const getWorkerDiagnosticsInput: z.ZodObject<{
+    workerId: z.ZodString;
+}, z.core.$strip>;
+declare const getWorkerDiagnosticsOutput: z.ZodObject<{
+    worker: z.ZodNullable<z.ZodObject<{
+        instance: z.ZodObject<{
+            workerId: z.ZodString;
+            queue: z.ZodString;
+            health: z.ZodType<WorkerHealth, unknown, z.core.$ZodTypeInternals<WorkerHealth, unknown>>;
+            connectedAt: z.ZodNumber;
+            startedAt: z.ZodNumber;
+            lastHeartbeatAt: z.ZodNumber;
+            heartbeatAgeMs: z.ZodNumber;
+        }, z.core.$strict>;
+        deploymentVersion: z.ZodObject<{
+            deploymentName: z.ZodString;
+            buildId: z.ZodString;
+            artifactDigest: z.ZodString;
+            runtimeName: z.ZodString;
+            runtimeVersion: z.ZodString;
+            sdkVersion: z.ZodString;
+            manifestVersion: z.ZodNumber;
+            protocolVersion: z.ZodNumber;
+            manifestDigest: z.ZodString;
+            workflows: z.ZodRecord<z.ZodString, z.ZodObject<{
+                workflowVersion: z.ZodString;
+                workflowRevision: z.ZodString;
+                contractHash: z.ZodString;
+                activities: z.ZodRecord<z.ZodString, z.ZodObject<{
+                    contractHash: z.ZodString;
+                    implementationRevision: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+export type GetWorkerDiagnosticsInput = z.infer<typeof getWorkerDiagnosticsInput>;
+export type WorkerDiagnosticsEntry = z.infer<typeof workerDiagnosticsEntrySchema>;
+export type GetWorkerDiagnosticsOutput = z.infer<typeof getWorkerDiagnosticsOutput>;
+type GetWorkerDiagnosticsOptions = {
+    workerRegistry?: WorkerRegistry;
+    clock?: () => number;
+};
+/**
+ * Build the `weft.workers.diagnostics` operation, optionally bound to a live
+ * `WorkerRegistry` and clock. Mirrors `createListWorkersOperation`'s
+ * discovery-only fallback: when `workerRegistry` is omitted, `invoke` throws
+ * if reached — reserved for discovery-only registries (OpenAPI/AsyncAPI).
+ */
+export declare function createGetWorkerDiagnosticsOperation(options?: GetWorkerDiagnosticsOptions): import("../operation-catalog.ts").OperationDefinition<{
+    workerId: string;
+}, {
+    worker: {
+        instance: {
+            workerId: string;
+            queue: string;
+            health: WorkerHealth;
+            connectedAt: number;
+            startedAt: number;
+            lastHeartbeatAt: number;
+            heartbeatAgeMs: number;
+        };
+        deploymentVersion: {
+            deploymentName: string;
+            buildId: string;
+            artifactDigest: string;
+            runtimeName: string;
+            runtimeVersion: string;
+            sdkVersion: string;
+            manifestVersion: number;
+            protocolVersion: number;
+            manifestDigest: string;
+            workflows: Record<string, {
+                workflowVersion: string;
+                workflowRevision: string;
+                contractHash: string;
+                activities: Record<string, {
+                    contractHash: string;
+                    implementationRevision: string;
+                }>;
+            }>;
+        };
+    } | null;
+}, unknown>;
+/** Default discovery-only operation; live servers use `createGetWorkerDiagnosticsOperation(...)`. */
+export declare const getWorkerDiagnosticsOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workerId: string;
+}, {
+    worker: {
+        instance: {
+            workerId: string;
+            queue: string;
+            health: WorkerHealth;
+            connectedAt: number;
+            startedAt: number;
+            lastHeartbeatAt: number;
+            heartbeatAgeMs: number;
+        };
+        deploymentVersion: {
+            deploymentName: string;
+            buildId: string;
+            artifactDigest: string;
+            runtimeName: string;
+            runtimeVersion: string;
+            sdkVersion: string;
+            manifestVersion: number;
+            protocolVersion: number;
+            manifestDigest: string;
+            workflows: Record<string, {
+                workflowVersion: string;
+                workflowRevision: string;
+                contractHash: string;
+                activities: Record<string, {
+                    contractHash: string;
+                    implementationRevision: string;
+                }>;
+            }>;
+        };
+    } | null;
+}, unknown>;
+/**
+ * Build the REST binding for `weft.workers.diagnostics`. The binding is
+ * metadata only; the live `WorkerRegistry` is wired into the operation.
+ */
+export declare function createGetWorkerDiagnosticsRestBinding(): UnknownRestBinding;
+export {};

package/dist/server/operations/get-worker-diagnostics.js

@@ -0,0 +1,117 @@
+import { z } from "zod";
+import { shapeOperationFaultAsJson } from "../operation-fault.js";
+import { defineOperation } from "../operation-registry.js";
+const workerHealthSchema = z.enum(["active", "draining", "drained"]), workerActivityContractSchema = z.object({
+  contractHash: z.string(),
+  implementationRevision: z.string()
+}).strict(), workerWorkflowContractSummarySchema = z.object({
+  workflowVersion: z.string(),
+  workflowRevision: z.string(),
+  contractHash: z.string(),
+  activities: z.record(z.string(), workerActivityContractSchema)
+}).strict(), workerInstanceIdentitySchema = z.object({
+  workerId: z.string(),
+  queue: z.string(),
+  health: workerHealthSchema,
+  connectedAt: z.number(),
+  startedAt: z.number(),
+  lastHeartbeatAt: z.number(),
+  heartbeatAgeMs: z.number()
+}).strict(), workerDeploymentVersionIdentitySchema = z.object({
+  deploymentName: z.string(),
+  buildId: z.string(),
+  artifactDigest: z.string(),
+  runtimeName: z.string(),
+  runtimeVersion: z.string(),
+  sdkVersion: z.string(),
+  manifestVersion: z.number(),
+  protocolVersion: z.number(),
+  manifestDigest: z.string(),
+  workflows: z.record(z.string(), workerWorkflowContractSummarySchema)
+}).strict(), workerDiagnosticsEntrySchema = z.object({
+  instance: workerInstanceIdentitySchema,
+  deploymentVersion: workerDeploymentVersionIdentitySchema
+}).strict(), getWorkerDiagnosticsInput = z.object({
+  workerId: z.string().min(1)
+}), getWorkerDiagnosticsOutput = z.object({
+  worker: workerDiagnosticsEntrySchema.nullable()
+});
+function projectWorkerDiagnostics(registry, workerId, now) {
+  const worker = registry.getWorker(workerId);
+  if (worker === void 0)
+    return null;
+  const summary = registry.getWorkerSummaries(now).find((entry) => entry.id === workerId);
+  if (summary === void 0)
+    return null;
+  const workflows = {};
+  for (const [workflowType, contract] of Object.entries(worker.manifest.workflows))
+    workflows[workflowType] = {
+      workflowVersion: contract.workflowVersion,
+      workflowRevision: contract.workflowRevision,
+      contractHash: contract.contractHash,
+      activities: { ...contract.activities }
+    };
+  return {
+    instance: {
+      workerId: worker.id,
+      queue: worker.queue,
+      health: summary.health,
+      connectedAt: worker.connectedAt,
+      startedAt: worker.startedAt,
+      lastHeartbeatAt: worker.lastHeartbeat,
+      heartbeatAgeMs: summary.heartbeatAgeMs
+    },
+    deploymentVersion: {
+      deploymentName: worker.manifest.deployment.name,
+      buildId: worker.manifest.deployment.buildId,
+      artifactDigest: worker.manifest.deployment.artifactDigest,
+      runtimeName: worker.manifest.runtime.name,
+      runtimeVersion: worker.manifest.runtime.version,
+      sdkVersion: worker.manifest.sdkVersion,
+      manifestVersion: worker.manifest.manifestVersion,
+      protocolVersion: worker.manifest.protocolVersion,
+      manifestDigest: worker.acceptedManifestDigest,
+      workflows
+    }
+  };
+}
+export function createGetWorkerDiagnosticsOperation(options = {}) {
+  const registry = options.workerRegistry, clock = options.clock ?? Date.now;
+  return defineOperation({
+    name: "weft.workers.diagnostics",
+    mcpExposable: !1,
+    summary: "Get bounded instance and deployment-version diagnostics for one connected worker",
+    description: "Report one connected worker's identity split into two parts: `instance` (this live " + "connection \u2014 queue, health, connection timestamps) and `deploymentVersion` (the " + "artifact it loaded \u2014 SDK/runtime identity, manifest digest, and every advertised " + "workflow's version, revision, and contract hash). Returns `worker: null` when the workerId is not currently connected. Excludes capabilities and raw payload schemas.",
+    destructive: !1,
+    tags: ["Observability"],
+    inputSchema: getWorkerDiagnosticsInput,
+    outputSchema: getWorkerDiagnosticsOutput,
+    access: { kind: "scoped", scopes: { kind: "anyOf", scopes: ["system:read"] } },
+    producibleFaults: [],
+    discoverable: !0,
+    transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+    unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+    invoke: async ({ input }) => {
+      if (registry === void 0)
+        throw Error("weft.workers.diagnostics invoked from a discovery-only operation registry; no WorkerRegistry was wired in");
+      return { worker: projectWorkerDiagnostics(registry, input.workerId, clock()) };
+    }
+  });
+}
+export const getWorkerDiagnosticsOperation = createGetWorkerDiagnosticsOperation();
+export function createGetWorkerDiagnosticsRestBinding() {
+  return {
+    method: "GET",
+    path: "/v1/workers/:workerId/diagnostics",
+    pathParamNames: ["workerId"],
+    operationName: "weft.workers.diagnostics",
+    inputSources: {
+      workerId: { kind: "path", pathParam: "workerId" }
+    },
+    extractInput: async (_request, pathParams) => ({
+      workerId: pathParams.workerId ?? ""
+    }),
+    success: { kind: "json", status: 200 },
+    shapeFault: shapeOperationFaultAsJson
+  };
+}

package/dist/server/operations/list-worker-registration-rejections.d.ts

@@ -0,0 +1,79 @@
+/**
+ * `weft.workers.rejections` operation + REST binding.
+ *
+ * Bounded, auditable log of recently declined `register` attempts (WFT-29):
+ * the rejection code, the attempted workerId when known, and whatever
+ * deployment/queue identity had already been parsed by the time the gate
+ * that rejected it ran. No free-text rejection message and no manifest
+ * content — this surfaces "who got rejected, when, and why (by code)", not
+ * a diagnostic dump.
+ *
+ * @module server/operations/list-worker-registration-rejections
+ */
+import { z } from 'zod';
+import type { WorkerRegistry } from '../../worker/registry.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const listWorkerRegistrationRejectionsInput: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+declare const listWorkerRegistrationRejectionsOutput: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            invalid_registration: "invalid_registration";
+            unsupported_protocol_version: "unsupported_protocol_version";
+            deployment_conflict: "deployment_conflict";
+            registration_rejected: "registration_rejected";
+        }>;
+        workerId: z.ZodOptional<z.ZodString>;
+        rejectedAt: z.ZodNumber;
+        queue: z.ZodOptional<z.ZodString>;
+        deploymentName: z.ZodOptional<z.ZodString>;
+        buildId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    limit: z.ZodNumber;
+}, z.core.$strip>;
+export type ListWorkerRegistrationRejectionsInput = z.infer<typeof listWorkerRegistrationRejectionsInput>;
+export type ListWorkerRegistrationRejectionsOutput = z.infer<typeof listWorkerRegistrationRejectionsOutput>;
+type ListWorkerRegistrationRejectionsOptions = {
+    workerRegistry?: WorkerRegistry;
+};
+/**
+ * Build the `weft.workers.rejections` operation, optionally bound to a live
+ * `WorkerRegistry`. Mirrors `createListWorkersOperation`'s discovery-only
+ * fallback: when `workerRegistry` is omitted, `invoke` throws if reached —
+ * reserved for discovery-only registries (OpenAPI/AsyncAPI).
+ */
+export declare function createListWorkerRegistrationRejectionsOperation(options?: ListWorkerRegistrationRejectionsOptions): import("../operation-catalog.ts").OperationDefinition<{
+    limit: number;
+}, {
+    items: {
+        code: "invalid_registration" | "unsupported_protocol_version" | "deployment_conflict" | "registration_rejected";
+        rejectedAt: number;
+        workerId?: string | undefined;
+        queue?: string | undefined;
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+    }[];
+    limit: number;
+}, unknown>;
+/** Default discovery-only operation; live servers use `createListWorkerRegistrationRejectionsOperation(...)`. */
+export declare const listWorkerRegistrationRejectionsOperation: import("../operation-catalog.ts").OperationDefinition<{
+    limit: number;
+}, {
+    items: {
+        code: "invalid_registration" | "unsupported_protocol_version" | "deployment_conflict" | "registration_rejected";
+        rejectedAt: number;
+        workerId?: string | undefined;
+        queue?: string | undefined;
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+    }[];
+    limit: number;
+}, unknown>;
+/**
+ * Build the REST binding for `weft.workers.rejections`. The
+ * binding is metadata only; the live `WorkerRegistry` is wired into the
+ * operation, not the binding.
+ */
+export declare function createListWorkerRegistrationRejectionsRestBinding(): UnknownRestBinding;
+export {};

package/dist/server/operations/list-worker-registration-rejections.js

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-registry.js";
+const DEFAULT_LIMIT = 20, MAX_LIMIT = 100, registrationRejectionCodeSchema = z.enum([
+  "invalid_registration",
+  "unsupported_protocol_version",
+  "deployment_conflict",
+  "registration_rejected"
+]), registrationRejectionEntrySchema = z.object({
+  code: registrationRejectionCodeSchema,
+  workerId: z.string().optional(),
+  rejectedAt: z.number(),
+  queue: z.string().optional(),
+  deploymentName: z.string().optional(),
+  buildId: z.string().optional()
+}).strict(), listWorkerRegistrationRejectionsInput = z.object({
+  limit: z.number().int().min(1).max(MAX_LIMIT).default(DEFAULT_LIMIT)
+}), listWorkerRegistrationRejectionsOutput = z.object({
+  items: z.array(registrationRejectionEntrySchema),
+  limit: z.number().int().min(1).max(MAX_LIMIT)
+});
+export function createListWorkerRegistrationRejectionsOperation(options = {}) {
+  const registry = options.workerRegistry;
+  return defineOperation({
+    name: "weft.workers.rejections",
+    mcpExposable: !1,
+    summary: "List recently declined worker registration attempts",
+    description: "Bounded, most-recent-first log of declined `register` attempts: rejection code, attempted workerId when known, and whatever deployment/queue identity had already been parsed by the time the rejecting gate ran. No free-text message and no manifest content.",
+    destructive: !1,
+    tags: ["Observability"],
+    inputSchema: listWorkerRegistrationRejectionsInput,
+    outputSchema: listWorkerRegistrationRejectionsOutput,
+    access: { kind: "scoped", scopes: { kind: "anyOf", scopes: ["system:read"] } },
+    producibleFaults: [],
+    discoverable: !0,
+    transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+    unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+    invoke: async ({ input }) => {
+      if (registry === void 0)
+        throw Error("weft.workers.rejections invoked from a discovery-only operation registry; no WorkerRegistry was wired in");
+      return { items: registry.getRecentRejections(input.limit), limit: input.limit };
+    }
+  });
+}
+export const listWorkerRegistrationRejectionsOperation = createListWorkerRegistrationRejectionsOperation();
+export function createListWorkerRegistrationRejectionsRestBinding() {
+  return {
+    method: "GET",
+    path: "/v1/workers/registration-rejections",
+    pathParamNames: [],
+    operationName: "weft.workers.rejections",
+    inputSources: {
+      limit: { kind: "query", queryParam: "limit" }
+    },
+    extractInput: async (request) => {
+      const limit = new URL(request.url).searchParams.get("limit");
+      return { limit: limit === null || limit.length === 0 ? void 0 : Number(limit) };
+    },
+    success: { kind: "json", status: 200 }
+  };
+}

package/dist/server/operations/list-workers.js

@@ -27,13 +27,11 @@ const listWorkersInput = z.object({}), routingPolicySchema = z.enum([
   health: workerHealthSchema,
   deploymentName: z.string().optional(),
   buildId: z.string().optional(),
-  runtimeVersion: z.string().optional(),
-  gitSha: z.string().optional()
+  runtimeVersion: z.string().optional()
 }), workerDeploymentSummarySchema = z.object({
   deploymentName: z.string().nullable(),
   buildId: z.string().nullable(),
   runtimeVersion: z.string().nullable(),
-  gitSha: z.string().nullable(),
   health: workerHealthSchema,
   workers: z.number(),
   activeWorkers: z.number(),

package/dist/server/operations/static-registrations.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Static operation and REST-binding registrations — every operation that
+ * needs no per-server configuration, in one place.
+ *
+ * `rest-bindings.ts` composes these arrays with the per-server factory
+ * operations (metrics, workers, task queues, diagnostics) to build the live
+ * registry and binding set. Adding a new statically-configured operation
+ * means adding its import and two array entries HERE; `rest-bindings.ts`
+ * itself only changes when an operation needs per-server wiring.
+ *
+ * @module server/operations/static-registrations
+ */
+import type { RegistrableOperation } from '../operation-catalog.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+/**
+ * Static REST bindings for all operations that do not need per-server
+ * configuration. `rest-bindings.ts` re-exports this as `REST_BINDINGS` and
+ * appends the per-server factory bindings in `createLiveRestBindings()`.
+ */
+export declare const STATIC_REST_BINDINGS: ReadonlyArray<UnknownRestBinding>;
+/**
+ * Statically-configured operations, in registration order.
+ * `rest-bindings.ts`'s `createLiveOperationRegistry()` appends the
+ * per-server factory operations (metrics, workers, task queues,
+ * diagnostics); the registry is keyed by operation name, so relative
+ * order carries no behavior.
+ */
+export declare const STATIC_OPERATIONS: ReadonlyArray<RegistrableOperation>;