deepline 0.1.302 → 0.1.304

package/dist/{tool-execution-error-9mH4i-mJ.d.ts → tool-execution-error-YDz7UMl-.d.ts}

@@ -240,25 +240,89 @@ type PlayCompilerManifest = {
 declare const TOOL_EXECUTION_ERROR_SCHEMA_VERSION: 1;
 declare const SUPPORTED_TOOL_EXECUTION_ERROR_SCHEMA_VERSIONS: readonly [0, 1];
 type ToolExecutionErrorSchemaVersion = (typeof SUPPORTED_TOOL_EXECUTION_ERROR_SCHEMA_VERSIONS)[number];
+/**
+ * The boundary responsible for a failed tool call.
+ *
+ * Use `provider` to distinguish a provider answer from caller input and
+ * Deepline infrastructure. `unknown` fails closed and must not trigger a
+ * waterfall fallback.
+ *
+ * @sdkReference errors 020
+ */
 type ToolExecutionErrorOrigin = 'caller' | 'provider' | 'deepline' | 'unknown';
+/**
+ * The stable reason family for a failed tool call.
+ *
+ * Branch on this field only after narrowing to `ToolExecutionError`. Catch
+ * `ProviderTransientError` when the policy is simply “try the next read
+ * provider”; it is the safer and shorter waterfall contract.
+ *
+ * @sdkReference errors 030
+ */
 type ToolExecutionErrorCategory = 'validation' | 'authentication' | 'authorization' | 'rate_limit' | 'network' | 'upstream' | 'billing' | 'conflict' | 'internal' | 'unknown';
+/**
+ * The transport failure observed when `category` is `network`.
+ *
+ * This is `null` for failures that are not network failures.
+ *
+ * @sdkReference errors 040
+ */
 type ToolExecutionNetworkKind = 'timeout' | 'dns' | 'connect' | 'reset' | 'unavailable' | 'unknown';
+/**
+ * The request boundary on which a network failure occurred.
+ *
+ * `deepline_to_provider` is provider-side. Client and runtime scopes are
+ * Deepline transport failures and never qualify as provider fallthrough.
+ *
+ * @sdkReference errors 050
+ */
 type ToolExecutionNetworkScope = 'client_to_deepline' | 'runtime_to_deepline' | 'deepline_to_provider';
+/**
+ * Portable version-1 `tool_error` payload.
+ *
+ * This allowlisted shape crosses the API, runtime, and SDK boundaries.
+ * `message` remains on the Error object and is deliberately not a policy
+ * field.
+ *
+ * @sdkReference errors 064
+ */
 type ToolExecutionFailureV1 = {
+    /** Payload version. */
     schemaVersion: typeof TOOL_EXECUTION_ERROR_SCHEMA_VERSION;
+    /** Public tool id passed to `tools.execute`. */
     toolId: string;
+    /** Provider responsible for the operation, or `null`. */
     provider: string | null;
+    /** Provider operation name, or `null`. */
     operation: string | null;
+    /** Stable machine-readable failure code, or `null`. */
     code: string | null;
+    /** Boundary responsible for the failure. */
     origin: ToolExecutionErrorOrigin;
+    /** Stable reason family. */
     category: ToolExecutionErrorCategory;
+    /** Whether repeating the same semantic call is delivery-safe. */
     retryable: boolean;
+    /** HTTP status when one exists, or `null`. */
     statusCode: number | null;
+    /** Provider or Deepline request id, or `null`. */
     requestId: string | null;
+    /** Suggested same-call retry delay in milliseconds, or `null`. */
     retryAfterMs: number | null;
+    /** Network failure kind, or `null`. */
     networkKind: ToolExecutionNetworkKind | null;
+    /** Network boundary that failed, or `null`. */
     networkScope: ToolExecutionNetworkScope | null;
 };
+/**
+ * Constructor input for a structured tool failure.
+ *
+ * Deepline creates these values while decoding the versioned wire payload.
+ * Customer code normally reads `ToolExecutionError` fields instead of
+ * constructing an error.
+ *
+ * @sdkReference errors 065
+ */
 type ToolExecutionErrorOptions = Omit<ToolExecutionFailureV1, 'schemaVersion'> & {
     /**
      * Local diagnostic context inherited from DeeplineError. This is not part of
@@ -266,18 +330,40 @@ type ToolExecutionErrorOptions = Omit<ToolExecutionFailureV1, 'schemaVersion'> &
      */
     details?: Record<string, unknown>;
 };
+/**
+ * Provider-owned failure categories that may fall through to another read
+ * provider.
+ *
+ * @sdkReference errors 060
+ */
 type ProviderTransientErrorCategory = 'rate_limit' | 'network' | 'upstream';
 /**
  * Base error class shared by the SDK and play runtime.
  *
  * The global brand preserves `instanceof DeeplineError` when a bundled play
  * and the runtime load separate physical copies of this module.
+ *
+ * @sdkReference errors 010
  */
 declare class DeeplineError extends Error {
-    statusCode?: number | undefined;
-    code?: string | undefined;
-    details?: Record<string, unknown> | undefined;
-    constructor(message: string, statusCode?: number | undefined, code?: string | undefined, details?: Record<string, unknown> | undefined);
+    /** HTTP status when the failure crossed an HTTP boundary. */
+    statusCode?: number;
+    /** Stable machine-readable error code when one exists. */
+    code?: string;
+    /** Local diagnostic context; not a portable error contract. */
+    details?: Record<string, unknown>;
+    /**
+     * Construct a Deepline error.
+     *
+     * SDK and runtime code construct these errors. Application and Play code
+     * normally catches the public subclasses instead.
+     *
+     * @param message Human-readable failure summary.
+     * @param statusCode HTTP status when one exists.
+     * @param code Stable machine-readable code when one exists.
+     * @param details Local diagnostic context; never a portable error contract.
+     */
+    constructor(message: string, statusCode?: number, code?: string, details?: Record<string, unknown>);
     static [Symbol.hasInstance](value: unknown): boolean;
 }
 /**
@@ -286,18 +372,45 @@ declare class DeeplineError extends Error {
  * `retryable` means Deepline's delivery/idempotency contract says it is safe
  * to repeat the same semantic call. It does not describe durable receipt
  * repairability and does not make arbitrary side-effecting fallbacks safe.
+ *
+ * In a Play, catch `ProviderTransientError` to continue a read waterfall and
+ * let every other `ToolExecutionError` remain loud. In an SDK client, catch
+ * this base class when you need structured diagnostics for every tool failure.
+ *
+ * @sdkReference errors 070
  */
 declare class ToolExecutionError extends DeeplineError {
+    /** Public tool id passed to `tools.execute`. */
     readonly toolId: string;
+    /** Provider responsible for the operation, or `null` when unattributed. */
     readonly provider: string | null;
+    /** Provider operation name, or `null` when unavailable. */
     readonly operation: string | null;
+    /** Boundary responsible for the failure. */
     readonly origin: ToolExecutionErrorOrigin;
+    /** Stable reason family for policy and diagnostics. */
     readonly category: ToolExecutionErrorCategory;
+    /**
+     * Whether repeating the same semantic call is delivery-safe.
+     *
+     * This does not mean the error may be ignored. Waterfall fallthrough is
+     * represented by `ProviderTransientError`.
+     */
     readonly retryable: boolean;
+    /** Provider or Deepline request id, or `null` when unavailable. */
     readonly requestId: string | null;
+    /** Suggested same-call retry delay in milliseconds, or `null`. */
     readonly retryAfterMs: number | null;
+    /** Network failure kind, or `null` for non-network failures. */
     readonly networkKind: ToolExecutionNetworkKind | null;
+    /** Network boundary that failed, or `null` for non-network failures. */
     readonly networkScope: ToolExecutionNetworkScope | null;
+    /**
+     * Construct a structured tool error.
+     *
+     * Deepline constructs this from the versioned `tool_error` payload.
+     * Application and Play code should catch it rather than create it.
+     */
     constructor(message: string, options: ToolExecutionErrorOptions);
     static [Symbol.hasInstance](value: unknown): boolean;
 }
@@ -305,14 +418,23 @@ declare class ToolExecutionError extends DeeplineError {
  * A provider-owned transient failure that is safe to handle as an empty
  * waterfall leg. Validation, auth, billing, Deepline, and unknown failures
  * never satisfy this type.
+ *
+ * `retryable` remains independent: it says whether the same semantic call may
+ * be repeated safely. Falling through to a different read provider depends on
+ * this class, not on `retryable`.
+ *
+ * @sdkReference errors 080
  */
 declare class ProviderTransientError extends ToolExecutionError {
+    /** Provider attribution is guaranteed for this subtype. */
     readonly origin: "provider";
+    /** Provider failure category that made this error eligible for fallthrough. */
     readonly category: ProviderTransientErrorCategory;
+    /** Constructed by Deepline when a provider-owned transient failure arrives. */
     constructor(message: string, options: Omit<ToolExecutionErrorOptions, 'origin' | 'category'> & {
         category: ProviderTransientErrorCategory;
     });
     static [Symbol.hasInstance](value: unknown): boolean;
 }
 
-export { DeeplineError as D, type PlayArtifactKind as P, type ToolExecutionErrorSchemaVersion as T, type PlayCompilerManifest as a, PLAY_ARTIFACT_KINDS as b, ToolExecutionError as c, type ToolExecutionErrorOptions as d, ProviderTransientError as e };
+export { DeeplineError as D, type PlayArtifactKind as P, type ToolExecutionErrorSchemaVersion as T, type PlayCompilerManifest as a, PLAY_ARTIFACT_KINDS as b, ToolExecutionError as c, type ToolExecutionErrorOptions as d, ProviderTransientError as e, type ProviderTransientErrorCategory as f, type ToolExecutionErrorCategory as g, type ToolExecutionErrorOrigin as h, type ToolExecutionFailureV1 as i, type ToolExecutionNetworkKind as j, type ToolExecutionNetworkScope as k };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.1.302",
+  "version": "0.1.304",
   "description": "Deepline SDK + CLI — B2B data enrichment powered by durable cloud execution",
   "license": "MIT",
   "repository": {