deepline 0.3.396 → 0.3.398

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

@@ -0,0 +1,930 @@
+"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 _chunkBQR6UN3Cjs = require('./chunk-BQR6UN3C.js');
+
+
+
+var _chunkZM2YPJQJjs = require('./chunk-ZM2YPJQJ.js');
+
+
+
+
+
+var _chunkNA4T3B62js = require('./chunk-NA4T3B62.js');
+
+
+var _chunkKB4SDX5Sjs = require('./chunk-KB4SDX5S.js');
+
+// ../plays/field-catalog.ts
+var value = (description) => ({ type: "string", description });
+var SOURCE = {
+  type: "string",
+  description: "The provider or step that found it."
+};
+var FIELD_CATALOG = {
+  person: {
+    name: {
+      description: "The person's name.",
+      leaves: {
+        value: value("Full name."),
+        first: value("First (given) name."),
+        last: value("Last (family) name.")
+      }
+    },
+    email: {
+      description: "An email address for the person.",
+      leaves: {
+        value: value("The address."),
+        validated: {
+          type: "boolean",
+          description: "Whether the address passed validation."
+        },
+        status: {
+          type: "EmailStatus",
+          description: "The validation verdict and its signals."
+        },
+        source: SOURCE
+      },
+      kinds: {
+        work: "At their employer.",
+        personal: "Their own, not tied to an employer."
+      }
+    },
+    phone: {
+      description: "A phone number for the person.",
+      leaves: {
+        value: value("The number."),
+        validated: {
+          type: "boolean",
+          description: "Whether the number passed validation."
+        },
+        status: {
+          type: '"valid" | "invalid" | "unknown"',
+          description: "The validation verdict."
+        },
+        line_type: value("Mobile, landline, VoIP and so on."),
+        carrier: value("The carrier serving the number."),
+        source: SOURCE
+      },
+      kinds: {
+        mobile: "Their mobile.",
+        work: "A direct line at their employer."
+      }
+    },
+    linkedin: {
+      description: "The person's LinkedIn profile.",
+      leaves: { url: value("The profile URL.") }
+    },
+    job: {
+      description: "The person's current role.",
+      leaves: {
+        title: value("Job title."),
+        change: {
+          type: "JobChange",
+          description: "Whether they changed jobs, and to what."
+        },
+        change_status: {
+          type: "JobChangeStatus",
+          description: "The job-change verdict alone."
+        }
+      }
+    },
+    record: {
+      description: "A provider's own record of the person.",
+      leaves: { id: value("The provider's id for the person.") }
+    }
+  },
+  company: {
+    name: {
+      description: "The company's name.",
+      leaves: { value: value("The name.") },
+      kinds: { legal: "As registered with a government." }
+    },
+    domain: {
+      description: "The company's web domain.",
+      leaves: { value: value("The bare domain, such as example.com.") }
+    },
+    website: {
+      description: "The company's website.",
+      leaves: { url: value("The site URL.") }
+    },
+    linkedin: {
+      description: "The company's LinkedIn page.",
+      leaves: { url: value("The page URL.") }
+    },
+    phone: {
+      description: "A phone number for the company.",
+      leaves: { value: value("The number.") }
+    },
+    industry: {
+      description: "The industry the company is in.",
+      leaves: { value: value("The industry.") }
+    },
+    record: {
+      description: "A provider's own record of the company.",
+      leaves: { id: value("The provider's id for the company.") }
+    }
+  }
+};
+function catalogFields() {
+  return Object.entries(FIELD_CATALOG).flatMap(
+    ([entity, groups]) => Object.entries(groups).flatMap(
+      ([group, definition]) => [void 0, ...Object.keys(_nullishCoalesce(definition.kinds, () => ( {})))].flatMap(
+        (kind) => Object.entries(definition.leaves).map(([leaf, described]) => ({
+          ...described,
+          id: [entity, group, kind, leaf].filter(Boolean).join("."),
+          entity,
+          group,
+          ...kind ? { kind } : {},
+          leaf
+        }))
+      )
+    )
+  );
+}
+var FIELDS_BY_ID = new Map(catalogFields().map((field) => [field.id, field]));
+function generalField(id) {
+  const field = FIELDS_BY_ID.get(id);
+  return _optionalChain([field, 'optionalAccess', _ => _.kind]) ? [field.entity, field.group, field.leaf].join(".") : null;
+}
+function fieldSatisfies(offered, wanted) {
+  return offered === wanted || generalField(offered) === wanted;
+}
+var EXTRACTOR_TARGET_FIELDS = {
+  email: ["person.email.value"],
+  personal_email: ["person.email.personal.value"],
+  email_status: ["person.email.status"],
+  phone: ["person.phone.value", "company.phone.value"],
+  phone_status: ["person.phone.status"],
+  first_name: ["person.name.first"],
+  last_name: ["person.name.last"],
+  full_name: ["person.name.value"],
+  // Also used for a list name, a channel title and a search suggestion.
+  name: ["person.name.value", "company.name.value"],
+  linkedin: ["person.linkedin.url", "company.linkedin.url"],
+  linkedin_url: ["person.linkedin.url"],
+  title: ["person.job.title"],
+  job_change: ["person.job.change"],
+  job_change_status: ["person.job.change_status"],
+  company: ["company.name.value"],
+  company_name: ["company.name.value"],
+  organization_name: ["company.name.value"],
+  company_domain: ["company.domain.value"],
+  domain: ["company.domain.value"],
+  company_website: ["company.website.url"],
+  // Also used for a podcast URL.
+  website: ["company.website.url"],
+  company_linkedin_url: ["company.linkedin.url"],
+  industry: ["company.industry.value"],
+  id: ["person.record.id", "company.record.id"],
+  // Used for unrelated provider statuses; none is a catalog field.
+  status: []
+};
+function fieldOfName(name, declared) {
+  const meanings = _nullishCoalesce(EXTRACTOR_TARGET_FIELDS[name], () => ( []));
+  if (declared === void 0) {
+    return meanings.length === 1 ? meanings[0] : void 0;
+  }
+  return meanings.some((meaning) => fieldSatisfies(declared, meaning)) ? declared : void 0;
+}
+
+// src/cli/described-tool.ts
+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 stringField(tool, "kind") === "monitor_type";
+}
+function playReferenceForTool(tool) {
+  const record = tool;
+  const declared = stringField(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, " "))}`;
+}
+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 toolContractJsonForDescribe(tool, requestedToolId, authoringContractEdition, seedStarterScript) {
+  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(
+    arrayField(toolExecutionResult, "extractedLists", "extracted_lists")
+  ).map((entry) => ({
+    ...entry,
+    returnType: _chunkKB4SDX5Sjs.playToolListGetterMode.call(void 0, authoringContractEdition) === "array" ? "Array" : "PlayDataset",
+    rowsExpression: _chunkKB4SDX5Sjs.playToolListGetterMode.call(void 0, authoringContractEdition) === "array" ? entry.expression : `await ${entry.expression}.materialize()`
+  }));
+  const extractedValues = extractionContractEntries(
+    arrayField(toolExecutionResult, "extractedValues", "extracted_values")
+  );
+  const pricing = _chunkZM2YPJQJjs.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 = stringField(
+    deprecation,
+    "replacementToolId",
+    "replacement_tool_id"
+  );
+  const deprecationMessage = stringField(deprecation, "message");
+  const deprecationExecution = stringField(deprecation, "execution");
+  const deprecated = tool.deprecated === true || stringField(tool, "credentialStatus", "credential_status") === "deprecated";
+  const starterScript = seedStarterScript && !deprecated && !isPlayLikeTool(tool) && extractedLists.length > 0 ? starterScriptJson(
+    seedStarterScript({
+      toolId,
+      payload: samplePayloadForInputFields(inputFields),
+      rows: []
+    })
+  ) : null;
+  const executeCommand = deprecated && replacementToolId ? `deepline tools execute ${replacementToolId} --input '{...}'` : isPlayLikeTool(tool) ? playRunCommandForTool(tool, toolId) : `deepline tools execute ${toolId} --input '{...}'`;
+  return {
+    schemaVersion: 1,
+    toolId,
+    provider: tool.provider,
+    displayName: tool.displayName,
+    cost: pricing,
+    description: tool.description,
+    ...Object.keys(guidance).length > 0 ? { guidance } : {},
+    categories: tool.categories,
+    ...Array.isArray(tool.requestWarnings) ? { requestWarnings: tool.requestWarnings } : {},
+    ...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 = stringField(entry, "name");
+    const expression = stringField(entry, "expression");
+    return name && expression ? [{ name, expression }] : [];
+  });
+}
+function schemaNodeAt(schema, path) {
+  let node = schema;
+  for (const part of path.split(".").filter(Boolean)) {
+    const [key, ...indexes] = part.split("[");
+    node = recordField(isRecord(node) ? node : {}, "properties")[key];
+    for (const _index of indexes)
+      node = isRecord(node) ? node.items : void 0;
+  }
+  return node;
+}
+var NAMED_VALUE_SHAPES = {
+  email_status: { shape: "EmailStatus", schema: _chunkNA4T3B62js.EMAIL_STATUS_JSON_SCHEMA },
+  job_change: { shape: "JobChange", schema: _chunkNA4T3B62js.JOB_CHANGE_JSON_SCHEMA }
+};
+function extractorValueType(name) {
+  if (!_chunkNA4T3B62js.isDeeplineExtractorTarget.call(void 0, name)) return void 0;
+  const definition = _chunkNA4T3B62js.DEEPLINE_EXTRACTOR_TARGET_DEFINITIONS[name];
+  if (definition.enum) {
+    return {
+      type: definition.enum.map((value2) => JSON.stringify(value2)).join(" | ")
+    };
+  }
+  const named = NAMED_VALUE_SHAPES[definition.valueKind];
+  if (!named) return { type: "string" };
+  const { type, fields } = _chunkBQR6UN3Cjs.schemaField.call(void 0, name, named.schema, true);
+  return { type, ...fields ? { fields } : {}, shape: named.shape };
+}
+function jsonSchemaOf(wrapper) {
+  return isRecord(wrapper.jsonSchema) ? wrapper.jsonSchema : wrapper;
+}
+function publicToolSchemas(tool) {
+  const scrubbed = (...keys) => {
+    const schema = recordField(tool, ...keys);
+    if (Object.keys(schema).length === 0) return null;
+    const cleaned = publicToolInputSchemaForDescribe(schema);
+    return isRecord(cleaned.jsonSchema) ? cleaned.jsonSchema : cleaned;
+  };
+  const responseSchema = scrubbed("responseSchema", "response_schema");
+  return {
+    inputSchema: scrubbed(
+      "inputSchema",
+      "input_schema",
+      "payload_schema",
+      "payloadSchema"
+    ),
+    outputSchema: scrubbed("outputSchema", "output_schema"),
+    ...responseSchema ? { responseSchema } : {}
+  };
+}
+function describedTool(tool, requestedToolId) {
+  const id = stringField(tool, "toolId") || requestedToolId;
+  const displayName = stringField(tool, "displayName") || void 0;
+  const description = stringField(tool, "bestFor", "best_for") || stringField(tool, "description") || void 0;
+  if (isMonitorTypeTool(tool)) {
+    return {
+      kind: "monitor_type",
+      id,
+      displayName,
+      description,
+      cost: stringField(recordField(tool, "pricing"), "displayText") || void 0,
+      guidance: [],
+      inputs: _chunkBQR6UN3Cjs.schemaFields.call(void 0, 
+        recordField(tool, "payload_schema", "payloadSchema")
+      ),
+      outputs: [],
+      runner: {
+        via: "monitor",
+        deploy: stringField(recordField(tool, "deploy"), "example") || `deepline monitors deploy '{"key":"...","tool":"${id}","payload":{...}}'`
+      }
+    };
+  }
+  const contract = toolContractJsonForDescribe(tool, requestedToolId);
+  const cost = recordField(contract, "cost");
+  const billing = stringField(cost, "billingSourceLabel");
+  const deprecation = recordField(contract, "deprecation");
+  const getters = recordField(contract, "getters");
+  const outputSchema = jsonSchemaOf(recordField(contract, "outputSchema"));
+  const toolResult = recordField(tool, "toolResult", "tool_result");
+  const getterDetails = (kind) => new Map(
+    arrayField(toolResult, kind).filter(isRecord).map((item) => [
+      stringField(item, "name"),
+      recordField(item, "details")
+    ])
+  );
+  const declared = recordField(tool, "extractors");
+  const getterOutputs = (kind, roots) => {
+    const details = getterDetails(kind);
+    return arrayField(getters, kind).filter(isRecord).map((entry) => {
+      const name = stringField(entry, "name");
+      const rawPaths = arrayField(
+        _nullishCoalesce(details.get(name), () => ( {})),
+        "rawToolOutputPaths"
+      ).map(String);
+      const paths = rawPaths.map(
+        (path) => path.replace(/^toolResponse\.raw\./, "")
+      );
+      const node = roots.flatMap((root) => paths.map((path) => schemaNodeAt(root, path))).find(isRecord);
+      const { fields, ...typed } = _chunkBQR6UN3Cjs.schemaField.call(void 0, name, node, true);
+      const valueType = stringField(_nullishCoalesce(details.get(name), () => ( {})), "valueType");
+      const deepline = kind === "extractedValues" ? extractorValueType(name) : void 0;
+      const known = typed.type !== "unknown" ? void 0 : kind === "extractedLists" ? { type: "object[]" } : deepline;
+      const means = kind === "extractedValues" ? fieldOfName(
+        name,
+        stringField(_nullishCoalesce(declared[name], () => ( {})), "means") || void 0
+      ) : void 0;
+      const field = {
+        ...typed,
+        ...means ? { means } : {},
+        // A normalized value has a named type instead of the response's
+        // shape; a normalized object is spelled out once under Types.
+        ..._optionalChain([deepline, 'optionalAccess', _2 => _2.shape]) ? deepline : valueType ? { type: valueType } : known ? known : fields ? { fields } : {},
+        // A list's row columns that matter are value getters of their own.
+        ...kind === "extractedLists" && fields ? { summarized: true } : {},
+        read: playResultExpression(entry),
+        ...rawPaths.length ? { paths: rawPaths } : {}
+      };
+      return { field, node };
+    });
+  };
+  const declaredLists = getterOutputs("extractedLists", [outputSchema]);
+  const lists = declaredLists.some(({ node }) => node) ? declaredLists.filter(({ node }) => node) : declaredLists;
+  const values = getterOutputs("extractedValues", [
+    outputSchema,
+    ...lists.map(({ node }) => _optionalChain([node, 'optionalAccess', _3 => _3.items]))
+  ]).map((value2) => {
+    if (!lists.length || !value2.field.paths) return value2;
+    const within = value2.field.paths.map(
+      (path) => path.replace(/^toolResponse\.raw\./, "")
+    );
+    const list = _nullishCoalesce(lists.find(
+      ({ node }) => within.some((path) => isRecord(schemaNodeAt(_optionalChain([node, 'optionalAccess', _4 => _4.items]), path)))
+    ), () => ( lists[0]));
+    return {
+      ...value2,
+      field: { ...value2.field, in: list.field.name, paths: within }
+    };
+  });
+  const playReference = isPlayLikeTool(tool) ? playReferenceForTool(tool) : null;
+  return {
+    kind: "tool",
+    id: String(contract.toolId),
+    displayName,
+    description,
+    cost: [
+      stringField(cost, "displayText"),
+      // "Free (free)" says the same thing twice.
+      billing.toLowerCase() === stringField(cost, "displayText").toLowerCase() ? "" : billing && `(${billing})`,
+      _chunkZM2YPJQJjs.observedMaxText.call(void 0, cost) && `\u2014 ${_chunkZM2YPJQJjs.observedMaxText.call(void 0, cost)}`
+    ].filter(Boolean).join(" ") || void 0,
+    guidance: [
+      ...contract.deprecated === true ? [`Deprecated. ${stringField(deprecation, "message")}`.trim()] : [],
+      ...Object.values(recordField(contract, "guidance")).filter(
+        (line) => typeof line === "string" && /[a-z0-9]/i.test(line)
+      )
+    ],
+    rateLimit: _chunkBQR6UN3Cjs.rateLimitSummary.call(void 0, 
+      recordField(contract, "executionMetadata").configuredRateLimits
+    ),
+    inputs: _chunkBQR6UN3Cjs.schemaFields.call(void 0, jsonSchemaOf(recordField(contract, "inputSchema"))),
+    outputs: [...lists, ...values].map(({ field }) => field),
+    rawResponse: _chunkBQR6UN3Cjs.schemaFields.call(void 0, outputSchema),
+    runner: playReference ? { via: "play", reference: playReference } : { via: "tool", toolId: String(contract.toolId) }
+  };
+}
+function sampleValueForField(field) {
+  const name = stringField(field, "name").toLowerCase();
+  const type = stringField(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 = stringField(field, "name");
+      if (!name) return [];
+      return [[name, sampleValueForField(field)]];
+    })
+  );
+}
+function playResultExpression(entry) {
+  return stringField(entry, "expression").replace(
+    /^toolExecutionResult\./,
+    "result."
+  );
+}
+function toolMetadataJsonForDescribe(tool, requestedToolId, seedStarterScript) {
+  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(
+    arrayField(toolExecutionResult, "extractedLists", "extracted_lists")
+  );
+  const starterScript = seedStarterScript && !isPlayLikeTool(tool) && extractedLists.length > 0 ? starterScriptJson(
+    seedStarterScript({
+      toolId,
+      payload: samplePayloadForInputFields(inputFields),
+      rows: []
+    })
+  ) : null;
+  const observedOutputCommand = isPlayLikeTool(tool) ? playRunCommandForTool(tool, toolId) : `deepline tools execute ${toolId} --input '{...}'`;
+  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,
+    // BYOK is shown only on request, via describe --feature byok.
+    byok: _byok,
+    ...publicTool
+  } = tool;
+  const outputSchemaRecord = recordField(tool, "outputSchema", "output_schema");
+  return {
+    cost: _chunkZM2YPJQJjs.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`, 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,
+      extractedValues: {
+        expression: "toolExecutionResult.extractedValues.<name>.get()",
+        meaning: "Declared Deepline scalar or normalized object extractors only."
+      },
+      ...existingAccess,
+      extractedLists: {
+        ...recordField(existingAccess, "extractedLists"),
+        expression: "toolExecutionResult.extractedLists.<name>.get()",
+        meaning: _chunkKB4SDX5Sjs.playToolListGetterMode.call(void 0, ) === "array" ? "Returns an ordinary array from this response. Use array methods directly or pass it to ctx.dataset to persist row work. Lazy or incomplete lists throw; use readList for an explicit dataset read. It does not fetch provider pages." : "Returns a PlayDataset, not a JavaScript array. Pass the handle to ctx.dataset, use first(), async iteration, or await handle.materialize() for the complete current list within the memory cap. materialize(n) and peek(n) return a prefix; none fetch additional provider pages. A missing getter is not an empty list."
+      },
+      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 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', _5 => _5.minItems]);
+      const maxItems = typeof field.maxItems === "number" ? field.maxItems : _optionalChain([jsonSchemaField, 'optionalAccess', _6 => _6.maxItems]);
+      const items = isRecord(field.items) ? field.items : _optionalChain([jsonSchemaField, 'optionalAccess', _7 => _7.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, value2]) => {
+    const property = isRecord(value2) ? value2 : {};
+    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 canonicalToolJsonSchema(inputSchema) {
+  return isRecord(inputSchema.jsonSchema) ? inputSchema.jsonSchema : 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 = (value2) => {
+    if (Array.isArray(value2)) return value2.map(stripDescriptions);
+    if (!isRecord(value2)) return value2;
+    return Object.fromEntries(
+      Object.entries(value2).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 = (value2) => {
+    if (Array.isArray(value2)) {
+      for (const item of value2) collectSchemaIds(item);
+      return;
+    }
+    if (!isRecord(value2)) return;
+    if (typeof value2.$id === "string" && value2.$id.trim()) {
+      schemasById.set(value2.$id.trim(), value2);
+    }
+    for (const nested of Object.values(value2)) 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, value2] of Object.entries(properties)) {
+      if (!isRecord(value2)) continue;
+      visit(
+        value2,
+        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 isRecord(value2) {
+  return Boolean(value2 && typeof value2 === "object" && !Array.isArray(value2));
+}
+function stringField(source, ...keys) {
+  for (const key of keys) {
+    const value2 = source[key];
+    if (typeof value2 === "string" && value2.trim()) return value2.trim();
+  }
+  return "";
+}
+function arrayField(source, ...keys) {
+  for (const key of keys) {
+    const value2 = source[key];
+    if (Array.isArray(value2)) return value2;
+  }
+  return [];
+}
+function recordField(source, ...keys) {
+  for (const key of keys) {
+    const value2 = source[key];
+    if (isRecord(value2)) return value2;
+  }
+  return {};
+}
+function starterScriptJson(script) {
+  return {
+    path: script.path,
+    sourceCode: script.sourceCode,
+    projectDir: script.projectDir,
+    copyToProject: {
+      macosLinux: script.macCopyCommand,
+      windowsPowerShell: script.windowsCopyCommand
+    }
+  };
+}
+
+// src/cli/commands/model-description.ts
+function formatModelDescription(description) {
+  const lines = [];
+  lines.push(description.model);
+  lines.push(`Provider: ${description.provider}`);
+  const name = stringField2(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 = arrayField2(description.modelMetadata, "tags").filter(
+    (value2) => typeof value2 === "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', _8 => _8.enumValues, 'optionalAccess', _9 => _9.length]) ? ` (${field.enumValues.map((value2) => JSON.stringify(value2)).join(" | ")})` : "";
+    lines.push(
+      `  - ${field.name}: ${field.type}${values} - ${field.description}`
+    );
+  }
+}
+function stringField2(value2, key) {
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) return null;
+  const candidate = value2[key];
+  return typeof candidate === "string" && candidate.trim() ? candidate.trim() : null;
+}
+function numberField(value2, key) {
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) return null;
+  const candidate = value2[key];
+  return typeof candidate === "number" ? candidate : null;
+}
+function arrayField2(value2, key) {
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) return [];
+  const candidate = value2[key];
+  return Array.isArray(candidate) ? candidate : [];
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.isPlayLikeTool = isPlayLikeTool; exports.isMonitorTypeTool = isMonitorTypeTool; exports.playReferenceForTool = playReferenceForTool; exports.playSearchCommandForToolId = playSearchCommandForToolId; exports.playRunCommandForTool = playRunCommandForTool; exports.toolContractJsonForDescribe = toolContractJsonForDescribe; exports.publicToolSchemas = publicToolSchemas; exports.describedTool = describedTool; exports.samplePayloadForInputFields = samplePayloadForInputFields; exports.playResultExpression = playResultExpression; exports.toolMetadataJsonForDescribe = toolMetadataJsonForDescribe; exports.toolInputFieldsForDisplay = toolInputFieldsForDisplay; exports.toolOutputFieldsForDisplay = toolOutputFieldsForDisplay; exports.recursiveToolInputFieldsForDisplay = recursiveToolInputFieldsForDisplay; exports.isRecord = isRecord; exports.stringField = stringField; exports.arrayField = arrayField; exports.recordField = recordField; exports.formatModelDescription = formatModelDescription;