deepline 0.1.274 → 0.1.276

package/dist/bundling-sources/shared_libs/play-runtime/app-runtime-api.ts

@@ -5,6 +5,10 @@ import { pipeline } from 'node:stream/promises';
 import type { PlaySheetContract } from '@shared_libs/plays/static-pipeline';
 import type { PlayRowUpdate } from '@shared_libs/play-runtime/ctx-types';
 import type { PlayRunTimelineEntry } from '@shared_libs/play-runtime/live-events';
+import {
+  routePlayActivityObservation,
+  type PlayActivityObservation,
+} from '@shared_libs/play-runtime/activity-observation';
 import {
   buildPlayRunLedgerEventsFromStatusPatch,
   buildTerminalLogReplayEvents,
@@ -82,6 +86,8 @@ export type RuntimeStatusUpdate = {
     complete?: boolean;
     at: number;
   }>;
+  /** Sparse typed activity facts. Routing/deduplication happens server-side. */
+  activityObservations?: PlayActivityObservation[];
   /**
    * Explicit terminal-output replay for final runner logs when the caller must
    * keep `status` nonterminal. Direct-worker/Postgres progress finalizers do this so
@@ -1491,6 +1497,25 @@ async function updateRunStatusViaAppRuntimeUnlocked(
       ...(event.complete === undefined ? {} : { complete: event.complete }),
     });
   }
+  const latestActivities = new Map(
+    Object.entries(previousSnapshot.activitiesById),
+  );
+  for (const observation of update.activityObservations ?? []) {
+    const previous = latestActivities.get(observation.activityId) ?? null;
+    const lane = routePlayActivityObservation({
+      previous,
+      next: observation,
+    });
+    if (lane === 'drop' || lane === 'liveness') continue;
+    events.push({
+      type: 'activity.observed',
+      runId: update.playId,
+      source: 'worker',
+      occurredAt: observation.observedAt,
+      observation,
+    });
+    latestActivities.set(observation.activityId, observation);
+  }
   const terminalLogEvents =
     terminalLogReplay && terminalLogReplay.lines.length > 0
       ? buildTerminalLogReplayEvents({

package/dist/bundling-sources/shared_libs/play-runtime/context.ts

@@ -8405,6 +8405,10 @@ export class PlayContextImpl {
     }
     const url = `${this.#options.baseUrl}/api/v2/integrations/${encodeURIComponent(toolId)}/execute`;
     const timeoutMs = resolveToolRuntimeTimeoutMs(toolId, options?.timeoutMs);
+    const provider = toolId.split(/[._]/)[0]?.trim() || 'provider';
+    const activityId = `provider:${toolId}`;
+    let retryActivityEmitted = false;
+    let toolCallSucceeded = false;
 
     // Hold one logical tool slot and charge one logical tool call for this
     // execution. Per-provider rate admission is intentionally deferred until
@@ -8757,8 +8761,46 @@ export class PlayContextImpl {
                 this.log(
                   `Tool ${toolId} returned ${response.status}; retrying after ${failure.retryDelayMs}ms`,
                 );
+                retryActivityEmitted = true;
+                this.emitExecutionEvent({
+                  type: 'activity.observed',
+                  observation: {
+                    schemaVersion: 1,
+                    activityId,
+                    target: {
+                      kind: 'provider',
+                      provider,
+                      operation: toolId,
+                      label: toolId,
+                    },
+                    state: {
+                      kind: 'retrying',
+                      reason: failure.isRateLimit
+                        ? 'rate_limit'
+                        : 'provider_error',
+                      retryAt: Date.now() + failure.retryDelayMs,
+                      attempt: httpFailureAttempt,
+                    },
+                    observedAt: Date.now(),
+                  },
+                });
                 await options?.parkProviderCall?.();
                 await this.sleepWithCheckpointHeartbeat(failure.retryDelayMs);
+                this.emitExecutionEvent({
+                  type: 'activity.observed',
+                  observation: {
+                    schemaVersion: 1,
+                    activityId,
+                    target: {
+                      kind: 'provider',
+                      provider,
+                      operation: toolId,
+                      label: toolId,
+                    },
+                    state: { kind: 'active' },
+                    observedAt: Date.now(),
+                  },
+                });
                 continue;
               }
               this.log(failure.error.message);
@@ -8775,11 +8817,31 @@ export class PlayContextImpl {
                     ? 'array'
                     : typeof parsed.result,
             });
+            toolCallSucceeded = true;
             return parsed;
           }
         },
       );
     } finally {
+      if (retryActivityEmitted) {
+        this.emitExecutionEvent({
+          type: 'activity.observed',
+          observation: {
+            schemaVersion: 1,
+            activityId,
+            target: {
+              kind: 'provider',
+              provider,
+              operation: toolId,
+              label: toolId,
+            },
+            state: toolCallSucceeded
+              ? { kind: 'completed' }
+              : { kind: 'failed', code: 'PROVIDER_CALL_FAILED' },
+            observedAt: Date.now(),
+          },
+        });
+      }
       toolSlot.release();
     }
   }

package/dist/bundling-sources/shared_libs/play-runtime/ctx-contract.ts

@@ -61,6 +61,7 @@ export interface PlayRowUpdate {
 }
 
 export type PlayExecutionEvent =
+  | PlayActivityEvent
   | {
       type: 'map.preparing';
       mapInvocationId: string;
@@ -264,3 +265,4 @@ export type PlayDatasetSubstep =
       results: PlayStepRowResult[];
       description?: string;
     };
+import type { PlayActivityEvent } from './activity-observation';

package/dist/bundling-sources/shared_libs/play-runtime/ctx-types.ts

@@ -25,6 +25,7 @@ import type { MapRowOutcome } from './durability-store';
 import type { WorkReceiptFailureKind } from './work-receipts';
 import type { RunExecutionScope } from './run-execution-scope';
 import type { PlayCallExecution } from './play-call-execution';
+import type { PlayActivityEvent } from './activity-observation';
 
 export interface RowState {
   results: Map<string, unknown>;
@@ -385,6 +386,7 @@ export interface MapExecutionScope {
 }
 
 export type PlayExecutionEvent =
+  | PlayActivityEvent
   | {
       type: 'dataset.lifecycle';
       datasetId: string;

package/dist/bundling-sources/shared_libs/play-runtime/live-state-contract.ts

@@ -1,4 +1,8 @@
 import type { PlayRunLifecycleStatus } from './run-lifecycle-policy';
+import type {
+  PlayActivityObservation,
+  PlayRunActivityProjection,
+} from './activity-observation';
 
 export type PlayRunLiveStatus = PlayRunLifecycleStatus;
 
@@ -46,4 +50,7 @@ export type PlayRunLiveSnapshot = {
   resultTableNamespace: string | null;
   nodeStates: PlayVisualNodeStateSnapshot[];
   activeNodeId: string | null;
+  activities?: PlayActivityObservation[];
+  activeActivity?: PlayActivityObservation | null;
+  activity?: PlayRunActivityProjection | null;
 };

package/dist/bundling-sources/shared_libs/play-runtime/run-ledger.ts

@@ -8,6 +8,10 @@ import {
   normalizePlayRunLedgerTerminalSource,
 } from './run-terminal-source';
 import { MAX_LEDGER_LOG_LINES_PER_EVENT } from './ledger-safe-payload';
+import {
+  isPlayActivityObservation,
+  type PlayActivityObservation,
+} from './activity-observation';
 
 export type PlayRunLedgerStatus =
   | 'queued'
@@ -111,6 +115,8 @@ export type PlayRunLedgerSnapshot = {
   stepsById: Record<string, PlayRunLedgerStepSnapshot>;
   orderedDatasetIds: string[];
   datasetsById: Record<string, PlayRunLedgerDatasetSnapshot>;
+  orderedActivityIds: string[];
+  activitiesById: Record<string, PlayActivityObservation>;
   /**
    * Bounded tail of the run's log lines (last {@link LOG_TAIL_LIMIT}).
    * Full retention lives in the Run Log Stream (Convex `playRunLogChunks`);
@@ -129,6 +135,7 @@ export type PlayRunLedgerSnapshot = {
    */
   logsTruncated: boolean;
   activeStepId?: string | null;
+  activeActivityId?: string | null;
   activeArtifactTableNamespace?: string | null;
   resultTableNamespace?: string | null;
   resultSummary?: unknown;
@@ -260,6 +267,10 @@ export type PlayRunLedgerEvent =
       failedRows?: number;
       complete?: boolean;
     })
