deepline 0.1.262 → 0.1.264

package/dist/bundling-sources/sdk/src/client.ts

@@ -1402,6 +1402,7 @@ export class DeeplineClient {
    */
   async listTools(options?: {
     categories?: string;
+    tags?: string;
     grep?: string;
     grepMode?: 'all' | 'any' | 'phrase';
     compact?: boolean;
@@ -1410,6 +1411,9 @@ export class DeeplineClient {
     if (options?.categories?.trim()) {
       params.set('categories', options.categories.trim());
     }
+    if (options?.tags?.trim()) {
+      params.set('tags', options.tags.trim());
+    }
     if (options?.grep?.trim()) {
       params.set('grep', options.grep.trim());
       params.set('grep_mode', options.grepMode ?? 'all');

package/dist/bundling-sources/sdk/src/release.ts

@@ -123,8 +123,10 @@ export const SDK_RELEASE = {
   // Deepline-native radars. Older clients must update before discovering,
   // checking, or deploying an unlaunched monitor integration.
   // 0.1.253 makes play-page browser opening opt-in and retires --no-open.
-  version: '0.1.262',
-  apiContract: '2026-07-native-monitor-launch-hard-cutover',
+  // 0.1.254 removes the internal operations tree from the published SDK CLI.
+  // Operators use the checkout-local deepline-admin binary instead.
+  version: '0.1.264',
+  apiContract: '2026-07-admin-cli-local-cutover',
   supportPolicy: {
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.219',

package/dist/bundling-sources/sdk/src/types.ts

@@ -151,6 +151,8 @@ export interface ToolDefinition {
   description: string;
   /** Categorization tags (e.g. `["people", "enrichment"]`). */
   categories: DeeplineToolCategory[];
+  /** Searchable provider and account-signal tags. */
+  tags?: string[];
   /** Operation slug within the provider. */
   operation?: string;
   /** Normalized operation identifier. */

package/dist/bundling-sources/shared_libs/play-runtime/row-isolation.ts

@@ -1,5 +1,6 @@
 import { isHardBillingToolHttpError } from './tool-http-errors';
 import { isRuntimePersistenceCircuitOpenError } from './persistence-latch';
+import { isWorkspaceStorageNotReadyFailure } from './run-failure';
 
 /**
  * Thrown by runner Adapters when a Play Run is externally cancelled. Row
@@ -41,6 +42,7 @@ export function isRowIsolationExemptError(error: unknown): boolean {
   if (isRuntimeReceiptPersistenceError(error)) return true;
   if (isRuntimeStoragePersistenceError(error)) return true;
   if (isRuntimePersistenceCircuitOpenError(error)) return true;
+  if (isWorkspaceStorageNotReadyFailure(error)) return true;
   return isHardBillingToolHttpError(error);
 }
 

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

@@ -59,6 +59,24 @@ export class WorkspaceStorageNotReadyError extends Error {
   }
 }
 
+export function isWorkspaceStorageNotReadyFailure(error: unknown): boolean {
+  if (error instanceof WorkspaceStorageNotReadyError) return true;
+  if (!error) return false;
+  if (typeof error === 'object') {
+    const code = (error as { code?: unknown }).code;
+    if (code === WORKSPACE_STORAGE_NOT_READY_CODE) return true;
+    const nestedErrors = (error as { errors?: unknown }).errors;
+    if (
+      Array.isArray(nestedErrors) &&
+      nestedErrors.some(isWorkspaceStorageNotReadyFailure)
+    ) {
+      return true;
+    }
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return /\bWORKSPACE_STORAGE_NOT_READY\b/.test(message);
+}
+
 export const PROVIDER_EXHAUSTED_CODE = 'PROVIDER_EXHAUSTED';
 
 /**
@@ -331,7 +349,7 @@ export function normalizePlayRunFailure(error: unknown): PlayRunFailureDetails {
     };
   }
   if (
-    error instanceof WorkspaceStorageNotReadyError ||
+    isWorkspaceStorageNotReadyFailure(error) ||
     /\bWORKSPACE_STORAGE_NOT_READY\b/.test(rawCause)
   ) {
     return {

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/daytona.ts

@@ -490,6 +490,25 @@ function isRetryableDaytonaInfrastructureFailure(error: unknown): boolean {
   return DAYTONA_INFRASTRUCTURE_RETRY_PATTERN.test(message);
 }
 
+function isRetryableUnstartedDaytonaRunner(
+  error: unknown,
+): error is DaytonaRunnerInitializationError {
+  if (!(error instanceof DaytonaRunnerInitializationError)) return false;
+  const diagnostic = error.startupDiagnostic;
+  // The sandbox runner cannot execute customer code until the worker observes
+  // its heartbeat, parks the scheduler attempt, and the gateway acknowledges
+  // that waiting state. If no heartbeat was observed and Daytona has no exit
+  // evidence, deleting this fenced sandbox and retrying once cannot duplicate
+  // customer side effects.
+  return (
+    diagnostic.commandFound &&
+    diagnostic.sessionFound &&
+    diagnostic.exitCode === null &&
+    diagnostic.exitCodeFile === null &&
+    !diagnostic.schedulerReadinessObserved
+  );
+}
+
 function prepareDaytonaExecution(
   input: PlayRunnerPrepareInput,
   callbacks: Parameters<PlayRunnerBackend['execute']>[1],
@@ -930,14 +949,19 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
             onCancel();
             throw new Error(DAYTONA_CANCELLED_ERROR);
           }
+          const retryReason = isRetryableUnstartedDaytonaRunner(error)
+            ? 'runner_startup_not_live'
+            : isRetryableDaytonaInfrastructureFailure(error)
+              ? 'daytona_infrastructure'
+              : null;
           if (
             executionAttempt < DAYTONA_INFRASTRUCTURE_MAX_ATTEMPTS &&
-            isRetryableDaytonaInfrastructureFailure(error)
+            retryReason
           ) {
             emitDaytonaStage(callbacks, config.context, 'execute:retry', {
               sandboxId: sandboxForAttempt?.id ?? null,
               attempt: executionAttempt + 1,
-              reason: 'daytona_infrastructure',
+              reason: retryReason,
               error: error instanceof Error ? error.message : String(error),
               elapsedMs: Date.now() - startedAt,
             });

package/dist/bundling-sources/shared_libs/play-runtime/transient-service-error.ts

@@ -2,6 +2,15 @@ export function transientServiceUnavailableDetail(
   error: unknown,
 ): string | null {
   const detail = error instanceof Error ? error.message : String(error);
+  // The Convex HTTP client surfaces socket/DNS interruptions as the native
+  // Undici `TypeError: fetch failed`, without an HTTP envelope. Callers only
+  // use this classifier where replay is explicitly safe (for example, reads).
+  if (
+    error instanceof TypeError &&
+    /^fetch failed$/i.test(detail.trim())
+  ) {
+    return detail;
+  }
   // Convex uses both an explicit ServiceUnavailable response and this generic
   // InternalServerError envelope for short control-plane outages. The latter
   // text is intentionally exact: application exceptions must not become