deepline 0.1.148 → 0.1.150

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

@@ -84,6 +84,7 @@ import type { EnrichCompiledConfig } from './cli/enrich-play-compiler.js';
 const TERMINAL_PLAY_STATUSES = new Set(['completed', 'failed', 'cancelled']);
 const INCLUDE_TOOL_METADATA_HEADER = 'x-deepline-include-tool-metadata';
 const EXECUTE_RESPONSE_CONTRACT_HEADER = 'x-deepline-execute-response-contract';
+const EXECUTE_RESPONSE_INTENT_HEADER = 'x-deepline-execute-response-intent';
 const V2_EXECUTE_RESPONSE_CONTRACT = 'v2-tool-response';
 const COMPILE_MANIFEST_RETRY_DELAYS_MS = [250, 1_000];
 const REGISTER_PLAY_ARTIFACTS_COMPILE_CONCURRENCY = 3;
@@ -163,6 +164,7 @@ function chunkRegisterPlayArtifacts<T>(artifacts: T[]): T[][] {
 
 type ExecuteToolRawOptions = {
   includeToolMetadata?: boolean;
+  responseIntent?: 'raw' | 'row_artifact';
 };
 
 /**
@@ -1156,6 +1158,9 @@ export class DeeplineClient {
       ...(options?.includeToolMetadata
         ? { [INCLUDE_TOOL_METADATA_HEADER]: 'true' }
         : {}),
+      ...(options?.responseIntent
+        ? { [EXECUTE_RESPONSE_INTENT_HEADER]: options.responseIntent }
+        : {}),
     };
     return this.http.post<ToolExecution<TData, TMeta>>(
       `/api/v2/integrations/${encodeURIComponent(toolId)}/execute`,

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

@@ -58,6 +58,8 @@ const DEFAULT_TIMEOUT = 60_000;
 const DEFAULT_MAX_RETRIES = 3;
 
 const PROJECT_DEEPLINE_ENV_FILE = '.env.deepline';
+const WORKSPACE_RESTORE_ENV_DIR = '.deepline';
+const WORKSPACE_RESTORE_ENV_FILE = '.env';
 const COWORK_IGNORED_WORKSPACE_DIRS = new Set([
   '.auto-memory',
   '.claude',
@@ -505,6 +507,27 @@ function ensureProjectEnvIsIgnored(dir: string): void {
   writeFileSync(gitignorePath, `${existing}${prefix}${entry}\n`, 'utf-8');
 }
 
+function ensureWorkspaceRestoreEnvIsIgnored(workspaceDir: string): void {
+  const gitignorePath = join(workspaceDir, '.gitignore');
+  const entry = `${WORKSPACE_RESTORE_ENV_DIR}/`;
+  const existing = existsSync(gitignorePath)
+    ? readFileSync(gitignorePath, 'utf-8')
+    : '';
+  const alreadyIgnored = existing
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .some(
+      (line) =>
+        line === entry ||
+        line === `/${entry}` ||
+        line === WORKSPACE_RESTORE_ENV_DIR ||
+        line === `/${WORKSPACE_RESTORE_ENV_DIR}`,
+    );
+  if (alreadyIgnored) return;
+  const prefix = existing && !existing.endsWith('\n') ? '\n' : '';
+  writeFileSync(gitignorePath, `${existing}${prefix}${entry}\n`, 'utf-8');
+}
+
 export function saveProjectDeeplineEnvValues(
   values: EnvValues,
   startDir: string = process.cwd(),
@@ -522,6 +545,32 @@ export function saveProjectDeeplineEnvValues(
   return [filePath];
 }
 
+export function saveCoworkWorkspaceRestoreEnvValues(
+  values: EnvValues,
+  startDir: string = process.cwd(),
+): string[] {
+  if (!isCoworkLikeSandbox()) return [];
+  const target = resolveProjectPinTarget(startDir);
+  if (!target.ok || target.source === 'cwd') return [];
+  const workspaceDir = target.dir;
+  const filePath = join(
+    workspaceDir,
+    WORKSPACE_RESTORE_ENV_DIR,
+    WORKSPACE_RESTORE_ENV_FILE,
+  );
+  const existing = parseEnvFile(filePath);
+  const merged = { ...existing, ...values };
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  ensureWorkspaceRestoreEnvIsIgnored(workspaceDir);
+  const allowedKeys = new Set([HOST_URL_ENV, API_KEY_ENV]);
+  const lines = Object.entries(merged)
+    .filter(([key, value]) => allowedKeys.has(key) && value !== '')
+    .map(([key, value]) => `${key}=${value}`);
+  writeFileSync(filePath, `${lines.join('\n')}\n`, 'utf-8');
+  return [filePath];
+}
+
 export function resolveProjectPinDir(startDir: string = process.cwd()): string {
   const target = resolveProjectPinTarget(startDir);
   if (!target.ok) {

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

@@ -102,10 +102,10 @@ export const SDK_RELEASE = {
   // the SDK enrich generator's one-second stale policy.
   // 0.1.110 ships authored V2 prebuilts and required top-level play descriptions.
   // 0.1.111 ships dataset-native tool list getters and result row datasets.
-  version: '0.1.148',
+  version: '0.1.150',
   apiContract: '2026-06-dataset-handle-results-hard-cutover',
   supportPolicy: {
-    latest: '0.1.148',
+    latest: '0.1.150',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
     commandMinimumSupported: [

package/dist/bundling-sources/sdk/src/tool-output.ts

@@ -23,7 +23,13 @@
  *
  * @module
  */
-import { mkdirSync, writeFileSync } from 'node:fs';
+import {
+  closeSync,
+  mkdirSync,
+  openSync,
+  writeFileSync,
+  writeSync,
+} from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 
@@ -54,6 +60,22 @@ export type ListConversionResult = {
   sourcePath: string | null;
 };
 
+export type RowOutputProjection = {
+  rows: Array<Record<string, unknown>>;
+  rowCount: number;
+  columns: string[];
+  previewRows: Array<Record<string, unknown>>;
+  strategy: ListConversionResult['strategy'];
+  sourcePath: string | null;
+};
+
+export type CsvOutputArtifact = {
+  path: string;
+  rowCount: number;
+  columns: string[];
+  preview: string;
+};
+
 type Scalar = string | number | boolean | null;
 
 function isPlainObject(value: unknown): value is Record<string, unknown> {
@@ -109,6 +131,20 @@ function normalizeRows(value: unknown): Array<Record<string, unknown>> | null {
   });
 }
 
