deepline 0.1.79 → 0.1.81

package/dist/repo/apps/play-runner-workers/src/runtime/tool-http-errors.ts

@@ -139,6 +139,43 @@ function formatInsufficientCreditsMessage(input: {
   return `Workspace balance ${balance} < required ${required} for ${operation}.${addSuffix}`;
 }
 
+function formatPublicToolErrorPayload(input: {
+  parsed: Record<string, unknown> | null;
+  bodyText: string;
+}): string {
+  if (!input.parsed) {
+    return input.bodyText.slice(0, 500);
+  }
+
+  const selected: Record<string, unknown> = {};
+  for (const key of [
+    'error',
+    'message',
+    'code',
+    'failure_origin',
+    'error_category',
+    'failure_description',
+    'operator_hint',
+    'failure_hint',
+    'details',
+    'provider',
+    'operation',
+    'request_id',
+    'requestId',
+    'credential_source',
+    'credential_owner',
+  ]) {
+    const value = input.parsed[key];
+    if (typeof value === 'string' && value.trim()) {
+      selected[key] = value;
+    }
+  }
+
+  return JSON.stringify(
+    Object.keys(selected).length > 0 ? selected : input.parsed,
+  ).slice(0, 1_500);
+}
+
 export function normalizeToolHttpErrorMessage(input: {
   toolId: string;
   status: number;
@@ -183,7 +220,12 @@ export function normalizeToolHttpErrorMessage(input: {
     );
   }
   return new ToolHttpError(
-    `tool ${input.toolId} ${input.status} attempt ${input.attempt}/${input.maxAttempts}: ${input.bodyText.slice(0, 500)}`,
+    `tool ${input.toolId} ${input.status} attempt ${input.attempt}/${input.maxAttempts}: ${formatPublicToolErrorPayload(
+      {
+        parsed,
+        bodyText: input.bodyText,
+      },
+    )}`,
     billing,
   );
 }

package/dist/repo/apps/play-runner-workers/src/workflow-retry-state.ts

@@ -6,10 +6,16 @@ import type {
   PlayRuntimeManifestMap,
 } from '../../../shared_libs/plays/compiler-manifest';
 
-export const WORKFLOW_RETRY_STATE_TARGET_BYTES = 100_000;
+import {
+  PLAY_SUBMIT_INPUT_INLINE_MAX_BYTES,
+  PLAY_SUBMIT_INPUT_MAX_BYTES,
+} from '../../../shared_libs/play-runtime/submit-limits';
+
+export const WORKFLOW_RETRY_STATE_TARGET_BYTES =
+  PLAY_SUBMIT_INPUT_INLINE_MAX_BYTES;
 export const WORKFLOW_RETRY_PARAMS_EXTERNALIZE_AFTER_BYTES =
   WORKFLOW_RETRY_STATE_TARGET_BYTES;
-export const WORKFLOW_RETRY_PARAMS_MAX_BYTES = 1024 * 1024;
+export const WORKFLOW_RETRY_PARAMS_MAX_BYTES = PLAY_SUBMIT_INPUT_MAX_BYTES;
 
 export type WorkflowRetryParamsRef = {
   storageKind: 'r2';

package/dist/repo/sdk/src/client.ts

@@ -642,6 +642,7 @@ export class DeeplineClient {
     categories?: string;
     grep?: string;
     grepMode?: 'all' | 'any' | 'phrase';
+    compact?: boolean;
   }): Promise<ToolDefinition[]> {
     const params = new URLSearchParams();
     if (options?.categories?.trim()) {
@@ -651,6 +652,7 @@ export class DeeplineClient {
       params.set('grep', options.grep.trim());
       params.set('grep_mode', options.grepMode ?? 'all');
     }
+    params.set('compact', options?.compact === true ? 'true' : 'false');
     const suffix = params.toString() ? `?${params.toString()}` : '';
     const res = await this.http.get<{ tools: ToolDefinition[] }>(
       `/api/v2/tools${suffix}`,
@@ -1295,7 +1297,7 @@ export class DeeplineClient {
     }
     const query = params.size > 0 ? `?${params.toString()}` : '';
     const response = await this.http.get<Record<string, unknown>>(
-      `/api/v2/plays/run/${encodeURIComponent(workflowId)}${query}`,
+      `/api/v2/runs/${encodeURIComponent(workflowId)}${query}`,
     );
     return normalizePlayStatus(response);
   }
@@ -1318,10 +1320,10 @@ export class DeeplineClient {
       options?.lastEventId && options.lastEventId.trim()
         ? { 'Last-Event-ID': options.lastEventId.trim() }
         : undefined;
-    const params = new URLSearchParams({ stream: 'true' });
+    const params = new URLSearchParams();
     params.set('mode', options?.mode ?? 'cli');
     for await (const event of this.http.streamSse<PlayLiveEvent>(
-      `/api/v2/plays/run/${encodeURIComponent(workflowId)}?${params.toString()}`,
+      `/api/v2/runs/${encodeURIComponent(workflowId)}/tail?${params.toString()}`,
       { signal: options?.signal, headers },
     )) {
       if (event.scope === 'play') {
@@ -1344,7 +1346,7 @@ export class DeeplineClient {
    */
   async cancelPlay(workflowId: string): Promise<void> {
     await this.http.request(
-      `/api/v2/plays/run/${encodeURIComponent(workflowId)}/stop`,
+      `/api/v2/runs/${encodeURIComponent(workflowId)}/stop`,
       { method: 'POST' },
     );
   }
@@ -1360,7 +1362,7 @@ export class DeeplineClient {
     options?: { reason?: string },
   ): Promise<StopPlayRunResult> {
     return this.http.post<StopPlayRunResult>(
-      `/api/v2/plays/run/${encodeURIComponent(workflowId)}/stop`,
+      `/api/v2/runs/${encodeURIComponent(workflowId)}/stop`,
       options?.reason ? { reason: options.reason } : {},
     );
   }
@@ -1433,6 +1435,7 @@ export class DeeplineClient {
     if (status) {
       params.set('status', status);
     }
+    params.set('compact', 'true');
     const response = await this.http.get<{ runs: PlayRunListItem[] }>(
       `/api/v2/runs?${params.toString()}`,
     );
@@ -1490,7 +1493,7 @@ export class DeeplineClient {
     runId: string,
     options?: RunsLogsOptions,
   ): Promise<RunsLogsResult> {
-    const status = await this.getRunStatus(runId);
+    const status = await this.getRunStatus(runId, { full: true });
     const logs = status.progress?.logs ?? [];
     const limit =
       typeof options?.limit === 'number' && Number.isFinite(options.limit)
@@ -1636,10 +1639,14 @@ export class DeeplineClient {
    * @param name - Play name
    * @returns Version list (newest first)
    */
-  async listPlayVersions(name: string): Promise<PlayRevisionSummary[]> {
+  async listPlayVersions(
+    name: string,
+    options?: { full?: boolean },
+  ): Promise<PlayRevisionSummary[]> {
     const encodedName = encodeURIComponent(name);
+    const suffix = options?.full ? '?full=true' : '';
     const response = await this.http.get<{ versions: PlayRevisionSummary[] }>(
-      `/api/v2/plays/${encodedName}/versions`,
+      `/api/v2/plays/${encodedName}/versions${suffix}`,
     );
     return response.versions ?? [];
   }

package/dist/repo/sdk/src/release.ts

@@ -50,10 +50,10 @@ export type SdkRelease = {
 };
 
 export const SDK_RELEASE = {
-  version: '0.1.79',
+  version: '0.1.81',
   apiContract: '2026-06-dataset-column-cell-stale-hard-cutover',
   supportPolicy: {
-    latest: '0.1.79',
+    latest: '0.1.81',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
   },

package/dist/repo/sdk/src/types.ts

@@ -131,6 +131,10 @@ export interface ToolDefinition {
   operationId?: string;
   /** Alternative names that resolve to this tool. */
   operationAliases?: string[];
+  /** Whether detailed input schema is available from `tools describe`. */
+  hasInputSchema?: boolean;
+  /** Whether detailed output schema is available from `tools describe`. */
+  hasOutputSchema?: boolean;
   /** JSON Schema describing the tool's input parameters. */
   inputSchema?: Record<string, unknown>;
   /** JSON Schema describing the tool's output shape. */
@@ -661,6 +665,7 @@ export interface PlayListItem {
   currentPublishedVersion?: number | null;
   tableNamespace?: string | null;
   isDraftDirty?: boolean;
+  hasInputSchema?: boolean;
   inputSchema?: Record<string, unknown> | null;
   outputSchema?: Record<string, unknown> | null;
   staticPipeline?: unknown;

package/dist/repo/shared_libs/play-runtime/governor/coordinator-rate-state-backend.ts

@@ -0,0 +1,231 @@
+import {
+  noopPacingPermit,
+  type PacingPermit,
+  type PacingRule,
+  type RateStateBackend,
+} from './rate-state-backend';
+
+/**
+ * Distributed Rate State Backend for the `esm_workers` substrate.
+ *
+ * On Cloudflare a single play run fans child plays and map rows across many
+ * V8 isolates, so the per-`(org, provider)` request window cannot be
+ * process-local — each isolate would otherwise pace against its own private
+ * counter and the org could blow past a provider's real limit by the number of
+ * isolates. This backend makes the window GLOBAL by RPCing the coordinator
+ * Durable Object addressed per bucket (`idFromName('rate:<orgId>:<provider>')`).
+ * The DO is single-threaded, so it runs the same sliding-window algorithm as
+ * `InMemoryRateStateBackend` correctly for all isolates at once.
+ *
+ * Latency: a full DO round-trip on every outbound tool call would tax the
+ * hello-world latency baseline. Instead the backend LEASES SMALL PERMIT BLOCKS:
+ * one `/rate-acquire` round-trip debits up to {@link LEASE_BLOCK_SIZE} permits
+ * from the global window, and subsequent acquires draw from the local block
+ * until it is exhausted or its short TTL expires. This bounds round-trips to
+ * roughly `calls / LEASE_BLOCK_SIZE` while keeping over-issuance bounded by one
+ * block per isolate per window.
+ *
+ * Fail-open: if the coordinator is unreachable the backend logs once and
+ * PROCEEDS (grants the permit) rather than stalling the run, matching the
+ * semantics of `src/lib/redis/customer-rate-limiter.ts` — a degraded limiter
+ * must never become an availability outage. The Governor's global
+ * tool-concurrency semaphore remains the unconditional backstop.
+ */
+
+/** Permits leased per round-trip. Tuned to amortize the DO hop, not to batch. */
+const LEASE_BLOCK_SIZE = 16;
+/**
+ * Max age of a leased block. A leased permit debited the global window already,
+ * but if it is held past roughly one window it could let an isolate run ahead
+ * of a rolled-over window. Discarding stale blocks bounds that to sub-window.
+ */
+const LEASE_BLOCK_TTL_MS = 250;
+/** Cap one coordinator-provided sleep hint; total wait is bounded by run timeout. */
+const MAX_ACQUIRE_SLEEP_MS = 5_000;
+
+export interface CoordinatorRatePort {
+  /**
+   * Lease up to `requested` request-window permits for `bucketId` under all
+   * `rules` from the coordinator DO. Returns how many were `granted` (0 when the
+   * window is saturated) and a `waitMs` hint before retrying.
+   */
+  rateAcquire(input: {
+    bucketId: string;
+    rules: PacingRule[];
+    requested: number;
+  }): Promise<{ granted: number; waitMs: number }>;
+  /** Feed a Retry-After cooldown back into the global bucket. */
+  ratePenalize(input: { bucketId: string; cooldownMs: number }): Promise<void>;
+}
+
+interface LeasedBlock {
+  remaining: number;
+  expiresAt: number;
+  /** Stable signature of the rules this block was leased under. */
+  rulesKey: string;
+}
+
+interface Options {
+  now?: () => number;
+  sleep?: (ms: number) => Promise<void>;
+  onDegraded?: (info: { bucketId: string; error: string }) => void;
+}
+
+function rulesSignature(rules: readonly PacingRule[]): string {
+  return [...rules]
+    .map(
+      (rule) =>
+        `${rule.ruleId}:${rule.requestsPerWindow}:${rule.windowMs}:${rule.maxConcurrency ?? ''}`,
+    )
+    .sort()
+    .join('|');
+}
+
+export class CoordinatorRateStateBackend implements RateStateBackend {
+  private readonly port: CoordinatorRatePort;
+  private readonly now: () => number;
+  private readonly sleep: (ms: number) => Promise<void>;
+  private readonly onDegraded: (info: {
+    bucketId: string;
+    error: string;
+  }) => void;
+  private readonly blocks = new Map<string, LeasedBlock>();
+  private degradedLogged = false;
+
+  constructor(port: CoordinatorRatePort, options: Options = {}) {
+    this.port = port;
+    this.now = options.now ?? (() => Date.now());
+    this.sleep =
+      options.sleep ??
+      ((ms: number) => new Promise((resolve) => setTimeout(resolve, ms)));
+    this.onDegraded =
+      options.onDegraded ??
+      ((info) => {
+        if (this.degradedLogged) return;
+        this.degradedLogged = true;
+        console.warn('[coordinator-rate-state] acquire failed open', info);
+      });
+  }
+
+  async acquire(input: {
+    bucketId: string;
+    rules: readonly PacingRule[];
+    signal?: AbortSignal;
+  }): Promise<PacingPermit> {
+    const { bucketId, rules, signal } = input;
+    if (rules.length === 0) {
+      return noopPacingPermit();
+    }
+    const rulesKey = rulesSignature(rules);
+
+    // Draw from a still-valid local block first — no round-trip.
+    if (this.drawFromBlock(bucketId, rulesKey)) {
+      return noopPacingPermit();
+    }
+
+    while (true) {
+      if (signal?.aborted) {
+        throw signal.reason instanceof Error
+          ? signal.reason
+          : new Error('Rate-state acquire aborted.');
+      }
+      let response: { granted: number; waitMs: number };
+      try {
+        response = await this.port.rateAcquire({
+          bucketId,
+          rules: [...rules],
+          requested: LEASE_BLOCK_SIZE,
+        });
+      } catch (error) {
+        // Fail open: a degraded coordinator must not stall the run.
+        this.onDegraded({
+          bucketId,
+          error: error instanceof Error ? error.message : String(error),
+        });
+        return noopPacingPermit();
+      }
+      if (response.granted > 0) {
+        // Consume one for this call; cache the rest as a short-lived block.
+        const remaining = response.granted - 1;
+        if (remaining > 0) {
+          this.mergeBlock(bucketId, remaining, rulesKey);
+        }
+        return noopPacingPermit();
+      }
+      // Window saturated. Park for the hint, then re-acquire. This is not a
+      // degraded coordinator: the limiter answered and said "wait", so granting
+      // here would violate the provider request-rate contract. Overall wait is
+      // bounded by the play runtime deadline / abort signal.
+      const waitMs = Math.max(
+        1,
+        Math.min(response.waitMs, MAX_ACQUIRE_SLEEP_MS),
+      );
+      await this.sleep(waitMs);
+    }
+  }
+
+  penalize(input: { bucketId: string; cooldownMs: number }): void {
+    if (input.cooldownMs <= 0) return;
+    // Drop any cached block for this bucket so the cooldown takes effect on the
+    // very next acquire instead of being masked by already-leased permits.
+    this.blocks.delete(input.bucketId);
+    void this.port
+      .ratePenalize({
+        bucketId: input.bucketId,
+        cooldownMs: input.cooldownMs,
+      })
+      .catch((error) => {
+        this.onDegraded({
+          bucketId: input.bucketId,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      });
+  }
+
+  /**
+   * Add freshly-leased permits to the bucket's block instead of overwriting it.
+   * Two concurrent acquires can both miss the local block and both round-trip;
+   * each debited the global window, so the DO already issued both blocks'
+   * permits. Overwriting would drop one set — under-issuance that wastes window
+   * capacity and over-throttles. Merging preserves every debited permit:
+   *  - same rulesKey + still valid → sum remaining, keep the earlier expiry so
+   *    the merged block never outlives the older lease's sub-window bound.
+   *  - missing / stale / different rules → start fresh from this lease.
+   */
+  private mergeBlock(
+    bucketId: string,
+    remaining: number,
+    rulesKey: string,
+  ): void {
+    const freshExpiresAt = this.now() + LEASE_BLOCK_TTL_MS;
+    const existing = this.blocks.get(bucketId);
+    if (
+      existing &&
+      existing.rulesKey === rulesKey &&
+      existing.expiresAt > this.now()
+    ) {
+      existing.remaining += remaining;
+      existing.expiresAt = Math.min(existing.expiresAt, freshExpiresAt);
+      return;
+    }
+    this.blocks.set(bucketId, {
+      remaining,
+      expiresAt: freshExpiresAt,
+      rulesKey,
+    });
+  }
+
+  private drawFromBlock(bucketId: string, rulesKey: string): boolean {
+    const block = this.blocks.get(bucketId);
+    if (!block) return false;
+    if (block.rulesKey !== rulesKey || block.expiresAt <= this.now()) {
+      this.blocks.delete(bucketId);
+      return false;
+    }
+    block.remaining -= 1;
+    if (block.remaining <= 0) {
+      this.blocks.delete(bucketId);
+    }
+    return true;
+  }
+}