deepline 0.1.12 → 0.1.19

package/dist/index.mjs

@@ -42,6 +42,10 @@ var ConfigError = class extends DeeplineError {
 var PROD_URL = "https://code.deepline.com";
 var DEFAULT_TIMEOUT = 6e4;
 var DEFAULT_MAX_RETRIES = 3;
+var ACTIVE_DEEPLINE_ENV_FILE = ".env.deepline";
+function projectEnvStartDir() {
+  return process.env.DEEPLINE_PROJECT_ENV_DIR?.trim() || process.cwd();
+}
 function baseUrlSlug(baseUrl) {
   let url;
   try {
@@ -77,16 +81,52 @@ function parseEnvFile(filePath) {
   }
   return env;
 }
-function findNearestWorktreeEnv(startDir = process.cwd()) {
+function findNearestEnvFile(names, startDir = process.cwd()) {
   let current = resolve(startDir);
   while (true) {
-    const values = parseEnvFile(join(current, ".env.worktree"));
-    if (Object.keys(values).length > 0) return values;
+    for (const name of names) {
+      const filePath = join(current, name);
+      if (existsSync(filePath)) return filePath;
+    }
     const parent = dirname(current);
-    if (parent === current) return {};
+    if (parent === current) return null;
     current = parent;
   }
 }
+function findNearestEnv(names, startDir = process.cwd()) {
+  const filePath = findNearestEnvFile(names, startDir);
+  return filePath ? parseEnvFile(filePath) : {};
+}
+function findNearestWorktreeEnv(startDir = process.cwd()) {
+  return findNearestEnv([".env.worktree"], startDir);
+}
+function resolveProfileEnvFileNames() {
+  const explicitProfile = process.env.DEEPLINE_ENV_PROFILE?.trim() || process.env.DEEPLINE_PROFILE?.trim() || "";
+  const names = [];
+  if (explicitProfile) names.push(`.env.deepline.${explicitProfile}`);
+  const nodeEnv = process.env.NODE_ENV?.trim();
+  if (nodeEnv === "production") names.push(".env.deepline.prod");
+  else if (nodeEnv === "staging") names.push(".env.deepline.staging");
+  names.push(ACTIVE_DEEPLINE_ENV_FILE);
+  return names;
+}
+function resolveProjectAppEnvFileNames() {
+  const nodeEnv = process.env.NODE_ENV?.trim();
+  const names = [];
+  if (nodeEnv === "production") names.push(".env.prod");
+  if (nodeEnv === "staging") names.push(".env.staging");
+  names.push(".env.local", ".env");
+  return names;
+}
+function resolveBaseUrlFromEnvValues(env) {
+  return env.DEEPLINE_ORIGIN_URL?.trim() || env.DEEPLINE_API_BASE_URL?.trim() || "";
+}
+function loadProjectDeeplineEnv() {
+  return findNearestEnv(resolveProfileEnvFileNames(), projectEnvStartDir());
+}
+function loadProjectAppEnv() {
+  return findNearestEnv(resolveProjectAppEnvFileNames(), projectEnvStartDir());
+}
 function normalizeWorktreeBaseUrl(baseUrl, worktreeEnv = findNearestWorktreeEnv()) {
   const trimmed = baseUrl.trim().replace(/\/$/, "");
   if (!trimmed) return trimmed;
@@ -123,6 +163,10 @@ function autoDetectBaseUrl() {
   if (envOrigin) return normalizeWorktreeBaseUrl(envOrigin);
   const envBase = process.env.DEEPLINE_API_BASE_URL?.trim();
   if (envBase) return normalizeWorktreeBaseUrl(envBase);
+  const projectDeeplineBaseUrl = resolveBaseUrlFromEnvValues(loadProjectDeeplineEnv());
+  if (projectDeeplineBaseUrl) return normalizeWorktreeBaseUrl(projectDeeplineBaseUrl);
+  const projectAppBaseUrl = resolveBaseUrlFromEnvValues(loadProjectAppEnv());
+  if (projectAppBaseUrl) return normalizeWorktreeBaseUrl(projectAppBaseUrl);
   const worktreeBaseUrl = resolveWorktreeBaseUrl();
   if (worktreeBaseUrl) return worktreeBaseUrl;
   const globalEnv = loadGlobalCliEnv();
@@ -134,7 +178,9 @@ function resolveConfig(options) {
   const requestedBaseUrl = options?.baseUrl?.trim() || autoDetectBaseUrl();
   const baseUrl = normalizeWorktreeBaseUrl(requestedBaseUrl);
   const cliEnv = loadCliEnv(baseUrl);
-  const apiKey = options?.apiKey?.trim() || process.env.DEEPLINE_API_KEY?.trim() || cliEnv.DEEPLINE_API_KEY || "";
+  const projectDeeplineEnv = loadProjectDeeplineEnv();
+  const projectAppEnv = loadProjectAppEnv();
+  const apiKey = options?.apiKey?.trim() || process.env.DEEPLINE_API_KEY?.trim() || projectDeeplineEnv.DEEPLINE_API_KEY || projectAppEnv.DEEPLINE_API_KEY || cliEnv.DEEPLINE_API_KEY || "";
   if (!apiKey) {
     throw new ConfigError(
       `No API key found. Set DEEPLINE_API_KEY env var, pass apiKey option, or run: deepline auth register`
@@ -149,8 +195,8 @@ function resolveConfig(options) {
 }
 
 // src/version.ts
-var SDK_VERSION = "0.1.12";
-var SDK_API_CONTRACT = "2026-04-plays-v1";
+var SDK_VERSION = "0.1.19";
+var SDK_API_CONTRACT = "2026-05-runs-v2";
 
 // ../shared_libs/play-runtime/coordinator-headers.ts
 var COORDINATOR_INTERNAL_TOKEN_HEADER = "x-deepline-internal-token";
@@ -343,8 +389,12 @@ var HttpClient = class {
    * @param path - API path
    * @param body - Request body (will be JSON-serialized)
    */
-  async post(path, body) {
-    return this.request(path, { method: "POST", body });
+  async post(path, body, headers) {
+    return this.request(path, {
+      method: "POST",
+      body,
+      headers
+    });
   }
   /**
    * Send a DELETE request.
@@ -424,6 +474,7 @@ function sleep(ms) {
 
 // src/client.ts
 var TERMINAL_PLAY_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+var INCLUDE_TOOL_METADATA_HEADER = "x-deepline-include-tool-metadata";
 function isRecord(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -456,6 +507,7 @@ function mapLegacyTemporalStatus(status) {
 var DeeplineClient = class {
   http;
   config;
+  runs;
   /**
    * @param options - Optional overrides for API key, base URL, timeout, and retries.
    * @throws {@link ConfigError} if no API key can be resolved from any source.
@@ -463,6 +515,13 @@ var DeeplineClient = class {
   constructor(options) {
     this.config = resolveConfig(options);
     this.http = new HttpClient(this.config);
+    this.runs = {
+      get: (runId) => this.getRunStatus(runId),
+      list: (options2) => this.listRuns(options2),
+      tail: (runId, options2) => this.tailRun(runId, options2),
+      logs: (runId, options2) => this.getRunLogs(runId, options2),
+      stop: (runId, options2) => this.stopRun(runId, options2)
+    };
   }
   /** The resolved base URL this client is targeting (e.g. `"http://localhost:3000"`). */
   get baseUrl() {
@@ -551,6 +610,31 @@ var DeeplineClient = class {
     );
     return res.tools;
   }
+  /**
+   * Search available tools using Deepline's ranked backend search.
+   *
+   * This is the same discovery surface used by the legacy CLI: it ranks across
+   * tool metadata, categories, agent guidance, and input schema fields.
+   */
+  async searchTools(options = {}) {
+    const params = new URLSearchParams();
+    const query = options.query?.trim() ?? "";
+    params.set("q", query);
+    params.set(
+      "include_search_debug",
+      options.includeSearchDebug ? "true" : "false"
+    );
+    params.set("search_mode", options.searchMode ?? "v2");
+    if (options.categories?.trim()) {
+      params.set("categories", options.categories.trim());
+    }
+    if (options.searchTerms?.trim()) {
+      params.set("search_terms", options.searchTerms.trim());
+    }
+    return this.http.get(
+      `/api/v2/integrations/list?${params.toString()}`
+    );
+  }
   /**
    * Get detailed metadata for a single tool.
    *
@@ -586,12 +670,17 @@ var DeeplineClient = class {
    * Top-level fields such as `status`, `job_id`, and `billing` describe the
    * Deepline execution.
    */
-  async executeTool(toolId, input) {
+  async executeTool(toolId, input, options) {
+    const headers = options?.includeToolMetadata ? { [INCLUDE_TOOL_METADATA_HEADER]: "true" } : void 0;
     return this.http.post(
       `/api/v2/integrations/${encodeURIComponent(toolId)}/execute`,
-      { payload: input }
+      { payload: input },
+      headers
     );
   }
+  async executeToolRaw(toolId, input, options) {
+    return this.executeTool(toolId, input, options);
+  }
   async queryCustomerDb(input) {
     return this.http.post("/api/v2/db/query", {
       sql: input.sql,
@@ -640,6 +729,7 @@ var DeeplineClient = class {
       ...request.revisionId ? { revisionId: request.revisionId } : {},
       ...request.artifactStorageKey ? { artifactStorageKey: request.artifactStorageKey } : {},
       ...request.sourceCode ? { sourceCode: request.sourceCode } : {},
+      ...request.sourceFiles ? { sourceFiles: request.sourceFiles } : {},
       ..."staticPipeline" in request ? { staticPipeline: request.staticPipeline } : {},
       ...request.artifactHash ? { artifactHash: request.artifactHash } : {},
       ...request.graphHash ? { graphHash: request.graphHash } : {},
@@ -664,6 +754,7 @@ var DeeplineClient = class {
       ...request.revisionId ? { revisionId: request.revisionId } : {},
       ...request.artifactStorageKey ? { artifactStorageKey: request.artifactStorageKey } : {},
       ...request.sourceCode ? { sourceCode: request.sourceCode } : {},
+      ...request.sourceFiles ? { sourceFiles: request.sourceFiles } : {},
       ..."staticPipeline" in request ? { staticPipeline: request.staticPipeline } : {},
       ...request.artifactHash ? { artifactHash: request.artifactHash } : {},
       ...request.graphHash ? { graphHash: request.graphHash } : {},
@@ -700,6 +791,7 @@ var DeeplineClient = class {
     const compilerManifest = input.compilerManifest ?? await this.compilePlayManifest({
       name: input.name,
       sourceCode: input.sourceCode,
+      sourceFiles: input.sourceFiles,
       artifact: input.artifact
     });
     return this.http.post("/api/v2/plays/artifacts", {
@@ -714,6 +806,7 @@ var DeeplineClient = class {
         compilerManifest: artifact.compilerManifest ?? await this.compilePlayManifest({
           name: artifact.name,
           sourceCode: artifact.sourceCode,
+          sourceFiles: artifact.sourceFiles,
           artifact: artifact.artifact
         })
       }))
@@ -740,11 +833,13 @@ var DeeplineClient = class {
     const compilerManifest = input.compilerManifest ?? await this.compilePlayManifest({
       name: input.name,
       sourceCode: input.sourceCode,
+      sourceFiles: input.sourceFiles,
       artifact: input.artifact
     });
     const registeredArtifact = await this.registerPlayArtifact({
       name: input.name,
       sourceCode: input.sourceCode,
+      sourceFiles: input.sourceFiles,
       artifact: input.artifact,
       compilerManifest,
       publish: false
@@ -804,11 +899,13 @@ var DeeplineClient = class {
     const compilerManifest = options?.compilerManifest ?? await this.compilePlayManifest({
       name,
       sourceCode,
+      sourceFiles: options?.sourceFiles,
       artifact
     });
     const registeredArtifact = await this.registerPlayArtifact({
       name,
       sourceCode,
+      sourceFiles: options?.sourceFiles,
       artifact,
       compilerManifest,
       publish: false
@@ -992,6 +1089,112 @@ var DeeplineClient = class {
     );
     return response.runs ?? [];
   }
+  /**
+   * Get a run by id using the public runs resource model.
+   *
+   * This is the SDK equivalent of:
+   *
+   * ```bash
+   * deepline runs get <run-id> --json
+   * ```
+   */
+  async getRunStatus(runId) {
+    const response = await this.http.get(
+      `/api/v2/runs/${encodeURIComponent(runId)}`
+    );
+    return normalizePlayStatus(response);
+  }
+  /**
+   * List play runs using the public runs resource model.
+   *
+   * This is the SDK equivalent of:
+   *
+   * ```bash
+   * deepline runs list --play <play-name> --status failed --json
+   * ```
+   */
+  async listRuns(options) {
+    const playName = options.play.trim();
+    if (!playName) {
+      throw new Error("runs.list requires options.play.");
+    }
+    const params = new URLSearchParams({ play: playName });
+    const status = options.status?.trim();
+    if (status) {
+      params.set("status", status);
+    }
+    const response = await this.http.get(
+      `/api/v2/runs?${params.toString()}`
+    );
+    return response.runs ?? [];
+  }
+  /**
+   * Fetch the lightweight tail status for a run using the public runs resource model.
+   *
+   * This is the SDK equivalent of:
+   *
+   * ```bash
+   * deepline runs tail <run-id> --json
+   * ```
+   */
+  async tailRun(runId, options) {
+    const afterLogIndex = typeof options?.afterLogIndex === "number" ? options.afterLogIndex : typeof options?.cursor === "number" ? options.cursor : typeof options?.cursor === "string" && options.cursor.trim() ? Number(options.cursor) : void 0;
+    const params = new URLSearchParams();
+    if (Number.isFinite(afterLogIndex)) {
+      params.set("afterLogIndex", String(Number(afterLogIndex)));
+    }
+    if (typeof options?.waitMs === "number") {
+      params.set("waitMs", String(options.waitMs));
+    }
+    if (options?.terminalOnly) {
+      params.set("terminalOnly", "true");
+    }
+    const suffix = params.toString() ? `?${params.toString()}` : "";
+    const response = await this.http.get(
+      `/api/v2/runs/${encodeURIComponent(runId)}/tail${suffix}`
+    );
+    return normalizePlayStatus(response);
+  }
+  /**
+   * Fetch persisted logs for a run using the public runs resource model.
+   *
+   * This is the SDK equivalent of:
+   *
+   * ```bash
+   * deepline runs logs <run-id> --limit 200 --json
+   * ```
+   */
+  async getRunLogs(runId, options) {
+    const status = await this.getRunStatus(runId);
+    const logs = status.progress?.logs ?? [];
+    const limit = typeof options?.limit === "number" && Number.isFinite(options.limit) ? Math.max(0, Math.trunc(options.limit)) : 200;
+    const entries = logs.slice(Math.max(0, logs.length - limit));
+    return {
+      runId: status.runId,
+      totalCount: logs.length,
+      returnedCount: entries.length,
+      firstSequence: logs.length === 0 ? null : logs.length - entries.length + 1,
+      lastSequence: logs.length === 0 ? null : logs.length,
+      truncated: logs.length > entries.length,
+      hasMore: logs.length > entries.length,
+      entries
+    };
+  }
+  /**
+   * Stop a run by id using the public runs resource model.
+   *
+   * This is the SDK equivalent of:
+   *
+   * ```bash
+   * deepline runs stop <run-id> --reason "stale lock" --json
+   * ```
+   */
+  async stopRun(runId, options) {
+    return this.http.post(
+      `/api/v2/runs/${encodeURIComponent(runId)}/stop`,
+      options?.reason ? { reason: options.reason } : {}
+    );
+  }
   async listPlays() {
     const response = await this.http.get(
       "/api/v2/plays"
@@ -1357,7 +1560,11 @@ var DeeplineContext = class {
       /** Get detailed metadata for a tool. */
       get: (toolId) => this.client.getTool(toolId),
       /** Execute a tool and return the standard execution envelope. */
-      execute: async (toolId, input) => this.client.executeTool(toolId, input)
+      execute: async (toolId, input) => this.client.executeTool(
+        toolId,
+        input,
+        { includeToolMetadata: true }
+      )
     };
   }
   get plays() {
@@ -1724,4 +1931,3 @@ export {
   writeCsvOutputFile,
   writeJsonOutputFile
 };
-//# sourceMappingURL=index.mjs.map

package/dist/repo/apps/play-runner-workers/src/coordinator-entry.ts

@@ -367,6 +367,8 @@ const WORKFLOW_POOL_TTL_MS = 8 * 60 * 1000;
 const WORKFLOW_POOL_TARGET_SIZE = 2;
 const WORKFLOW_POOL_READY_TIMEOUT_MS = 1_500;
 const WORKFLOW_POOL_READY_POLL_MS = 250;
+const WORKFLOW_POOL_REFILL_ON_MISS_TIMEOUT_MS = 2_500;
+const WORKFLOW_POOL_REFILL_ON_MISS_MIN_AVAILABLE = 1;
 
 function buildDynamicWorkflowMetadata(
   params: PlayWorkflowParams,
@@ -901,7 +903,7 @@ async function submitViaPooledWorkflow(input: {
     return null;
   }
   const leaseStartedAt = Date.now();
-  const pooledInstanceId = await leaseWorkflowPoolId(input.env);
+  let pooledInstanceId = await leaseWorkflowPoolId(input.env);
   const missCounts = pooledInstanceId
     ? null
     : await workflowPoolCount(input.env).catch(() => null);
@@ -919,6 +921,47 @@ async function submitViaPooledWorkflow(input: {
         : {}),
     },
   });
+
+  if (!pooledInstanceId) {
+    // A pool miss is often a timing gap rather than a true lack of warm
+    // capacity. Wait briefly for refill/promotion, then retry lease once
+    // before falling back to a cold workflow create.
+    const refillStartedAt = Date.now();
+    const refillResult = await refillWorkflowPool(input.env, {
+      waitReady: true,
+      minAvailable: WORKFLOW_POOL_REFILL_ON_MISS_MIN_AVAILABLE,
+      waitTimeoutMs: WORKFLOW_POOL_REFILL_ON_MISS_TIMEOUT_MS,
+    }).catch(() => null);
+    input.recordSubmitTiming({
+      phase: 'coordinator.workflow_pool_refill_on_miss',
+      ms: Date.now() - refillStartedAt,
+      graphHash: input.params.graphHash ?? null,
+      extra:
+        refillResult === null
+          ? { ok: false }
+          : {
+              ok: true,
+              available: refillResult.available,
+              warming: refillResult.warming,
+              created: refillResult.created,
+              promoted: refillResult.promoted,
+              removed: refillResult.removed,
+              waitedMs: refillResult.waitedMs,
+              waitIterations: refillResult.waitIterations,
+            },
+    });
+    if (refillResult?.available) {
+      const retryStartedAt = Date.now();
+      pooledInstanceId = await leaseWorkflowPoolId(input.env);
+      input.recordSubmitTiming({
+        phase: 'coordinator.workflow_pool_lease_retry',
+        ms: Date.now() - retryStartedAt,
+        graphHash: input.params.graphHash ?? null,
+        extra: { pooled: Boolean(pooledInstanceId) },
+      });
+    }
+  }
+
   if (!pooledInstanceId) {
     return null;
   }
@@ -2781,10 +2824,11 @@ function loadDynamicPlayWorkerSync(
         // which case the per-play stub throws a loud error on first use
         // (no silent fallbacks — see harness-stub.ts → requireBinding).
         HARNESS: env.HARNESS,
+        VERCEL_PROTECTION_BYPASS_TOKEN: env.VERCEL_PROTECTION_BYPASS_TOKEN,
         // In-process runtime API bridge used by the play harness for status,
         // tool execution, DB session, and artifact callbacks. This avoids a
-        // public fetch hop and is required by apps/play-runner-workers/src/entry.ts.
-        RUNTIME_API: makeRuntimeApiBinding(),
+        // public fetch hop when Cloudflare exposes the RuntimeApi export.
+        ...makeRuntimeApiEnvBinding(),
         // NOTE: We intentionally do NOT pass `env.PLAYS_BUCKET` (an R2Bucket
         // binding) through to the per-play Worker's env. Including a raw
         // R2Bucket in the dynamically-loaded Worker's env makes Cloudflare
@@ -2861,7 +2905,8 @@ async function loadDynamicPlayWorker(
         // HARNESS, and child workflow control uses the coordinator URL in the
         // run request.
         HARNESS: env.HARNESS,
-        RUNTIME_API: makeRuntimeApiBinding(),
+        VERCEL_PROTECTION_BYPASS_TOKEN: env.VERCEL_PROTECTION_BYPASS_TOKEN,
+        ...makeRuntimeApiEnvBinding(),
       },
     };
   });
@@ -3169,11 +3214,15 @@ async function handleCoordinatorWarmup(
  * structured-cloneable. WorkerEntrypoint stubs ARE cloneable — same trick
  * `makePlayAssetsBinding` already uses.
  *
- * Falls back transparently in legacy coordinators: if the binding isn't
- * present in `env`, the harness uses its existing `fetch(req.baseUrl + path)`
- * path, which still works (just slower).
+ * Falls back transparently when Cloudflare does not expose module exports in
+ * the current execution path: if the binding is omitted from `env`, the play
+ * worker uses its existing `fetch(req.baseUrl + path)` transport.
  */
-function makeRuntimeApiBinding(): { fetch(req: Request): Promise<Response> } {
+let loggedMissingRuntimeApiExport = false;
+
+function makeRuntimeApiEnvBinding():
+  | { RUNTIME_API: { fetch(req: Request): Promise<Response> } }
+  | Record<string, never> {
   const exports = workersExports as unknown as {
     RuntimeApi?: (init: { props: undefined }) => {
       fetch(req: Request): Promise<Response>;
@@ -3181,11 +3230,15 @@ function makeRuntimeApiBinding(): { fetch(req: Request): Promise<Response> } {
   };
   const ctor = exports.RuntimeApi;
   if (typeof ctor !== 'function') {
-    throw new Error(
-      'RuntimeApi is not registered on cloudflare:workers exports.',
-    );
+    if (!loggedMissingRuntimeApiExport) {
+      loggedMissingRuntimeApiExport = true;
+      console.warn(
+        '[coordinator] RuntimeApi is not registered on cloudflare:workers exports; using public runtime API transport.',
+      );
+    }
+    return {};
   }
-  return ctor({ props: undefined });
+  return { RUNTIME_API: ctor({ props: undefined }) };
 }
 
 function makeCoordinatorControlBinding(): {
@@ -3261,6 +3314,9 @@ function mapWorkflowResult(
       : null;
   return {
     runId,
+    ...(typeof output?.playName === 'string' && output.playName.trim()
+      ? { playName: output.playName.trim() }
+      : {}),
     status: mapped,
     result: output?.result ?? status.output ?? null,
     error,