deepline 0.1.317 → 0.1.319

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

@@ -1127,6 +1127,13 @@ function isStagedUploadMintUnsupported(error: unknown): boolean {
   return error instanceof DeeplineError && error.statusCode === 404;
 }
 
+function isStagedUploadDirectEgressDenied(error: unknown): boolean {
+  return (
+    error instanceof DeeplineError &&
+    error.code === 'STAGED_FILE_UPLOAD_EGRESS_DENIED'
+  );
+}
+
 function formatMegabytes(bytes: number): string {
   return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
 }
@@ -1159,10 +1166,16 @@ async function uploadStagedFileToPresignedUrl(input: {
         return;
       }
       const text = await response.text().catch(() => '');
+      const egressDenied =
+        response.status === 403 &&
+        response.headers.get('x-deny-reason')?.trim().toLowerCase() ===
+          'host_not_allowed';
       lastError = new DeeplineError(
         `Direct storage upload of ${input.logicalPath} failed: ${response.status} ${text.slice(0, 200)}`,
         response.status,
-        'STAGED_FILE_UPLOAD_FAILED',
+        egressDenied
+          ? 'STAGED_FILE_UPLOAD_EGRESS_DENIED'
+          : 'STAGED_FILE_UPLOAD_FAILED',
         { logicalPath: input.logicalPath },
       );
       // 4xx (other than throttling) will not recover on retry.
@@ -2502,7 +2515,10 @@ export class DeeplineClient {
       );
     }
 
-    await Promise.all(
+    type DirectStageResult =
+      | { ref: PlayStagedFileRef }
+      | { fallbackFile: (typeof files)[number] };
+    const directResults: DirectStageResult[] = await Promise.all(
       files.map(async (file) => {
         const upload = uploadByIdentity.get(
           stagedUploadIdentity(file.logicalPath, file.contentHash),
@@ -2515,32 +2531,46 @@ export class DeeplineClient {
           );
         }
         if (upload.alreadyStaged || !upload.uploadUrl) {
-          return;
+          return { ref: upload.ref };
+        }
+        try {
+          await uploadStagedFileToPresignedUrl({
+            url: upload.uploadUrl,
+            headers: upload.uploadHeaders ?? {
+              'content-type': file.contentType,
+            },
+            body: decodeBase64Bytes(file.contentBase64),
+            logicalPath: file.logicalPath,
+          });
+          return { ref: upload.ref };
+        } catch (error) {
+          if (isStagedUploadDirectEgressDenied(error)) {
+            return { fallbackFile: file };
+          }
+          throw error;
         }
-        await uploadStagedFileToPresignedUrl({
-          url: upload.uploadUrl,
-          headers: upload.uploadHeaders ?? {
-            'content-type': file.contentType,
-          },
-          body: decodeBase64Bytes(file.contentBase64),
-          logicalPath: file.logicalPath,
-        });
       }),
     );
 
-    return files.map((file) => {
-      const upload = uploadByIdentity.get(
-        stagedUploadIdentity(file.logicalPath, file.contentHash),
-      );
-      if (!upload) {
-        throw new DeeplineError(
-          `The staging server did not return an upload target for ${file.logicalPath}.`,
-          undefined,
-          'STAGED_FILE_MINT_INCOMPLETE',
-        );
-      }
-      return upload.ref;
-    });
+    return await Promise.all(
+      directResults.map(async (result) => {
+        if ('fallbackFile' in result) {
+          const [ref] = await this.stagePlayFilesViaMultipart(
+            [result.fallbackFile],
+            'direct-egress-denied',
+          );
+          if (!ref) {
+            throw new DeeplineError(
+              `The staging server did not return an upload target for ${result.fallbackFile.logicalPath}.`,
+              undefined,
+              'STAGED_FILE_MINT_INCOMPLETE',
+            );
+          }
+          return ref;
+        }
+        return result.ref;
+      }),
+    );
   }
 
   /**
@@ -2572,11 +2602,16 @@ export class DeeplineClient {
       contentType: string;
       bytes: number;
     }>,
+    reason: 'mint-unsupported' | 'direct-egress-denied' = 'mint-unsupported',
   ): Promise<PlayStagedFileRef[]> {
     for (const file of files) {
       if (file.bytes > STAGE_LEGACY_MULTIPART_MAX_BYTES) {
+        const reasonMessage =
+          reason === 'direct-egress-denied'
+            ? "direct storage is blocked by this environment's network egress policy"
+            : 'the connected Deepline server does not support direct-to-storage uploads';
         throw new DeeplineError(
-          `Cannot stage ${file.logicalPath} (${formatMegabytes(file.bytes)}): the connected Deepline server does not support direct-to-storage uploads, and this file exceeds the ~4.5MB request-body limit the legacy upload path is subject to. Update the Deepline server (or target code.deepline.com) to stage files this large.`,
+          `Cannot stage ${file.logicalPath} (${formatMegabytes(file.bytes)}): ${reasonMessage}, and this file exceeds the ~4.5MB request-body limit the legacy upload path is subject to.`,
           413,
           'STAGED_FILE_TOO_LARGE_FOR_LEGACY_UPLOAD',
           {

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

@@ -157,7 +157,7 @@ export const SDK_RELEASE = {
   // 0.1.253 makes play-page browser opening opt-in and retires --no-open.
   // 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.317',
+  version: '0.1.319',
   contracts: {
     api: {
       name: 'sdk-http-api',

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

@@ -276,16 +276,30 @@ export interface ToolDefinition {
   }>;
   /**
    * Whether this tool is callable in the current workspace. `false` for a
-   * bring-your-own-credential provider (e.g. Apollo) that has not been
-   * connected — the agent should offer to connect it rather than call it.
+   * bring-your-own-credential provider that has not been connected.
    */
   connected?: boolean;