+function columnsForRows(rows: readonly Record<string, unknown>[]): string[] {
+  const seen = new Set<string>();
+  const columns: string[] = [];
+  for (const row of rows) {
+    for (const key of Object.keys(row)) {
+      if (!seen.has(key)) {
+        seen.add(key);
+        columns.push(key);
+      }
+    }
+  }
+  return columns;
+}
+
 /**
  * Generate candidate root objects to search for lists.
  * Tries: raw payload → V2 toolResponse.raw → legacy payload.output.body → legacy payload.result → legacy payload.result.data.
@@ -271,6 +307,19 @@ export function tryConvertToList(
   return null;
 }
 
+export function projectRowOutput(
+  conversion: ListConversionResult,
+): RowOutputProjection {
+  return {
+    rows: conversion.rows,
+    rowCount: conversion.rows.length,
+    columns: columnsForRows(conversion.rows),
+    previewRows: conversion.rows.slice(0, 5),
+    strategy: conversion.strategy,
+    sourcePath: conversion.sourcePath,
+  };
+}
+
 /** Ensure the shared output directory exists. Returns its path. */
 function ensureOutputDir(): string {
   const outputDir = join(homedir(), '.local', 'share', 'deepline', 'data');
@@ -330,21 +379,12 @@ export function writeCsvOutputFile(
   rows: Array<Record<string, unknown>>,
   stem: string,
   options?: { outPath?: string },
-): { path: string; rowCount: number; columns: string[]; preview: string } {
+): CsvOutputArtifact {
   const outputPath = options?.outPath
     ? options.outPath
     : join(ensureOutputDir(), `${stem}_${Date.now()}.csv`);
   mkdirSync(dirname(outputPath), { recursive: true });
-  const seen = new Set<string>();
-  const columns: string[] = [];
-  for (const row of rows) {
-    for (const key of Object.keys(row)) {
-      if (!seen.has(key)) {
-        seen.add(key);
-        columns.push(key);
-      }
-    }
-  }
+  const columns = columnsForRows(rows);
 
   const escapeCell = (value: unknown): string => {
     const normalized =
@@ -361,12 +401,18 @@ export function writeCsvOutputFile(
     return normalized;
   };
 
-  const lines: string[] = [];
-  lines.push(columns.map(escapeCell).join(','));
-  for (const row of rows) {
-    lines.push(columns.map((column) => escapeCell(row[column])).join(','));
+  const fd = openSync(outputPath, 'w');
+  try {
+    writeSync(fd, `${columns.map(escapeCell).join(',')}\n`);
+    for (const row of rows) {
+      writeSync(
+        fd,
+        `${columns.map((column) => escapeCell(row[column])).join(',')}\n`,
+      );
+    }
+  } finally {
+    closeSync(fd);
   }
-  writeFileSync(outputPath, `${lines.join('\n')}\n`, 'utf-8');
 
   const previewRows = rows.slice(0, 5);
   const previewColumns = columns.slice(0, 5);

package/dist/bundling-sources/shared_libs/play-runtime/runtime-pg-driver-neon-serverless.ts

@@ -98,7 +98,6 @@ interface NeonModule {
     query<R = Record<string, unknown>>(
       text: string,
       params?: unknown[],
-      options?: { fullResults?: boolean },
     ): Promise<{ rows: R[] }>;
   };
 }
@@ -186,7 +185,7 @@ export function installNeonServerlessRuntimePoolDriver(): void {
         params?: unknown[],
       ) => {
         const sql = await getSql();
-        return await sql.query<R>(text, params, { fullResults: true });
+        return await sql.query<R>(text, params);
       },
     };
   });

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

