deepline 0.3.294 → 0.3.295

package/dist/cli/chunk-7P5AA3SN.js

@@ -0,0 +1,344 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;// ../plays/tool-execution-error.ts
+var DEEPLINE_ERROR_BRAND = Symbol.for("deepline.error.v1");
+var TOOL_EXECUTION_ERROR_BRAND = Symbol.for(
+  "deepline.tool-execution-error.v1"
+);
+var PROVIDER_TRANSIENT_ERROR_BRAND = Symbol.for(
+  "deepline.provider-transient-error.v1"
+);
+var LEGACY_TOOL_EXECUTION_ERROR_SCHEMA_VERSION = 0;
+var TOOL_EXECUTION_ERROR_SCHEMA_VERSION = 1;
+var TOOL_EXECUTION_ERROR_SCHEMA_HEADER = "x-deepline-tool-error-schema";
+var MAX_IDENTIFIER_LENGTH = 200;
+var MAX_CODE_LENGTH = 160;
+function nativeInstanceOf(constructor, value) {
+  return Reflect.apply(Function.prototype[Symbol.hasInstance], constructor, [
+    value
+  ]);
+}
+function hasBrand(value, brand) {
+  return typeof value === "object" && value !== null && value[brand] === true;
+}
+function applyBrand(value, brand) {
+  if (hasBrand(value, brand)) return;
+  Object.defineProperty(value, brand, {
+    configurable: false,
+    enumerable: false,
+    writable: false,
+    value: true
+  });
+}
+var DeeplineError = class _DeeplineError extends Error {
+  /** HTTP status when the failure crossed an HTTP boundary. */
+  
+  /** Stable machine-readable error code when one exists. */
+  
+  /** Local diagnostic context; not a portable error contract. */
+  
+  /**
+   * 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, statusCode, code, details) {
+    super(message);
+    this.name = "DeeplineError";
+    this.statusCode = statusCode;
+    this.code = code;
+    this.details = details;
+    applyBrand(this, DEEPLINE_ERROR_BRAND);
+  }
+  static [Symbol.hasInstance](value) {
+    if (this !== _DeeplineError) return nativeInstanceOf(this, value);
+    return hasBrand(value, DEEPLINE_ERROR_BRAND);
+  }
+};
+var ToolExecutionError = class _ToolExecutionError extends DeeplineError {
+  /** Public tool id passed to `tools.execute`. */
+  
+  /** Provider responsible for the operation, or `null` when unattributed. */
+  
+  /** Provider operation name, or `null` when unavailable. */
+  
+  /** Boundary responsible for the failure. */
+  
+  /** Stable reason family for policy and diagnostics. */
+  
+  /**
+   * Whether repeating the same semantic call is delivery-safe.
+   *
+   * This does not mean the error may be ignored. Waterfall fallthrough is
+   * represented by `ProviderTransientError`.
+   */
+  
+  /** Provider or Deepline request id, or `null` when unavailable. */
+  
+  /** Suggested same-call retry delay in milliseconds, or `null`. */
+  
+  /** Network failure kind, or `null` for non-network failures. */
+  
+  /** Network boundary that failed, or `null` for non-network failures. */
+  
+  /** Explicitly allowlisted diagnostics safe for SDK and Play callers. */
+  
+  /**
+   * 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, options) {
+    super(
+      message,
+      _nullishCoalesce(options.statusCode, () => ( void 0)),
+      _nullishCoalesce(options.code, () => ( void 0)),
+      options.details
+    );
+    this.name = "ToolExecutionError";
+    this.toolId = options.toolId;
+    this.provider = options.provider;
+    this.operation = options.operation;
+    this.origin = options.origin;
+    this.category = options.category;
+    this.retryable = options.retryable;
+    this.requestId = options.requestId;
+    this.retryAfterMs = options.retryAfterMs;
+    this.networkKind = options.networkKind;
+    this.networkScope = options.networkScope;
+    this.publicDetails = _nullishCoalesce(options.publicDetails, () => ( null));
+    applyBrand(this, TOOL_EXECUTION_ERROR_BRAND);
+    if (isProviderTransientFailure(options)) {
+      applyBrand(this, PROVIDER_TRANSIENT_ERROR_BRAND);
+    }
+  }
+  static [Symbol.hasInstance](value) {
+    if (this !== _ToolExecutionError) return nativeInstanceOf(this, value);
+    return hasBrand(value, TOOL_EXECUTION_ERROR_BRAND);
+  }
+};
+function brandAsToolExecutionError(value) {
+  applyBrand(value, TOOL_EXECUTION_ERROR_BRAND);
+}
+function isProviderTransientFailure(input) {
+  return input.origin === "provider" && (input.category === "rate_limit" || input.category === "network" || input.category === "upstream");
+}
+var ProviderTransientError = (_class = class _ProviderTransientError extends ToolExecutionError {
+  /** Provider attribution is guaranteed for this subtype. */
+  __init() {this.origin = "provider"}
+  /** Constructed by Deepline when a provider-owned transient failure arrives. */
+  constructor(message, options) {
+    super(message, {
+      ...options,
+      origin: "provider",
+      category: options.category
+    });_class.prototype.__init.call(this);;
+    this.name = "ProviderTransientError";
+    this.category = options.category;
+    applyBrand(this, PROVIDER_TRANSIENT_ERROR_BRAND);
+  }
+  static [Symbol.hasInstance](value) {
+    if (this !== _ProviderTransientError) return nativeInstanceOf(this, value);
+    return hasBrand(value, PROVIDER_TRANSIENT_ERROR_BRAND);
+  }
+}, _class);
+function getProviderUnavailableReason(error) {
+  if (error instanceof ProviderTransientError) return error.category;
+  if (error instanceof ToolExecutionError && error.origin === "provider" && error.code === "PROVIDER_ACCOUNT_CAPACITY") {
+    return "account_capacity";
+  }
+  if (error instanceof ToolExecutionError && error.origin === "caller" && error.code === "INTEGRATION_CREDENTIALS_MISSING") {
+    return "credentials_missing";
+  }
+  return null;
+}
+function isProviderUnavailable(error) {
+  return getProviderUnavailableReason(error) !== null;
+}
+var isProviderWaterfallUnavailableError = isProviderUnavailable;
+function brandAsProviderTransientError(value) {
+  applyBrand(value, PROVIDER_TRANSIENT_ERROR_BRAND);
+}
+function boundedString(value, maxLength = MAX_IDENTIFIER_LENGTH) {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim();
+  return normalized ? normalized.slice(0, maxLength) : null;
+}
+function finiteNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && Number.isInteger(value) ? value : null;
+}
+function normalizeToolExecutionOrigin(value, input) {
+  const normalized = _optionalChain([boundedString, 'call', _ => _(value), 'optionalAccess', _2 => _2.toLowerCase, 'call', _3 => _3()]);
+  if (normalized === "caller") return "caller";
+  if (normalized === "provider" || normalized === "provider_network") {
+    return "provider";
+  }
+  if (normalized === "upstream" && boundedString(_optionalChain([input, 'optionalAccess', _4 => _4.provider])) && boundedString(_optionalChain([input, 'optionalAccess', _5 => _5.operation]))) {
+    return "provider";
+  }
+  if (normalized === "deepline" || normalized === "deepline_billing" || normalized === "deepline_rate_limit" || normalized === "internal" || normalized === "server") {
+    return "deepline";
+  }
+  if (normalized === "provider_account") return "provider";
+  return "unknown";
+}
+function normalizeToolExecutionCategory(value) {
+  switch (_optionalChain([boundedString, 'call', _6 => _6(value), 'optionalAccess', _7 => _7.toLowerCase, 'call', _8 => _8()])) {
+    case "validation":
+    case "authorization":
+    case "rate_limit":
+    case "network":
+    case "upstream":
+    case "billing":
+    case "conflict":
+    case "internal":
+      return boundedString(value).toLowerCase();
+    case "authentication":
+    case "provider_auth":
+    case "provider_account":
+      return "authentication";
+    case "execution":
+    case "parse":
+    case "stub":
+    case "internal_native_search_performance":
+      return "internal";
+    default:
+      return "unknown";
+  }
+}
+function normalizeNetworkKind(value) {
+  switch (_optionalChain([boundedString, 'call', _9 => _9(value), 'optionalAccess', _10 => _10.toLowerCase, 'call', _11 => _11()])) {
+    case "timeout":
+    case "dns":
+    case "connect":
+    case "reset":
+    case "unavailable":
+    case "unknown":
+      return boundedString(value).toLowerCase();
+    default:
+      return null;
+  }
+}
+function normalizeNetworkScope(value) {
+  switch (_optionalChain([boundedString, 'call', _12 => _12(value), 'optionalAccess', _13 => _13.toLowerCase, 'call', _14 => _14()])) {
+    case "client_to_deepline":
+    case "runtime_to_deepline":
+    case "deepline_to_provider":
+      return boundedString(value).toLowerCase();
+    default:
+      return null;
+  }
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+var MAX_PUBLIC_DETAIL_ENTRIES = 20;
+var MAX_PUBLIC_DETAIL_KEY_LENGTH = 80;
+var MAX_PUBLIC_DETAIL_STRING_LENGTH = 512;
+function normalizeToolExecutionPublicDetails(value) {
+  if (!isRecord(value)) return null;
+  const details = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (Object.keys(details).length >= MAX_PUBLIC_DETAIL_ENTRIES) break;
+    if (key.length === 0 || key.length > MAX_PUBLIC_DETAIL_KEY_LENGTH || !/^[a-z][a-zA-Z0-9_]*$/.test(key)) {
+      continue;
+    }
+    if (typeof entry === "string") {
+      if (entry.length <= MAX_PUBLIC_DETAIL_STRING_LENGTH) details[key] = entry;
+      continue;
+    }
+    if (typeof entry === "number") {
+      if (Number.isFinite(entry)) details[key] = entry;
+      continue;
+    }
+    if (typeof entry === "boolean") {
+      details[key] = entry;
+      continue;
+    }
+    if (entry === null) details[key] = null;
+  }
+  return Object.keys(details).length > 0 ? details : null;
+}
+function normalizeToolExecutionFailure(value) {
+  if (!isRecord(value) || value.schemaVersion !== TOOL_EXECUTION_ERROR_SCHEMA_VERSION) {
+    return null;
+  }
+  const toolId = boundedString(value.toolId);
+  if (!toolId) return null;
+  const provider = boundedString(value.provider);
+  const operation = boundedString(value.operation);
+  const origin = normalizeToolExecutionOrigin(value.origin, {
+    provider,
+    operation
+  });
+  const category = normalizeToolExecutionCategory(value.category);
+  const publicDetails = normalizeToolExecutionPublicDetails(value.publicDetails);
+  const trustworthy = origin !== "unknown" && category !== "unknown" && typeof value.retryable === "boolean";
+  return {
+    schemaVersion: TOOL_EXECUTION_ERROR_SCHEMA_VERSION,
+    toolId,
+    provider,
+    operation,
+    code: boundedString(value.code, MAX_CODE_LENGTH),
+    origin,
+    category,
+    retryable: trustworthy ? value.retryable === true : false,
+    statusCode: finiteNonNegativeInteger(value.statusCode),
+    requestId: boundedString(value.requestId),
+    retryAfterMs: finiteNonNegativeInteger(value.retryAfterMs),
+    networkKind: normalizeNetworkKind(value.networkKind),
+    networkScope: normalizeNetworkScope(value.networkScope),
+    ...publicDetails ? { publicDetails } : {}
+  };
+}
+function serializeToolExecutionFailure(error) {
+  if (!(error instanceof ToolExecutionError)) return null;
+  return normalizeToolExecutionFailure({
+    schemaVersion: TOOL_EXECUTION_ERROR_SCHEMA_VERSION,
+    toolId: error.toolId,
+    provider: error.provider,
+    operation: error.operation,
+    code: _nullishCoalesce(error.code, () => ( null)),
+    origin: error.origin,
+    category: error.category,
+    retryable: error.retryable,
+    statusCode: _nullishCoalesce(error.statusCode, () => ( null)),
+    requestId: error.requestId,
+    retryAfterMs: error.retryAfterMs,
+    networkKind: error.networkKind,
+    networkScope: error.networkScope,
+    publicDetails: error.publicDetails
+  });
+}
+function deserializeToolExecutionFailure(message, value, acceptedSchemaVersion) {
+  if (acceptedSchemaVersion === LEGACY_TOOL_EXECUTION_ERROR_SCHEMA_VERSION) {
+    return null;
+  }
+  const failure = normalizeToolExecutionFailure(value);
+  if (!failure) return null;
+  if (isProviderTransientFailure(failure)) {
+    return new ProviderTransientError(message, failure);
+  }
+  return new ToolExecutionError(message, failure);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.TOOL_EXECUTION_ERROR_SCHEMA_VERSION = TOOL_EXECUTION_ERROR_SCHEMA_VERSION; exports.TOOL_EXECUTION_ERROR_SCHEMA_HEADER = TOOL_EXECUTION_ERROR_SCHEMA_HEADER; exports.DeeplineError = DeeplineError; exports.ToolExecutionError = ToolExecutionError; exports.brandAsToolExecutionError = brandAsToolExecutionError; exports.isProviderTransientFailure = isProviderTransientFailure; exports.ProviderTransientError = ProviderTransientError; exports.getProviderUnavailableReason = getProviderUnavailableReason; exports.isProviderUnavailable = isProviderUnavailable; exports.isProviderWaterfallUnavailableError = isProviderWaterfallUnavailableError; exports.brandAsProviderTransientError = brandAsProviderTransientError; exports.serializeToolExecutionFailure = serializeToolExecutionFailure; exports.deserializeToolExecutionFailure = deserializeToolExecutionFailure;

package/dist/cli/chunk-AYHLUHE5.js

@@ -0,0 +1,52 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/cli/trace.ts
+var cliTraceStartedAt = Date.now();
+function isTruthyEnv(value) {
+  return value === "1" || value === "true" || value === "yes";
+}
+function isCliTraceEnabled() {
+  return isTruthyEnv(process.env.DEEPLINE_CLI_TRACE);
+}
+function recordCliTrace(event) {
+  if (!isCliTraceEnabled()) {
+    return;
+  }
+  const now = Date.now();
+  const payload = {
+    ts: now,
+    source: "cli",
+    sinceStartMs: now - cliTraceStartedAt,
+    ...event
+  };
+  process.stderr.write(`[cli-trace] ${JSON.stringify(payload)}
+`);
+}
+async function traceCliSpan(phase, fields, run) {
+  if (!isCliTraceEnabled()) {
+    return run();
+  }
+  const startedAt = Date.now();
+  try {
+    const result = await run();
+    recordCliTrace({
+      phase,
+      ms: Date.now() - startedAt,
+      ok: true,
+      ...fields
+    });
+    return result;
+  } catch (error) {
+    recordCliTrace({
+      phase,
+      ms: Date.now() - startedAt,
+      ok: false,
+      error: error instanceof Error ? error.message : String(error),
+      ...fields
+    });
+    throw error;
+  }
+}
+
+
+
+
+exports.recordCliTrace = recordCliTrace; exports.traceCliSpan = traceCliSpan;