deepline 0.3.294 → 0.3.296

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-7UAO5MWV.mjs

@@ -0,0 +1,190 @@
+import {
+  DeeplineClient
+} from "./chunk-J2D3VDOU.mjs";
+import {
+  printCommandEnvelope
+} from "./chunk-NTEZFZLE.mjs";
+import {
+  resolveConfig,
+  sdkCliStateDirPath
+} from "./chunk-NPPJX3BL.mjs";
+
+// src/cli/search-ref.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+var SEARCH_REF_TTL_MS = 15 * 6e4;
+function lastSearchPath() {
+  return join(sdkCliStateDirPath(resolveConfig().baseUrl), "last-search.json");
+}
+function rememberSearchRef(searchRef) {
+  try {
+    mkdirSync(dirname(lastSearchPath()), { recursive: true });
+    writeFileSync(
+      lastSearchPath(),
+      JSON.stringify({ searchRef, at: Date.now() }),
+      { mode: 384 }
+    );
+  } catch {
+  }
+}
+function recentSearchRef() {
+  try {
+    const saved = JSON.parse(readFileSync(lastSearchPath(), "utf8"));
+    return typeof saved.searchRef === "string" && typeof saved.at === "number" && Date.now() - saved.at < SEARCH_REF_TTL_MS ? saved.searchRef : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/cli/commands/search.ts
+var SEARCH_TYPES = [
+  "tools",
+  "plays",
+  "monitors",
+  "prebuilts",
+  "custom"
+];
+var USAGE = "Usage: deepline search [query] [--type <types>] [--categories <categories>] [--search_terms <terms>] [--json]";
+function parseTypes(flag, raw) {
+  const names = (raw ?? "").split(",").map((name) => name.trim().toLowerCase()).filter(Boolean);
+  const unknown = names.filter(
+    (name) => !SEARCH_TYPES.includes(name)
+  );
+  if (unknown.length > 0) {
+    throw new Error(
+      `Unknown ${flag} ${unknown.join(", ")}. Use any of: ${SEARCH_TYPES.join(", ")}.`
+    );
+  }
+  return names;
+}
+function optionalInteger(raw) {
+  return raw === void 0 ? void 0 : Number.parseInt(raw, 10);
+}
+function appendCsv(value, previous) {
+  return previous ? `${previous},${value}` : value;
+}
+function addSearchOptions(command) {
+  return command.option(
+    "--categories <categories>",
+    "Comma-separated tool categories; may be used without a query"
+  ).option(
+    "--search_terms <terms>",
+    "Comma-separated structured search terms; may be used without a query"
+  ).option("--search-terms <terms>", "Alias for --search_terms").option(
+    "--task <sentence>",
+    "What you are trying to accomplish: input you have -> result you need"
+  ).option("--limit <count>", "Maximum ranked results to return (1-50)").option("--offset <count>", "Zero-based ranked result offset").option("--search-mode <mode>", "Ranked search mode: v1 or v2").option("--include-search-debug", "Include ranked search debug metadata").option("--json", "Emit JSON output instead of the readable default");
+}
+async function runSearch(queryInput, options, types, exclude = []) {
+  const query = queryInput?.trim() ?? "";
+  const searchTerms = options.searchTerms ?? options.search_terms;
+  if (!query && !options.categories?.trim() && !searchTerms?.trim()) {
+    console.error(USAGE);
+    return 1;
+  }
+  const { search_ref: searchRef, ...result } = await new DeeplineClient().search({
+    query,
+    types,
+    exclude,
+    categories: options.categories,
+    searchTerms,
+    task: options.task,
+    limit: optionalInteger(options.limit),
+    offset: optionalInteger(options.offset),
+    searchMode: options.searchMode === "v1" || options.searchMode === "v2" ? options.searchMode : void 0,
+    includeSearchDebug: Boolean(options.includeSearchDebug)
+  });
+  if (searchRef) rememberSearchRef(searchRef);
+  printCommandEnvelope(result, {
+    json: options.json === true
+  });
+  return 0;
+}
+function registerDeprecatedSearchCommand(parent, typesFor) {
+  const name = `deepline ${parent.name()} search`;
+  addSearchOptions(
+    parent.command("search [query]").description(`Deprecated. Use deepline search --type <types>.`).addHelpText(
+      "after",
+      `
+Notes:
+  Deprecated alias for the unified search. It runs deepline search with the
+  matching --type and returns the same results envelope.
+
+Examples:
+  deepline search email --type ${typesFor({}).join(",")}
+`
+    ).option("--all", "Include plays your workspace created").option("--compact", "Accepted for compatibility; results are compact")
+  ).action(async (query, options) => {
+    const types = typesFor(options);
+    console.error(
+      `${name} is deprecated. Use: deepline search${query ? ` ${JSON.stringify(query)}` : ""} --type ${types.join(",")}`
+    );
+    process.exitCode = await runSearch(query, options, types);
+  });
+}
+function registerSearchCommand(program) {
+  addSearchOptions(
+    program.command("search [query]").description(
+      "Search tools, monitors, and plays together, ranked by intent."
+    ).addHelpText(
+      "after",
+      `
+Notes:
+  One ranked search across everything Deepline can run, deploy, or explain.
+  Every result carries a kind: tool, monitor_type, prebuilt_play, custom_play
+  (a play your workspace created), or doc. Narrow with --type, a
+  comma-separated list of:
+    tools      atomic provider operations (deepline tools execute)
+    monitors   monitor types you can deploy
+    prebuilts  Deepline-maintained plays
+    custom     plays your workspace created
+    plays      prebuilts and custom together
+  --exclude takes the same names and leaves those kinds out instead.
+  Ranking uses a third-party AI relevance model. For plays your workspace
+  created it is sent only the play name and description, never play code.
+  Both flags may be repeated: --type tools --type prebuilts.
+  Provide a query, or omit it only when --categories and/or --search_terms is
+  supplied. Use --limit and --offset to page (limit 1-50, offset zero-based);
+  JSON includes next_offset. Pass --task with one sentence on what you are
+  trying to accomplish: the input you have and the result you need. It
+  materially improves ranking, especially for short queries.
+  Search prints a readable result list by default, piped or not, and that is
+  the recommended form. Pass --json only when a program parses the result.
+
+Examples:
+  deepline search "find work email"
+  deepline search "find work email" --type tools --limit 10
+  deepline search "company to contacts" --type plays
+  deepline search "enrich a company" --exclude monitors,custom
+  deepline search linkedin --task "I have 200 LinkedIn profile URLs and need each person's current title and company"
+  deepline search --type tools --categories company_search --search_terms "investors,funding"
+`
+    ).option(
+      "--type <types>",
+      `Kinds to search, comma-separated or repeated: ${SEARCH_TYPES.join(", ")}`,
+      appendCsv
+    ).option(
+      "--exclude <types>",
+      "Kinds to leave out, comma-separated or repeated; the opposite of --type",
+      appendCsv
+    )
+  ).action(async (query, options) => {
+    let types;
+    let exclude;
+    try {
+      types = parseTypes("--type", options.type);
+      exclude = parseTypes("--exclude", options.exclude);
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+      process.exitCode = 1;
+      return;
+    }
+    process.exitCode = await runSearch(query, options, types, exclude);
+  });
+}
+
+export {
+  recentSearchRef,
+  registerDeprecatedSearchCommand,
+  registerSearchCommand
+};