@@ -1,6 +1,6 @@
 import type { EmailStatusExtractorConfig } from './email-status';
 import type { DeeplineGetterValueMap } from './extractor-targets';
-import type { PlayDataset } from '../plays/dataset';
+import type { PlayDataset, SerializedPlayDataset } from '../plays/dataset';
 
 export type ToolResultExecutionMetadata = {
   idempotent: true;
@@ -73,10 +73,22 @@ export type ToolResultEnvelope<
 export type SerializedToolExecuteResult = {
   __kind: 'deepline.tool_execute_result.v1';
   status: string;
+  job_id?: string;
+  /** Deepline-owned execution/result metadata. */
+  meta?: Record<string, unknown>;
   toolResponse: {
+    /**
+     * Raw provider/tool data with declared row-list payloads clipped to bounded
+     * previews. Use list getters for row-shaped data.
+     */
     raw: unknown;
     meta?: Record<string, unknown>;
   };
+  listDatasets?: Record<string, SerializedPlayDataset<Record<string, unknown>>>;
+  /** Full declared list rows used to rehydrate list Dataset Handles. */
+  listRows?: Record<string, Array<Record<string, unknown>>>;
+  /** Computed scalar/object getters preserved before raw list previews are clipped. */
+  targetValues?: Record<string, ToolResultTargetMetadata>;
   metadata: ToolResultMetadataInput;
   execution: ToolResultExecutionMetadata;
 };
@@ -142,9 +154,10 @@ export type ToolExecuteResultAccessors<
  * getters live under `extractedValues.<name>.get()`, and list getters live
  * under `extractedLists.<name>.get()`.
  *
- * Use extractors first when a tool contract exposes them. Drop to
- * `toolResponse.raw` when you need provider-specific fields or when debugging
- * from persisted run rows.
+ * Use extractors first when a tool contract exposes them. Use list getters for
+ * row-shaped data. Drop to `toolResponse.raw` only for provider-specific scalar
+ * fields or bounded debugging context; persisted rows may clip declared lists to
+ * previews.
  *
  * @sdkReference runtime 200
  */