+  /** Whether the tool can be executed. Exact lookup may return non-callable deprecated aliases. */
+  callable?: boolean;
+  /** True when callers should migrate this exact tool id to its replacement. */
+  deprecated?: boolean;
+  /** Deprecation reason, replacement, and compatibility execution behavior. */
+  deprecation?: {
+    replacementToolId: string;
+    message: string;
+    execution?: 'terminal' | 'forward';
+  };
   /**
    * Connection status for discovery: `managed` (Deepline-run credentials),
    * `connected` (your own credential is connected), or `requires_connection`
-   * (BYO provider not yet connected in this workspace).
+   * (BYO provider not yet connected in this workspace). `deprecated` means
+   * connecting credentials will not make the tool callable.
    */
-  credentialStatus?: 'managed' | 'connected' | 'requires_connection';
+  credentialStatus?:
+    | 'managed'
+    | 'connected'
+    | 'requires_connection'
+    | 'deprecated';
   /** True when the tool requires a customer-provided credential to run. */
   requiresOwnCredential?: boolean;
   /** Actionable message shown when a connection is required. */

package/dist/cli/index.js

@@ -1037,7 +1037,7 @@ var SDK_RELEASE = {
   // 0.1.253 makes play-page browser opening opt-in and retires --no-open.
   // 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.317",
+  version: "0.1.319",
   contracts: {
     api: {
       name: "sdk-http-api",
@@ -3527,6 +3527,9 @@ function stagedUploadIdentity(logicalPath, contentHash) {
 function isStagedUploadMintUnsupported(error) {
   return error instanceof DeeplineError && error.statusCode === 404;
 }
+function isStagedUploadDirectEgressDenied(error) {
+  return error instanceof DeeplineError && error.code === "STAGED_FILE_UPLOAD_EGRESS_DENIED";
+}
 function formatMegabytes(bytes) {
   return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
 }
@@ -3547,10 +3550,11 @@ async function uploadStagedFileToPresignedUrl(input2) {
         return;
       }
       const text = await response.text().catch(() => "");
+      const egressDenied = response.status === 403 && response.headers.get("x-deny-reason")?.trim().toLowerCase() === "host_not_allowed";
       lastError = new DeeplineError(
         `Direct storage upload of ${input2.logicalPath} failed: ${response.status} ${text.slice(0, 200)}`,
         response.status,
-        "STAGED_FILE_UPLOAD_FAILED",
+        egressDenied ? "STAGED_FILE_UPLOAD_EGRESS_DENIED" : "STAGED_FILE_UPLOAD_FAILED",
         { logicalPath: input2.logicalPath }
       );
       if (response.status < 500 && response.status !== 429) {
@@ -4450,7 +4454,7 @@ var DeeplineClient = class {
         upload
       );
     }
-    await Promise.all(
+    const directResults = await Promise.all(
       files.map(async (file) => {
         const upload = uploadByIdentity.get(
           stagedUploadIdentity(file.logicalPath, file.contentHash)
@@ -4463,31 +4467,45 @@ var DeeplineClient = class {
           );
         }
         if (upload.alreadyStaged || !upload.uploadUrl) {
-          return;
+          return { ref: upload.ref };
+        }
+        try {
+          await uploadStagedFileToPresignedUrl({
+            url: upload.uploadUrl,
+            headers: upload.uploadHeaders ?? {
+              "content-type": file.contentType
+            },
+            body: decodeBase64Bytes(file.contentBase64),
+            logicalPath: file.logicalPath
+          });
+          return { ref: upload.ref };
+        } catch (error) {
+          if (isStagedUploadDirectEgressDenied(error)) {
+            return { fallbackFile: file };
+          }
+          throw error;
         }
-        await uploadStagedFileToPresignedUrl({
-          url: upload.uploadUrl,
-          headers: upload.uploadHeaders ?? {
-            "content-type": file.contentType
-          },
-          body: decodeBase64Bytes(file.contentBase64),
-          logicalPath: file.logicalPath
-        });
       })
     );
-    return files.map((file) => {
-      const upload = uploadByIdentity.get(
-        stagedUploadIdentity(file.logicalPath, file.contentHash)
-      );
-      if (!upload) {
-        throw new DeeplineError(
-          `The staging server did not return an upload target for ${file.logicalPath}.`,
-          void 0,
-          "STAGED_FILE_MINT_INCOMPLETE"
-        );
-      }
-      return upload.ref;
-    });
+    return await Promise.all(
+      directResults.map(async (result) => {
+        if ("fallbackFile" in result) {
+          const [ref] = await this.stagePlayFilesViaMultipart(
+            [result.fallbackFile],
+            "direct-egress-denied"
+          );
+          if (!ref) {
+            throw new DeeplineError(
+              `The staging server did not return an upload target for ${result.fallbackFile.logicalPath}.`,
+              void 0,
+              "STAGED_FILE_MINT_INCOMPLETE"
+            );
+          }
+          return ref;
+        }
+        return result.ref;
+      })
+    );
   }
   /**
    * Mint short-lived presigned upload targets for staged play files.
@@ -4500,11 +4518,12 @@ var DeeplineClient = class {
     const response = await this.http.post("/api/v2/plays/files/stage/mint", { files });
     return response.uploads ?? [];
   }
-  async stagePlayFilesViaMultipart(files) {
+  async stagePlayFilesViaMultipart(files, reason = "mint-unsupported") {
     for (const file of files) {
       if (file.bytes > STAGE_LEGACY_MULTIPART_MAX_BYTES) {
+        const reasonMessage = reason === "direct-egress-denied" ? "direct storage is blocked by this environment's network egress policy" : "the connected Deepline server does not support direct-to-storage uploads";
         throw new DeeplineError(
-          `Cannot stage ${file.logicalPath} (${formatMegabytes(file.bytes)}): the connected Deepline server does not support direct-to-storage uploads, and this file exceeds the ~4.5MB request-body limit the legacy upload path is subject to. Update the Deepline server (or target code.deepline.com) to stage files this large.`,
+          `Cannot stage ${file.logicalPath} (${formatMegabytes(file.bytes)}): ${reasonMessage}, and this file exceeds the ~4.5MB request-body limit the legacy upload path is subject to.`,
           413,
           "STAGED_FILE_TOO_LARGE_FOR_LEGACY_UPLOAD",
           {
@@ -28570,14 +28589,23 @@ function toolContractJsonForDescribe(tool, requestedToolId) {
     "deeplineUsdPerPricingUnit",
     "deepline_usd_per_pricing_unit"
   );
-  const starterScript = !isPlayLikeTool(tool) && extractedLists.length > 0 ? starterScriptJson(
+  const deprecation = recordField2(tool, "deprecation");
+  const replacementToolId = stringField2(
+    deprecation,
+    "replacementToolId",
+    "replacement_tool_id"
+  );
+  const deprecationMessage = stringField2(deprecation, "message");
+  const deprecationExecution = stringField2(deprecation, "execution");
+  const deprecated = tool.deprecated === true || stringField2(tool, "credentialStatus", "credential_status") === "deprecated";
+  const starterScript = !deprecated && !isPlayLikeTool(tool) && extractedLists.length > 0 ? starterScriptJson(
     seedToolListScript({
       toolId,
       payload: samplePayloadForInputFields(inputFields),
       rows: []
     })
   ) : null;
-  const executeCommand = isPlayLikeTool(tool) ? playRunCommandForTool(tool, toolId) : `deepline tools execute ${toolId} --input '{...}' --json`;
+  const executeCommand = deprecated && replacementToolId ? `deepline tools execute ${replacementToolId} --input '{...}' --json` : isPlayLikeTool(tool) ? playRunCommandForTool(tool, toolId) : `deepline tools execute ${toolId} --input '{...}' --json`;
   return {
     schemaVersion: 1,
     toolId,
@@ -28585,6 +28613,15 @@ function toolContractJsonForDescribe(tool, requestedToolId) {
     displayName: tool.displayName,
     description: tool.description,
     categories: tool.categories,
+    ...deprecated ? {
+      deprecated: true,
+      callable: tool.callable !== false,
+      deprecation: {
+        replacementToolId,
+        message: deprecationMessage,
+        ...deprecationExecution ? { execution: deprecationExecution } : {}
+      }
+    } : {},
     inputFields: inputFields.map((field) => ({
       name: field.name,
       type: field.type ?? "unknown",
@@ -28727,6 +28764,29 @@ function printCompactToolContract(tool, requestedToolId) {
   if (Array.isArray(contract.categories) && contract.categories.length) {
     console.log(`Tags: ${contract.categories.join(", ")}`);
   }
+  if (contract.deprecated === true) {
+    const deprecation = isRecord11(contract.deprecation) ? contract.deprecation : {};
+    const message = stringField2(deprecation, "message");
+    const replacementToolId = stringField2(
+      deprecation,
+      "replacementToolId",
+      "replacement_tool_id"
+    );
+    console.log(
+      contract.callable === false ? "Status: deprecated \u2014 this tool cannot be executed" : "Status: deprecated \u2014 legacy executions forward for compatibility"
+    );
+    if (message) console.log(`Migration: ${message}`);
+    if (replacementToolId) {
+      console.log(
+        `Use: deepline tools execute ${replacementToolId} --input '{...}'`
+      );
+    }
+    console.log("");
+    console.log(
+      `More: deepline tools describe ${replacementToolId || contract.toolId} --json`
+    );
+    return;
+  }
   printToolPricingOnly(tool, requestedToolId, { heading: "Cost" });
   if (inputFields.length) {
     console.log("");
@@ -29226,6 +29286,32 @@ function samplePayload(samples, key) {
 function commandEnvelopeFromRawResponse(rawResponse) {
   return isRecord11(rawResponse) ? { ...rawResponse } : { status: "completed", result: rawResponse };
 }
+function extractToolExecutionWarningMessages(rawResponse) {
+  if (!isRecord11(rawResponse)) return [];
+  const candidates = [
+    recordField2(recordField2(rawResponse, "toolResponse"), "meta"),
+    recordField2(
+      recordField2(recordField2(rawResponse, "toolResponse"), "raw"),
+      "meta"
+    ),
+    recordField2(rawResponse, "meta"),
+    recordField2(recordField2(rawResponse, "result"), "meta")
+  ];
+  const messages = [];
+  for (const candidate of candidates) {
+    const warnings = candidate?.warnings;
+    if (!Array.isArray(warnings)) continue;
+    for (const warning of warnings) {
+      if (typeof warning === "string" && warning.trim()) {
+        messages.push(warning.trim());
+      } else if (isRecord11(warning)) {
+        const message = stringField2(warning, "message");
+        if (message) messages.push(message);
+      }
+    }
+  }
+  return [...new Set(messages)];
+}
 function apifySyncRecoveryNext(rawResponse) {
   if (!isRecord11(rawResponse) || rawResponse.status !== "running") return null;
   const toolResponse = recordField2(rawResponse, "toolResponse");
@@ -29493,6 +29579,9 @@ export default definePlay(${JSON.stringify(playName)}, async (ctx) => {
 }
 function buildToolExecuteBaseEnvelope(input2) {
   const envelope = commandEnvelopeFromRawResponse(input2.rawResponse);
+  const warningMessages = extractToolExecutionWarningMessages(
+    input2.rawResponse
+  );
   const apifyRecovery = apifySyncRecoveryNext(input2.rawResponse);
   const summaryEntries = Object.entries(input2.summary);
   const outputPreview = input2.listConversion ? {
@@ -29530,6 +29619,7 @@ function buildToolExecuteBaseEnvelope(input2) {
     ...envelope,
     ...envelopeHasCanonicalOutput || envelopeHasDeclaredOutput ? { output_preview: outputPreview } : { output: outputPreview },
     ...summaryEntries.length > 0 ? { summary: input2.summary } : {},
+    ...warningMessages.length > 0 ? { warnings: warningMessages } : {},
     next: {
       inspect: inspectCommand,
       ...apifyRecovery ?? {},
@@ -29541,6 +29631,7 @@ function buildToolExecuteBaseEnvelope(input2) {
     },
     render: {
       sections: input2.listConversion ? [
+        ...warningMessages.length > 0 ? [{ title: "warnings", lines: warningMessages }] : [],
         {
           title: "output",
           lines: [
@@ -29551,6 +29642,7 @@ function buildToolExecuteBaseEnvelope(input2) {
           ]
         }
       ] : [
+        ...warningMessages.length > 0 ? [{ title: "warnings", lines: warningMessages }] : [],
         {
           title: "result",
           lines: apifyRecovery ? [