deepline 0.3.71 → 0.3.73

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

@@ -69,6 +69,8 @@ export interface ToolCallRequest {
   providerIdempotencyKeyBase?: string | null;
   cacheable?: boolean;
   receiptKey?: string | null;
+  /** Pre-cutover result-cache keys to read before executing a canonical miss. */
+  legacyReceiptKeys?: string[];
   executionAuthScopeDigest?: string | null;
   receiptLeaseId?: string | null;
   receiptLeaseExpiresAt?: string | null;

package/dist/bundling-sources/shared_libs/play-runtime/durable-call-cache.ts

@@ -45,10 +45,39 @@ export function buildDurableToolCallCacheKey(input: {
   /** Run-stable clock used to choose the stale bucket. */
   cacheEpochMs?: number;
   playLocalScope?: string | null;
-  /**
-   * Explicit revision for a response transformation. Bump it only when the
-   * serialized tool output changes; omit it for historical artifacts.
-   */
+}): string {
+  return buildDurableToolCallCacheKeyWithPresentation(input);
+}
+
+/**
+ * Reads receipt keys written before response presentation stopped partitioning
+ * the exact-request cache. New writes must use `buildDurableToolCallCacheKey`.
+ */
+export function buildLegacyRevisionedDurableToolCallCacheKey(input: {
+  orgId?: string | null;
+  toolId: string;
+  requestInput: Record<string, unknown>;
+  authScopeDigest?: string | null;
+  providerActionVersion?: string | null;
+  cachePolicyVersion?: string | null;
+  staleAfterSeconds?: number | null;
+  cacheEpochMs?: number;
+  playLocalScope?: string | null;
+  toolResponseReceiptRevision: string;
+}): string {
+  return buildDurableToolCallCacheKeyWithPresentation(input);
+}
+
+function buildDurableToolCallCacheKeyWithPresentation(input: {
+  orgId?: string | null;
+  toolId: string;
+  requestInput: Record<string, unknown>;
+  authScopeDigest?: string | null;
+  providerActionVersion?: string | null;
+  cachePolicyVersion?: string | null;
+  staleAfterSeconds?: number | null;
+  cacheEpochMs?: number;
+  playLocalScope?: string | null;
   toolResponseReceiptRevision?: string | null;
 }): string {
   const orgId = input.orgId?.trim() || 'org';
@@ -63,11 +92,6 @@ export function buildDurableToolCallCacheKey(input: {
     );
   }
   const playLocalScope = input.playLocalScope?.trim() || 'play';
-  // Keep historical digests byte-for-byte stable when no explicit revision
-  // exists on the stored artifact.
-  const toolResponseReceiptRevision = normalizeToolResponseReceiptRevision(
-    input.toolResponseReceiptRevision,
-  );
   const digest = sha256Hex(
     stableStringify({
       kind: 'tool' satisfies DurableCallKind,
@@ -78,9 +102,15 @@ export function buildDurableToolCallCacheKey(input: {
       requestInput: input.requestInput,
       authScopeDigest: input.authScopeDigest ?? null,
       providerActionVersion,
+      ...(input.toolResponseReceiptRevision
+        ? {
+            toolResponseReceiptRevision: normalizeToolResponseReceiptRevision(
+              input.toolResponseReceiptRevision,
+            ),
+          }
+        : {}),
       cachePolicyVersion:
         input.cachePolicyVersion ?? DURABLE_CALL_CACHE_POLICY_VERSION,
-      ...(toolResponseReceiptRevision ? { toolResponseReceiptRevision } : {}),
       staleBucket: durableCacheStaleBucket({
         staleAfterSeconds: input.staleAfterSeconds,
         nowMs: input.cacheEpochMs,

package/dist/bundling-sources/shared_libs/play-runtime/log-provenance.ts

@@ -52,6 +52,27 @@ export type LogProvenance =
    *  Never customer-facing. */
   | 'receipt';
 
+/**
+ * How urgent a log line is. This is deliberately independent from provenance:
+ * a customer can write an error, while a runtime can emit a harmless debug
+ * detail. CLI log-level filters use this ordered taxonomy.
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+
+export const LOG_LEVELS: readonly LogLevel[] = [
+  'debug',
+  'info',
+  'warn',
+  'error',
+] as const;
+
+const LOG_LEVEL_RANK: Record<LogLevel, number> = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+};
+
 /** Every provenance class, for exhaustiveness checks and tests. */
 export const LOG_PROVENANCE_CLASSES: readonly LogProvenance[] = [
   'user',
@@ -125,6 +146,51 @@ export function tagLogProvenance(
   return `${PROVENANCE_PREFIX}${provenance}${PROVENANCE_SENTINEL}${line}`;
 }
 
+/**
+ * Persist a severity in text that released readers can still render sensibly.
+ * The provenance tag is already a compatible structural carrier; level text
+ * must remain readable after an older client strips only that provenance tag.
+ */
+export function tagLogLevel(line: string, level: LogLevel): string {
+  const timestamp = line.match(/^(\[[^\]]+\]\s*)/u)?.[1] ?? '';
+  const message = timestamp ? line.slice(timestamp.length) : line;
+  const explicitLevel = message.match(/^\[(debug|info|warn|error)\]\s*/i);
+  // The caller-selected severity is authoritative, but customer text remains
+  // immutable. Add a framework marker before a conflicting customer prefix
+  // instead of replacing the author's original `[warn]`/`[error]` wording.
+  if (explicitLevel?.[1]?.toLowerCase() === level) return line;
+  const needsInfoDisambiguation =
+    level === 'info' &&
+    (explicitLevel !== null ||
+      /^\[console\.(?:debug|warn|error)\]/i.test(message));
+  if (level === 'info' && !needsInfoDisambiguation) {
+    return line;
+  }
+  return `${timestamp}[${level}] ${message}`;
+}
+
+/** Tag a new log line with both independent dimensions. */
+export function tagLogEntry(
+  provenance: LogProvenance,
+  level: LogLevel,
+  line: string,
+): string {
+  return tagLogProvenance(provenance, tagLogLevel(line, level));
+}
+
+/** True when a line at `level` reaches a minimum-severity filter. */
+export function logLevelReaches(level: LogLevel, minimum: LogLevel): boolean {
+  return LOG_LEVEL_RANK[level] >= LOG_LEVEL_RANK[minimum];
+}
+
+/** Parse a user-supplied log level without accepting a silently ignored value. */
+export function parseLogLevel(value: string): LogLevel | null {
+  const normalized = value.trim().toLowerCase();
+  return LOG_LEVELS.includes(normalized as LogLevel)
+    ? (normalized as LogLevel)
+    : null;
+}
+
 /**
  * A customer-safe record of a `ctx.fetch` response that reached the server but
  * was not successful. Its URL is destination-origin-only; it deliberately
@@ -179,9 +245,10 @@ export function parseCtxFetchHttpFailureDiagnostic(
 ): CtxFetchHttpFailureDiagnostic | null {
   const tagged = readProvenanceTag(rawLine);
   if (tagged.provenance !== 'diagnostic') return null;
-  const index = tagged.line.indexOf(CTX_FETCH_HTTP_FAILURE_LOG_PREFIX);
+  const line = tagged.line;
+  const index = line.indexOf(CTX_FETCH_HTTP_FAILURE_LOG_PREFIX);
   if (index === -1) return null;
-  const json = tagged.line
+  const json = line
     .slice(index + CTX_FETCH_HTTP_FAILURE_LOG_PREFIX.length)
     .trim();
   try {
@@ -296,13 +363,58 @@ export function classifyLegacyLogLine(line: string): LogProvenance {
  */
 export function classifyLogLine(line: string): {
   provenance: LogProvenance;
+  level: LogLevel;
   line: string;
 } {
   const tagged = readProvenanceTag(line);
+  const provenance = tagged.provenance ?? classifyLegacyLogLine(tagged.line);
   if (tagged.provenance !== null) {
-    return { provenance: tagged.provenance, line: tagged.line };
+    return {
+      provenance,
+      level: inferLogLevel(provenance, tagged.line),
+      line: tagged.line,
+    };
+  }
+  return {
+    provenance,
+    level: inferLogLevel(provenance, tagged.line),
+    line: tagged.line,
+  };
+}
+
+/**
+ * Compatibility classification for lines that predate explicit level tags.
+ * New runtime-authored lines should use `tagLogEntry`; these rules keep old
+ * run history useful without pretending arbitrary customer text is an error.
+ */
+function inferLogLevel(provenance: LogProvenance, line: string): LogLevel {
+  const message = stripLeadingTimestamp(line);
+  if (/^\[info\]/i.test(message)) {
+    return 'info';
+  }
+  if (/^\[debug\]/i.test(message)) {
+    return 'debug';
+  }
+  if (/^\[console\.error\]/i.test(message) || /^\[error\]/i.test(message)) {
+    return 'error';
+  }
+  if (/^\[console\.warn\]/i.test(message) || /^\[warn\]/i.test(message)) {
+    return 'warn';
+  }
+  if (/^\[console\.debug\]/i.test(message)) {
+    return 'debug';
+  }
+  if (
+    provenance === 'replay' ||
+    provenance === 'infra' ||
+    provenance === 'receipt'
+  ) {
+    return 'debug';
+  }
+  if (provenance === 'diagnostic') {
+    return 'warn';
   }
-  return { provenance: classifyLegacyLogLine(tagged.line), line: tagged.line };
+  return 'info';
 }
 
 /** True when a raw (possibly tagged) log line should render on the surface. */

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

@@ -21,6 +21,7 @@ import {
   type PlayActivityObservation,
   type PlayRunActivityProjection,
 } from './activity-observation';
+import { stripProvenanceTag } from './log-provenance';
 
 /**
  * Run Snapshot Stream.
@@ -238,7 +239,9 @@ function buildSnapshotFromLedger(
     durationMs: snapshot.durationMs ?? null,
     updatedAt:
       snapshot.updatedAt ?? snapshot.finishedAt ?? snapshot.startedAt ?? null,
-    logs: snapshot.logTail,
+    // This snapshot is public SDK/API transport. Keep the historical plain
+    // timestamp-prefixed text while provenance remains runtime metadata.
+    logs: snapshot.logTail.map(stripProvenanceTag),
     totalLogCount: snapshot.totalLogCount,
     ...(snapshot.logsTruncated ? { logsTruncated: true } : {}),
     activeArtifactTableNamespace: snapshot.activeArtifactTableNamespace ?? null,

package/dist/bundling-sources/shared_libs/play-runtime/tool-call/index.ts

@@ -15,7 +15,6 @@ export {
 } from './runtime-step-receipts-adapter';
 export {
   createToolCallReceiptCohortJob,
-  ToolCallReceiptCohortWaitTimeoutError,
   type ToolCallReceiptCohort,
   type ToolCallReceiptCohortJob,
   type ToolCallReceiptCohortMember,
@@ -54,12 +53,8 @@ export { ToolCallReceiptLeaseLostError } from './contract';
  * Adapts a receipt lifecycle that is already owned by a higher-level runtime
  * job.  This is a composition seam, not a second receipt implementation.
  *
- * PlayContext's direct-call path currently owns a richer runtime receipt
- * protocol: completed-cache publication, non-idempotent execution locks,
- * auth-scope re-keying, and external-call-slot retention.  Once it has
- * claimed that protocol's receipt, ToolCall can still own the call boundary
- * (validation and dispatch) without trying to claim or terminally write the
- * same receipt a second time.  The outer job remains the sole durable owner.
+ * The outer runtime owns the physical batch operation. ToolCall keeps the
+ * result boundary uniform without performing a second cache write.
  *
  * Do not use this for a new caller. New runtimes should provide a real
  * ToolResultReceipts Adapter. This exists only while PlayContext's historical
@@ -117,21 +112,14 @@ export function createExternallyOwnedToolResultReceipts(input: {
     },
     async heartbeat(candidate) {
       assertKeyAndLease(candidate);
-      // The outer runtime owns durable heartbeating / execution locks. Returning
-      // active here deliberately avoids a duplicate heartbeat write.
       return 'active';
     },
     async complete(candidate) {
       assertKeyAndLease(candidate);
-      // The outer runtime atomically publishes the result, including its
-      // cache-only convergence behaviour. A second completion here would alter
-      // that race and can overwrite its execution metadata.
       return { kind: 'stored', result: candidate.result };
     },
     async fail(candidate) {
       assertKeyAndLease(candidate);
-      // Failure publication belongs to the outer state machine because it
-      // classifies auth-scope changes, suspensions, and lost ownership.
     },
   };
 }

package/dist/bundling-sources/shared_libs/play-runtime/tool-call/native-batch.ts

@@ -1,6 +1,5 @@
 import type { ToolExecuteResult } from '../tool-result';
 import {
-  ToolCallReceiptLeaseLostError,
   type ToolCallInput,
   type ToolCallJob,
   type ToolCallReceiptLease,
@@ -24,8 +23,6 @@ export type NativeBatchToolCallMember = {
 
 export type NativeBatchOwnedToolCallMember = NativeBatchToolCallMember & {
   receipt: ToolCallReceiptLease;
-  /** Actual member lease expiry supplied by the receipt-cohort Adapter. */
-  leaseExpiresAt?: string | null;
 };
 
 export type NativeBatchToolCallInput = {
@@ -50,14 +47,6 @@ export type NativeBatchToolCallInput = {
   }):
     | Array<{ memberId: string; result: ToolExecuteResult }>
     | Promise<Array<{ memberId: string; result: ToolExecuteResult }>>;
-  /** Keep all owned member leases alive during a long provider batch. */
-  heartbeat?: {
-    /** May derive a real interval from the claimed member leases. */
-    intervalMs:
-      | number
-      | ((input: { members: NativeBatchOwnedToolCallMember[] }) => number);
-    onTransientFailure?(error: unknown): void;
-  };
 };
 
 /** A native batch returns each local member result, including cache followers. */
@@ -70,12 +59,8 @@ export type NativeBatchToolCallJob = {
 /**
  * Owns one provider-native map batch.
  *
- * The Module composes two deep jobs rather than copying either protocol:
- * `ToolCallReceiptCohort` owns per-member receipt leases, recovery and terminal
- * fanout; `ToolCall` owns the physical provider-operation invocation. This
- * Module supplies the missing semantic rule between them: exactly one
- * aggregate operation may be dispatched, and it must be split completely
- * before every owned member receipt is completed.
+ * It reads each member's completed-result cache before assembling one physical
+ * provider batch for the misses, then atomically stores each successful split.
  */
 export function createNativeBatchToolCallJob(dependencies: {
   receiptCohort: ToolCallReceiptCohortJob;
@@ -98,68 +83,26 @@ export function createNativeBatchToolCallJob(dependencies: {
           forceFailedRefresh: member.forceFailedRefresh,
           waitMaxAttempts: member.waitMaxAttempts,
         })),
-        // Do not make locally owned rows wait behind a foreign receipt's
-        // bounded recovery. The first aggregate can run now; any receipt
-        // reclaimed after the wait forms its own later aggregate operation.
-        eager: true,
       });
       const executeOwned = async (): Promise<void> => {
         const owned = ownedMembers(cohort, input.members);
         if (owned.length === 0) return;
         const physical = input.buildPhysicalCall({ members: owned });
         validatePhysicalCall(physical, input.owner);
-        let leaseLost: ToolCallReceiptLeaseLostError | null = null;
-        const heartbeatIntervalMs = input.heartbeat
-          ? typeof input.heartbeat.intervalMs === 'function'
-            ? input.heartbeat.intervalMs({ members: owned })
-            : input.heartbeat.intervalMs
-          : null;
-        const heartbeat =
-          input.heartbeat && heartbeatIntervalMs !== null
-            ? cohort.startHeartbeat({
-                intervalMs: positiveHeartbeatInterval(heartbeatIntervalMs),
-                onLeaseLost(error) {
-                  leaseLost ??= error;
-                },
-                onTransientFailure: input.heartbeat.onTransientFailure,
-              })
-            : null;
         try {
-          await assertCohortOwned(cohort, heartbeat, leaseLost);
           const aggregate = await dependencies.physicalToolCall.call(physical);
-          await assertCohortOwned(cohort, heartbeat, leaseLost);
-          let split: Array<{ memberId: string; result: ToolExecuteResult }>;
-          try {
-            split = await input.splitResult({
-              result: aggregate,
-              members: owned,
-            });
-            validateSplit(owned, split);
-          } catch (error) {
-            throw error;
-          }
+          const split = await input.splitResult({
+            result: aggregate,
+            members: owned,
+          });
+          validateSplit(owned, split);
           await cohort.complete(split);
         } catch (error) {
-          // Once the aggregate call begins, a provider/transport failure is a
-          // terminal fact for every owned member. Lease loss is the exception:
-          // a stale owner must not overwrite the new holder's receipt state.
-          if (!(error instanceof ToolCallReceiptLeaseLostError)) {
-            await failOwned(cohort, owned, error);
-          }
+          await failOwned(cohort, owned, error);
           throw error;
-        } finally {
-          heartbeat?.stop();
         }
       };
 
-      // Start the known-owned aggregate before foreign receipt hydration. The
-      // settlement is still awaited before collection, and any newly reclaimed
-      // member gets a distinct physical operation rather than being silently
-      // omitted from this batch.
-      const initialExecution = executeOwned();
-      const settlement = cohort.settle();
-      await initialExecution;
-      await settlement;
       await executeOwned();
 
       return await collectMemberResults(cohort, input.members);
@@ -178,21 +121,11 @@ function ownedMembers(
     owned.push({
       ...member,
       receipt: state.lease,
-      ...(state.leaseExpiresAt ? { leaseExpiresAt: state.leaseExpiresAt } : {}),
     });
   }
   return owned;
 }
 
-function positiveHeartbeatInterval(value: number): number {
-  if (!Number.isFinite(value) || value <= 0) {
-    throw new Error(
-      'Native Batch Tool Call heartbeat interval must be positive.',
-    );
-  }
-  return Math.max(1, Math.floor(value));
-}
-
 async function collectMemberResults(
   cohort: ToolCallReceiptCohort,
   members: NativeBatchToolCallMember[],
@@ -204,11 +137,10 @@ async function collectMemberResults(
       results.set(member.memberId, state.result);
       continue;
     }
-    if (state.kind === 'following' || state.kind === 'recovering') {
+    if (state.kind === 'following') {
       results.set(member.memberId, await state.result);
       continue;
     }
-    if (state.kind === 'failed') throw state.error;
     throw new Error(
       `Native Batch Tool Call left owned member ${member.memberId} without a terminal result.`,
     );
@@ -216,21 +148,6 @@ async function collectMemberResults(
   return results;
 }
 
-async function assertCohortOwned(
-  cohort: ToolCallReceiptCohort,
-  heartbeat: { assertOwned(): void } | null,
-  leaseLost: ToolCallReceiptLeaseLostError | null,
-): Promise<void> {
-  heartbeat?.assertOwned();
-  if (leaseLost) throw leaseLost;
-  const status = await cohort.heartbeat();
-  if (status === 'terminal') {
-    throw new ToolCallReceiptLeaseLostError('native-batch-cohort');
-  }
-  heartbeat?.assertOwned();
-  if (leaseLost) throw leaseLost;
-}
-
 async function failOwned(
   cohort: ToolCallReceiptCohort,
   owned: NativeBatchOwnedToolCallMember[],