@lostgradient/weft 0.19.0 → 0.20.0

package/dist/server/operations/get-task-detail.d.ts

@@ -0,0 +1,346 @@
+/**
+ * `weft.tasks.get` operation + REST binding (WFT-92).
+ *
+ * Reads the full durable ledger state for one `operationId` — the wire
+ * counterpart to `WeftServer.getTaskResult()`, which is same-process-only
+ * (`src/server/runtime/task-result-view.ts`). This operation exposes the
+ * complete dispatch envelope and current ledger state so an HTTP/JSON-RPC
+ * caller — an operator console, for instance — can render one task's
+ * authoritative state without reconstructing it from the bounded
+ * `weft.tasks.diagnostics` alerting shape, which deliberately collapses
+ * `leased`/`completing`/`cancelling` into one `inflight` value and carries
+ * no attempt identity, priority, headers, retry-availability, adoption, or
+ * retention evidence.
+ *
+ * **Excluded fields.** `attemptToken`, `workerSessionId`, and
+ * `executionIdentity` are never projected here, matching
+ * `TaskResultView`'s own documented exclusion list — they are worker
+ * ownership/session internals with no business being public. `headers`
+ * are summarized as key names only (`headerKeys`): interceptor headers can
+ * carry trace context or auth material, and this is a read surface, not a
+ * payload inspector. The task `input` value and a dead-lettered record's
+ * pending result `value` are omitted for the same "digest not value"
+ * reason `TaskResultView` omits a resolved result's value — the ledger
+ * proves which attempt won, it does not re-deliver payloads. `resultDigest`
+ * is only projected for `disposition: 'resolved'`: the `cancelled`
+ * (mid-attempt) and `retryExhausted` lineages store a synthetic
+ * `${disposition}:${operationId}:${attemptToken}` placeholder there instead
+ * of a real content hash (`task-ledger-transitions(-cancellation).ts`),
+ * which would otherwise leak the excluded `attemptToken` verbatim.
+ *
+ * **Read-only by design.** This issue deliberately does not add an HTTP
+ * path to `adoptTaskResultImpl`. WFT-24 describes adoption as "an explicit
+ * caller assertion" that a workflow incorporated a result — a browser
+ * operator clicking a button cannot honestly make that assertion. If an
+ * HTTP adoption path is ever wanted, it needs its own design discussion,
+ * not a bundled addition here.
+ *
+ * @module server/operations/get-task-detail
+ */
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+export { executionRequirementSchema, getTaskDetailOutputSchema, retryPolicySchema, type GetTaskDetailInput, type GetTaskDetailOutput, } from './get-task-detail-schema.ts';
+export declare const getTaskDetailOperation: import("../operation-catalog.ts").OperationDefinition<{
+    operationId: string;
+}, {
+    disposition: "resolved";
+    resultDigest: string;
+    resultStatus: "completed" | "failed";
+    state: "terminal";
+    terminalAt: number;
+    adopted: boolean;
+    operationId: string;
+    workflowType: string;
+    activityName: string;
+    queue: string;
+    headerKeys: string[];
+    visibilityTimeoutMilliseconds: number;
+    createdAt: number;
+    attempt: number;
+    error?: string | undefined;
+    adoptedAt?: number | undefined;
+    workflowId?: string | undefined;
+    workflowExecutionToken?: string | undefined;
+    priority?: number | undefined;
+    retryPolicy?: {
+        maxAttempts: number;
+        initialBackoff: string | number;
+        backoffMultiplier: number;
+        maxBackoff: string | number;
+        nonRetryableErrors?: string[] | undefined;
+    } | undefined;
+    scheduleToCloseDeadline?: number | undefined;
+    executionRequirement?: {
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+        artifactDigest?: string | undefined;
+        workflowRevision?: string | undefined;
+        activityContractHash?: string | undefined;
+    } | undefined;
+    fairShareKey?: string | undefined;
+    stickyWorkflowId?: string | undefined;
+} | {
+    disposition: "cancelled";
+    cancellationReason: string;
+    state: "terminal";
+    terminalAt: number;
+    adopted: boolean;
+    operationId: string;
+    workflowType: string;
+    activityName: string;
+    queue: string;
+    headerKeys: string[];
+    visibilityTimeoutMilliseconds: number;
+    createdAt: number;
+    attempt: number;
+    adoptedAt?: number | undefined;
+    workflowId?: string | undefined;
+    workflowExecutionToken?: string | undefined;
+    priority?: number | undefined;
+    retryPolicy?: {
+        maxAttempts: number;
+        initialBackoff: string | number;
+        backoffMultiplier: number;
+        maxBackoff: string | number;
+        nonRetryableErrors?: string[] | undefined;
+    } | undefined;
+    scheduleToCloseDeadline?: number | undefined;
+    executionRequirement?: {
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+        artifactDigest?: string | undefined;
+        workflowRevision?: string | undefined;
+        activityContractHash?: string | undefined;
+    } | undefined;
+    fairShareKey?: string | undefined;
+    stickyWorkflowId?: string | undefined;
+} | {
+    disposition: "retryExhausted";
+    error: string;
+    state: "terminal";
+    terminalAt: number;
+    adopted: boolean;
+    operationId: string;
+    workflowType: string;
+    activityName: string;
+    queue: string;
+    headerKeys: string[];
+    visibilityTimeoutMilliseconds: number;
+    createdAt: number;
+    attempt: number;
+    adoptedAt?: number | undefined;
+    workflowId?: string | undefined;
+    workflowExecutionToken?: string | undefined;
+    priority?: number | undefined;
+    retryPolicy?: {
+        maxAttempts: number;
+        initialBackoff: string | number;
+        backoffMultiplier: number;
+        maxBackoff: string | number;
+        nonRetryableErrors?: string[] | undefined;
+    } | undefined;
+    scheduleToCloseDeadline?: number | undefined;
+    executionRequirement?: {
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+        artifactDigest?: string | undefined;
+        workflowRevision?: string | undefined;
+        activityContractHash?: string | undefined;
+    } | undefined;
+    fairShareKey?: string | undefined;
+    stickyWorkflowId?: string | undefined;
+} | {
+    state: "queued";
+    availableAt: number;
+    firstQueuedAt: number;
+    lastQueuedAt: number;
+    retryCount: number;
+    requeueCount: number;
+    operationId: string;
+    workflowType: string;
+    activityName: string;
+    queue: string;
+    headerKeys: string[];
+    visibilityTimeoutMilliseconds: number;
+    createdAt: number;
+    attempt: number;
+    lastDispatchedAt?: number | undefined;
+    startedAt?: number | undefined;
+    lastRequeueReason?: string | undefined;
+    workflowId?: string | undefined;
+    workflowExecutionToken?: string | undefined;
+    priority?: number | undefined;
+    retryPolicy?: {
+        maxAttempts: number;
+        initialBackoff: string | number;
+        backoffMultiplier: number;
+        maxBackoff: string | number;
+        nonRetryableErrors?: string[] | undefined;
+    } | undefined;
+    scheduleToCloseDeadline?: number | undefined;
+    executionRequirement?: {
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+        artifactDigest?: string | undefined;
+        workflowRevision?: string | undefined;
+        activityContractHash?: string | undefined;
+    } | undefined;
+    fairShareKey?: string | undefined;
+    stickyWorkflowId?: string | undefined;
+} | {
+    leaseDeadline: number;
+    firstQueuedAt: number;
+    lastQueuedAt: number;
+    startedAt: number;
+    lastHeartbeatAt: number;
+    state: "leased";
+    retryCount: number;
+    requeueCount: number;
+    operationId: string;
+    workflowType: string;
+    activityName: string;
+    queue: string;
+    headerKeys: string[];
+    visibilityTimeoutMilliseconds: number;
+    createdAt: number;
+    attempt: number;
+    lastRequeueReason?: string | undefined;
+    workflowId?: string | undefined;
+    workflowExecutionToken?: string | undefined;
+    priority?: number | undefined;
+    retryPolicy?: {
+        maxAttempts: number;
+        initialBackoff: string | number;
+        backoffMultiplier: number;
+        maxBackoff: string | number;
+        nonRetryableErrors?: string[] | undefined;
+    } | undefined;
+    scheduleToCloseDeadline?: number | undefined;
+    executionRequirement?: {
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+        artifactDigest?: string | undefined;
+        workflowRevision?: string | undefined;
+        activityContractHash?: string | undefined;
+    } | undefined;
+    fairShareKey?: string | undefined;
+    stickyWorkflowId?: string | undefined;
+} | {
+    pendingStatus: "completed" | "failed";
+    resultDigest: string;
+    leaseDeadline: number;
+    firstQueuedAt: number;
+    lastQueuedAt: number;
+    startedAt: number;
+    lastHeartbeatAt: number;
+    state: "completing";
+    retryCount: number;
+    requeueCount: number;
+    operationId: string;
+    workflowType: string;
+    activityName: string;
+    queue: string;
+    headerKeys: string[];
+    visibilityTimeoutMilliseconds: number;
+    createdAt: number;
+    attempt: number;
+    lastRequeueReason?: string | undefined;
+    workflowId?: string | undefined;
+    workflowExecutionToken?: string | undefined;
+    priority?: number | undefined;
+    retryPolicy?: {
+        maxAttempts: number;
+        initialBackoff: string | number;
+        backoffMultiplier: number;
+        maxBackoff: string | number;
+        nonRetryableErrors?: string[] | undefined;
+    } | undefined;
+    scheduleToCloseDeadline?: number | undefined;
+    executionRequirement?: {
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+        artifactDigest?: string | undefined;
+        workflowRevision?: string | undefined;
+        activityContractHash?: string | undefined;
+    } | undefined;
+    fairShareKey?: string | undefined;
+    stickyWorkflowId?: string | undefined;
+} | {
+    cancellationReason: string;
+    cancellationRequestedAt: number;
+    leaseDeadline: number;
+    firstQueuedAt: number;
+    lastQueuedAt: number;
+    startedAt: number;
+    lastHeartbeatAt: number;
+    state: "cancelling";
+    retryCount: number;
+    requeueCount: number;
+    operationId: string;
+    workflowType: string;
+    activityName: string;
+    queue: string;
+    headerKeys: string[];
+    visibilityTimeoutMilliseconds: number;
+    createdAt: number;
+    attempt: number;
+    lastRequeueReason?: string | undefined;
+    workflowId?: string | undefined;
+    workflowExecutionToken?: string | undefined;
+    priority?: number | undefined;
+    retryPolicy?: {
+        maxAttempts: number;
+        initialBackoff: string | number;
+        backoffMultiplier: number;
+        maxBackoff: string | number;
+        nonRetryableErrors?: string[] | undefined;
+    } | undefined;
+    scheduleToCloseDeadline?: number | undefined;
+    executionRequirement?: {
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+        artifactDigest?: string | undefined;
+        workflowRevision?: string | undefined;
+        activityContractHash?: string | undefined;
+    } | undefined;
+    fairShareKey?: string | undefined;
+    stickyWorkflowId?: string | undefined;
+} | {
+    state: "deadLettered";
+    pendingStatus: "completed" | "failed";
+    resultDigest: string;
+    deadLetteredAt: number;
+    persistenceFailureReason: string;
+    retryCount: number;
+    requeueCount: number;
+    operationId: string;
+    workflowType: string;
+    activityName: string;
+    queue: string;
+    headerKeys: string[];
+    visibilityTimeoutMilliseconds: number;
+    createdAt: number;
+    attempt: number;
+    error?: string | undefined;
+    lastRequeueReason?: string | undefined;
+    workflowId?: string | undefined;
+    workflowExecutionToken?: string | undefined;
+    priority?: number | undefined;
+    retryPolicy?: {
+        maxAttempts: number;
+        initialBackoff: string | number;
+        backoffMultiplier: number;
+        maxBackoff: string | number;
+        nonRetryableErrors?: string[] | undefined;
+    } | undefined;
+    scheduleToCloseDeadline?: number | undefined;
+    executionRequirement?: {
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+        artifactDigest?: string | undefined;
+        workflowRevision?: string | undefined;
+        activityContractHash?: string | undefined;
+    } | undefined;
+    fairShareKey?: string | undefined;
+    stickyWorkflowId?: string | undefined;
+}, unknown>;
+export declare const getTaskDetailRestBinding: UnknownRestBinding;

