deepline 0.3.294 → 0.3.295

package/dist/cli/tools-QXEVCN45.js

@@ -0,0 +1,2955 @@
+"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 _chunkWQICC2B3js = require('./chunk-WQICC2B3.js');
+
+
+
+
+
+
+
+var _chunkNXDRDJ4Kjs = require('./chunk-NXDRDJ4K.js');
+
+
+var _chunk2S5Y3TZPjs = require('./chunk-2S5Y3TZP.js');
+require('./chunk-LA46MMTL.js');
+
+
+
+
+
+
+
+
+var _chunkF35VOIQLjs = require('./chunk-F35VOIQL.js');
+
+
+
+var _chunkXRK2TZT5js = require('./chunk-XRK2TZT5.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-D4AZUZO4.js');
+require('./chunk-6A3TJUWC.js');
+
+
+var _chunk7P5AA3SNjs = require('./chunk-7P5AA3SN.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+// src/cli/commands/tools.ts
+var _commander = require('commander');
+
+
+
+
+
+
+var _fs = require('fs');
+var _os = require('os');
+var _path = require('path');
+
+// src/cli/tool-call-recovery.ts
+var _crypto = require('crypto');
+
+
+
+
+
+
+
+
+
+var ToolCallRecovery = class _ToolCallRecovery {
+  constructor(idempotencyKey, path) {
+    this.idempotencyKey = idempotencyKey;
+    this.path = path;
+  }
+  static open(input) {
+    if (!input.recover || input.idempotencyKey) {
+      return new _ToolCallRecovery(input.idempotencyKey, null);
+    }
+    const path = pendingToolExecutionPath(input);
+    return new _ToolCallRecovery(loadOrCreatePendingToolExecution(path), path);
+  }
+  async acknowledgeDelivery() {
+    await completePendingToolExecution(this.path, this.idempotencyKey);
+  }
+};
+function pendingToolExecutionPath(input) {
+  const config = _chunkXRK2TZT5js.resolveConfig.call(void 0, );
+  const fingerprint = _crypto.createHash.call(void 0, "sha256").update(config.baseUrl).update("\0").update(_crypto.createHash.call(void 0, "sha256").update(config.apiKey).digest("hex")).update("\0").update(input.toolId).update("\0").update(_chunkNXDRDJ4Kjs.stableStringify.call(void 0, input.params)).update("\0").update(input.responseIntent).digest("hex");
+  return _path.join.call(void 0, 
+    _chunkXRK2TZT5js.sdkCliStateDirPath.call(void 0, config.baseUrl),
+    `pending-tool-execution-${fingerprint}.json`
+  );
+}
+function loadOrCreatePendingToolExecution(path) {
+  _fs.mkdirSync.call(void 0, _path.dirname.call(void 0, path), { recursive: true });
+  if (_fs.existsSync.call(void 0, path)) {
+    return readPendingToolExecution(path);
+  }
+  const idempotencyKey = _crypto.randomUUID.call(void 0, );
+  const temporaryPath = `${path}.${process.pid}.${_crypto.randomUUID.call(void 0, )}.tmp`;
+  try {
+    _fs.writeFileSync.call(void 0, temporaryPath, `${JSON.stringify({ idempotencyKey })}
+`, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 384
+    });
+    _fs.linkSync.call(void 0, temporaryPath, path);
+    return idempotencyKey;
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    return readPendingToolExecution(path);
+  } finally {
+    if (_fs.existsSync.call(void 0, temporaryPath)) _fs.unlinkSync.call(void 0, temporaryPath);
+  }
+}
+function readPendingToolExecution(path) {
+  const saved = JSON.parse(_fs.readFileSync.call(void 0, path, "utf8"));
+  if (typeof saved.idempotencyKey !== "string") {
+    throw new Error(
+      `Cannot resume the saved tool execution at ${path}: invalid recovery key.`
+    );
+  }
+  return saved.idempotencyKey;
+}
+async function completePendingToolExecution(path, idempotencyKey) {
+  if (!path || !idempotencyKey || !_fs.existsSync.call(void 0, path)) return;
+  await new Promise((resolve2, reject) => {
+    const onError = (error) => {
+      process.stdout.off("error", onError);
+      reject(error);
+    };
+    process.stdout.once("error", onError);
+    process.stdout.write("", (error) => {
+      process.stdout.off("error", onError);
+      if (error) {
+        reject(error);
+      } else {
+        resolve2();
+      }
+    });
+  });
+  try {
+    if (readPendingToolExecution(path) !== idempotencyKey) return;
+    _fs.unlinkSync.call(void 0, path);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+}
+
+// ../plays/tool-category-descriptions.ts
+var TOOL_CATEGORY_DESCRIPTIONS = {
+  company_search: "Find companies matching firmographic, ad, or web criteria.",
+  people_search: "Find people matching role, company, or persona criteria.",
+  people_enrich: "Enrich a known person with contact, social, and profile data.",
+  company_enrich: "Enrich a known company with firmographic and account data.",
+  email_finder: "Find work or personal email addresses for a person.",
+  email_verify: "Validate email deliverability and catch-all status.",
+  phone_finder: "Find mobile or direct phone numbers for a person.",
+  phone_verify: "Validate phone-number reachability and line type.",
+  research: "Research accounts, people, news, and signals for context and scoring.",
+  autocomplete: "Resolve names and entities to canonical catalog records.",
+  automation: "Kick off provider-side jobs, exports, and asynchronous workflows.",
+  outbound_tools: "Run outbound sequencing, deliverability, and campaign operations.",
+  admin: "Provider-side status, metadata, and account operations behind other tools.",
+  smb: "Look up small-business listings, local records, and public filings.",
+  identity_resolution: "Match a partial identity to a single resolved person or company.",
+  reverse_lookup: "Resolve an email, phone, or profile back to a person.",
+  enrichment: "General-purpose record enrichment across people and companies.",
+  batch: "Run an enrichment or search operation over many rows at once.",
+  premium: "Higher-cost tools with premium provider coverage.",
+  free: "Free tools that do not spend Deepline credits."
+};
+var WELL_KNOWN_TOOL_CATEGORIES = Object.freeze(
+  Object.keys(TOOL_CATEGORY_DESCRIPTIONS)
+);
+function describeToolCategory(category) {
+  return _nullishCoalesce(TOOL_CATEGORY_DESCRIPTIONS[category], () => ( null));
+}
+
+// src/cli/commands/model-description.ts
+function formatModelDescription(description) {
+  const lines = [];
+  lines.push(description.model);
+  lines.push(`Provider: ${description.provider}`);
+  const name = stringField(description.modelMetadata, "name");
+  if (name) lines.push(`Name: ${name}`);
+  const contextWindow = numberField(
+    description.modelMetadata,
+    "context_window"
+  );
+  if (contextWindow !== null) lines.push(`Context: ${contextWindow}`);
+  const tags = arrayField(description.modelMetadata, "tags").filter(
+    (value) => typeof value === "string"
+  );
+  if (tags.length) lines.push(`Tags: ${tags.join(", ")}`);
+  lines.push("");
+  lines.push("Provider options:");
+  appendNamespace(lines, description.providerOptions.gateway);
+  if (description.providerOptions.selectedProvider) {
+    appendNamespace(lines, description.providerOptions.selectedProvider);
+  }
+  lines.push("");
+  lines.push("Example input:");
+  lines.push(JSON.stringify(description.exampleInput, null, 2));
+  if (description.caveats.length) {
+    lines.push("");
+    lines.push("Caveats:");
+    for (const caveat of description.caveats) {
+      lines.push(`- ${caveat}`);
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+function appendNamespace(lines, namespace) {
+  lines.push(`- ${namespace.provider} (${namespace.sourceSymbol})`);
+  for (const field of namespace.fields) {
+    const values = _optionalChain([field, 'access', _ => _.enumValues, 'optionalAccess', _2 => _2.length]) ? ` (${field.enumValues.map((value) => JSON.stringify(value)).join(" | ")})` : "";
+    lines.push(
+      `  - ${field.name}: ${field.type}${values} - ${field.description}`
+    );
+  }
+}
+function stringField(value, key) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const candidate = value[key];
+  return typeof candidate === "string" && candidate.trim() ? candidate.trim() : null;
+}
+function numberField(value, key) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const candidate = value[key];
+  return typeof candidate === "number" ? candidate : null;
+}
+function arrayField(value, key) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return [];
+  const candidate = value[key];
+  return Array.isArray(candidate) ? candidate : [];
+}
+
+// src/cli/tool-description.ts
+var Capability = class _Capability {
+  #catalogEntry;
+  constructor(catalogEntry) {
+    this.#catalogEntry = catalogEntry;
+  }
+  static fromCatalogEntry(catalogEntry) {
+    return new _Capability(catalogEntry);
+  }
+  describe() {
+    return CapabilityDescription.fromCatalogEntry(this.#catalogEntry);
+  }
+};
+var CapabilityDescription = class _CapabilityDescription {
+  #catalogEntry;
+  constructor(catalogEntry) {
+    this.#catalogEntry = catalogEntry;
+  }
+  static fromCatalogEntry(catalogEntry) {
+    return new _CapabilityDescription(catalogEntry);
+  }
+  /**
+   * The customer price already resolved by the catalog. This intentionally
+   * omits provider-price fields, even when a catalog Adapter carried them.
+   */
+  customerCost() {
+    const legacyCost = recordValue(this.#catalogEntry.cost);
+    const pricing = recordValue(this.#catalogEntry.pricing);
+    const unit = stringValue(pricing.unit);
+    const legacyPricingModel = stringValue(
+      _nullishCoalesce(legacyCost.pricingModel, () => ( legacyCost.pricing_model))
+    );
+    const pricingModel = unit === "call" ? "fixed" : unit === "result" || unit === "page" ? `per_${unit}` : unit === "usage" ? "provider_usage" : legacyPricingModel;
+    const canonicalCredits = pricingNumber(
+      pricing,
+      "creditsPerUnit",
+      "credits_per_unit",
+      _nullishCoalesce(this.#catalogEntry.deeplineCreditsPerPricingUnit, () => ( this.#catalogEntry.deepline_credits_per_pricing_unit))
+    );
+    const canonicalUsd = pricingNumber(
+      pricing,
+      "usdPerUnit",
+      "usd_per_unit",
+      _nullishCoalesce(this.#catalogEntry.deeplineUsdPerPricingUnit, () => ( this.#catalogEntry.deepline_usd_per_pricing_unit))
+    );
+    const billingSource = stringValue(
+      _nullishCoalesce(this.#catalogEntry.billingSource, () => ( this.#catalogEntry.billing_source))
+    );
+    const billingSourceLabel = stringValue(
+      _nullishCoalesce(this.#catalogEntry.billingSourceLabel, () => ( this.#catalogEntry.billing_source_label))
+    );
+    const isFree = billingSource === "free";
+    return {
+      pricingModel: pricingModel || null,
+      unit: unit || null,
+      displayText: isFree ? "Free" : stringValue(_nullishCoalesce(pricing.displayText, () => ( pricing.display_text))),
+      summary: isFree ? null : stringValue(pricing.summary),
+      billingMode: stringValue(
+        _nullishCoalesce(legacyCost.billingMode, () => ( legacyCost.billing_mode))
+      ),
+      billingSource,
+      billingSourceLabel,
+      deeplineCreditsPerPricingUnit: isFree ? 0 : canonicalCredits,
+      deeplineUsdPerPricingUnit: isFree ? 0 : canonicalUsd
+    };
+  }
+};
+function recordValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value : null;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function pricingNumber(pricing, canonicalKey, aliasKey, legacyValue) {
+  for (const key of [canonicalKey, aliasKey]) {
+    if (Object.prototype.hasOwnProperty.call(pricing, key))
+      return numberValue(pricing[key]);
+  }
+  return numberValue(legacyValue);
+}
+
+// src/cli/tool-connection-status.ts
+function toolConnectionStatusMessage(input) {
+  if (input.credentialStatus === "requires_connection") {
+    return "requires your credentials \u2014 not connected (connect to use)";
+  }
+  if (input.connected === false && input.credentialStatus === "managed") {
+    return "temporarily unavailable";
+  }
+  return null;
+}
+
+// src/cli/commands/tools.ts
+var TOOL_COMMAND_TEMPLATES = {
+  describe: "deepline tools describe <toolId>",
+  execute: "deepline tools execute <toolId> --input '{...}'"
+};
+function toListedTool(tool) {
+  if (isPlayLikeTool(tool)) {
+    return {
+      ...tool,
+      description: listedToolDescription(tool),
+      id: tool.toolId,
+      type: "play",
+      executeCommand: playRunCommandForTool(tool, tool.toolId)
+    };
+  }
+  return {
+    ...tool,
+    description: listedToolDescription(tool),
+    id: tool.toolId,
+    type: "tool",
+    executeCommand: `deepline tools execute ${tool.toolId}`
+  };
+}
+function normalizeGrepText(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "string") return value.toLowerCase();
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value).toLowerCase();
+  }
+  if (Array.isArray(value)) return value.map(normalizeGrepText).join(" ");
+  if (typeof value === "object") {
+    return Object.values(value).map(normalizeGrepText).join(" ");
+  }
+  return "";
+}
+function parseGrepTerms(query, mode) {
+  const trimmed = query.trim().toLowerCase();
+  if (!trimmed) return [];
+  if (mode === "phrase") return [trimmed];
+  const matches = _nullishCoalesce(trimmed.match(/"([^"]+)"|'([^']+)'|\S+/g), () => ( []));
+  return matches.map((term) => term.replace(/^["']|["']$/g, "").trim()).filter(Boolean);
+}
+function matchesGrepQuery(value, query, mode) {
+  const terms = parseGrepTerms(query, mode);
+  if (terms.length === 0) return true;
+  const haystack = normalizeGrepText(value);
+  if (mode === "any") return terms.some((term) => haystack.includes(term));
+  return terms.every((term) => haystack.includes(term));
+}
+function shellCommandArg(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function zeroMatchToolGuidance(options) {
+  const categories = _nullishCoalesce(options.categories, () => ( []));
+  const query = _nullishCoalesce(_optionalChain([options, 'access', _3 => _3.query, 'optionalAccess', _4 => _4.trim, 'call', _5 => _5()]), () => ( ""));
+  const filterText = [
+    categories.length ? `categories=${categories.join(",")}` : null,
+    query ? `grep=${query}` : null,
+    query ? `grep_mode=${_nullishCoalesce(options.mode, () => ( "all"))}` : null
+  ].filter(Boolean).join(" ");
+  const suggestions = [
+    ...query ? [
+      {
+        label: "Use ranked semantic search for intent-style queries",
+        command: `deepline search --type tools -- ${shellCommandArg(query)}`
+      },
+      ...options.mode === "all" ? [
+        {
+          label: "Relax literal grep from AND to OR matching",
+          command: `deepline tools grep --mode any -- ${shellCommandArg(query)}`
+        }
+      ] : []
+    ] : [],
+    {
+      label: "List the current atomic tool catalog",
+      command: "deepline tools list --json"
+    },
+    ...query ? [
+      {
+        label: "Search composed Deepline plays separately",
+        command: `deepline search --type prebuilts -- ${shellCommandArg(query)}`
+      }
+    ] : []
+  ];
+  return {
+    reason: "filters_matched_no_atomic_tools",
+    message: `The tools catalog responded successfully, but no atomic provider tools matched ${filterText || "the current filters"}. This is a zero-match filter result, not a registry outage.`,
+    suggestions
+  };
+}
+function zeroMatchRender(emptyResult) {
+  return {
+    sections: [
+      {
+        title: "0 tools available:",
+        lines: [emptyResult.message]
+      },
+      {
+        title: "suggestions",
+        lines: emptyResult.suggestions.map(
+          (suggestion) => `${suggestion.label}: ${suggestion.command}`
+        )
+      }
+    ]
+  };
+}
+function firstSentence(text) {
+  const clean = (_nullishCoalesce(text, () => ( ""))).replace(/\s+/g, " ").trim();
+  if (!clean) return "";
+  const match = clean.match(/^.*?[.!?](?=\s|$)/);
+  return (match ? match[0] : clean).trim();
+}
+function requiredInputIds(tool) {
+  const inputSchema = recordField(
+    tool,
+    "inputSchema",
+    "input_schema"
+  );
+  return toolInputFieldsForDisplay(inputSchema).filter((field) => field.required === true).map((field) => String(_nullishCoalesce(field.name, () => ( "")))).filter(Boolean);
+}
+function notConnectedSuffix(tool) {
+  const record = tool;
+  const status = stringField2(record, "credentialStatus", "credential_status");
+  const connected = record.connected;
+  const message = toolConnectionStatusMessage({
+    connected: connected === false ? false : void 0,
+    credentialStatus: status || void 0
+  });
+  return message ? ` - \u26A0 ${message}` : "";
+}
+function shortPricingHint(tool) {
+  const pricing = recordField(
+    tool,
+    "pricing"
+  );
+  const credits = numberField2(pricing, "creditsPerUnit", "credits_per_unit");
+  const unit = stringField2(pricing, "unit");
+  if (credits !== null) {
+    return `${formatDecimal(credits)} cr/${unit || "unit"}`;
+  }
+  const summary = stringField2(pricing, "summary");
+  if (summary) return summary;
+  const displayText = stringField2(pricing, "displayText", "display_text");
+  return displayText || null;
+}
+function aggregateCategorySummaries(tools) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const tool of tools) {
+    for (const category of _nullishCoalesce(tool.categories, () => ( []))) {
+      counts.set(category, (_nullishCoalesce(counts.get(category), () => ( 0))) + 1);
+    }
+  }
+  return [...counts.entries()].map(([name, count]) => ({
+    name,
+    count,
+    description: describeToolCategory(name)
+  })).sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
+}
+function categoryEnumerationRender(summaries) {
+  const nameWidth = summaries.reduce(
+    (max, item) => Math.max(max, item.name.length),
+    0
+  );
+  const countWidth = summaries.reduce(
+    (max, item) => Math.max(max, String(item.count).length),
+    0
+  );
+  return {
+    sections: [
+      {
+        title: `${summaries.length} tool categories:`,
+        lines: summaries.map((item) => {
+          const name = item.name.padEnd(nameWidth);
+          const count = String(item.count).padStart(countWidth);
+          const definition = item.description ? ` - ${item.description}` : "";
+          return `${name}  ${count}${definition}`;
+        })
+      },
+      {
+        title: "next",
+        lines: ["Pass a category: deepline tools list email_finder"]
+      }
+    ]
+  };
+}
+async function listToolCategories(emitJson, compact) {
+  const client = new (0, _chunk2S5Y3TZPjs.DeeplineClient)();
+  const rawTools = await client.listTools({ compact });
+  const items = rawTools.map(toListedTool);
+  const summaries = aggregateCategorySummaries(rawTools);
+  const outputItems = compact ? items.map(compactTool) : items;
+  _chunkF35VOIQLjs.printCommandEnvelope.call(void 0, 
+    {
+      tools: outputItems,
+      count: outputItems.length,
+      categories: summaries,
+      filters: {
+        categories: []
+      },
+      commandTemplates: TOOL_COMMAND_TEMPLATES,
+      render: categoryEnumerationRender(summaries)
+    },
+    { json: emitJson }
+  );
+  return 0;
+}
+function unknownCategoryError(category, summaries, emitJson) {
+  const known = summaries.map((item) => item.name);
+  const message = `Unknown tool category "${category}". Run \`deepline tools list\` to browse categories.`;
+  if (emitJson) {
+    _chunkF35VOIQLjs.printJson.call(void 0, {
+      ok: false,
+      exitCode: 4,
+      code: "TOOL_CATEGORY_NOT_FOUND",
+      message,
+      category,
+      categories: summaries,
+      next: "deepline tools list"
+    });
+    return 4;
+  }
+  const render = categoryEnumerationRender(summaries);
+  console.error(message);
+  console.error("");
+  console.error(_chunkF35VOIQLjs.renderCommandEnvelopeText.call(void 0, { render }).trimEnd());
+  console.error("");
+  console.error(`Valid categories: ${known.join(", ")}`);
+  return 4;
+}
+async function listToolsInCategory(category, emitJson) {
+  const client = new (0, _chunk2S5Y3TZPjs.DeeplineClient)();
+  const rawTools = await client.listTools({
+    categories: category,
+    compact: false
+  });
+  const allTools = await client.listTools({ compact: true });
+  const summaries = aggregateCategorySummaries(allTools);
+  if (!summaries.some((item) => item.name === category)) {
+    return unknownCategoryError(category, summaries, emitJson);
+  }
+  const rows = rawTools.filter((tool) => _optionalChain([tool, 'access', _6 => _6.categories, 'optionalAccess', _7 => _7.includes, 'call', _8 => _8(category)])).map((tool) => ({
+    id: tool.toolId,
+    provider: tool.provider,
+    required: requiredInputIds(tool),
+    pricing: shortPricingHint(tool),
+    description: firstSentence(tool.description),
+    notConnected: notConnectedSuffix(tool)
+  })).sort((a, b) => a.id.localeCompare(b.id));
+  const idWidth = rows.reduce((max, row) => Math.max(max, row.id.length), 0);
+  const render = {
+    sections: [
+      {
+        title: `${rows.length} tools in ${category}:`,
+        lines: rows.map((row) => {
+          const id = row.id.padEnd(idWidth);
+          const required = row.required.length ? `(${row.required.join(", ")})` : "(no required inputs)";
+          const pricing = row.pricing ? ` [${row.pricing}]` : "";
+          const description = row.description ? ` - ${row.description}` : "";
+          return `${id}  ${required}${pricing}${description}${row.notConnected}`;
+        })
+      },
+      {
+        title: "next",
+        lines: [
+          "Run `deepline tools describe <toolId>` for the full contract."
+        ]
+      }
+    ]
+  };
+  _chunkF35VOIQLjs.printCommandEnvelope.call(void 0, 
+    {
+      category,
+      total: rows.length,
+      tools: rows,
+      commandTemplates: TOOL_COMMAND_TEMPLATES,
+      render
+    },
+    { json: emitJson }
+  );
+  return 0;
+}
+async function listToolsForCategoryFilter(requestedCategories, emitJson, compact) {
+  const client = new (0, _chunk2S5Y3TZPjs.DeeplineClient)();
+  const items = (await client.listTools({
+    categories: requestedCategories.join(","),
+    compact
+  })).map(toListedTool).filter(
+    (item) => requestedCategories.some(
+      (category) => item.categories.includes(category)
+    )
+  );
+  const emptyResult = items.length === 0 ? zeroMatchToolGuidance({ categories: requestedCategories }) : null;
+  const render = {
+    sections: emptyResult ? zeroMatchRender(emptyResult).sections : [
+      {
+        title: `${items.length} tools available:`,
+        lines: items.map((item) => {
+          const cats = item.categories.length ? ` [${item.categories.join(", ")}]` : "";
+          const pricing = formatListedToolCost(item);
+          return `${item.toolId}${cats} - ${item.description}${pricing ? ` - ${pricing}` : ""}${notConnectedSuffix(item)}`;
+        })
+      },
+      {
+        title: "next",
+        lines: [
+          "Run `deepline tools describe <toolId>` before executing a tool."
+        ]
+      }
+    ]
+  };
+  const outputItems = compact ? items.map(compactTool) : items;
+  _chunkF35VOIQLjs.printCommandEnvelope.call(void 0, 
+    {
+      tools: outputItems,
+      count: outputItems.length,
+      ...emptyResult ? { emptyResult } : {},
+      filters: {
+        categories: requestedCategories
+      },
+      commandTemplates: TOOL_COMMAND_TEMPLATES,
+      render
+    },
+    { json: emitJson }
+  );
+  return 0;
+}
+async function listTools(category, options = {}) {
+  const positional = _nullishCoalesce(_optionalChain([category, 'optionalAccess', _9 => _9.trim, 'call', _10 => _10()]), () => ( ""));
+  const flagCategories = (_nullishCoalesce(options.categories, () => ( ""))).split(",").map((item) => item.trim()).filter(Boolean);
+  const compact = options.compact !== false;
+  const emitJson = options.json === true || _chunkF35VOIQLjs.shouldEmitJson.call(void 0, );
+  if (positional && flagCategories.length > 0) {
+    const flagIsSameSingle = flagCategories.length === 1 && flagCategories[0] === positional;
+    if (!flagIsSameSingle) {
+      const message = `Category "${positional}" and --categories ${flagCategories.join(",")} disagree. Pass one: deepline tools list ${positional}`;
+      if (emitJson) {
+        _chunkF35VOIQLjs.printJson.call(void 0, {
+          ok: false,
+          exitCode: 2,
+          code: "TOOL_LIST_CATEGORY_CONFLICT",
+          message,
+          next: `deepline tools list ${positional}`
+        });
+      } else {
+        console.error(message);
+      }
+      return 2;
+    }
+  }
+  if (positional) {
+    return listToolsInCategory(positional, emitJson);
+  }
+  if (flagCategories.length > 0) {
+    return listToolsForCategoryFilter(flagCategories, emitJson, compact);
+  }
+  return listToolCategories(emitJson, compact);
+}
+async function grepTools(queryInput, options = {}) {
+  const query = queryInput.trim();
+  if (!query) {
+    console.error("Usage: deepline tools grep <query> [--json]");
+    return 1;
+  }
+  const client = new (0, _chunk2S5Y3TZPjs.DeeplineClient)();
+  const requestedCategories = options.categories ? options.categories.split(",").map((item) => item.trim()).filter(Boolean) : [];
+  const mode = _nullishCoalesce(options.mode, () => ( "all"));
+  const jsonOutput = options.json === true;
+  let apiCompact = !jsonOutput;
+  if (typeof options.compact === "boolean") {
+    apiCompact = options.compact;
+  }
+  const tools = (await client.listTools({
+    grep: query,
+    grepMode: mode,
+    ...options.categories ? { categories: options.categories } : {},
+    compact: apiCompact
+  })).map(toListedTool).filter(
+    (item) => requestedCategories.length === 0 || requestedCategories.some(
+      (category) => item.categories.includes(category)
+    )
+  ).filter(
+    (item) => apiCompact ? true : matchesGrepQuery(
+      {
+        id: item.toolId,
+        toolId: item.toolId,
+        provider: item.provider,
+        displayName: item.displayName,
+        description: item.description,
+        categories: item.categories,
+        operation: item.operation,
+        operationAliases: item.operationAliases,
+        inputSchema: item.inputSchema,
+        outputSchema: item.outputSchema,
+        inputFields: item.inputFields
+      },
+      query,
+      mode
+    )
+  );
+  const shouldCompact = apiCompact;
+  const outputTools = shouldCompact ? tools.slice(0, 8).map(compactTool) : tools;
+  const emptyResult = tools.length === 0 ? zeroMatchToolGuidance({
+    categories: requestedCategories,
+    query,
+    mode
+  }) : null;
+  _chunkF35VOIQLjs.printCommandEnvelope.call(void 0, 
+    {
+      tools: outputTools,
+      count: outputTools.length,
+      query,
+      grep: {
+        mode,
+        terms: parseGrepTerms(query, mode)
+      },
+      filters: {
+        categories: requestedCategories
+      },
+      ...emptyResult ? {
+        emptyResult,
+        render: zeroMatchRender(emptyResult)
+      } : {},
+      commandTemplates: TOOL_COMMAND_TEMPLATES
+    },
+    { json: options.json || _chunkF35VOIQLjs.shouldEmitJson.call(void 0, ) }
+  );
+  return 0;
+}
+function numericToolField(tool, field) {
+  const value = tool[field];
+  return typeof value === "number" ? value : void 0;
+}
+function compactTool(tool) {
+  const listed = toListedTool(tool);
+  const searchScore = numericToolField(tool, "searchScore");
+  const search_score = numericToolField(tool, "search_score");
+  return {
+    id: listed.id,
+    toolId: listed.toolId,
+    ...search_score !== void 0 ? { search_score } : {},
+    ...searchScore !== void 0 ? { searchScore } : {},
+    provider: listed.provider,
+    displayName: listed.displayName,
+    description: listed.description,
+    categories: listed.categories,
+    type: listed.type,
+    executeCommand: listed.executeCommand
+  };
+}
+function playIdentifiers(play) {
+  return [play.name, play.reference, ..._nullishCoalesce(play.aliases, () => ( []))].filter((value) => Boolean(_optionalChain([value, 'optionalAccess', _11 => _11.trim, 'call', _12 => _12()]))).map((value) => value.trim());
+}
+async function findPlayForToolId(client, toolId) {
+  const requested = toolId.trim();
+  if (!requested) {
+    return null;
+  }
+  const plays = await client.searchPlays({ query: requested, compact: true });
+  return _nullishCoalesce(plays.find((play) => playIdentifiers(play).includes(requested)), () => ( null));
+}
+function isMissingToolMetadataError(error) {
+  return error instanceof _chunk7P5AA3SNjs.DeeplineError && error.statusCode === 404;
+}
+function playAliasToolErrorMessage(toolId, play) {
+  const playName = _nullishCoalesce(play.reference, () => ( play.name));
+  return `${toolId} is a play, not a tool.
+Use: deepline plays run ${playName} --input '{...}'
+Inspect its schema with: deepline plays describe ${playName} --json`;
+}
+function printPlayAliasToolError(toolId, play) {
+  console.error(playAliasToolErrorMessage(toolId, play));
+}
+function isPlayLikeTool(tool) {
+  const record = tool;
+  if (record.isPlay === true || record.is_play === true) return true;
+  const playExpansion = recordField(record, "playExpansion", "play_expansion");
+  if (Object.keys(playExpansion).length > 0) return true;
+  const toolId = typeof record.toolId === "string" ? record.toolId : "";
+  return toolId.endsWith("_waterfall");
+}
+function isMonitorTypeTool(tool) {
+  return stringField2(tool, "kind") === "monitor_type";
+}
+function playReferenceForTool(tool) {
+  const record = tool;
+  const declared = stringField2(record, "playReference", "play_reference");
+  if (declared.startsWith("prebuilt/")) {
+    return declared;
+  }
+  return null;
+}
+function playSearchCommandForToolId(toolId) {
+  return `deepline search --type prebuilts ${JSON.stringify(toolId.replace(/_/g, " "))} --json`;
+}
+function playRunCommandForTool(tool, toolId, input) {
+  const playReference = playReferenceForTool(tool);
+  if (!playReference) return playSearchCommandForToolId(toolId);
+  const inputArg = input === void 0 ? "'{...}'" : `'${JSON.stringify(input)}'`;
+  return `deepline plays run ${playReference} --input ${inputArg}`;
+}
+function playLikeToolExecuteErrorMessage(toolId, tool) {
+  const playReference = tool ? playReferenceForTool(tool) : null;
+  const nextStep = playReference ? `Use: deepline plays run ${playReference} --input '{...}'` : `Find the maintained workflow with: ${playSearchCommandForToolId(toolId)}`;
+  return [
+    `${toolId} is a workflow/play entry, not an atomic provider tool.`,
+    nextStep,
+    'Or search provider tools only with: deepline search --type tools "<query>" --json'
+  ].join("\n");
+}
+function printPlayLikeToolExecuteError(toolId, tool) {
+  console.error(playLikeToolExecuteErrorMessage(toolId, tool));
+}
+function registerToolsCommands(program) {
+  const tools = program.command("tools").description(
+    "Search by intent or structured filters, describe, and execute atomic provider tools."
+  ).addHelpText(
+    "after",
+    `
+Concepts:
+  Tools are atomic provider/API operations. Plays are workflows and must be run
+  through the plays namespace.
+
+Common commands:
+  deepline search --type tools email --json
+  deepline tools describe hunter_email_verifier --json
+  deepline tools describe hunter_email_verifier --pricing-only --json
+  deepline tools execute hunter_email_verifier --input '{"email":"a@b.com"}'
+  deepline billing usage --request-id <job_id> --json
+
+Output:
+  Use describe for tool contracts.
+  Use execute to run a tool.
+  Read pricing before execution; use the returned next.billing command for its
+  exact charge. Workspace balance changes also include other callers' activity.
+`
+  );
+  tools.command("list [category]").description("Browse tool categories, or list every tool in a category.").addHelpText(
+    "after",
+    `
+Notes:
+  Bare \`tools list\` prints the category enumeration: one line per category with
+  its tool count and definition. Pass a category to list every tool in it, one
+  succinct row each (required inputs, Deepline pricing hint, first sentence).
+  The listing is exhaustive and never truncated. Use search for ranked discovery
+  by intent, aliases, descriptions, and schema fields.
+
+  --categories is a back-compat inventory filter. Passing it alone returns the
+  legacy flat inventory envelope (one row per tool). The positional category is
+  the newer exhaustive per-category view. If both are given they must name the
+  same category (the positional view wins); otherwise it is a usage error.
+
+Examples:
+  deepline tools list
+  deepline tools list email_finder
+  deepline tools list email_finder --json
+  deepline tools list --categories email_finder --json
+  deepline search --type tools email --json
+`
+  ).option(
+    "--categories <categories>",
+    "Comma-separated categories filter (back-compat alias for the positional)"
+  ).option("--compact", "Drop verbose fields from JSON output").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (category, options) => {
+    process.exitCode = await listTools(category, {
+      categories: typeof options.categories === "string" ? options.categories : void 0,
+      compact: options.compact !== false,
+      json: Boolean(options.json)
+    });
+  });
+  _chunkWQICC2B3js.registerDeprecatedSearchCommand.call(void 0, tools, () => ["tools", "monitors"]);
+  tools.command("grep <query>").description(
+    "Literal grep over tool ids, descriptions, categories, and input fields."
+  ).addHelpText(
+    "after",
+    `
+Notes:
+  Literal registry filtering. Terms are matched case-insensitively against tool
+  ids, provider, display name, description, categories, aliases, and input
+  fields. Use --mode phrase for exact phrase matching, --mode any for OR, and
+  the default --mode all for AND.
+
+Examples:
+  deepline tools grep email --categories email_finder --json
+  deepline tools grep "phone validate" --mode all --json
+  deepline tools grep hunter --mode phrase --json
+`
+  ).option(
+    "--categories <categories>",
+    "Comma-separated categories to filter inventory"
+  ).option("--mode <mode>", "Grep matching mode: all, any, or phrase").option("--compact", "Drop verbose fields from JSON output").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (query, options) => {
+    const mode = options.mode === "any" || options.mode === "phrase" ? options.mode : "all";
+    process.exitCode = await grepTools(query, {
+      json: options.json,
+      compact: options.compact,
+      categories: options.categories,
+      mode
+    });
+  });
+  const addToolMetadataCommand = (command) => command.description("Show metadata for a tool.").addHelpText(
+    "after",
+    `
+Notes:
+  Shows the compact agent contract by default: what the tool does, cost,
+  required inputs, play getters, input and full Deepline response examples,
+  and a ctx.tools.execute snippet. Tool responses live at toolResponse.rawV2;
+  preserve the nesting shown in the tool's example. Schemas and examples are
+  separate describe fields.
+  get is accepted as a compatibility alias for describe.
+
+Examples:
+  deepline tools describe hunter_email_verifier
+  deepline tools describe hunter_email_verifier --pricing-only
+  deepline tools describe hunter_email_verifier --pricing-only --json
+  deepline tools describe hunter_email_verifier --schema-only
+  deepline tools describe hunter_email_verifier --examples-only
+  deepline tools describe hunter_email_verifier --json
+  deepline tools describe deeplineagent --model openai/gpt-5.6-luna --json
+  deepline tools describe ai_inference --estimate-payload @payload.json --json
+  deepline tools describe ai_evaluate --estimate-payload @payload.json --json
+  deepline tools execute hunter_email_verifier --input '{"email":"a@b.com"}'
+`
+  ).option("--json", "Emit JSON output. Also automatic when stdout is piped").option(
+    "--model <model>",
+    "For language tools, include AI Gateway metadata; for ai_evaluate, set the quote payload model"
+  ).option(
+    "--estimate-payload <payload>",
+    "Quote an ai_evaluate, ai_inference, or deeplineagent JSON payload (inline or @file)"
+  ).option("--pricing-only", "Only print pricing and billing semantics").option("--schema-only", "Only print input schema fields").option(
+    "--examples-only",
+    "Only print input payload and full Deepline execution response examples"
+  ).option("--getters-only", "Only print extracted list/value getters").addOption(
+    new (0, _commander.Option)(
+      "--compact",
+      "Compatibility alias for the default compact view"
+    ).hideHelp()
+  ).addOption(
+    new (0, _commander.Option)(
+      "--contract-json",
+      "Compatibility alias for compact contract JSON"
+    ).hideHelp()
+  ).action(async (toolId, options) => {
+    process.exitCode = await getTool(toolId, {
+      json: Boolean(options.json),
+      compact: Boolean(options.compact),
+      contractJson: Boolean(options.contractJson),
+      pricingOnly: Boolean(options.pricingOnly),
+      schemaOnly: Boolean(options.schemaOnly),
+      examplesOnly: Boolean(options.examplesOnly),
+      gettersOnly: Boolean(options.gettersOnly),
+      model: typeof options.model === "string" ? options.model : void 0,
+      estimatePayload: typeof options.estimatePayload === "string" ? options.estimatePayload : void 0
+    });
+  });
+  addToolMetadataCommand(tools.command("describe <toolId>").alias("get"));
+  tools.command("execute <toolId>").description("Execute a tool by id.").addHelpText(
+    "after",
+    `
+Notes:
+  Use tools for one atomic provider/API operation. Use plays for composed workflows,
+  waterfalls, row maps, checkpoints, and retries.
+  Calling a provider-backed tool can spend Deepline credits. Use --json for the
+  stable result payload plus output preview and debugging helpers.
+  Read pricing first with tools describe <toolId> --pricing-only --json.
+  Use the returned next.billing command to look up this execution's exact charge;
+  workspace balance changes also include other callers' activity.
+  --timeout sets this CLI request's HTTP deadline; it does not cancel provider work.
+
+Examples:
+  deepline tools execute hunter_email_verifier --input '{"email":"a@b.com"}'
+  deepline tools describe hunter_email_verifier --pricing-only --json
+  deepline billing usage --request-id <job_id> --json
+  deepline tools execute bounceban_verify_bulk --input @batch.json --timeout 10m --json
+  deepline tools execute hunter_email_verifier -p email=a@b.com
+  deepline tools execute test_rate_limit --input '{"key":"smoke"}' --timeout 90s --json
+  deepline tools execute test_rate_limit --input '{"key":"smoke"}' --json | jq '.status'
+  deepline tools execute free_simple_company_search --input '{"sql":"SELECT company_name FROM companies LIMIT 10"}' --out companies.csv
+`
+  ).option(
+    "-p, --param <key=value>",
+    "Pass one parameter. Repeat for multiple values.",
+    (value, acc) => {
+      acc.push(value);
+      return acc;
+    },
+    []
+  ).option(
+    "--json [payload]",
+    "Emit JSON output. Use `--input` or `--payload` for passing JSON params."
+  ).option(
+    "--input <payload>",
+    "Merge a JSON object or @file path into the tool params"
+  ).option(
+    "--payload <payload>",
+    "Merge a JSON object or @file path into the tool params"
+  ).option(
+    "--timeout <duration>",
+    "Client-side HTTP deadline (for example 90s, 5m, or 1h; bare numbers are seconds); it does not cancel provider work"
+  ).option(
+    "--output-format <format>",
+    "Output format: auto, csv, csv_file, json, or json_file"
+  ).option("-o, --out <path>", "Write row-shaped tool output to this CSV path").option(
+    "--no-preview",
+    "Only print the extracted output path when applicable"
+  ).option(
+    "--idempotency-key <key>",
+    "Stable key for retrying or recovering this tool execution"
+  ).option(
+    "--recover",
+    "Generate or reuse a saved idempotency key for safe recovery"
+  ).option(
+    "--recovery-timeout-ms <milliseconds>",
+    "Maximum wait for a keyed execution to finish (default: 900000)"
+  ).action(async (toolId, options) => {
+    const args = [
+      toolId,
+      ...options.param.flatMap((value) => ["--param", value]),
+      ...options.json === true ? ["--json"] : [],
+      ...typeof options.json === "string" ? ["--json", options.json] : [],
+      ...options.input ? ["--input", options.input] : [],
+      ...options.payload ? ["--payload", options.payload] : [],
+      ...options.timeout ? ["--timeout", options.timeout] : [],
+      ...options.outputFormat ? ["--output-format", options.outputFormat] : [],
+      ...options.out ? ["--out", options.out] : [],
+      ...options.preview === false ? ["--no-preview"] : [],
+      ...options.idempotencyKey ? ["--idempotency-key", options.idempotencyKey] : [],
+      ...options.recover ? ["--recover"] : [],
+      ...options.recoveryTimeoutMs ? ["--recovery-timeout-ms", options.recoveryTimeoutMs] : []
+    ];
+    process.exitCode = await executeTool(args);
+  });
+}
+async function getTool(toolId, options = {}) {
+  if (!toolId) {
+    console.error("Usage: deepline tools describe <toolId> [--json]");
+    return 1;
+  }
+  const client = new (0, _chunk2S5Y3TZPjs.DeeplineClient)();
+  let tool;
+  try {
+    tool = await client.getTool(toolId);
+  } catch (error) {
+    if (isMissingToolMetadataError(error)) {
+      const play = await findPlayForToolId(client, toolId);
+      if (play) {
+        printPlayAliasToolError(toolId, play);
+        return 2;
+      }
+    }
+    throw error;
+  }
+  let inferenceQuote = null;
+  if (options.estimatePayload) {
+    if (toolId !== "deeplineagent" && toolId !== "ai_inference" && toolId !== "ai_evaluate") {
+      console.error(
+        "--estimate-payload is only supported for ai_evaluate, deeplineagent, and ai_inference."
+      );
+      return 2;
+    }
+    const estimatePayload = parseJsonObjectArgument(
+      options.estimatePayload,
+      "--estimate-payload"
+    );
+    if (options.model && estimatePayload.model === void 0) {
+      estimatePayload.model = options.model;
+    }
+    inferenceQuote = await client.quoteInferenceTool(toolId, estimatePayload);
+  }
+  const modelDescription = options.model && (toolId === "deeplineagent" || toolId === "ai_inference") ? await client.describeModel(options.model) : null;
+  if (options.model && !modelDescription && toolId !== "ai_evaluate") {
+    console.error(
+      "--model is only supported for deeplineagent and ai_inference."
+    );
+    return 2;
+  }
+  const onlyModes = [
+    options.pricingOnly,
+    options.schemaOnly,
+    options.examplesOnly,
+    options.gettersOnly
+  ].filter(Boolean).length;
+  if (onlyModes > 1) {
+    console.error(
+      "Use only one of --pricing-only, --schema-only, --examples-only, or --getters-only."
+    );
+    return 2;
+  }
+  if (options.pricingOnly) {
+    const lines = toolPricingOnlyLines(tool, toolId);
+    if (inferenceQuote)
+      lines.push(...inferenceQuoteSummaryLines(inferenceQuote));
+    _chunkF35VOIQLjs.printCommandEnvelope.call(void 0, 
+      {
+        toolId: String(tool.toolId || toolId),
+        cost: Capability.fromCatalogEntry(tool).describe().customerCost(),
+        ...modelDescription ? { modelOptions: modelDescription } : {},
+        ...isMonitorTypeTool(tool) ? { pricing: recordField(tool, "pricing") } : {},
+        ...inferenceQuote ? { inferenceQuote } : {}
+      },
+      {
+        json: Boolean(options.json || options.contractJson),
+        text: `${lines.join("\n")}
+`
+      }
+    );
+    return 0;
+  }
+  if ((options.schemaOnly || options.examplesOnly || options.gettersOnly) && !isMonitorTypeTool(tool) && !isPlayLikeTool(tool) && (options.json || options.contractJson)) {
+    const contract = toolContractJsonForDescribe(tool, toolId);
+    _chunkF35VOIQLjs.printCompactJson.call(void 0, {
+      toolId: contract.toolId,
+      ...options.schemaOnly ? {
+        inputSchema: contract.inputSchema,
+        inputFields: contract.inputFields,
+        outputSchema: contract.outputSchema,
+        outputFields: contract.outputFields,
+        responseSchema: contract.responseSchema
+      } : options.examplesOnly ? {
+        examples: _nullishCoalesce(contract.examples, () => ( [])),
+        responseAccess: contract.responseAccess,
+        getters: contract.getters,
+        executeCommand: contract.executeCommand
+      } : {
+        getters: contract.getters,
+        responseAccess: contract.responseAccess
+      },
+      ...modelDescription ? { modelOptions: modelDescription } : {},
+      ...inferenceQuote ? { inferenceQuote } : {}
+    });
+    return 0;
+  }
+  if (options.contractJson) {
+    _chunkF35VOIQLjs.printCompactJson.call(void 0, {
+      ...toolContractJsonForDescribe(tool, toolId),
+      ...modelDescription ? { modelOptions: modelDescription } : {},
+      ...inferenceQuote ? { inferenceQuote } : {}
+    });
+    return 0;
+  }
+  const emitJson = options.json === true;
+  if (emitJson) {
+    _chunkF35VOIQLjs.printCompactJson.call(void 0, {
+      ...toolMetadataJsonForDescribe(tool, toolId),
+      ...modelDescription ? { modelOptions: modelDescription } : {},
+      ...inferenceQuote ? { inferenceQuote } : {}
+    });
+    return 0;
+  }
+  if (options.schemaOnly) {
+    printToolSchemaOnly(tool, toolId);
+    if (inferenceQuote) printInferenceQuoteSummary(inferenceQuote);
+    return 0;
+  }
+  if (options.examplesOnly) {
+    printToolExamplesOnly(tool, toolId);
+    if (inferenceQuote) printInferenceQuoteSummary(inferenceQuote);
+    return 0;
+  }
+  if (options.gettersOnly) {
+    printToolGettersOnly(tool, toolId);
+    if (inferenceQuote) printInferenceQuoteSummary(inferenceQuote);
+    return 0;
+  }
+  if (options.compact) {
+    printCompactToolContract(tool, toolId);
+    if (modelDescription) {
+      process.stdout.write(`
+${formatModelDescription(modelDescription)}`);
+    }
+    if (inferenceQuote) printInferenceQuoteSummary(inferenceQuote);
+    return 0;
+  }
+  if (_chunkF35VOIQLjs.shouldEmitJson.call(void 0, )) {
+    _chunkF35VOIQLjs.printCompactJson.call(void 0, {
+      ...toolContractJsonForDescribe(tool, toolId),
+      ...modelDescription ? { modelOptions: modelDescription } : {},
+      ...inferenceQuote ? { inferenceQuote } : {}
+    });
+    return 0;
+  }
+  printCompactToolContract(tool, toolId);
+  if (modelDescription) {
+    process.stdout.write(`
+${formatModelDescription(modelDescription)}`);
+  }
+  if (inferenceQuote) printInferenceQuoteSummary(inferenceQuote);
+  return 0;
+}
+function inferenceQuoteSummaryLines(_quote) {
+  return [
+    "",
+    "Inference quote:",
+    "- Temporary hold: priced estimate (minimum 0.02 credits)",
+    "- Final charge: actual usage"
+  ];
+}
+function printInferenceQuoteSummary(quote) {
+  for (const line of inferenceQuoteSummaryLines(quote)) console.log(line);
+}
+function toolContractJsonForDescribe(tool, requestedToolId) {
+  const toolId = String(tool.toolId || requestedToolId);
+  const inputFields = toolInputFieldsForDisplay(
+    recordField(tool, "inputSchema", "input_schema")
+  );
+  const inputSchema = publicToolInputSchemaForDescribe(
+    recordField(tool, "inputSchema", "input_schema")
+  );
+  const outputSchemaRecord = recordField(tool, "outputSchema", "output_schema");
+  const outputFields = toolOutputFieldsForDisplay(outputSchemaRecord);
+  const usageGuidance = recordField(tool, "usageGuidance", "usage_guidance");
+  const guidance = recordField(tool, "guidance");
+  const toolExecutionResult = recordField(
+    usageGuidance,
+    "toolExecutionResult",
+    "tool_execution_result"
+  );
+  const extractedLists = extractionContractEntries(
+    arrayField2(toolExecutionResult, "extractedLists", "extracted_lists")
+  );
+  const extractedValues = extractionContractEntries(
+    arrayField2(toolExecutionResult, "extractedValues", "extracted_values")
+  );
+  const pricing = Capability.fromCatalogEntry(tool).describe().customerCost();
+  const executionMetadataRecord = recordField(
+    tool,
+    "executionMetadata",
+    "execution_metadata"
+  );
+  const executionMetadata = Object.keys(executionMetadataRecord).length > 0 ? executionMetadataRecord : null;
+  const batchCapabilityRecord = recordField(
+    tool,
+    "batchCapability",
+    "batch_capability"
+  );
+  const batchCapability = Object.keys(batchCapabilityRecord).length > 0 ? batchCapabilityRecord : null;
+  const deprecation = recordField(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 = deprecated && replacementToolId ? `deepline tools execute ${replacementToolId} --input '{...}' --json` : isPlayLikeTool(tool) ? playRunCommandForTool(tool, toolId) : `deepline tools execute ${toolId} --input '{...}' --json`;
+  return {
+    schemaVersion: 1,
+    toolId,
+    provider: tool.provider,
+    displayName: tool.displayName,
+    cost: pricing,
+    description: tool.description,
+    ...Object.keys(guidance).length > 0 ? { guidance } : {},
+    categories: tool.categories,
+    ...deprecated ? {
+      deprecated: true,
+      callable: tool.callable !== false,
+      deprecation: {
+        replacementToolId,
+        message: deprecationMessage,
+        ...deprecationExecution ? { execution: deprecationExecution } : {}
+      }
+    } : {},
+    inputFields: inputFields.map(inputFieldJsonForDescribe),
+    inputSchema,
+    ...isRecord(tool.responseSchema) ? { responseSchema: tool.responseSchema } : {},
+    ...Array.isArray(tool.examples) ? { examples: tool.examples } : {},
+    responseAccess: "result.toolResponse.rawV2",
+    ...Object.keys(outputSchemaRecord).length > 0 ? {
+      outputSchema: publicToolInputSchemaForDescribe(outputSchemaRecord),
+      outputFields: outputFields.map(inputFieldJsonForDescribe)
+    } : {},
+    ...executionMetadata ? { executionMetadata } : {},
+    ...batchCapability ? { batchCapability } : {},
+    getters: {
+      extractedLists,
+      extractedValues
+    },
+    executeCommand,
+    ...starterScript ? { starterScript } : {}
+  };
+}
+function extractionContractEntries(entries) {
+  return entries.flatMap((entry) => {
+    if (!isRecord(entry)) return [];
+    const name = stringField2(entry, "name");
+    const expression = stringField2(entry, "expression");
+    return name && expression ? [{ name, expression }] : [];
+  });
+}
+function printMonitorTypeFilters(tool) {
+  const schema = recordField(tool, "payload_schema", "payloadSchema");
+  const properties = recordField(schema, "properties");
+  const required = new Set(
+    arrayField2(schema, "required").filter(
+      (v) => typeof v === "string"
+    )
+  );
+  const names = Object.keys(properties);
+  if (!names.length) {
+    console.log("Deploy filters: none");
+    return;
+  }
+  console.log("Deploy filters (set in the monitor payload):");
+  for (const name of names) {
+    const field = isRecord(properties[name]) ? properties[name] : {};
+    const star = required.has(name) ? "*" : "";
+    const enumVals = arrayField2(field, "enum").filter(
+      (v) => typeof v === "string"
+    );
+    const type = enumVals.length ? `one of [${enumVals.join(", ")}]` : stringField2(field, "type") || "string";
+    const desc = stringField2(field, "description");
+    console.log(`- ${name}${star}: ${type}${desc ? ` - ${desc}` : ""}`);
+  }
+}
+function printMonitorTypeFilterExamples(tool) {
+  const documentation = recordField(tool, "documentation");
+  const fields = recordField(documentation, "fields");
+  const examples = Object.entries(fields).flatMap(([name, rawField]) => {
+    const grammar = recordField(isRecord(rawField) ? rawField : {}, "grammar");
+    const example = stringField2(grammar, "example");
+    const values = [
+      ...arrayField2(grammar, "examples").filter(
+        (value) => typeof value === "string" && Boolean(value)
+      ),
+      ...example ? [example] : []
+    ];
+    return [...new Set(values)].map((example2) => ({ name, example: example2 }));
+  });
+  if (examples.length === 0) return;
+  console.log("");
+  console.log("Filter examples:");
+  for (const { name, example } of examples) {
+    console.log(`- ${name}: ${example}`);
+  }
+}
+function printMonitorTypeStreams(tool) {
+  const streams = arrayField2(tool, "streams", "output_streams").filter(
+    isRecord
+  );
+  if (!streams.length) return;
+  console.log("");
+  console.log("Filter columns (a play's sqlListeners.where, per stream):");
+  for (const stream of streams) {
+    const name = stringField2(stream, "stream");
+    const cols = arrayField2(stream, "columns").filter(isRecord).map((col) => stringField2(col, "name")).filter(Boolean);
+    console.log(`- ${name}: ${cols.join(", ")}`);
+  }
+}
+function monitorTypePricingLines(tool) {
+  const pricing = recordField(tool, "pricing");
+  const byType = recordField(
+    pricing,
+    "pricing_by_radar_type",
+    "pricingByRadarType"
+  );
+  const keys = Object.keys(byType);
+  if (!keys.length) {
+    return ["Pricing: Deepline credits per accepted event (see --json)"];
+  }
+  const lines = ["Pricing (Deepline credits per accepted event):"];
+  for (const key of keys) {
+    const entry = isRecord(byType[key]) ? byType[key] : {};
+    const credits = numberField2(entry, "deepline_credits", "deeplineCredits");
+    const display = stringField2(entry, "display");
+    const shown = display || (credits !== null ? `${formatDecimal(credits)} credits/event` : "see --json");
+    lines.push(`- ${key}: ${shown}`);
+  }
+  return lines;
+}
+function printMonitorTypePricing(tool) {
+  for (const line of monitorTypePricingLines(tool)) console.log(line);
+}
+function printMonitorTypeDeploy(tool) {
+  const deploy = recordField(tool, "deploy");
+  const toolId = stringField2(tool, "toolId");
+  const example = stringField2(deploy, "example") || `deepline monitors deploy '{"key":"...","tool":"${toolId}","payload":{...}}'`;
+  console.log("Deploy (a monitor type is deployed, not executed):");
+  console.log(`  ${example}`);
+}
+function printMonitorTypeContract(tool, requestedToolId) {
+  const toolId = stringField2(tool, "toolId") || requestedToolId;
+  console.log(toolId);
+  const displayName = stringField2(tool, "displayName");
+  if (displayName) console.log(`Best for: ${displayName}`);
+  const description = stringField2(tool, "description");
+  if (description) console.log(`Description: ${description}`);
+  const categories = arrayField2(tool, "categories").filter(
+    (v) => typeof v === "string"
+  );
+  if (categories.length) console.log(`Tags: ${categories.join(", ")}`);
+  console.log("");
+  console.log(
+    "Monitor type \u2014 streams a provider's events into your warehouse. Deploy it, don't execute it."
+  );
+  console.log("");
+  printMonitorTypeFilters(tool);
+  printMonitorTypeFilterExamples(tool);
+  printMonitorTypeStreams(tool);
+  console.log("");
+  printMonitorTypePricing(tool);
+  console.log("");
+  printMonitorTypeDeploy(tool);
+  console.log("");
+  console.log(`More: deepline tools get ${toolId} --json`);
+}
+function toolGuidanceLines(guidance) {
+  const record = isRecord(guidance) ? guidance : {};
+  const toolGuidance = stringField2(record, "tool");
+  const providerGuidance = stringField2(record, "provider");
+  return [
+    ...toolGuidance ? [`- This tool: ${toolGuidance}`] : [],
+    ...providerGuidance ? [`- Provider: ${providerGuidance}`] : []
+  ];
+}
+function printCompactToolContract(tool, requestedToolId) {
+  if (isMonitorTypeTool(tool)) {
+    printMonitorTypeContract(tool, requestedToolId);
+    return;
+  }
+  const contract = toolContractJsonForDescribe(tool, requestedToolId);
+  const cost = isRecord(contract.cost) ? contract.cost : {};
+  const getters = isRecord(contract.getters) ? contract.getters : {};
+  const listGetters = Array.isArray(getters.extractedLists) ? getters.extractedLists : [];
+  const valueGetters = Array.isArray(getters.extractedValues) ? getters.extractedValues : [];
+  const inputFields = recursiveToolInputFieldsForDisplay(
+    recordField(contract, "inputSchema")
+  );
+  console.log(String(contract.toolId));
+  if (contract.displayName) console.log(`Best for: ${contract.displayName}`);
+  if (typeof contract.description === "string" && contract.description.trim()) {
+    console.log(`Description: ${contract.description.trim()}`);
+  }
+  if (Array.isArray(contract.categories) && contract.categories.length) {
+    console.log(`Tags: ${contract.categories.join(", ")}`);
+  }
+  const guidanceLines = toolGuidanceLines(contract.guidance);
+  if (guidanceLines.length > 0) {
+    console.log(["Guidance:", ...guidanceLines].join("\n"));
+  }
+  printToolOutputArrayShape(contract);
+  printToolExecutionHints(contract);
+  if (contract.deprecated === true) {
+    const deprecation = isRecord(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("");
+    console.log("Inputs:");
+    for (const field of inputFields) {
+      if (!isRecord(field)) continue;
+      const name = stringField2(field, "name");
+      if (!name) continue;
+      const required = field.required ? "*" : "";
+      const type = stringField2(field, "type") || "unknown";
+      const description = stringField2(field, "description");
+      const enumValues = Array.isArray(field.enum) ? field.enum : [];
+      const enumSuffix = enumValues.length ? ` enum=${enumValues.map(String).join("|")}` : "";
+      const itemBoundsSuffix = arrayItemBoundsSuffix(field);
+      const defaultSuffix = Object.prototype.hasOwnProperty.call(
+        field,
+        "default"
+      ) ? ` default=${JSON.stringify(field.default)}` : "";
+      console.log(
+        `- ${name}${required}: ${type}${enumSuffix}${itemBoundsSuffix}${defaultSuffix}${description ? ` - ${description}` : ""}`
+      );
+    }
+  }
+  console.log("");
+  printToolExamplesOnly(tool, requestedToolId);
+  const starterScript = isRecord(contract.starterScript) ? contract.starterScript : {};
+  const starterPath = stringField2(starterScript, "path");
+  if (starterPath) {
+    console.log("");
+    console.log(`Starter script: ${starterPath}`);
+    console.log("Copy it into your project and adapt the example input.");
+  }
+  if (listGetters.length || valueGetters.length) {
+    console.log("");
+    console.log("Getters:");
+    if (listGetters.length) console.log("Lists:");
+    for (const entry of listGetters) {
+      if (isRecord(entry))
+        console.log(
+          `- ${stringField2(entry, "name")}: ${playResultExpression(entry)}`
+        );
+    }
+    if (valueGetters.length) console.log("Values:");
+    for (const entry of valueGetters) {
+      if (isRecord(entry))
+        console.log(
+          `- ${stringField2(entry, "name")}: ${playResultExpression(entry)}`
+        );
+    }
+  }
+  console.log("");
+  console.log(
+    "Provider-specific fields: inspect result.toolResponse.rawV2 and its observed envelope. Prefer the declared getters above."
+  );
+  console.log(
+    `More: deepline tools describe ${contract.toolId} --pricing-only | --schema-only | --examples-only | --getters-only | --json`
+  );
+}
+function toolPricingOnlyLines(tool, requestedToolId, options = {}) {
+  if (isMonitorTypeTool(tool)) {
+    return monitorTypePricingLines(tool);
+  }
+  const toolId = String(tool.toolId || requestedToolId);
+  const cost = Capability.fromCatalogEntry(tool).describe().customerCost();
+  const pricingModel = stringField2(cost, "pricingModel") || "unknown";
+  const billing = stringField2(cost, "billingSourceLabel") || stringField2(cost, "billingSource") || stringField2(cost, "billingMode") || "unknown";
+  const explicitUnit = stringField2(cost, "unit");
+  const unit = explicitUnit || (pricingModel === "per_page" ? "page" : pricingModel === "per_result" ? "result" : pricingModel === "fixed" ? "call" : pricingModel.replace(/^per_/, "") || "unit");
+  const credits = numberField2(cost, "deeplineCreditsPerPricingUnit");
+  const usd = numberField2(cost, "deeplineUsdPerPricingUnit");
+  const displayText = stringField2(cost, "displayText");
+  const summary = stringField2(cost, "summary");
+  const price = displayText || summary || (credits !== null ? `${formatDecimal(credits)} Deepline credits${usd !== null ? ` / ${formatUsd(usd)}` : ""} per ${unit}` : "pricing unavailable");
+  return [
+    `${_nullishCoalesce(options.heading, () => ( `Pricing: ${toolId}`))}: ${price}`,
+    `Billing: ${billing}`
+  ];
+}
+function printToolPricingOnly(tool, requestedToolId, options = {}) {
+  for (const line of toolPricingOnlyLines(tool, requestedToolId, options))
+    console.log(line);
+}
+function printToolSchemaOnly(tool, requestedToolId) {
+  if (isMonitorTypeTool(tool)) {
+    printMonitorTypeFilters(tool);
+    printMonitorTypeStreams(tool);
+    return;
+  }
+  const contract = toolContractJsonForDescribe(tool, requestedToolId);
+  const inputFields = recursiveToolInputFieldsForDisplay(
+    recordField(contract, "inputSchema")
+  );
+  console.log(`Schema: ${contract.toolId}`);
+  if (!inputFields.length) {
+    console.log("Inputs: none");
+  } else {
+    console.log("Inputs:");
+    for (const field of inputFields) {
+      const name = typeof field.name === "string" ? field.name : "";
+      if (!name) continue;
+      const required = field.required ? "*" : "";
+      const type = typeof field.type === "string" ? field.type : "unknown";
+      const description = typeof field.description === "string" ? field.description : "";
+      const enumValues = Array.isArray(field.enum) ? field.enum : [];
+      const enumSuffix = enumValues.length ? ` enum=${enumValues.map(String).join("|")}` : "";
+      const itemBoundsSuffix = arrayItemBoundsSuffix(field);
+      const defaultSuffix = Object.prototype.hasOwnProperty.call(
+        field,
+        "default"
+      ) ? ` default=${JSON.stringify(field.default)}` : "";
+      console.log(
+        `- ${name}${required}: ${type}${enumSuffix}${itemBoundsSuffix}${defaultSuffix}${description ? ` - ${description}` : ""}`
+      );
+    }
+  }
+  printToolOutputArrayShape(contract);
+  const declaredSchema = declaredToolJsonSchema(
+    recordField(contract, "inputSchema")
+  );
+  if (declaredSchema) {
+    console.log("Declared input JSON Schema:");
+    console.log(JSON.stringify(declaredSchema, null, 2));
+  }
+  if (isRecord(contract.responseSchema)) {
+    console.log("Deepline execution response JSON Schema:");
+    console.log(JSON.stringify(contract.responseSchema, null, 2));
+  }
+}
+function printToolExamplesOnly(tool, requestedToolId) {
+  if (isMonitorTypeTool(tool)) {
+    printMonitorTypeDeploy(tool);
+    return;
+  }
+  if (isPlayLikeTool(tool)) {
+    printPlayLikeToolUsage(tool, requestedToolId);
+    return;
+  }
+  const contract = toolContractJsonForDescribe(tool, requestedToolId);
+  const toolId = String(contract.toolId);
+  const inputFields = Array.isArray(contract.inputFields) ? contract.inputFields : [];
+  const examples = arrayField2(tool, "examples").filter(isRecord);
+  const firstExample = examples[0];
+  const sampleInput = firstExample && isRecord(firstExample.input) ? firstExample.input : _nullishCoalesce(samplePayload(recordField(tool, "samples"), "request"), () => ( samplePayloadForInputFields(inputFields)));
+  console.log("Example input payload:");
+  console.log(JSON.stringify(sampleInput, null, 2));
+  console.log(`Use in a play:`);
+  console.log("```ts");
+  console.log("const result = await ctx.tools.execute({");
+  console.log(`  id: '${stableStepIdForTool(toolId)}',`);
+  console.log(`  tool: '${toolId}',`);
+  console.log(
+    `  input: ${JSON.stringify(sampleInput || {}, null, 2).replace(/\n/g, "\n  ")},`
+  );
+  console.log("});");
+  console.log("const response = result.toolResponse.rawV2;");
+  const getters = isRecord(contract.getters) ? contract.getters : {};
+  const valueGetters = Array.isArray(getters.extractedValues) ? getters.extractedValues : [];
+  const listGetters = Array.isArray(getters.extractedLists) ? getters.extractedLists : [];
+  const firstGetter = [...valueGetters, ...listGetters].find(isRecord);
+  if (firstGetter) {
+    const name = stringField2(firstGetter, "name") || "value";
+    const expression = stringField2(firstGetter, "expression");
+    if (expression)
+      console.log(
+        `const ${safeIdentifier(name)} = ${expression.replace(/^toolExecutionResult\./, "result.")};`
+      );
+  }
+  console.log("```");
+  for (const example of examples) {
+    const description = stringField2(example, "description");
+    if (description) console.log(description);
+    console.log("Example Deepline execution response:");
+    console.log(JSON.stringify(example.response, null, 2));
+  }
+  if (!examples.length)
+    console.log(
+      "No Deepline execution response example is published by this server."
+    );
+  console.log(
+    "Read tool-specific fields from result.toolResponse.rawV2 using the nesting above. In a play, use the declared getters for extracted values and lists. Billing and execution metadata may also be returned."
+  );
+}
+function printPlayLikeToolUsage(tool, requestedToolId) {
+  const toolId = String(tool.toolId || requestedToolId);
+  const inputFields = toolInputFieldsForDisplay(
+    recordField(tool, "inputSchema", "input_schema")
+  );
+  const sampleInput = samplePayloadForInputFields(inputFields);
+  const playReference = playReferenceForTool(tool);
+  console.log("Run as a play:");
+  console.log(
+    playRunCommandForTool(
+      tool,
+      toolId,
+      Object.keys(sampleInput).length ? sampleInput : void 0
+    )
+  );
+  if (playReference) {
+    console.log(`deepline plays describe ${playReference} --json`);
+  }
+}
+function printToolGettersOnly(tool, requestedToolId) {
+  const contract = toolContractJsonForDescribe(tool, requestedToolId);
+  const getters = isRecord(contract.getters) ? contract.getters : {};
+  const listGetters = Array.isArray(getters.extractedLists) ? getters.extractedLists : [];
+  const valueGetters = Array.isArray(getters.extractedValues) ? getters.extractedValues : [];
+  console.log(`Getters: ${contract.toolId}`);
+  if (!listGetters.length && !valueGetters.length) {
+    console.log(
+      "No generated getters declared. Use --json only if you need raw metadata."
+    );
+    return;
+  }
+  if (listGetters.length) {
+    console.log("Lists:");
+    for (const entry of listGetters) {
+      if (isRecord(entry))
+        console.log(
+          `- ${stringField2(entry, "name")}: ${playResultExpression(entry)}`
+        );
+    }
+  }
+  if (valueGetters.length) {
+    console.log("Values:");
+    for (const entry of valueGetters) {
+      if (isRecord(entry))
+        console.log(
+          `- ${stringField2(entry, "name")}: ${playResultExpression(entry)}`
+        );
+    }
+  }
+}
+function sampleValueForField(field) {
+  const name = stringField2(field, "name").toLowerCase();
+  const type = stringField2(field, "type").toLowerCase();
+  if (Object.prototype.hasOwnProperty.call(field, "default"))
+    return field.default;
+  if (name.includes("email")) return "ada@example.com";
+  if (name.includes("domain") || name.includes("website")) return "example.com";
+  if (name.includes("first")) return "Ada";
+  if (name.includes("last")) return "Lovelace";
+  if (name.includes("name")) return "Ada Lovelace";
+  if (type === "integer" || type === "number") return 1;
+  if (type === "boolean") return true;
+  if (type === "array") return [];
+  if (type === "object") return {};
+  return "...";
+}
+function samplePayloadForInputFields(fields) {
+  return Object.fromEntries(
+    fields.slice(0, 4).flatMap((field) => {
+      if (!isRecord(field)) return [];
+      const name = stringField2(field, "name");
+      if (!name) return [];
+      return [[name, sampleValueForField(field)]];
+    })
+  );
+}
+function stableStepIdForTool(toolId) {
+  return toolId.replace(/^[a-z0-9]+_/, "").replace(/[^a-z0-9_]+/gi, "_") || "tool_call";
+}
+function safeIdentifier(name) {
+  const cleaned = name.replace(/[^a-zA-Z0-9_$]+/g, "_").replace(/^[^a-zA-Z_$]+/, "");
+  return cleaned || "value";
+}
+function playResultExpression(entry) {
+  return stringField2(entry, "expression").replace(
+    /^toolExecutionResult\./,
+    "result."
+  );
+}
+function toolMetadataJsonForDescribe(tool, requestedToolId) {
+  const toolId = String(tool.toolId || requestedToolId);
+  const inputFields = toolInputFieldsForDisplay(
+    recordField(tool, "inputSchema", "input_schema")
+  );
+  const usageGuidance = usageGuidanceWithAccessDefaults(
+    recordField(tool, "usageGuidance", "usage_guidance")
+  );
+  const toolExecutionResult = recordField(
+    usageGuidance,
+    "toolExecutionResult",
+    "tool_execution_result"
+  );
+  const extractedLists = extractionContractEntries(
+    arrayField2(toolExecutionResult, "extractedLists", "extracted_lists")
+  );
+  const starterScript = !isPlayLikeTool(tool) && extractedLists.length > 0 ? starterScriptJson(
+    seedToolListScript({
+      toolId,
+      payload: samplePayloadForInputFields(inputFields),
+      rows: []
+    })
+  ) : null;
+  const observedOutputCommand = isPlayLikeTool(tool) ? playRunCommandForTool(tool, toolId) : `deepline tools execute ${toolId} --input '{...}' --json`;
+  const {
+    cost: _cost,
+    deeplineCreditsPerPricingUnit: _deeplineCreditsPerPricingUnit,
+    deeplineUsdPerPricingUnit: _deeplineUsdPerPricingUnit,
+    deeplineUsdPerCredit: _deeplineUsdPerCredit,
+    deeplinePricingSummary: _deeplinePricingSummary,
+    deeplinePricingDetails: _deeplinePricingDetails,
+    deepline_credits_per_pricing_unit: _snakeDeeplineCreditsPerPricingUnit,
+    deepline_usd_per_pricing_unit: _snakeDeeplineUsdPerPricingUnit,
+    deepline_usd_per_credit: _snakeDeeplineUsdPerCredit,
+    deepline_pricing_summary: _snakeDeeplinePricingSummary,
+    deepline_pricing_details: _snakeDeeplinePricingDetails,
+    ...publicTool
+  } = tool;
+  const outputSchemaRecord = recordField(tool, "outputSchema", "output_schema");
+  return {
+    cost: Capability.fromCatalogEntry(tool).describe().customerCost(),
+    ...publicTool,
+    toolId,
+    provider: tool.provider,
+    displayName: tool.displayName,
+    ...Object.keys(outputSchemaRecord).length > 0 ? {
+      outputSchema: publicToolInputSchemaForDescribe(outputSchemaRecord),
+      outputFields: toolOutputFieldsForDisplay(outputSchemaRecord).map(
+        inputFieldJsonForDescribe
+      )
+    } : {},
+    inputFields: inputFields.map(inputFieldJsonForDescribe),
+    usageGuidance,
+    runtimeOutputHelp: {
+      contract: "Schemas declare field shapes. Examples illustrate input payloads and full Deepline execution responses; they are not observed responses from this call.",
+      getterScope: "extractedValues/extractedLists .get() only works for declared Deepline getters listed in usageGuidance.toolExecutionResult.",
+      rawToolResponse: "Use toolExecutionResult.toolResponse.rawV2 for the complete tool response. Preserve its nesting and sibling fields as shown in examples; use declared getters for extracted values and lists.",
+      invalidGetterHint: "If TypeScript says an extractedValues/extractedLists property does not exist, that field is not a declared Deepline getter.",
+      observeActualShape: observedOutputCommand,
+      observedOutput: observedOutputCommand,
+      forPlayGetterBugs: "Run a tiny play, inspect returned handles with `deepline runs get <run-id> --full --json`, then export row datasets with `deepline runs export`.",
+      executeOutputFields: "tools execute JSON may include output_preview for this direct probe only; play debugging uses run output and returned dataset handles."
+    },
+    ...starterScript ? { starterScript } : {}
+  };
+}
+function usageGuidanceWithAccessDefaults(usageGuidance) {
+  if (Object.keys(usageGuidance).length === 0) return usageGuidance;
+  const existingAccess = recordField(usageGuidance, "access");
+  return {
+    ...usageGuidance,
+    prefer: [
+      "Use only the declared extractedLists and extractedValues getters listed below.",
+      "Use toolExecutionResult.toolResponse.rawV2 for the complete tool response, preserving the nesting shown in the response example.",
+      "Schemas declare field shapes; examples illustrate input values and full Deepline execution responses."
+    ],
+    toolExecutionResult: {
+      ...recordField(
+        usageGuidance,
+        "toolExecutionResult",
+        "tool_execution_result"
+      ),
+      toolResponse: {
+        rawV2: "toolResponse.rawV2",
+        view: "toolResponse.view",
+        responseMeta: "toolResponse.responseMeta"
+      }
+    },
+    access: {
+      ...existingAccess,
+      extractedLists: {
+        expression: "toolExecutionResult.extractedLists.<name>.get()",
+        meaning: "Declared Deepline list extractors only."
+      },
+      extractedValues: {
+        expression: "toolExecutionResult.extractedValues.<name>.get()",
+        meaning: "Declared Deepline scalar or normalized object extractors only."
+      },
+      ...existingAccess,
+      rawToolResponse: {
+        expression: "toolExecutionResult.toolResponse.rawV2",
+        meaning: "Complete tool response with its original nesting. Read tool-specific fields here; use declared getters for extracted values and lists."
+      },
+      canonicalToolResponse: {
+        expression: "toolExecutionResult.toolResponse.rawV2",
+        meaning: "Complete tool response with its original nesting and sibling fields."
+      },
+      invalidGetterHint: "If TypeScript says an extractedValues/extractedLists property does not exist, that field is not a declared Deepline getter; read it from toolResponse.rawV2 using the nesting shown in the response example."
+    }
+  };
+}
+function singleLineText(value, maxLength = 260) {
+  if (typeof value !== "string") return "";
+  const text = value.replace(/\s+/g, " ").trim();
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, maxLength - 3).trimEnd()}...`;
+}
+function listedToolDescription(tool) {
+  const record = tool;
+  return singleLineText(_nullishCoalesce(_nullishCoalesce(record.bestFor, () => ( record.best_for)), () => ( tool.description)));
+}
+function formatListedToolCost(tool) {
+  const record = tool;
+  if (stringField2(record, "billingSource", "billing_source") === "free") {
+    return "Cost: Free";
+  }
+  const pricing = recordField(record, "pricing");
+  const displayText = stringField2(pricing, "displayText", "display_text");
+  return displayText ? `Cost: ${displayText}` : "";
+}
+function toolInputFieldsForDisplay(inputSchema) {
+  if (Array.isArray(inputSchema.fields)) {
+    const fields = inputSchema.fields.filter(isRecord);
+    if (!isRecord(inputSchema.jsonSchema)) return fields;
+    const jsonSchemaFields = new Map(
+      recursiveToolInputFieldsForDisplay({
+        jsonSchema: inputSchema.jsonSchema
+      }).flatMap(
+        (field) => typeof field.name === "string" ? [[field.name, field]] : []
+      )
+    );
+    return fields.map((field) => {
+      const jsonSchemaField = typeof field.name === "string" ? jsonSchemaFields.get(field.name) : void 0;
+      const minItems = typeof field.minItems === "number" ? field.minItems : _optionalChain([jsonSchemaField, 'optionalAccess', _13 => _13.minItems]);
+      const maxItems = typeof field.maxItems === "number" ? field.maxItems : _optionalChain([jsonSchemaField, 'optionalAccess', _14 => _14.maxItems]);
+      const items = isRecord(field.items) ? field.items : _optionalChain([jsonSchemaField, 'optionalAccess', _15 => _15.items]);
+      return {
+        ...field,
+        ...isRecord(items) ? { items } : {},
+        ...typeof minItems === "number" ? { minItems } : {},
+        ...typeof maxItems === "number" ? { maxItems } : {}
+      };
+    });
+  }
+  const jsonSchema = isRecord(inputSchema.jsonSchema) ? inputSchema.jsonSchema : inputSchema;
+  const properties = isRecord(jsonSchema.properties) ? jsonSchema.properties : {};
+  const required = Array.isArray(jsonSchema.required) ? new Set(jsonSchema.required.map(String)) : /* @__PURE__ */ new Set();
+  return Object.entries(properties).map(([name, value]) => {
+    const property = isRecord(value) ? value : {};
+    return {
+      name,
+      type: typeof property.type === "string" ? property.type : "unknown",
+      required: required.has(name),
+      description: property.description,
+      ...isRecord(property.items) ? { items: property.items } : {},
+      ...typeof property.minItems === "number" ? { minItems: property.minItems } : {},
+      ...typeof property.maxItems === "number" ? { maxItems: property.maxItems } : {},
+      ...Object.prototype.hasOwnProperty.call(property, "default") ? { default: property.default } : {}
+    };
+  });
+}
+function toolOutputFieldsForDisplay(outputSchema) {
+  if (Object.keys(outputSchema).length === 0) return [];
+  return recursiveToolInputFieldsForDisplay({
+    jsonSchema: outputSchema
+  }).filter(
+    (field) => typeof field.name === "string" && field.name.includes("[]")
+  );
+}
+function printToolOutputArrayShape(tool) {
+  const outputFields = toolOutputFieldsForDisplay(
+    recordField(isRecord(tool) ? tool : {}, "outputSchema", "output_schema")
+  );
+  if (outputFields.length === 0) return;
+  console.log("  Output array shape (declared schema):");
+  for (const field of outputFields.slice(0, 60)) {
+    const name = String(field.name);
+    const type = stringField2(field, "type") || "unknown";
+    const itemBounds = arrayItemBoundsSuffix(field);
+    console.log(`    - ${name}: ${type}${itemBounds}`);
+  }
+  if (outputFields.length > 60) {
+    console.log(`    - \u2026 ${outputFields.length - 60} more schema fields`);
+  }
+}
+function canonicalToolJsonSchema(inputSchema) {
+  return isRecord(inputSchema.jsonSchema) ? inputSchema.jsonSchema : inputSchema;
+}
+function declaredToolJsonSchema(inputSchema) {
+  if (isRecord(inputSchema.jsonSchema)) {
+    return inputSchema.jsonSchema;
+  }
+  return Array.isArray(inputSchema.fields) ? null : inputSchema;
+}
+function publicToolInputSchemaForDescribe(inputSchema) {
+  const exposesProviderSpend = (description) => {
+    const withoutDeeplineCredits = description.replace(
+      /\bdeepline(?:-facing)?\s+credits?\b/gi,
+      ""
+    );
+    return /\bcredits?\b/i.test(withoutDeeplineCredits) || /\bprovider\s+(?:cost|spend|price|pricing|usage)\b/i.test(
+      withoutDeeplineCredits
+    ) || /\b(?:costs?|charges?|priced at)\s+[$€£]\s*\d/i.test(
+      withoutDeeplineCredits
+    ) || /\b(?:costs?|charges?|priced at)\s+\d+(?:\.\d+)?\s*(?:usd|eur|gbp)\b/i.test(
+      withoutDeeplineCredits
+    ) || /\battribute-priced\b/i.test(withoutDeeplineCredits) || /\b(?:cost|price|pricing)\s+(?:grows?|increases?|scales?|varies?)\b/i.test(
+      withoutDeeplineCredits
+    ) || /\b(?:will be|are|is|be)\s+(?:billed|charged)\b/i.test(
+      withoutDeeplineCredits
+    ) || /\b(?:additional|extra)\s+charges?\b/i.test(withoutDeeplineCredits) || /\bcharg(?:e|ed)\s+(?:double|per)\b/i.test(withoutDeeplineCredits) || /\bpricing page\b/i.test(withoutDeeplineCredits);
+  };
+  const stripDescriptions = (value) => {
+    if (Array.isArray(value)) return value.map(stripDescriptions);
+    if (!isRecord(value)) return value;
+    return Object.fromEntries(
+      Object.entries(value).flatMap(([key, nested]) => {
+        if (key === "description" && typeof nested === "string" && exposesProviderSpend(nested)) {
+          return [];
+        }
+        return [[key, stripDescriptions(nested)]];
+      })
+    );
+  };
+  return stripDescriptions(inputSchema);
+}
+function recursiveToolInputFieldsForDisplay(inputSchema) {
+  const root = canonicalToolJsonSchema(inputSchema);
+  const fields = /* @__PURE__ */ new Map();
+  const schemasById = /* @__PURE__ */ new Map();
+  const collectSchemaIds = (value) => {
+    if (Array.isArray(value)) {
+      for (const item of value) collectSchemaIds(item);
+      return;
+    }
+    if (!isRecord(value)) return;
+    if (typeof value.$id === "string" && value.$id.trim()) {
+      schemasById.set(value.$id.trim(), value);
+    }
+    for (const nested of Object.values(value)) collectSchemaIds(nested);
+  };
+  collectSchemaIds(root);
+  const resolveRef = (schema) => {
+    const ref = typeof schema.$ref === "string" ? schema.$ref : "";
+    if (!ref.startsWith("#/")) return _nullishCoalesce(schemasById.get(ref), () => ( schema));
+    let current = root;
+    for (const rawSegment of ref.slice(2).split("/")) {
+      const segment = rawSegment.replace(/~1/g, "/").replace(/~0/g, "~");
+      if (!isRecord(current)) return schema;
+      current = current[segment];
+    }
+    return isRecord(current) ? current : schema;
+  };
+  const addField = (field) => {
+    const name = typeof field.name === "string" ? field.name : "";
+    if (!name) return;
+    const existing = fields.get(name);
+    if (!existing || existing.type === "unknown") {
+      fields.set(name, field);
+    }
+  };
+  const visit = (unresolvedSchema, path, required, activeRefs = /* @__PURE__ */ new Set()) => {
+    const ref = typeof unresolvedSchema.$ref === "string" ? unresolvedSchema.$ref : "";
+    if (ref && activeRefs.has(ref)) return;
+    const schema = resolveRef(unresolvedSchema);
+    const nextActiveRefs = ref ? /* @__PURE__ */ new Set([...activeRefs, ref]) : activeRefs;
+    const type = Array.isArray(schema.type) ? schema.type.map(String).join("|") : typeof schema.type === "string" ? schema.type : isRecord(schema.properties) ? "object" : schema.items ? "array" : "unknown";
+    if (path) {
+      addField({
+        name: path,
+        type,
+        required,
+        description: schema.description,
+        ...Array.isArray(schema.enum) ? { enum: schema.enum } : {},
+        ...isRecord(schema.items) ? { items: schema.items } : {},
+        ...typeof schema.minItems === "number" ? { minItems: schema.minItems } : {},
+        ...typeof schema.maxItems === "number" ? { maxItems: schema.maxItems } : {},
+        ...Object.prototype.hasOwnProperty.call(schema, "default") ? { default: schema.default } : {}
+      });
+    }
+    const properties = isRecord(schema.properties) ? schema.properties : {};
+    const requiredNames = new Set(
+      Array.isArray(schema.required) ? schema.required.map(String) : []
+    );
+    for (const [name, value] of Object.entries(properties)) {
+      if (!isRecord(value)) continue;
+      visit(
+        value,
+        path ? `${path}.${name}` : name,
+        requiredNames.has(name),
+        nextActiveRefs
+      );
+    }
+    if (isRecord(schema.items)) {
+      visit(schema.items, `${path}[]`, false, nextActiveRefs);
+    }
+    for (const keyword of ["anyOf", "oneOf", "allOf"]) {
+      const branches = Array.isArray(schema[keyword]) ? schema[keyword] : [];
+      for (const branch of branches) {
+        if (isRecord(branch)) {
+          visit(branch, path, required, nextActiveRefs);
+        }
+      }
+    }
+  };
+  visit(root, "", false);
+  return fields.size ? [...fields.values()] : toolInputFieldsForDisplay(inputSchema);
+}
+function inputFieldJsonForDescribe(field) {
+  const publicItems = isRecord(field.items) ? publicToolInputSchemaForDescribe({ items: field.items }).items : void 0;
+  return {
+    name: field.name,
+    type: _nullishCoalesce(field.type, () => ( "unknown")),
+    required: Boolean(field.required),
+    ...field.description ? { description: field.description } : {},
+    ...isRecord(publicItems) ? { items: publicItems } : {},
+    ...typeof field.minItems === "number" ? { minItems: field.minItems } : {},
+    ...typeof field.maxItems === "number" ? { maxItems: field.maxItems } : {},
+    ...Object.prototype.hasOwnProperty.call(field, "default") ? { default: field.default } : {}
+  };
+}
+function arrayItemBoundsSuffix(field) {
+  const itemSchema = isRecord(field.items) ? field.items : null;
+  const itemType = itemSchema ? typeof itemSchema.type === "string" ? itemSchema.type : isRecord(itemSchema.properties) ? "object" : "unknown" : null;
+  const itemEnum = Array.isArray(_optionalChain([itemSchema, 'optionalAccess', _16 => _16.enum])) ? ` enum=${itemSchema.enum.map(String).join("|")}` : "";
+  const itemTypeSuffix = itemType && itemType !== "unknown" ? ` items=${itemType}${itemEnum}` : "";
+  const minItems = typeof field.minItems === "number" && Number.isFinite(field.minItems) ? field.minItems : null;
+  const maxItems = typeof field.maxItems === "number" && Number.isFinite(field.maxItems) ? field.maxItems : null;
+  if (minItems !== null && maxItems !== null) {
+    return itemTypeSuffix ? `${itemTypeSuffix} minItems=${minItems} maxItems=${maxItems}` : ` items=${minItems}..${maxItems}`;
+  }
+  if (minItems !== null) return `${itemTypeSuffix} minItems=${minItems}`;
+  if (maxItems !== null) return `${itemTypeSuffix} maxItems=${maxItems}`;
+  return itemTypeSuffix;
+}
+function printToolExecutionHints(value) {
+  const batchCapabilityRecord = recordField(
+    isRecord(value) ? value : {},
+    "batchCapability",
+    "batch_capability"
+  );
+  const batchCapability = Object.keys(batchCapabilityRecord).length > 0 ? batchCapabilityRecord : null;
+  const executionMetadata = recordField(
+    isRecord(value) ? value : {},
+    "executionMetadata",
+    "execution_metadata"
+  );
+  if (batchCapability) {
+    const status = stringField2(batchCapability, "status") || "unknown";
+    const surface = stringField2(batchCapability, "surface");
+    const operation = stringField2(
+      batchCapability,
+      "batchOperation",
+      "batch_operation"
+    );
+    const maxBatchSize = numberField2(
+      batchCapability,
+      "maxBatchSize",
+      "max_batch_size"
+    );
+    const notes = stringField2(batchCapability, "notes");
+    console.log("");
+    console.log("Batching:");
+    console.log(`- Catalog status: ${status}${surface ? ` (${surface})` : ""}`);
+    if (operation) console.log(`- Batch operation: ${operation}`);
+    if (maxBatchSize !== null) {
+      console.log(`- Maximum batch size: ${maxBatchSize} items`);
+    }
+    if (status === "compiled") {
+      console.log(
+        "- Compatible per-row Play calls can coalesce; separate tools execute requests do not coalesce."
+      );
+    } else if (surface !== "docs") {
+      console.log(
+        "- Play does not automatically coalesce per-row calls for this operation; send a native batch as one request when its input schema supports one."
+      );
+    }
+    if (notes) console.log(`- Details: ${notes}`);
+  }
+  const configuredRateLimits = arrayField2(
+    executionMetadata,
+    "configuredRateLimits",
+    "configured_rate_limits"
+  ).filter(isRecord);
+  if (configuredRateLimits.length > 0) {
+    console.log("");
+    console.log(
+      "Configured Deepline pacing (guidance, not a guaranteed provider quota):"
+    );
+    for (const limit of configuredRateLimits) {
+      const requests = numberField2(limit, "requestsPerWindow");
+      const windowMs = numberField2(limit, "windowMs");
+      if (requests === null || windowMs === null) continue;
+      const usage = stringField2(limit, "usage") || "unknown";
+      const usageText = usage === "queue_hint" ? "queue hint" : usage === "enforced" ? "Deepline enforced" : usage === "queue_hint_and_enforced" ? "queue hint and Deepline enforced" : usage === "disabled" ? "disabled" : usage;
+      const explicitMaxConcurrency = numberField2(
+        limit,
+        "explicitMaxConcurrency",
+        "explicit_max_concurrency"
+      );
+      const concurrencyText = explicitMaxConcurrency === null ? "no explicit concurrency limit" : `explicit concurrency limit ${explicitMaxConcurrency}`;
+      console.log(
+        `- ${requests} requests per ${formatRateWindow(windowMs)} (${usageText}; ${concurrencyText})`
+      );
+    }
+  }
+  const queueHint = recordField(executionMetadata, "queueHint", "queue_hint");
+  const requestsPerSecondHint = numberField2(
+    queueHint,
+    "requestsPerSecondHint",
+    "requests_per_second_hint"
+  );
+  const derivedConcurrency = numberField2(
+    queueHint,
+    "derivedConcurrency",
+    "derived_concurrency"
+  );
+  if (requestsPerSecondHint !== null && requestsPerSecondHint > 0 && derivedConcurrency !== null) {
+    console.log(
+      `Derived runtime queue hint: ${requestsPerSecondHint} requests/second; ${derivedConcurrency} derived concurrency. This is not an observed provider concurrency limit.`
+    );
+  }
+}
+function formatRateWindow(windowMs) {
+  if (windowMs === 1e3) return "second";
+  if (windowMs === 6e4) return "minute";
+  if (windowMs === 36e5) return "hour";
+  return `${windowMs}ms`;
+}
+function samplePayload(samples, key) {
+  const entry = samples[key];
+  if (!isRecord(entry)) return void 0;
+  return Object.prototype.hasOwnProperty.call(entry, "payload") ? entry.payload : entry;
+}
+function commandEnvelopeFromRawResponse(rawResponse) {
+  return isRecord(rawResponse) ? { ...rawResponse } : { status: "completed", result: rawResponse };
+}
+function toolExecuteExitCode(envelope) {
+  return envelope.status === "failed" || envelope.ok === false ? 1 : 0;
+}
+function extractToolExecutionWarningMessages(rawResponse) {
+  if (!isRecord(rawResponse)) return [];
+  const candidates = [
+    recordField(recordField(rawResponse, "toolResponse"), "meta"),
+    recordField(
+      recordField(recordField(rawResponse, "toolResponse"), "raw"),
+      "meta"
+    ),
+    recordField(rawResponse, "meta"),
+    recordField(recordField(rawResponse, "result"), "meta")
+  ];
+  const messages = [];
+  for (const candidate of candidates) {
+    const warnings = _optionalChain([candidate, 'optionalAccess', _17 => _17.warnings]);
+    if (!Array.isArray(warnings)) continue;
+    for (const warning of warnings) {
+      if (typeof warning === "string" && warning.trim()) {
+        messages.push(warning.trim());
+      } else if (isRecord(warning)) {
+        const message = stringField2(warning, "message");
+        if (message) messages.push(message);
+      }
+    }
+  }
+  return [...new Set(messages)];
+}
+function apifySyncRecoveryNext(rawResponse) {
+  if (!isRecord(rawResponse) || rawResponse.status !== "running") return null;
+  const toolResponse = recordField(rawResponse, "toolResponse");
+  const raw = recordField(toolResponse, "raw");
+  if (raw.state !== "awaiting_apify") return null;
+  const next = recordField(raw, "next");
+  const getActorRun = recordField(next, "getActorRun");
+  const getActorRunTool = stringField2(getActorRun, "tool");
+  const getActorRunPayload = recordField(getActorRun, "payload");
+  if (!getActorRunTool || Object.keys(getActorRunPayload).length === 0) {
+    return null;
+  }
+  const getDatasetItems = recordField(next, "getDatasetItems");
+  const getDatasetItemsTool = stringField2(getDatasetItems, "tool");
+  const getDatasetItemsPayload = recordField(getDatasetItems, "payload");
+  return {
+    getActorRun: `deepline tools execute ${getActorRunTool} --input ${shellQuote(JSON.stringify(getActorRunPayload))} --json`,
+    ...getDatasetItemsTool && Object.keys(getDatasetItemsPayload).length > 0 ? {
+      getDatasetItems: `deepline tools execute ${getDatasetItemsTool} --input ${shellQuote(JSON.stringify(getDatasetItemsPayload))} --json`
+    } : {}
+  };
+}
+function listExtractorPathsFromUsageGuidance(tool) {
+  const toolExecutionResult = _optionalChain([tool, 'access', _18 => _18.usageGuidance, 'optionalAccess', _19 => _19.toolExecutionResult]);
+  const extractedLists = Array.isArray(_optionalChain([toolExecutionResult, 'optionalAccess', _20 => _20.extractedLists])) ? toolExecutionResult.extractedLists : isRecord(_optionalChain([toolExecutionResult, 'optionalAccess', _21 => _21.extractedLists])) ? Object.values(toolExecutionResult.extractedLists) : [];
+  return extractedLists.flatMap((entry) => {
+    const paths = _nullishCoalesce(_optionalChain([entry, 'access', _22 => _22.details, 'optionalAccess', _23 => _23.candidatePaths]), () => ( _optionalChain([entry, 'access', _24 => _24.details, 'optionalAccess', _25 => _25.rawToolOutputPaths])));
+    if (!Array.isArray(paths)) return [];
+    return paths.map(
+      (path) => path.trim().replace(/^toolExecutionResult\.toolResponse\.raw\.?/, "").replace(/^toolExecutionResult\.toolOutput\.raw\.?/, "").replace(/^\./, "")
+    ).filter(Boolean);
+  });
+}
+function formatDecimal(value) {
+  const text = value.toFixed(12).replace(/0+$/, "").replace(/\.$/, "");
+  return text || "0";
+}
+function formatUsd(value) {
+  return `$${formatDecimal(value)}`;
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function stringField2(source, ...keys) {
+  for (const key of keys) {
+    const value = source[key];
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return "";
+}
+function numberField2(source, ...keys) {
+  for (const key of keys) {
+    const value = source[key];
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+  }
+  return null;
+}
+function arrayField2(source, ...keys) {
+  for (const key of keys) {
+    const value = source[key];
+    if (Array.isArray(value)) return value;
+  }
+  return [];
+}
+function recordField(source, ...keys) {
+  for (const key of keys) {
+    const value = source[key];
+    if (isRecord(value)) return value;
+  }
+  return {};
+}
+function normalizeOutputFormat(raw) {
+  switch ((raw || "auto").trim().toLowerCase()) {
+    case "auto":
+      return "auto";
+    case "csv":
+      return "csv";
+    case "csv_file":
+      return "csv_file";
+    case "json":
+      return "json";
+    case "json_file":
+      return "json_file";
+    default:
+      throw new Error(`Invalid value for --output-format: ${raw}`);
+  }
+}
+function resolveAtFilePath(rawPath) {
+  const trimmed = rawPath.trim();
+  const resolved = _path.resolve.call(void 0, trimmed);
+  if (_fs.existsSync.call(void 0, resolved)) return resolved;
+  if (process.platform !== "win32" && trimmed.includes("\\")) {
+    const normalized = _path.resolve.call(void 0, trimmed.replace(/\\/g, "/"));
+    if (_fs.existsSync.call(void 0, normalized)) return normalized;
+  }
+  return resolved;
+}
+function readJsonArgument(raw, flagName) {
+  if (!raw.startsWith("@")) return raw.replace(/^\uFEFF/, "");
+  const filePath = raw.slice(1).trim();
+  if (!filePath) {
+    throw new Error(`Invalid ${flagName} value: empty @file path.`);
+  }
+  try {
+    return _fs.readFileSync.call(void 0, resolveAtFilePath(filePath), "utf8").replace(
+      /^\uFEFF/,
+      ""
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Failed to read ${flagName} file '${filePath}': ${message}`
+    );
+  }
+}
+function invalidJsonError(flagName, message) {
+  const error = new Error(
+    `Invalid JSON in ${flagName}: ${message}`
+  );
+  error.code = "INVALID_JSON";
+  return error;
+}
+function parseJsonObjectArgument(raw, flagName) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readJsonArgument(raw, flagName));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.startsWith("Failed to read ") || message.startsWith("Invalid ")) {
+      throw error;
+    }
+    throw invalidJsonError(flagName, message);
+  }
+  if (!isRecord(parsed)) {
+    throw invalidJsonError(flagName, "expected an object.");
+  }
+  return parsed;
+}
+function parseExecuteOptions(args) {
+  const toolId = args[0];
+  if (!toolId) {
+    throw new Error(
+      `Usage: deepline tools execute <toolId> [--param key=value ...] [--input '{"k":"v"}'] [--timeout <duration>] [--recover | --idempotency-key <key>] [--recovery-timeout-ms <ms>] [--out rows.csv] [--output-format auto|csv|csv_file|json|json_file] [--no-preview]`
+    );
+  }
+  const params = {};
+  let outputFormat = "auto";
+  let noPreview = false;
+  let outPath = null;
+  let timeoutMs;
+  let idempotencyKey;
+  let recover = false;
+  let recoveryTimeoutMs;
+  for (let index = 1; index < args.length; index += 1) {
+    const arg = args[index];
+    if ((arg === "--param" || arg === "-p") && args[index + 1]) {
+      const kv = args[++index];
+      const eqIdx = kv.indexOf("=");
+      if (eqIdx > 0) params[kv.slice(0, eqIdx)] = kv.slice(eqIdx + 1);
+      continue;
+    }
+    if (arg === "--json") {
+      const next = args[index + 1];
+      outputFormat = "json";
+      if (next && !next.startsWith("--")) {
+        Object.assign(
+          params,
+          parseJsonObjectArgument(args[++index], "--json")
+        );
+      }
+      continue;
+    }
+    if ((arg === "--input" || arg === "--payload") && args[index + 1]) {
+      Object.assign(params, parseJsonObjectArgument(args[++index], arg));
+      continue;
+    }
+    if (arg === "--timeout" && args[index + 1]) {
+      timeoutMs = parseToolExecuteTimeout(args[++index]);
+      continue;
+    }
+    if (arg === "--output-format" && args[index + 1]) {
+      outputFormat = normalizeOutputFormat(args[++index]);
+      continue;
+    }
+    if (arg === "--no-preview") {
+      noPreview = true;
+      continue;
+    }
+    if (arg === "--idempotency-key" && args[index + 1]) {
+      idempotencyKey = args[++index];
+      continue;
+    }
+    if (arg === "--recover") {
+      recover = true;
+      continue;
+    }
+    if (arg === "--recovery-timeout-ms" && args[index + 1]) {
+      const parsed = Number(args[++index]);
+      if (!Number.isFinite(parsed) || parsed < 0) {
+        throw new Error("--recovery-timeout-ms must be a non-negative number.");
+      }
+      recoveryTimeoutMs = parsed;
+      continue;
+    }
+    if ((arg === "--out" || arg === "-o") && args[index + 1]) {
+      outPath = _path.resolve.call(void 0, args[++index]);
+      continue;
+    }
+    throw new Error(`Unknown option: ${arg}`);
+  }
+  return {
+    toolId,
+    params,
+    outputFormat,
+    noPreview,
+    outPath,
+    timeoutMs,
+    idempotencyKey,
+    recover,
+    recoveryTimeoutMs
+  };
+}
+function parseToolExecuteTimeout(raw) {
+  const match = /^(\d+)(ms|s|m|h)?$/i.exec(raw.trim());
+  if (!match) {
+    throw new Error(
+      "--timeout must be a duration like 500ms, 90s, 10m, or 1h (a bare number is seconds)."
+    );
+  }
+  const value = Number(match[1]);
+  const unit = (_nullishCoalesce(match[2], () => ( "s"))).toLowerCase();
+  const factor = unit === "ms" ? 1 : unit === "s" ? 1e3 : unit === "m" ? 6e4 : 36e5;
+  const timeoutMs = value * factor;
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 2147483647) {
+    throw new Error(
+      "--timeout must be between 1ms and 2147483647ms (24d 20h 31m 23s)."
+    );
+  }
+  return timeoutMs;
+}
+function safeFileStem(value) {
+  return value.trim().replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || "tool";
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function powerShellQuote(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function starterScriptJson(script) {
+  return {
+    path: script.path,
+    sourceCode: script.sourceCode,
+    projectDir: script.projectDir,
+    copyToProject: {
+      macosLinux: script.macCopyCommand,
+      windowsPowerShell: script.windowsCopyCommand
+    }
+  };
+}
+function seedToolListScript(input) {
+  const stem = safeFileStem(input.toolId);
+  const fileName = `${stem}-workflow-seed-${Date.now()}.play.ts`;
+  const scriptDir = _fs.mkdtempSync.call(void 0, _path.join.call(void 0, _os.tmpdir.call(void 0, ), "deepline-workflow-seed-"));
+  _fs.chmodSync.call(void 0, scriptDir, 448);
+  const scriptPath = _path.join.call(void 0, scriptDir, fileName);
+  const projectDir = `deepline/projects/${stem}-workflow`;
+  const playName = `${stem}-workflow`;
+  const sampleRows = input.rows.length > 0 ? `${JSON.stringify(input.rows.slice(0, 2)).replace(/\]$/, "")}, ...]` : "[]";
+  const columns = Object.keys(_nullishCoalesce(input.rows[0], () => ( {}))).join(", ");
+  const rowKey = Object.prototype.hasOwnProperty.call(_nullishCoalesce(input.rows[0], () => ( {})), "id") ? '"id"' : "(row) => JSON.stringify(row)";
+  const script = `import { definePlay } from 'deepline';
+
+export default definePlay(${JSON.stringify(playName)}, async (ctx) => {
+  const result = await ctx.tools.execute({
+    id: ${JSON.stringify(input.toolId)},
+    tool: ${JSON.stringify(input.toolId)},
+    input: ${JSON.stringify(input.payload)},
+    description: ${JSON.stringify(`Seed ${input.toolId} rows for workflow expansion.`)},
+  });
+
+  const list = Object.values(result.extractedLists)[0];
+  if (!list) {
+    throw new Error('Expected ${input.toolId} to expose an extracted list getter.');
+  }
+  const rows = list.get();
+  // ${sampleRows}
+  // columns: ${columns}
+  // extractedLists.<name>.get() returns a dataset handle for row-shaped list outputs.
+  // Pass it to ctx.dataset; use rows.peek/count/materialize only for deliberate bounded inspection.
+  // .withColumn('email_waterfall', (row, rowCtx) => rowCtx.runPlay('name_domain_email', 'name-and-domain-to-email', { first_name: String(row.first_name ?? ''), last_name: String(row.last_name ?? ''), domain: String(row.domain ?? '') }, { description: 'Resolve email.' }))
+  // .withColumn('phone_waterfall', (row, rowCtx) => rowCtx.runPlay('contact_phone', 'contact-to-phone', { first_name: String(row.first_name ?? ''), last_name: String(row.last_name ?? ''), email: String(row.email ?? '') }, { description: 'Resolve phone.' }))
+  // ctx.dataset is idempotent by dataset key + row key; reruns reuse completed rows.
+  const enrichedData = await ctx
+    .dataset('enriched_data', rows)
+    .run({
+      key: ${rowKey},
+      description: 'Enrich seeded rows.',
+    });
+
+  return {
+    rows: enrichedData,
+    count: await enrichedData.count(),
+  };
+}, {
+  description: ${JSON.stringify(`Seed ${input.toolId} rows into a Deepline workflow-ready dataset.`)},
+});
+`;
+  _fs.writeFileSync.call(void 0, scriptPath, script, { encoding: "utf-8", mode: 384 });
+  return {
+    path: scriptPath,
+    sourceCode: script,
+    projectDir,
+    macCopyCommand: `mkdir -p ${shellQuote(projectDir)} && cp ${shellQuote(scriptPath)} ${shellQuote(`${projectDir}/${fileName}`)}`,
+    windowsCopyCommand: `New-Item -ItemType Directory -Force -Path ${powerShellQuote(projectDir.replace(/\//g, "\\"))} | Out-Null; Copy-Item -LiteralPath ${powerShellQuote(scriptPath)} -Destination ${powerShellQuote(`${projectDir.replace(/\//g, "\\")}\\${fileName}`)}`
+  };
+}
+function buildToolExecuteBaseEnvelope(input) {
+  const envelope = commandEnvelopeFromRawResponse(input.rawResponse);
+  const guidanceLines = toolExecuteExitCode(envelope) !== 0 || input.listExpected === true && !input.listConversion ? toolGuidanceLines(input.guidance) : [];
+  const warningMessages = extractToolExecutionWarningMessages(
+    input.rawResponse
+  );
+  const apifyRecovery = apifySyncRecoveryNext(input.rawResponse);
+  const summaryEntries = Object.entries(input.summary);
+  const outputPreview = input.listConversion ? {
+    kind: "list",
+    rowCount: input.listConversion.rows.length,
+    columns: Object.keys(_nullishCoalesce(input.listConversion.rows[0], () => ( {}))),
+    preview: input.listConversion.rows.slice(0, 5),
+    listStrategy: input.listConversion.strategy,
+    listSourcePath: input.listConversion.sourcePath
+  } : {
+    kind: summaryEntries.length > 0 ? "object" : "raw",
+    summary: input.summary
+  };
+  const envelopeHasCanonicalOutput = isRecord(envelope.toolResponse) && Object.prototype.hasOwnProperty.call(envelope.toolResponse, "raw");
+  const envelopeHasDeclaredOutput = Object.prototype.hasOwnProperty.call(
+    envelope,
+    "output"
+  );
+  const billingLookup = typeof envelope.job_id === "string" && envelope.job_id.trim() ? `deepline billing usage --request-id ${shellQuote(envelope.job_id)} --json` : null;
+  const inspectCommand = `deepline tools execute ${input.toolId} --input ${shellQuote(JSON.stringify(input.params))} --json`;
+  const actions = input.listConversion ? [
+    {
+      label: "next",
+      command: "move starter script into a project folder and expand it into a Deepline play"
+    }
+  ] : apifyRecovery ? [
+    { label: "check Apify run", command: apifyRecovery.getActorRun },
+    ...apifyRecovery.getDatasetItems ? [
+      {
+        label: "get Apify dataset items",
+        command: apifyRecovery.getDatasetItems
+      }
+    ] : []
+  ] : [];
+  if (billingLookup) {
+    actions.push({ label: "charge", command: billingLookup });
+  }
+  return {
+    ...envelope,
+    ...input.idempotencyKey ? { idempotency_key: input.idempotencyKey } : {},
+    ...isRecord(input.rawResponse) && isRecord(input.rawResponse.executionRecovery) ? { execution_recovery: input.rawResponse.executionRecovery } : {},
+    ...envelopeHasCanonicalOutput || envelopeHasDeclaredOutput ? { output_preview: outputPreview } : { output: outputPreview },
+    ...summaryEntries.length > 0 ? { summary: input.summary } : {},
+    ...warningMessages.length > 0 ? { warnings: warningMessages } : {},
+    next: {
+      inspect: inspectCommand,
+      ...billingLookup ? { billing: billingLookup } : {},
+      ..._nullishCoalesce(apifyRecovery, () => ( {})),
+      ...guidanceLines.length > 0 ? { guidance: input.guidance } : {},
+      playDebugging: "When fixing a play getter, inspect returned dataset handles with runs get and export rows with runs export; do not copy CLI preview paths blindly.",
+      ...input.listConversion ? {
+        expandToPlay: "Use stable map and step keys so reruns are idempotent: completed rows are reused, and only missing or stale work runs again.",
+        listSourcePath: _nullishCoalesce(input.listConversion.sourcePath, () => ( "auto-detected list in the CLI response preview"))
+      } : {}
+    },
+    render: {
+      sections: input.listConversion ? [
+        ...warningMessages.length > 0 ? [{ title: "warnings", lines: warningMessages }] : [],
+        {
+          title: "output",
+          lines: [
+            `${input.listConversion.rows.length} row(s) extracted from ${_nullishCoalesce(input.listConversion.sourcePath, () => ( "auto-detected list"))}`,
+            "paths above are observed from this execute response; use runs get and runs export to validate play output",
+            `columns: ${JSON.stringify(Object.keys(_nullishCoalesce(input.listConversion.rows[0], () => ( {}))))}`,
+            `preview: ${JSON.stringify(input.listConversion.rows.slice(0, 5))}`
+          ]
+        }
+      ] : [
+        ...warningMessages.length > 0 ? [{ title: "warnings", lines: warningMessages }] : [],
+        {
+          title: "result",
+          lines: apifyRecovery ? [
+            "Apify is still running. Run the follow-up command(s) below."
+          ] : summaryEntries.length > 0 ? summaryEntries.map(
+            ([key, value]) => `${key}=${String(value)}`
+          ) : [JSON.stringify(input.rawResponse, null, 2)]
+        },
+        ...guidanceLines.length > 0 ? [{ title: "guidance", lines: guidanceLines }] : []
+      ],
+      actions
+    }
+  };
+}
+function buildToolExecuteRowArtifactEnvelope(input) {
+  const {
+    toolResponse: _toolResponse,
+    result: _result,
+    output: _output,
+    output_preview: _outputPreview,
+    render: _render,
+    next: _next,
+    local: _local,
+    ...base
+  } = input.baseEnvelope;
+  void _toolResponse;
+  void _result;
+  void _output;
+  void _outputPreview;
+  void _render;
+  void _next;
+  void _local;
+  const billingLookup = isRecord(input.baseEnvelope.next) && typeof input.baseEnvelope.next.billing === "string" ? input.baseEnvelope.next.billing : null;
+  return {
+    ...base,
+    status: typeof base.status === "string" ? base.status : "completed",
+    output_preview: {
+      kind: "list",
+      rowCount: input.rowOutput.rowCount,
+      columns: input.rowOutput.columns,
+      preview: input.rowOutput.previewRows,
+      listStrategy: input.rowOutput.strategy,
+      listSourcePath: input.rowOutput.sourcePath
+    },
+    csv_path: input.csv.path,
+    row_count: input.csv.rowCount,
+    row_count_returned: input.csv.rowCount,
+    columns: input.csv.columns,
+    extracted_csv: input.csv.path,
+    extracted_csv_rows: input.csv.rowCount,
+    extracted_csv_columns: input.csv.columns,
+    preview: input.csv.preview,
+    list_strategy: input.rowOutput.strategy,
+    list_source_path: input.rowOutput.sourcePath,
+    summary: input.summary,
+    local: {
+      extracted_csv: input.csv.path,
+      extracted_csv_rows: input.csv.rowCount,
+      extracted_csv_columns: input.csv.columns,
+      preview: input.csv.preview,
+      starter_script: input.seededScript.path,
+      project_dir: input.seededScript.projectDir,
+      copy_to_project: {
+        macos_linux: input.seededScript.macCopyCommand,
+        windows_powershell: input.seededScript.windowsCopyCommand
+      }
+    },
+    starter_script: input.seededScript.path,
+    project_dir: input.seededScript.projectDir,
+    copy_to_project: {
+      macos_linux: input.seededScript.macCopyCommand,
+      windows_powershell: input.seededScript.windowsCopyCommand
+    },
+    next: {
+      inspect: "Re-run with --json only when you need the raw provider/tool response.",
+      ...billingLookup ? { billing: billingLookup } : {},
+      listSourcePath: input.rowOutput.sourcePath,
+      expandToPlay: "Use stable map and step keys so reruns are idempotent: completed rows are reused, and only missing or stale work runs again."
+    },
+    render: {
+      sections: [
+        {
+          title: `${input.csv.path} (${input.csv.rowCount} rows)`,
+          lines: [
+            ...input.csv.columns.length > 0 ? [`columns: ${JSON.stringify(input.csv.columns)}`] : [],
+            ...Object.keys(input.summary).length > 0 ? [
+              `summary: ${Object.entries(input.summary).map(([key, value]) => `${key}=${String(value)}`).join(", ")}`
+            ] : [],
+            `preview: ${JSON.stringify(input.rowOutput.previewRows)}`,
+            `starter script: ${input.seededScript.path}`
+          ]
+        }
+      ],
+      actions: [
+        ...billingLookup ? [{ label: "charge", command: billingLookup }] : [],
+        {
+          label: "next",
+          command: "Move the script into a project folder and expand it into a Deepline play. Use stable map and step keys so reruns are idempotent: completed rows are reused, and only missing or stale work runs again."
+        },
+        {
+          label: "macOS/Linux",
+          command: input.seededScript.macCopyCommand
+        },
+        {
+          label: "Windows PowerShell",
+          command: input.seededScript.windowsCopyCommand
+        }
+      ]
+    }
+  };
+}
+async function executeTool(args) {
+  let parsed;
+  try {
+    parsed = parseExecuteOptions(args);
+  } catch (error) {
+    if (_chunkF35VOIQLjs.argsWantJson.call(void 0, args)) {
+      _chunkF35VOIQLjs.printJsonError.call(void 0, error);
+    } else {
+      console.error(error instanceof Error ? error.message : String(error));
+    }
+    return 1;
+  }
+  const client = new (0, _chunk2S5Y3TZPjs.DeeplineClient)();
+  let metadata;
+  try {
+    metadata = await client.getTool(parsed.toolId);
+  } catch (error) {
+    if (isMissingToolMetadataError(error)) {
+      const play = await findPlayForToolId(client, parsed.toolId);
+      if (play) {
+        if (_chunkF35VOIQLjs.argsWantJson.call(void 0, args)) {
+          _chunkF35VOIQLjs.printJsonError.call(void 0, 
+            new Error(playAliasToolErrorMessage(parsed.toolId, play))
+          );
+        } else {
+          printPlayAliasToolError(parsed.toolId, play);
+        }
+        return 2;
+      }
+    }
+    throw error;
+  }
+  if (isPlayLikeTool(metadata)) {
+    if (_chunkF35VOIQLjs.argsWantJson.call(void 0, args)) {
+      _chunkF35VOIQLjs.printJsonError.call(void 0, 
+        new Error(
+          playLikeToolExecuteErrorMessage(
+            parsed.toolId,
+            metadata
+          )
+        )
+      );
+    } else {
+      printPlayLikeToolExecuteError(
+        parsed.toolId,
+        metadata
+      );
+    }
+    return 2;
+  }
+  const responseIntent = parsed.outPath || parsed.outputFormat === "csv" || parsed.outputFormat === "csv_file" ? "row_artifact" : "raw";
+  const recovery = ToolCallRecovery.open({
+    toolId: parsed.toolId,
+    params: parsed.params,
+    responseIntent,
+    recover: parsed.recover,
+    idempotencyKey: parsed.idempotencyKey
+  });
+  const { idempotencyKey } = recovery;
+  if (idempotencyKey) {
+    console.error(`Tool execution recovery key: ${idempotencyKey}`);
+  }
+  const rawResponse = await client.executeTool(parsed.toolId, parsed.params, {
+    ...parsed.timeoutMs !== void 0 ? { timeout: parsed.timeoutMs } : {},
+    ..._optionalChain([metadata, 'access', _26 => _26.executionMetadata, 'optionalAccess', _27 => _27.retrySafeTransientHttp]) === true ? { maxRetries: 2, retryApiErrors: true } : {},
+    responseIntent,
+    ...idempotencyKey ? { idempotencyKey } : {},
+    ...parsed.recoveryTimeoutMs !== void 0 ? { recoveryTimeoutMs: parsed.recoveryTimeoutMs } : {},
+    searchRef: _chunkWQICC2B3js.recentSearchRef.call(void 0, )
+  }).catch((error) => {
+    const guidanceLines = toolGuidanceLines(metadata.guidance);
+    if (guidanceLines.length > 0) {
+      if (args.includes("--json") && error instanceof Error) {
+        Object.assign(error, { guidance: metadata.guidance });
+      } else {
+        console.error(
+          [`Guidance for ${parsed.toolId}:`, ...guidanceLines].join("\n")
+        );
+      }
+    }
+    throw error;
+  });
+  const listExtractorPaths = listExtractorPathsFromUsageGuidance(metadata);
+  const listConversion = _chunkNXDRDJ4Kjs.tryConvertToList.call(void 0, rawResponse, { listExtractorPaths });
+  const summary = _chunkNXDRDJ4Kjs.extractSummaryFields.call(void 0, rawResponse);
+  const baseEnvelope = buildToolExecuteBaseEnvelope({
+    toolId: parsed.toolId,
+    params: parsed.params,
+    ...idempotencyKey ? { idempotencyKey } : {},
+    rawResponse,
+    listConversion,
+    summary,
+    guidance: metadata.guidance,
+    listExpected: listExtractorPaths.length > 0
+  });
+  const executeExitCode = toolExecuteExitCode(baseEnvelope);
+  const delivered = (() => {
+    if (!parsed.outPath && (parsed.outputFormat === "json" || parsed.outputFormat === "auto" && _chunkF35VOIQLjs.shouldEmitJson.call(void 0, ))) {
+      _chunkF35VOIQLjs.printCommandEnvelope.call(void 0, baseEnvelope, { json: true });
+      return true;
+    }
+    if (parsed.outputFormat === "json_file") {
+      const jsonPath = _chunkNXDRDJ4Kjs.writeJsonOutputFile.call(void 0, 
+        rawResponse,
+        `payload_${parsed.toolId}`
+      );
+      _chunkF35VOIQLjs.printCommandEnvelope.call(void 0, 
+        {
+          ...baseEnvelope,
+          local: {
+            ...isRecord(baseEnvelope.local) ? baseEnvelope.local : {},
+            payload_file: jsonPath
+          }
+        },
+        { json: true }
+      );
+      return true;
+    }
+    if (!listConversion) {
+      if (parsed.outPath) {
+        const error = new Error(
+          `${parsed.toolId} did not expose row-shaped output to write as CSV. Re-run with --json to inspect the raw tool response.`
+        );
+        if (_chunkF35VOIQLjs.argsWantJson.call(void 0, args)) {
+          _chunkF35VOIQLjs.printJsonError.call(void 0, error);
+        } else {
+          console.error(error.message);
+        }
+        return false;
+      }
+      if (parsed.outputFormat === "csv" || parsed.outputFormat === "csv_file") {
+        const jsonPath = _chunkNXDRDJ4Kjs.writeJsonOutputFile.call(void 0, 
+          rawResponse,
+          `payload_${parsed.toolId}`
+        );
+        _chunkF35VOIQLjs.printCommandEnvelope.call(void 0, 
+          {
+            ...baseEnvelope,
+            local: {
+              payload_file: jsonPath
+            }
+          },
+          { json: parsed.outputFormat === "csv_file" || _chunkF35VOIQLjs.shouldEmitJson.call(void 0, ) }
+        );
+        return true;
+      }
+      _chunkF35VOIQLjs.printCommandEnvelope.call(void 0, baseEnvelope, { json: false });
+      return true;
+    }
+    const rowOutput = _chunkNXDRDJ4Kjs.projectRowOutput.call(void 0, listConversion);
+    const csv = _chunkNXDRDJ4Kjs.writeCsvOutputFile.call(void 0, 
+      listConversion.rows,
+      `${parsed.toolId}_output`,
+      parsed.outPath ? { outPath: parsed.outPath } : void 0
+    );
+    const seededScript = seedToolListScript({
+      toolId: parsed.toolId,
+      payload: parsed.params,
+      rows: listConversion.rows
+    });
+    const materializedEnvelope = buildToolExecuteRowArtifactEnvelope({
+      baseEnvelope,
+      csv,
+      rowOutput,
+      summary,
+      seededScript
+    });
+    if (parsed.outputFormat === "csv_file") {
+      _chunkF35VOIQLjs.printCommandEnvelope.call(void 0, materializedEnvelope, { json: true });
+      return true;
+    }
+    if (parsed.outPath) {
+      _chunkF35VOIQLjs.printCommandEnvelope.call(void 0, materializedEnvelope, {
+        json: _chunkF35VOIQLjs.argsWantJson.call(void 0, args) || _chunkF35VOIQLjs.shouldEmitJson.call(void 0, ),
+        text: `Wrote ${csv.rowCount} row(s) to ${csv.path}
+`
+      });
+      return true;
+    }
+    if (parsed.noPreview) {
+      _chunkF35VOIQLjs.printCommandEnvelope.call(void 0, 
+        {
+          ...materializedEnvelope,
+          local: {
+            ..._nullishCoalesce(materializedEnvelope.local, () => ( {})),
+            output_path: csv.path
+          }
+        },
+        { json: _chunkF35VOIQLjs.shouldEmitJson.call(void 0, ), text: `${csv.path}
+` }
+      );
+      return true;
+    }
+    _chunkF35VOIQLjs.printCommandEnvelope.call(void 0, materializedEnvelope, { json: false });
+    return true;
+  })();
+  if (delivered) await recovery.acknowledgeDelivery();
+  return delivered ? executeExitCode : 1;
+}
+
+
+
+
+
+
+
+
+exports.buildToolExecuteBaseEnvelope = buildToolExecuteBaseEnvelope; exports.extractToolExecutionWarningMessages = extractToolExecutionWarningMessages; exports.isMonitorTypeTool = isMonitorTypeTool; exports.printCompactToolContract = printCompactToolContract; exports.printMonitorTypeContract = printMonitorTypeContract; exports.registerToolsCommands = registerToolsCommands; exports.toolContractJsonForDescribe = toolContractJsonForDescribe;