deepline 0.1.108 → 0.1.110

package/dist/repo/apps/play-runner-workers/src/runtime/csv-rows.ts

@@ -0,0 +1,102 @@
+import {
+  cloneCsvAliasedRow,
+  stripCsvProjectionMetadata,
+} from '../../../../shared_libs/play-runtime/csv-rename';
+
+const CSV_TEMPLATE_CONTEXT = '__deeplineCsvProjectedValues';
+const RUNTIME_STORAGE_FIELDS = [
+  '__deeplineRowKey',
+  '__deeplineCellMetaPatch',
+  '__deeplineRowStatus',
+  '__deeplineRowError',
+] as const;
+
+export type CsvRuntimeRow = Record<string, unknown>;
+
+function copyVisibleFields(
+  row: CsvRuntimeRow,
+  keepTemplateContext: boolean,
+): CsvRuntimeRow {
+  const publicRow: CsvRuntimeRow = {};
+  for (const fieldName of Reflect.ownKeys(row)) {
+    if (
+      typeof fieldName === 'string' &&
+      fieldName.startsWith('__deepline') &&
+      (!keepTemplateContext || fieldName !== CSV_TEMPLATE_CONTEXT)
+    ) {
+      continue;
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(row, fieldName);
+    if (!descriptor) continue;
+    Object.defineProperty(publicRow, fieldName, descriptor);
+  }
+  return publicRow;
+}
+
+function withCtx(
+  row: CsvRuntimeRow,
+  contextSource: CsvRuntimeRow = row,
+): CsvRuntimeRow {
+  const ctx = contextSource[CSV_TEMPLATE_CONTEXT];
+  if (ctx) {
+    const values = ctx as CsvRuntimeRow;
+    for (const fieldName in values) {
+      delete row[fieldName];
+      row[fieldName] = values[fieldName];
+    }
+  }
+  return row;
+}
+
+export function publicCsvInputRow<T extends CsvRuntimeRow>(row: T): T {
+  return copyVisibleFields(stripCsvProjectionMetadata(row), false) as T;
+}
+
+export function runtimeCsvInputRow<T extends CsvRuntimeRow>(row: T): T {
+  return withCtx(copyVisibleFields(cloneCsvAliasedRow(row), true)) as T;
+}
+
+export function runtimeCsvExecutionRow<T extends CsvRuntimeRow>(
+  sourceRow: T,
+  pendingRow?: CsvRuntimeRow | null,
+): T {
+  const source = runtimeCsvInputRow(sourceRow) as CsvRuntimeRow;
+  if (!pendingRow) return source as T;
+  const pending = runtimeCsvInputRow(pendingRow);
+  const executionRow = { ...pending, ...source };
+  if ('__deeplineCellMeta' in pendingRow) {
+    executionRow.__deeplineCellMeta = pendingRow.__deeplineCellMeta;
+  }
+  return withCtx(executionRow) as T;
+}
+
+export function publicCsvOutputRow<T extends CsvRuntimeRow>(row: T): T {
+  return publicCsvInputRow(row);
+}
+
+function copyRuntimeStorageFields(
+  target: CsvRuntimeRow,
+  row: CsvRuntimeRow,
+): CsvRuntimeRow {
+  for (const runtimeField of RUNTIME_STORAGE_FIELDS) {
+    if (runtimeField in row) {
+      target[runtimeField] = row[runtimeField];
+    }
+  }
+  return target;
+}
+
+export function publicCsvStorageRow<T extends CsvRuntimeRow>(row: T): T {
+  const publicRow = publicCsvInputRow(row) as CsvRuntimeRow;
+  const storageRow: CsvRuntimeRow = {};
+  for (const fieldName of Reflect.ownKeys(publicRow)) {
+    if (typeof fieldName !== 'string') continue;
+    storageRow[fieldName] = publicRow[fieldName];
+  }
+  return copyRuntimeStorageFields(storageRow, row) as T;
+}
+
+export function runtimeCsvStorageRow<T extends CsvRuntimeRow>(row: T): T {
+  const storageRow = publicCsvStorageRow(row) as CsvRuntimeRow;
+  return withCtx(storageRow, row) as T;
+}

package/dist/repo/apps/play-runner-workers/src/runtime/dataset-handles.ts

@@ -1,7 +1,7 @@
 import {
   applyCsvRenameProjection,
+  cloneCsvAliasedRow,
   stripCsvProjectedFields,
-  stripCsvProjectionMetadata,
   type CsvRenameOptions,
 } from '../../../../shared_libs/play-runtime/csv-rename';
 import {
@@ -53,10 +53,15 @@ function cloneRow<T extends DatasetRow>(row: T): T {
 }
 
 function internalDatasetRow<T extends DatasetRow>(row: T): T {
-  const stripped = stripCsvProjectionMetadata(row) as DatasetRow;
+  const stripped = cloneCsvAliasedRow(row);
   const publicRow: DatasetRow = {};
   for (const key of Reflect.ownKeys(stripped)) {
-    if (typeof key === 'string' && key.startsWith('__deepline')) continue;
+    if (
+      typeof key === 'string' &&
+      /^__deepline(?!CsvProjectedValues$)/.test(key)
+    ) {
+      continue;
+    }
     const descriptor = Object.getOwnPropertyDescriptor(stripped, key);
     if (!descriptor) continue;
     Object.defineProperty(publicRow, key, descriptor);

package/dist/repo/apps/play-runner-workers/src/runtime/receipts.ts

@@ -41,22 +41,13 @@ function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
-function runningReceiptError(
-  key: string,
-  receipt: WorkerRuntimeReceipt,
-): Error {
-  return new Error(
-    `Runtime receipt ${key} is already running for run ${receipt.runId ?? 'unknown'}.`,
-  );
-}
-
 async function executeAndPersistReceipt<T>(input: {
   key: string;
   playName: string;
   runId: string;
   execute: () => Promise<T> | T;
   receiptStore: WorkerRuntimeReceiptStore;
-  ownership: 'claimed' | 'workflow_replay';
+  ownership: 'claimed' | 'reconciled';
 }): Promise<T> {
   let output: T;
   try {
@@ -83,9 +74,13 @@ async function executeAndPersistReceipt<T>(input: {
     output,
   });
   if (!completed) {
-    throw new Error(
-      `Runtime receipt ${input.key} ${input.ownership} execution completed but completed receipt could not be persisted.`,
-    );
+    return output;
+  }
+  if (
+    (completed.status === 'completed' || completed.status === 'skipped') &&
+    completed.output !== undefined
+  ) {
+    return receiptOutput<T>(completed);
   }
   return output;
 }
@@ -94,6 +89,7 @@ export async function runWorkerRuntimeReceiptBoundary<T>(
   input: RuntimeReceiptContext & {
     execute: () => Promise<T> | T;
     repairRunningReceiptForSameRun?: boolean;
+    reclaimRunning?: boolean;
   },
 ): Promise<T> {
   const key = scopedReceiptKey(input);
@@ -102,25 +98,20 @@ export async function runWorkerRuntimeReceiptBoundary<T>(
     playName: input.playName,
     runId: input.runId,
     key,
+    ...(input.reclaimRunning === true ? { reclaimRunning: true } : {}),
   });
   if (claimed.disposition === 'reused') {
     return receiptOutput<T>(claimed.receipt);
   }
   if (claimed.disposition === 'running') {
-    if (
-      input.repairRunningReceiptForSameRun &&
-      claimed.receipt.runId === input.runId
-    ) {
-      return executeAndPersistReceipt({
-        key,
-        playName: input.playName,
-        runId: input.runId,
-        execute: input.execute,
-        receiptStore,
-        ownership: 'workflow_replay',
-      });
-    }
-    throw runningReceiptError(key, claimed.receipt);
+    return executeAndPersistReceipt({
+      key,
+      playName: input.playName,
+      runId: input.runId,
+      execute: input.execute,
+      receiptStore,
+      ownership: 'reconciled',
+    });
   }
   if (claimed.disposition === 'failed') {
     throw new Error(

package/dist/repo/apps/play-runner-workers/src/workflow-instance-create.ts

@@ -0,0 +1,44 @@
+export type WorkflowInstanceLike = {
+  id: string;
+};
+
+export type WorkflowInstanceCreateResult<T extends WorkflowInstanceLike> = {
+  instance: T;
+  startMode: 'created' | 'reattached_existing';
+};
+
+export function isWorkflowInstanceAlreadyExistsError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error);
+  return /instance[._ -]?already[._ -]?exists|Instance already exists/i.test(
+    message,
+  );
+}
+
+export async function createOrAttachWorkflowInstance<
+  T extends WorkflowInstanceLike,
+>(input: {
+  create: () => Promise<T>;
+  getExisting: () => Promise<T>;
+}): Promise<WorkflowInstanceCreateResult<T>> {
+  try {
+    return { instance: await input.create(), startMode: 'created' };
+  } catch (error) {
+    if (!isWorkflowInstanceAlreadyExistsError(error)) {
+      throw error;
+    }
+    try {
+      return {
+        instance: await input.getExisting(),
+        startMode: 'reattached_existing',
+      };
+    } catch (attachError) {
+      const message =
+        attachError instanceof Error
+          ? attachError.message
+          : String(attachError);
+      throw new Error(
+        `Workflow instance already exists but could not be reattached: ${message}`,
+      );
+    }
+  }
+}

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

@@ -1,7 +1,4 @@
-import {
-  isCloudflareDurableObjectCodeUpdatedError,
-  normalizePlayRunFailure,
-} from '../../../shared_libs/play-runtime/run-failure';
+import { normalizePlayRunFailure } from '../../../shared_libs/play-runtime/run-failure';
 
 export const PLATFORM_DEPLOY_WORKFLOW_RETRY_LIMIT = 1;
 
@@ -26,25 +23,24 @@ export function decideWorkflowPlatformRetry(input: {
   if (!input.error) {
     return { action: 'fail', reason: null, message: null };
   }
-  const retryablePlatformReset = isCloudflareDurableObjectCodeUpdatedError(
-    input.error,
-  );
+  const failure = normalizePlayRunFailure(input.error);
+  const retryablePlatformReset = failure.code === 'PLATFORM_DEPLOY_INTERRUPTED';
   if (
     retryablePlatformReset &&
     input.retryAttempts < PLATFORM_DEPLOY_WORKFLOW_RETRY_LIMIT
   ) {
     return {
       action: 'retry',
-      reason: 'cloudflare_durable_object_code_updated',
+      reason: 'cloudflare_durable_object_reset',
       nextAttempt: input.retryAttempts + 1,
-      message: normalizePlayRunFailure(input.error).message,
+      message: failure.message,
     };
   }
   return {
     action: 'fail',
     reason: retryablePlatformReset
-      ? 'cloudflare_durable_object_code_updated_retry_exhausted'
+      ? 'cloudflare_durable_object_reset_retry_exhausted'
       : null,
-    message: normalizePlayRunFailure(input.error).message,
+    message: failure.message,
   };
 }

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

@@ -413,11 +413,14 @@ export type BillingPlanEntry = {
 };
 
 /** One usage metric published in the billing catalog. */
-export type BillingMetricEntry = {
+export type BillingMeterEntry = {
   id: string;
   name: string;
 };
 
+/** @deprecated Use BillingMeterEntry. Retained for wire/API alias compatibility. */
+export type BillingMetricEntry = BillingMeterEntry;
+
 /** The caller's active plan as reported by the plans endpoint. */
 export type BillingActivePlan = {
   plan_family_id: string;
@@ -440,6 +443,8 @@ export type BillingPlansResult = {
   catalog_version: string;
   active_plan: BillingActivePlan;
   plans: BillingPlanEntry[];
+  meters: BillingMeterEntry[];
+  /** @deprecated Use meters. Retained for installed SDK compatibility. */
   metrics: BillingMetricEntry[];
 };
 
@@ -1075,12 +1080,12 @@ export class DeeplineClient {
    * Returns everything from {@link ToolDefinition} plus pricing info, sample
    * inputs/outputs, failure modes, and cost estimates.
    *
-   * @param toolId - Tool identifier (e.g. `"apollo_people_search"`)
+   * @param toolId - Tool identifier (e.g. `"dropleads_search_people"`)
    * @returns Full tool metadata
    *
    * @example
    * ```typescript
-   * const meta = await client.getTool('apollo_people_search');
+   * const meta = await client.getTool('dropleads_search_people');
    * console.log(`Cost: ${meta.estimatedCreditsRange} credits`);
    * console.log(`Input schema:`, meta.inputSchema);
    * ```
@@ -1120,6 +1125,7 @@ export class DeeplineClient {
       `/api/v2/integrations/${encodeURIComponent(toolId)}/execute`,
       { payload: input },
       headers,
+      { forbiddenAsApiError: true },
     );
   }
 
@@ -1228,7 +1234,7 @@ export class DeeplineClient {
           ? { waitForCompletionMs: request.waitForCompletionMs }
           : {}),
         // Profile selection is the API's job, not the CLI's. The server
-        // hardcodes workers_edge as the default; tests that want a
+        // defaults to workers_edge; tests and runtime probes that want a
         // different profile pass `request.profile` explicitly.
         ...(request.profile ? { profile: request.profile } : {}),
       },
@@ -1338,10 +1344,15 @@ export class DeeplineClient {
         sourceFiles: input.sourceFiles,
         artifact: input.artifact,
       }));
-    return this.http.post('/api/v2/plays/artifacts', {
-      ...input,
-      compilerManifest,
-    });
+    return this.http.post(
+      '/api/v2/plays/artifacts',
+      {
+        ...input,
+        compilerManifest,
+      },
+      undefined,
+      { forbiddenAsApiError: true, retryApiErrors: true },
+    );
   }
 
   /**
@@ -1379,7 +1390,12 @@ export class DeeplineClient {
     }>;
   }> {
     if (artifacts.length === 0) {
-      return this.http.post('/api/v2/plays/artifacts', { artifacts });
+      return this.http.post(
+        '/api/v2/plays/artifacts',
+        { artifacts },
+        undefined,
+        { forbiddenAsApiError: true, retryApiErrors: true },
+      );
     }
     const compiledArtifacts = await mapWithConcurrency(
       artifacts,
@@ -1414,9 +1430,14 @@ export class DeeplineClient {
             triggerMetadata?: unknown;
             triggerBindings?: unknown;
           }>;
-        }>('/api/v2/plays/artifacts', {
-          artifacts: chunk,
-        }),
+        }>(
+          '/api/v2/plays/artifacts',
+          {
+            artifacts: chunk,
+          },
+          undefined,
+          { forbiddenAsApiError: true, retryApiErrors: true },
+        ),
       );
     }
     return {
@@ -2446,6 +2467,8 @@ export class DeeplineClient {
     return this.http.post<PublishPlayVersionResult>(
       `/api/v2/plays/${encodedName}/live`,
       request,
+      undefined,
+      { forbiddenAsApiError: true },
     );
   }
 

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

@@ -10,7 +10,7 @@
  *
  * const client = new DeeplineClient();
  * try {
- *   await client.executeTool('apollo_people_search', { query: 'cto' });
+ *   await client.executeTool('dropleads_search_people', { query: 'cto' });
  * } catch (err) {
  *   if (err instanceof AuthError) {
  *     console.error('Bad API key — run: deepline auth register');
@@ -77,7 +77,7 @@ export class AuthError extends DeeplineError {
  * import { RateLimitError } from 'deepline';
  *
  * try {
- *   await client.executeTool('apollo_people_search', { query: 'cto' });
+ *   await client.executeTool('dropleads_search_people', { query: 'cto' });
  * } catch (err) {
  *   if (err instanceof RateLimitError) {
  *     console.log(`Retry after ${err.retryAfterMs}ms`);

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

@@ -29,11 +29,14 @@ import { baseUrlSlug } from './config.js';
 import {
   COORDINATOR_INTERNAL_TOKEN_HEADER,
   COORDINATOR_URL_OVERRIDE_HEADER,
+  RUNTIME_SCHEDULER_SCHEMA_OVERRIDE_HEADER,
   SYNTHETIC_RUN_HEADER,
   WORKER_CALLBACK_URL_OVERRIDE_HEADER,
 } from '../../shared_libs/play-runtime/coordinator-headers.js';
 
 const MAX_DIAGNOSTIC_HEADER_LENGTH = 120;
+const COWORK_NETWORK_HINT =
+  'Claude Cowork appears to be running Deepline in a network-restricted sandbox. In Claude Desktop, open Settings > Capabilities, turn on Allow network egress, and set Domain allowlist to All domains for the Cowork session.';
 
 interface RequestOptions {
   method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
@@ -50,6 +53,11 @@ interface RequestOptions {
    * {@link AuthError}.
    */
   forbiddenAsApiError?: boolean;
+  /**
+   * Retry HTTP 408/425/5xx JSON API responses. Use only for idempotent requests;
+   * most mutating API calls must fail loudly after the first server response.
+   */
+  retryApiErrors?: boolean;
 }
 
 interface StreamOptions {
@@ -113,6 +121,7 @@ export class HttpClient {
       'User-Agent': `deepline-ts-sdk/${SDK_VERSION}`,
       'X-Deepline-Client-Family': 'sdk',
       'X-Deepline-CLI-Family': 'sdk',
+      'X-Deepline-Agent-Runtime': detectAgentRuntime(),
       'X-Deepline-CLI-Version': SDK_VERSION,
       'X-Deepline-SDK-Version': SDK_VERSION,
       'X-Deepline-API-Contract': SDK_API_CONTRACT,
@@ -158,6 +167,14 @@ export class HttpClient {
     if (workerCallbackUrl?.trim()) {
       headers[WORKER_CALLBACK_URL_OVERRIDE_HEADER] = workerCallbackUrl.trim();
     }
+    const runtimeSchedulerSchema =
+      typeof process !== 'undefined'
+        ? process.env?.DEEPLINE_RUNTIME_SCHEDULER_SCHEMA
+        : undefined;
+    if (runtimeSchedulerSchema?.trim()) {
+      headers[RUNTIME_SCHEDULER_SCHEMA_OVERRIDE_HEADER] =
+        runtimeSchedulerSchema.trim();
+    }
     // Automated test harnesses (e.g. tests/v2-plays) set DEEPLINE_SYNTHETIC_RUN
     // so their intentionally failing plays do not page the SDK CLI error
     // channel. Honored server-side only in non-prod (see plays/run route).
@@ -261,6 +278,9 @@ export class HttpClient {
           }
 
           if (!response.ok) {
+            const retryableApiError =
+              options?.retryApiErrors === true &&
+              isRetryableApiErrorResponse(response.status);
             // A 5xx that escaped a Worker can return Cloudflare's default HTML
             // error page. Never surface raw HTML to CLI users: replace the
             // message with a structured summary and store a short flag in
@@ -271,7 +291,7 @@ export class HttpClient {
               response.headers.get('content-type'),
             );
             if (htmlError) {
-              throw new DeeplineError(
+              lastError = new DeeplineError(
                 htmlError.message(response.status),
                 response.status,
                 'API_ERROR',
@@ -283,6 +303,11 @@ export class HttpClient {
                     : {}),
                 },
               );
+              if (retryableApiError && attempt < this.config.maxRetries) {
+                retryAfterDelayMs = parseOptionalRetryAfter(response);
+                break;
+              }
+              throw lastError;
             }
             const errorValue =
               typeof parsed === 'object' && parsed && 'error' in parsed
@@ -304,9 +329,20 @@ export class HttpClient {
                         'string'
                     ? (parsed as Record<string, string>).message
                     : `HTTP ${response.status}`;
-            throw new DeeplineError(msg, response.status, 'API_ERROR', {
+            const apiErrorCode =
+              errorValue &&
+              typeof errorValue === 'object' &&
+              typeof (errorValue as Record<string, unknown>).code === 'string'
+                ? (errorValue as Record<string, string>).code
+                : 'API_ERROR';
+            lastError = new DeeplineError(msg, response.status, apiErrorCode, {
               response: parsed,
             });
+            if (retryableApiError && attempt < this.config.maxRetries) {
+              retryAfterDelayMs = parseOptionalRetryAfter(response);
+              break;
+            }
+            throw lastError;
           }
 
           return parsed as T;
@@ -332,7 +368,7 @@ export class HttpClient {
     const errorMessage = lastError?.message
       ? `Unable to connect to ${baseUrl}. ${lastError.message}`
       : `Unable to connect to ${baseUrl}. Is the computer able to access the url?`;
-    throw new DeeplineError(errorMessage);
+    throw new DeeplineError(withCoworkNetworkHint(errorMessage));
   }
 
   /**
@@ -418,9 +454,11 @@ export class HttpClient {
     }
 
     throw new DeeplineError(
-      lastError?.message
-        ? `Unable to stream from ${this.config.baseUrl}. ${lastError.message}`
-        : `Unable to stream from ${this.config.baseUrl}.`,
+      withCoworkNetworkHint(
+        lastError?.message
+          ? `Unable to stream from ${this.config.baseUrl}. ${lastError.message}`
+          : `Unable to stream from ${this.config.baseUrl}.`,
+      ),
     );
   }
 
@@ -435,11 +473,16 @@ export class HttpClient {
     path: string,
     body: unknown,
     headers?: Record<string, string>,
+    options?: Pick<
+      RequestOptions,
+      'forbiddenAsApiError' | 'retryApiErrors' | 'timeout'
+    >,
   ): Promise<T> {
     return this.request<T>(path, {
       method: 'POST',
       body,
       headers,
+      ...options,
     });
   }
 
@@ -455,12 +498,23 @@ export class HttpClient {
     });
   }
 
+  /**
+   * Send a PATCH request with a JSON body.
+   *
+   * @typeParam T - Expected response body type
+   * @param path - API path
+   * @param body - JSON-serializable request body
+   */
   async patch<T = unknown>(
     path: string,
-    body: unknown,
+    body?: unknown,
     headers?: Record<string, string>,
   ): Promise<T> {
-    return this.request<T>(path, { method: 'PATCH', body, headers });
+    return this.request<T>(path, {
+      method: 'PATCH',
+      body,
+      headers,
+    });
   }
 
   /**
@@ -482,6 +536,10 @@ function parseResponseBody(body: string): unknown {
   }
 }
 
+function isRetryableApiErrorResponse(status: number): boolean {
+  return status === 408 || status === 425 || (status >= 500 && status < 600);
+}
+
 /**
  * Detect a raw Cloudflare HTML error page in an error response body.
  *
@@ -559,6 +617,10 @@ function apiErrorMessage(parsed: unknown, status: number): string {
 
 /** Parse the `Retry-After` header as milliseconds. Falls back to 5000ms. */
 function parseRetryAfter(response: Response): number {
+  return parseOptionalRetryAfter(response) ?? 5000;
+}
+
+function parseOptionalRetryAfter(response: Response): number | null {
   const header = response.headers.get('retry-after');
   if (header) {
     const seconds = Number(header);
@@ -566,7 +628,7 @@ function parseRetryAfter(response: Response): number {
       return seconds * 1000;
     }
   }
-  return 5000;
+  return null;
 }
 
 /**
@@ -650,3 +712,41 @@ function decodeSseFrame<TEvent extends LiveEventEnvelope>(
 function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+
+function isTruthyEnv(name: string): boolean {
+  const normalized = process.env[name]?.trim().toLowerCase();
+  return ['1', 'true', 'yes', 'on'].includes(normalized ?? '');
+}
+
+function isCoworkLikeSandbox(): boolean {
+  const pluginMode = isTruthyEnv('DEEPLINE_PLUGIN_MODE');
+  const claudeRemote = isTruthyEnv('CLAUDE_CODE_REMOTE');
+  const projectDir = Boolean(process.env.CLAUDE_PROJECT_DIR?.trim());
+  const pluginRoot = Boolean(process.env.DEEPLINE_PLUGIN_ROOT?.trim());
+  const home = process.env.HOME?.trim() ?? '';
+  const sessionHome = home.startsWith('/sessions/');
+  return (
+    (pluginMode || pluginRoot) && (claudeRemote || projectDir || sessionHome)
+  );
+}
+
+function detectAgentRuntime(): string {
+  if (process.env.CODEX_THREAD_ID?.trim()) return 'codex';
+  if (isCoworkLikeSandbox()) return 'claude_cowork';
+  if (process.env.CLAUDECODE?.trim() === '1') return 'claude_code';
+  if (process.env.CLINE_ACTIVE?.trim().toLowerCase() === 'true') return 'cline';
+  if (process.env.CURSOR_TRACE_ID?.trim() || process.env.CURSOR_AGENT?.trim()) {
+    return 'cursor';
+  }
+  if (process.env.WINDSURF?.trim() || process.env.CASCADE?.trim()) {
+    return 'windsurf';
+  }
+  return 'unknown';
+}
+
+function withCoworkNetworkHint(message: string): string {
+  if (!isCoworkLikeSandbox() || message.includes(COWORK_NETWORK_HINT)) {
+    return message;
+  }
+  return `${message}\n${COWORK_NETWORK_HINT}`;
+}

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

@@ -173,6 +173,10 @@ export type {
   FileInput,
   PlayInputContract,
   PlayJob,
+  SqlListenerDeclaration,
+  SqlListenerEvent,
+  SqlListenerOperation,
+  SqlQuery,
   ConditionalStepResolver,
   PreviousCell,
   PlayDataset,