+  | (PlayRunLedgerBaseEvent & {
+      type: 'activity.observed';
+      observation: PlayActivityObservation;
+    })
   | (PlayRunLedgerBaseEvent & {
       /**
        * @deprecated Mixed-version deploy seam only. Owner: Play Runtime.
@@ -362,6 +373,15 @@ export function isTerminalPlayRunLedgerStatus(
   return TERMINAL_STATUSES.has(status);
 }
 
+function isTerminalActivityObservation(
+  observation: PlayActivityObservation,
+): boolean {
+  return (
+    observation.state.kind === 'completed' ||
+    observation.state.kind === 'failed'
+  );
+}
+
 /**
  * Aggregate, row-level outcome of a run derived purely from the settled step
  * progress. This is an ADDITIVE truthfulness signal, NOT a status: a run can be
@@ -449,10 +469,13 @@ export function createEmptyPlayRunLedgerSnapshot(input: {
     stepsById: {},
     orderedDatasetIds: [],
     datasetsById: {},
+    orderedActivityIds: [],
+    activitiesById: {},
     logTail: [],
     totalLogCount: 0,
     logsTruncated: false,
     activeStepId: null,
+    activeActivityId: null,
     activeArtifactTableNamespace: null,
     resultTableNamespace: null,
   };
@@ -516,6 +539,19 @@ export function normalizePlayRunLedgerSnapshot(
       updatedAt: finiteNumber(rawDataset.updatedAt) ?? 0,
     };
   }
+  const rawActivities = isRecord(value.activitiesById)
+    ? value.activitiesById
+    : {};
+  const activitiesById: Record<string, PlayActivityObservation> = {};
+  for (const [activityId, rawActivity] of Object.entries(rawActivities)) {
+    if (
+      activityId.trim() &&
+      isPlayActivityObservation(rawActivity) &&
+      rawActivity.activityId === activityId
+    ) {
+      activitiesById[activityId] = rawActivity;
+    }
+  }
   const createdAt = finiteNumber(value.createdAt) ?? fallback.createdAt ?? null;
   const startedAt = finiteNumber(value.startedAt) ?? fallback.startedAt ?? null;
   const finishedAt =
@@ -561,6 +597,14 @@ export function normalizePlayRunLedgerSnapshot(
         typeof datasetId === 'string' && Boolean(datasetsById[datasetId]),
     ),
     datasetsById,
+    orderedActivityIds: (Array.isArray(value.orderedActivityIds)
+      ? value.orderedActivityIds
+      : Object.keys(activitiesById)
+    ).filter(
+      (activityId): activityId is string =>
+        typeof activityId === 'string' && Boolean(activitiesById[activityId]),
+    ),
+    activitiesById,
     logTail: logTail.slice(-LOG_TAIL_LIMIT),
     // Snapshots persisted before totalLogCount existed only know the retained
     // tail, so the best lower bound for the cumulative count is the tail size.
@@ -570,6 +614,7 @@ export function normalizePlayRunLedgerSnapshot(
     ),
     logsTruncated: value.logsTruncated === true,
     activeStepId: optionalNullableString(value.activeStepId),
+    activeActivityId: optionalNullableString(value.activeActivityId),
     activeArtifactTableNamespace: optionalNullableString(
       value.activeArtifactTableNamespace,
     ),
@@ -1177,6 +1222,7 @@ export function reducePlayRunLedgerEvent(
           startedAt: base.startedAt ?? occurredAt,
           finishedAt: terminalFinishedAt(base, event.type, occurredAt),
           activeStepId: null,
+          activeActivityId: null,
           activeArtifactTableNamespace: null,
           result: event.result ?? base.result,
           resultSummary: event.resultSummary ?? base.resultSummary,
@@ -1202,6 +1248,7 @@ export function reducePlayRunLedgerEvent(
           startedAt: base.startedAt ?? occurredAt,
           finishedAt: terminalFinishedAt(base, event.type, occurredAt),
           activeStepId: null,
+          activeActivityId: null,
           activeArtifactTableNamespace: null,
           result: event.result ?? base.result,
           terminalSource: nextTerminalSource(base, event.source),
@@ -1225,6 +1272,7 @@ export function reducePlayRunLedgerEvent(
           startedAt: base.startedAt ?? occurredAt,
           finishedAt: terminalFinishedAt(base, event.type, occurredAt),
           activeStepId: null,
+          activeActivityId: null,
           activeArtifactTableNamespace: null,
           result: event.result ?? base.result,
           terminalSource: nextTerminalSource(base, event.source),
@@ -1473,6 +1521,28 @@ export function reducePlayRunLedgerEvent(
         resultTableNamespace: base.resultTableNamespace ?? event.tableNamespace,
       });
     }
+    case 'activity.observed': {
+      const current = base.activitiesById[event.observation.activityId];
+      if (current && current.observedAt >= event.observation.observedAt) {
+        return withTiming(base);
+      }
+      const terminal = isTerminalActivityObservation(event.observation);
+      return withTiming({
+        ...base,
+        orderedActivityIds: current
+          ? base.orderedActivityIds
+          : [...base.orderedActivityIds, event.observation.activityId],
+        activitiesById: {
+          ...base.activitiesById,
+          [event.observation.activityId]: event.observation,
+        },
+        activeActivityId: terminal
+          ? base.activeActivityId === event.observation.activityId
+            ? null
+            : base.activeActivityId
+          : event.observation.activityId,
+      });
+    }
     case 'sheet.summary.updated':
       return withTiming({
         ...base,

package/dist/bundling-sources/shared_libs/play-runtime/run-snapshot-stream.ts

@@ -14,6 +14,11 @@ import {
   normalizePlayRunLifecycleStatus,
   type PlayRunLifecycleStatus,
 } from './run-lifecycle-policy';
+import {
+  projectPlayRunActivity,
+  type PlayActivityObservation,
+  type PlayRunActivityProjection,
+} from './activity-observation';
 
 /**
  * Run Snapshot Stream.
@@ -79,6 +84,11 @@ export type PlayRunLiveSnapshot = {
   activeArtifactTableNamespace: string | null;
   resultTableNamespace: string | null;
   datasets?: PlayRunLedgerDatasetSnapshot[];
+  /** Explicit typed activity facts; legacy steps/datasets remain alongside them. */
+  activities?: PlayActivityObservation[];
+  activeActivity?: PlayActivityObservation | null;
+  /** Canonical current activity, including compatibility projection. */
+  activity?: PlayRunActivityProjection | null;
   nodeStates: PlayRunStreamNodeState[];
   activeNodeId: string | null;
   /**
@@ -121,6 +131,11 @@ export type LedgerBackedRunLike = {
   updatedAt?: number | null;
   runSnapshot?: unknown;
   result?: unknown;
+  wait?: { kind?: string; eventKey?: string; boundaryId?: string } | null;
+  waitKind?: string | null;
+  waitUntil?: number | null;
+  activeBoundaryId?: string | null;
+  runtimeBackend?: string | null;
 };
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -221,6 +236,14 @@ function buildSnapshotFromLedger(
       .filter((dataset): dataset is PlayRunLedgerDatasetSnapshot =>
         Boolean(dataset),
       ),
+    activities: snapshot.orderedActivityIds
+      .map((activityId) => snapshot.activitiesById[activityId])
+      .filter((activity): activity is PlayActivityObservation =>
+        Boolean(activity),
+      ),
+    activeActivity: snapshot.activeActivityId
+      ? (snapshot.activitiesById[snapshot.activeActivityId] ?? null)
+      : null,
     nodeStates,
     activeNodeId: snapshot.activeStepId ?? null,
     ...(rowOutcomes ? { rowOutcomes } : {}),
@@ -240,17 +263,33 @@ export function buildPlayRunStatusSnapshot(input: {
     finishedAt: input.run.finishedAt ?? null,
   });
   const terminalRunLogTail = extractTerminalRunLogTail(input.run.result);
-  if (
+  const projectedSnapshot =
     terminalRunLogTail &&
     terminalRunLogTail.totalLogCount > ledgerSnapshot.totalLogCount
-  ) {
-    return buildSnapshotFromLedger({
-      ...ledgerSnapshot,
-      logTail: terminalRunLogTail.logTail,
-      totalLogCount: terminalRunLogTail.totalLogCount,
-    });
-  }
-  return buildSnapshotFromLedger(ledgerSnapshot);
+      ? buildSnapshotFromLedger({
+          ...ledgerSnapshot,
+          logTail: terminalRunLogTail.logTail,
+          totalLogCount: terminalRunLogTail.totalLogCount,
+        })
+      : buildSnapshotFromLedger(ledgerSnapshot);
+  const activity = projectPlayRunActivity({
+    runId: input.run.workflowId,
+    playName: input.run.name,
+    status: projectedSnapshot.status,
+    updatedAt: projectedSnapshot.updatedAt,
+    waitKind: input.run.waitKind ?? input.run.wait?.kind ?? null,
+    waitUntil: input.run.waitUntil,
+    eventKey: input.run.wait?.eventKey ?? null,
+    runtimeBackend: input.run.runtimeBackend,
+    activeNodeId: input.run.activeBoundaryId ?? projectedSnapshot.activeNodeId,
+    nodeStates: projectedSnapshot.nodeStates,
+    datasets: projectedSnapshot.datasets,
+    explicit: projectedSnapshot.activities,
+  });
+  return {
+    ...projectedSnapshot,
+    activity,
+  };
 }
 
 /** Generic live-event envelope shape shared with the SSE protocol. */
@@ -635,6 +674,7 @@ export function diffPlayRunStreamEvents(input: {
           runId: snapshot.runId,
           status: snapshot.status,
           updatedAt: snapshot.updatedAt,
+          ...(snapshot.activity ? { activity: snapshot.activity } : {}),
         },
       }),
     );