package/dist/server/operations/get-task-detail.js

@@ -0,0 +1,215 @@
+import { raiseFault } from "../operation-catalog/raise-fault.js";
+import { defineOperation } from "../operation-registry.js";
+import {
+  decodeRemoteTaskRecord,
+  taskLedgerKey
+} from "../task-ledger.js";
+import {
+  executionRequirementSchema,
+  getTaskDetailInput,
+  getTaskDetailOutputSchema,
+  retryPolicySchema
+} from "./get-task-detail-schema.js";
+export {
+  executionRequirementSchema,
+  getTaskDetailOutputSchema,
+  retryPolicySchema
+} from "./get-task-detail-schema.js";
+function projectRetryPolicy(retryPolicy) {
+  return {
+    maxAttempts: retryPolicy.maxAttempts,
+    initialBackoff: retryPolicy.initialBackoff,
+    backoffMultiplier: retryPolicy.backoffMultiplier,
+    maxBackoff: retryPolicy.maxBackoff,
+    ...retryPolicy.nonRetryableErrors !== void 0 ? { nonRetryableErrors: retryPolicy.nonRetryableErrors } : {}
+  };
+}
+function projectExecutionRequirement(executionRequirement) {
+  return {
+    ...executionRequirement.deploymentName !== void 0 ? { deploymentName: executionRequirement.deploymentName } : {},
+    ...executionRequirement.buildId !== void 0 ? { buildId: executionRequirement.buildId } : {},
+    ...executionRequirement.artifactDigest !== void 0 ? { artifactDigest: executionRequirement.artifactDigest } : {},
+    ...executionRequirement.workflowRevision !== void 0 ? { workflowRevision: executionRequirement.workflowRevision } : {},
+    ...executionRequirement.activityContractHash !== void 0 ? { activityContractHash: executionRequirement.activityContractHash } : {}
+  };
+}
+function baseEnvelopeFields(record) {
+  return {
+    operationId: record.operationId,
+    ...record.workflowId !== void 0 ? { workflowId: record.workflowId } : {},
+    ...record.workflowExecutionToken !== void 0 ? { workflowExecutionToken: record.workflowExecutionToken } : {},
+    workflowType: record.workflowType,
+    activityName: record.activityName,
+    queue: record.queue,
+    ...record.priority !== void 0 ? { priority: record.priority } : {},
+    headerKeys: Object.keys(record.headers),
+    visibilityTimeoutMilliseconds: record.visibilityTimeoutMilliseconds,
+    ...record.retryPolicy !== void 0 ? { retryPolicy: projectRetryPolicy(record.retryPolicy) } : {},
+    ...record.scheduleToCloseDeadline !== void 0 ? { scheduleToCloseDeadline: record.scheduleToCloseDeadline } : {},
+    ...record.executionRequirement !== void 0 ? { executionRequirement: projectExecutionRequirement(record.executionRequirement) } : {},
+    ...record.fairShareKey !== void 0 ? { fairShareKey: record.fairShareKey } : {},
+    ...record.stickyWorkflowId !== void 0 ? { stickyWorkflowId: record.stickyWorkflowId } : {},
+    createdAt: record.createdAt,
+    attempt: record.attempt
+  };
+}
+function attemptFields(record) {
+  return {
+    retryCount: record.retryCount,
+    requeueCount: record.requeueCount,
+    ...record.lastRequeueReason !== void 0 ? { lastRequeueReason: record.lastRequeueReason } : {}
+  };
+}
+function leaseHolderFields(record) {
+  return {
+    leaseDeadline: record.leaseDeadline,
+    firstQueuedAt: record.firstQueuedAt,
+    lastQueuedAt: record.lastQueuedAt,
+    startedAt: record.startedAt,
+    lastHeartbeatAt: record.lastHeartbeatAt
+  };
+}
+function projectQueued(record) {
+  return {
+    ...baseEnvelopeFields(record),
+    ...attemptFields(record),
+    state: "queued",
+    availableAt: record.availableAt,
+    firstQueuedAt: record.firstQueuedAt,
+    lastQueuedAt: record.lastQueuedAt,
+    ...record.lastDispatchedAt !== void 0 ? { lastDispatchedAt: record.lastDispatchedAt } : {},
+    ...record.startedAt !== void 0 ? { startedAt: record.startedAt } : {}
+  };
+}
+function projectLeased(record) {
+  return {
+    ...baseEnvelopeFields(record),
+    ...attemptFields(record),
+    ...leaseHolderFields(record),
+    state: "leased"
+  };
+}
+function projectCompleting(record) {
+  return {
+    ...baseEnvelopeFields(record),
+    ...attemptFields(record),
+    ...leaseHolderFields(record),
+    state: "completing",
+    pendingStatus: record.pendingStatus,
+    resultDigest: record.pendingResultDigest
+  };
+}
+function projectCancelling(record) {
+  return {
+    ...baseEnvelopeFields(record),
+    ...attemptFields(record),
+    ...leaseHolderFields(record),
+    state: "cancelling",
+    cancellationReason: record.cancellationReason,
+    cancellationRequestedAt: record.cancellationRequestedAt
+  };
+}
+function terminalDispositionFields(record) {
+  if (record.disposition === "resolved")
+    return {
+      disposition: "resolved",
+      resultDigest: record.resultDigest,
+      resultStatus: record.status,
+      ...record.error !== void 0 ? { error: record.error } : {}
+    };
+  if (record.disposition === "cancelled")
+    return {
+      disposition: "cancelled",
+      cancellationReason: record.cancellationReason
+    };
+  return {
+    disposition: "retryExhausted",
+    error: record.error
+  };
+}
+function projectTerminal(record) {
+  return {
+    ...baseEnvelopeFields(record),
+    state: "terminal",
+    terminalAt: record.terminalAt,
+    adopted: record.adopted,
+    ...record.adoptedAt !== void 0 ? { adoptedAt: record.adoptedAt } : {},
+    ...terminalDispositionFields(record)
+  };
+}
+function projectDeadLettered(record) {
+  return {
+    ...baseEnvelopeFields(record),
+    ...attemptFields(record),
+    state: "deadLettered",
+    pendingStatus: record.pendingStatus,
+    resultDigest: record.pendingResultDigest,
+    deadLetteredAt: record.deadLetteredAt,
+    persistenceFailureReason: record.persistenceFailureReason,
+    ...record.error !== void 0 ? { error: record.error } : {}
+  };
+}
+function projectTaskDetail(record) {
+  switch (record.state) {
+    case "queued":
+      return projectQueued(record);
+    case "leased":
+      return projectLeased(record);
+    case "completing":
+      return projectCompleting(record);
+    case "cancelling":
+      return projectCancelling(record);
+    case "terminal":
+      return projectTerminal(record);
+    case "deadLettered":
+      return projectDeadLettered(record);
+    default:
+      return record;
+  }
+}
+export const getTaskDetailOperation = defineOperation({
+  name: "weft.tasks.get",
+  mcpExposable: !1,
+  summary: "Get one task's full durable ledger state",
+  destructive: !1,
+  tags: ["Observability"],
+  inputSchema: getTaskDetailInput,
+  outputSchema: getTaskDetailOutputSchema,
+  access: {
+    kind: "scoped",
+    scopes: { kind: "anyOf", scopes: ["system:read"] }
+  },
+  producibleFaults: ["NotFound"],
+  discoverable: !0,
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const raw = await engine.storage.get(taskLedgerKey(input.operationId));
+    if (raw === null)
+      raiseFault(getTaskDetailOperation, {
+        code: "NotFound",
+        message: `No task found for operation "${input.operationId}"`,
+        data: { resource: "task", identifier: input.operationId }
+      });
+    const decoded = decodeRemoteTaskRecord(raw);
+    if (decoded === null || decoded.operationId !== input.operationId)
+      raiseFault(getTaskDetailOperation, {
+        code: "EngineFailure",
+        message: `Task ledger record for operation "${input.operationId}" could not be decoded`,
+        data: {}
+      });
+    return projectTaskDetail(decoded);
+  }
+}), getTaskDetailRestBinding = {
+  method: "GET",
+  path: "/v1/tasks/detail/:operationId",
+  pathParamNames: ["operationId"],
+  operationName: "weft.tasks.get",
+  inputSources: {
+    operationId: { kind: "path", pathParam: "operationId" }
+  },
+  extractInput: async (_request, pathParams) => ({
+    operationId: pathParams.operationId ?? ""
+  }),
+  success: { kind: "json", status: 200 }
+};

