deepline 0.3.71 → 0.3.72

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/plays/authoring-contract.ts

@@ -456,9 +456,7 @@ export type PlayAuthoringCronInput<TInput> = TInput extends readonly unknown[]
     : never;
 
 /** The one public type for options accepted by definePlay. */
-export type PlayAuthoringBindings<
-  TInput = Record<string, unknown>,
-> = {
+export type PlayAuthoringBindings<TInput = Record<string, unknown>> = {
   description?: string;
   compatibility?: {
     toolErrorSchemaVersion?: ToolExecutionErrorSchemaVersion;
@@ -1239,7 +1237,14 @@ export interface PlayAuthoringRuntimeContext {
     options: PlayAuthoringCallOptions,
   ): Promise<TOutput>;
 
-  log(message: string): void;
+  /**
+   * Write a customer-safe line to the durable Run Log Stream. Omitting level
+   * preserves the historical info-level behavior.
+   */
+  log(
+    message: string,
+    options?: { level?: 'debug' | 'info' | 'warn' | 'error' },
+  ): void;
   sleep(ms: number): Promise<void>;
 }
 
@@ -2783,7 +2788,7 @@ export const PLAY_AUTHORING_CLOUD_TYPE_DECLARATIONS = [
   "  fetch(key: string, url: string | URL, init?: RequestInit & { headers?: HeadersInit & { 'Idempotency-Key'?: string; 'X-Idempotency-Key'?: string }; auth?: SecretAuthInput }, options?: FetchOptions): Promise<PlayFetchResponse>;",
   '  secrets: { get(name: string): SecretPromise; bearer(secret: string | SecretPromise | SecretHandle): SecretAuth; header(header: string, secret: string | SecretPromise | SecretHandle): SecretAuth };',
   `  runPlay<TOutput = unknown>(key: string, playRef: ${cloudReferenceType('ctx.runPlay.playRef')}, input: ${cloudReferenceType('ctx.runPlay.input')}, options: PlayCallOptions): Promise<TOutput>;`,
-  '  log(message: string): void;',
+  "  log(message: string, options?: { level?: 'debug' | 'info' | 'warn' | 'error' }): void;",
   `  sleep(ms: ${cloudReferenceType('ctx.sleep.ms')}): Promise<void>;`,
   '}',
   "export type DefinePlayConfig<TInput, TOutput extends PlayReturnObject> = { id: string; description?: string; input: PlayInputContract<TInput>; run: (ctx: DeeplinePlayRuntimeContext, input: TInput) => Promise<TOutput>; bindings?: PlayBindings<TInput>; billing?: PlayBindings<TInput>['billing']; runtime?: PlayBindings<TInput>['runtime']; compatibility?: PlayBindings<TInput>['compatibility'] };",