package/dist/server/operations/static-registrations.js

@@ -41,6 +41,7 @@ import { getReviewOperation, getReviewRestBinding } from "./get-review.js";
 import { getScheduleOperation, getScheduleRestBinding } from "./get-schedule.js";
 import { getStreamChunksOperation, getStreamChunksRestBinding } from "./get-stream-chunks.js";
 import { getSystemLeaseOperation, getSystemLeaseRestBinding } from "./get-system-lease.js";
+import { getTaskDetailOperation, getTaskDetailRestBinding } from "./get-task-detail.js";
 import {
   clearTaskDeadLetterOperation,
   clearTaskDeadLetterRestBinding,
@@ -170,6 +171,7 @@ export const STATIC_REST_BINDINGS = [
   fleetEventsSseRestBinding,
   getTaskDiagnosticsRestBinding,
   clearTaskDeadLetterRestBinding,
+  getTaskDetailRestBinding,
   listSchedulesRestBinding,
   getScheduleRestBinding,
   replayWorkflowRestBinding,
@@ -233,6 +235,7 @@ export const STATIC_REST_BINDINGS = [
   workflowEventsSubscriptionOperation,
   fleetEventsSubscriptionOperation,
   clearTaskDeadLetterOperation,
+  getTaskDetailOperation,
   listSchedulesOperation,
   listAlertsOperation,
   getPrincipalOperation,

package/dist/version.d.ts

@@ -9,4 +9,4 @@
  * console.log(`Running Weft ${VERSION}`);
  * ```
  */
-export declare const VERSION = "0.19.0";
+export declare const VERSION = "0.20.0";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = "0.19.0";
+export const VERSION = "0.20.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lostgradient/weft",
-  "version": "0.19.0",
+  "version": "0.20.0",
   "description": "A Bun-native durable execution engine with pluggable key-value storage.",
   "keywords": [
     "bun",