@sixb/core 0.1.7 → 0.1.9

package/src/lake-storage/source-ordering.ts

@@ -0,0 +1,95 @@
+import { createHash } from "node:crypto"
+import type { DatasetDefinition, MergeChange } from "../datasets"
+import { datasetSequenceValue } from "../datasets/sequence"
+import { stableJsonStringify } from "../json"
+import { normalizeDecimalValue } from "../ontology/decimal"
+import { LakeStorageError } from "./errors"
+import { encodeDatasetPrimaryKey } from "./merge-validation"
+import type { DatasetRow } from "./types"
+
+/** Current source revision; a null content digest is a deletion tombstone. */
+export interface DatasetSequenceState {
+  readonly sequence: string
+  readonly content: string | null
+}
+
+export interface DatasetSequenceChange extends DatasetSequenceState {
+  readonly key: string
+}
+
+export function datasetSequenceChange(
+  dataset: DatasetDefinition,
+  change: MergeChange<DatasetRow, DatasetRow>
+): DatasetSequenceChange {
+  const value = change.kind === "upsert" ? change.row[dataset.sequenceBy ?? ""] : change.sequence
+  return {
+    key: encodeDatasetPrimaryKey(dataset, change.kind === "upsert" ? change.row : change.key),
+    sequence: datasetSequenceValue(dataset, value).toString(),
+    content: change.kind === "delete" ? null : rowDigest(dataset, change.row),
+  }
+}
+
+/** Process in submission order against a private copy; conflicts publish no partial state. */
+export function reconcileDatasetSequences(
+  dataset: DatasetDefinition,
+  previous: ReadonlyMap<string, DatasetSequenceState>,
+  changes: readonly DatasetSequenceChange[]
+): { states: Map<string, DatasetSequenceState>; accepted: Map<string, number> } {
+  const states = new Map(previous)
+  const accepted = new Map<string, number>()
+  for (const [index, change] of changes.entries()) {
+    const current = states.get(change.key)
+    if (current) {
+      const difference = BigInt(change.sequence) - BigInt(current.sequence)
+      if (difference < 0n) continue
+      if (difference === 0n) {
+        if (current.content !== change.content) {
+          throw new LakeStorageError(
+            `[SixbLake] Dataset '${dataset.id}' has conflicting content at source sequence '${change.sequence}' for key ${change.key}.`
+          )
+        }
+        continue
+      }
+    }
+    states.set(change.key, { sequence: change.sequence, content: change.content })
+    accepted.set(change.key, index)
+  }
+  return { states, accepted }
+}
+
+function rowDigest(dataset: DatasetDefinition, row: DatasetRow): string {
+  const content: Record<string, unknown> = Object.create(null)
+  for (const column of dataset.schema.columns) {
+    const value = row[column.name]
+    // Nullable additions and omitted/undefined/null values have identical content.
+    if (value == null) continue
+    switch (column.type) {
+      case "int64":
+        content[column.name] = BigInt(value as string | number).toString()
+        break
+      case "timestamp":
+        content[column.name] = new Date(value as string | Date).toISOString()
+        break
+      case "date":
+        content[column.name] = new Date(value as string | Date).toISOString().slice(0, 10)
+        break
+      case "decimal":
+        content[column.name] = normalizeDecimalValue(value as string)
+        break
+      default:
+        content[column.name] = value
+    }
+  }
+  return createHash("sha256")
+    .update(stableJsonStringify(JSON.parse(JSON.stringify(content))))
+    .digest("hex")
+}
+
+/** Until row reconciliation is supported, replacement writes must not erase source history. */
+export function assertUnsequencedDatasetWrite(dataset: DatasetDefinition): void {
+  if (dataset.sequenceBy !== undefined) {
+    throw new LakeStorageError(
+      `[SixbLake] Dataset '${dataset.id}' declares sequenceBy; use beginMerge with source-ordered changes.`
+    )
+  }
+}

package/src/lake-storage/sql-transforms.ts

@@ -39,7 +39,8 @@ export interface ExecuteSqlTransformInput<TSqlDialect extends SqlDialect = SqlDi
   readonly target: DatasetDefinition
   readonly mode: DatasetWriteMode
   readonly producer?: DatasetProducer
-  readonly expectedLatestVersionId?: string
+  /** Atomic target version guard; null requires that no version exists. */
+  readonly expectedLatestVersionId?: string | null
   readonly commitMessage?: string
 }
 

package/src/lake-storage/types.ts

@@ -19,7 +19,8 @@ export interface DatasetVersionRef {
 }
 
 export interface DatasetProducer {
-  readonly kind: "sync" | "pipeline"
+  readonly kind: "sync" | "pipeline" | "ingest"
+  /** For ingestion, the bound execution id; otherwise the sync/pipeline definition id. */
   readonly id?: string
   readonly runId?: string
   readonly stepId?: string
@@ -73,7 +74,8 @@ export interface ReadDatasetRowsInput {
 }
 
 export interface CommitDatasetWriteInput {
-  readonly expectedLatestVersionId?: string
+  /** Atomic version guard; null requires that no version exists, undefined leaves it unguarded. */
+  readonly expectedLatestVersionId?: string | null
   readonly commitMessage?: string
 }
 
@@ -81,11 +83,14 @@ export interface DatasetWriteCommitResult extends DatasetVersion {
   /**
    * Whether this operation created the returned version or reused the
    * unchanged latest version. When a latest version exists, providers must
-   * report `unchanged` and reuse it for commits that cannot change visible
-   * dataset content: a snapshot whose rows equal the latest visible rows
+   * report `unchanged` and reuse it for commits that change neither visible
+   * dataset content nor explicitly supplied input lineage: a snapshot whose
+   * rows equal the latest visible rows
    * (order-insensitive, with equal duplicate counts), or an append of zero
    * rows. Without a latest version, an empty snapshot or append still creates
-   * the first addressable dataset version.
+   * the first addressable dataset version. New input versions create a version
+   * even for identical rows, so a newer pipeline calculation fences concurrent
+   * work based on older inputs.
    */
   readonly outcome: "created" | "unchanged"
 }

package/src/lake-storage/version-inputs.ts

@@ -0,0 +1,14 @@
+import type { DatasetVersionRef } from "./types"
+
+/** Input lineage participates in write identity when the caller supplies it. */
+export function hasDatasetInputChanges(
+  previous: readonly DatasetVersionRef[] | undefined,
+  next: readonly DatasetVersionRef[] | undefined
+): boolean {
+  if (next === undefined) return false
+  const keys = (refs: readonly DatasetVersionRef[]) =>
+    new Set(refs.map((ref) => JSON.stringify([ref.datasetId, ref.versionId])))
+  const before = keys(previous ?? [])
+  const after = keys(next)
+  return before.size !== after.size || [...after].some((key) => !before.has(key))
+}

package/src/logging/index.ts

@@ -1,25 +1,5 @@
-export {
-  ConsoleLogger,
-  type ConsoleLoggerOptions,
-  noopLogger,
-  noopLoggerProvider,
-} from "./console-logger"
-export {
-  LoggingService,
-  type LoggingServiceOptions,
-  type LogsObservabilityOptions,
-  type LogsPage,
-  type LogsReadInput,
-  type LogsSubscribeInput,
-  type LogsTailInput,
-  type ObservabilityOptions,
-  resolveLoggingService,
-} from "./service"
-export {
-  DEFAULT_LOGS_MAX_BYTES,
-  DEFAULT_LOGS_RETENTION,
-  LOGS_STREAM,
-} from "./stream"
+/** Browser-safe logging contracts and record readers. */
+export type * from "./types"
 export {
   isLevelEnabled,
   isLogLevel,
@@ -27,17 +7,6 @@ export {
   isSixbRunKind,
   isStoredLogLine,
   LOG_LEVELS,
-  type LogContext,
-  type LogEntry,
-  type LogFields,
-  type Logger,
-  type LoggerProvider,
-  type LogLevel,
-  type LogRecord,
-  type LogRunRef,
   logLevelsAtOrAbove,
-  normalizeLogError,
   SIXB_RUN_KINDS,
-  type SixbRunKind,
-  type StoredLogLine,
 } from "./types"

package/src/logging/internal.ts

@@ -0,0 +1,43 @@
+export {
+  ConsoleLogger,
+  type ConsoleLoggerOptions,
+  noopLogger,
+  noopLoggerProvider,
+} from "./console-logger"
+export {
+  LoggingService,
+  type LoggingServiceOptions,
+  type LogsObservabilityOptions,
+  type LogsPage,
+  type LogsReadInput,
+  type LogsSubscribeInput,
+  type LogsTailInput,
+  type ObservabilityOptions,
+  resolveLoggingService,
+} from "./service"
+export {
+  DEFAULT_LOGS_MAX_BYTES,
+  DEFAULT_LOGS_RETENTION,
+  LOGS_STREAM,
+} from "./stream"
+export {
+  isLevelEnabled,
+  isLogLevel,
+  isLogRecord,
+  isSixbRunKind,
+  isStoredLogLine,
+  LOG_LEVELS,
+  type LogContext,
+  type LogEntry,
+  type LogFields,
+  type Logger,
+  type LoggerProvider,
+  type LogLevel,
+  type LogRecord,
+  type LogRunRef,
+  logLevelsAtOrAbove,
+  normalizeLogError,
+  SIXB_RUN_KINDS,
+  type SixbRunKind,
+  type StoredLogLine,
+} from "./types"

package/src/models/errors.ts

@@ -43,6 +43,18 @@ export class ModelStreamError extends Error {
 
 export class UnsupportedModelFeatureError extends Error {
   readonly name = "UnsupportedModelFeatureError"
+
+  constructor(
+    message?: string,
+    options?: ErrorOptions & {
+      readonly reason?: "unsupported-model" | "unsupported-schema"
+    }
+  ) {
+    super(message, options)
+    this.reason = options?.reason
+  }
+
+  readonly reason?: "unsupported-model" | "unsupported-schema"
 }
 
 export class StructuredOutputError extends Error {

package/src/models/execution/binding.ts

@@ -0,0 +1,29 @@
+import type { ModelsRuntime } from "../generation-types"
+
+export interface ModelExecutionAttempt {
+  readonly attempt: number
+  readonly signal: AbortSignal
+}
+
+const bindings = new WeakMap<ModelsRuntime, (input: ModelExecutionAttempt) => void>()
+
+export function registerModelExecutionBinding(
+  models: ModelsRuntime,
+  bind: (input: ModelExecutionAttempt) => void
+): void {
+  bindings.set(models, bind)
+}
+
+/** Called once on a fresh facade at the request or worker delivery boundary. */
+export function bindModelExecutionAttempt(
+  models: ModelsRuntime,
+  input: ModelExecutionAttempt
+): void {
+  const bind = bindings.get(models)
+  if (!bind) throw new Error("[SixbModels] Model runtime has no execution binding.")
+  if (!Number.isSafeInteger(input.attempt) || input.attempt < 1) {
+    throw new TypeError("[SixbModels] Execution attempt must be a positive safe integer.")
+  }
+  bind(input)
+  bindings.delete(models)
+}

package/src/models/execution/errors.ts

@@ -0,0 +1,18 @@
+/** A provider call was not recorded synchronously, so its execution must stop. */
+export class ModelUsageRecordingError extends Error {
+  readonly name = "ModelUsageRecordingError"
+
+  constructor(
+    readonly executionId: string,
+    readonly callId: string,
+    readonly recoveryScheduled: boolean,
+    options?: ErrorOptions
+  ) {
+    super(
+      recoveryScheduled
+        ? `[SixbModels] AI usage for call '${callId}' in execution '${executionId}' was deferred to durable recovery.`
+        : `[SixbModels] Could not preserve AI usage for call '${callId}' in execution '${executionId}'.`,
+      options
+    )
+  }
+}

package/src/models/execution/index.ts

@@ -0,0 +1,26 @@
+export { resolveLanguageModel } from "../resolve"
+export { ModelUsageRecordingError } from "./errors"
+export type {
+  AiModelCallAdmissionDecision,
+  AiModelCallAdmissionInput,
+  AiModelCallInputTokenEstimate,
+  BeforeAiModelCall,
+  MarkAiModelCallUnknown,
+} from "./model-call-admission"
+export type { AiModelCallLimitController } from "./model-call-limits"
+export { createAiModelCallLimitController } from "./model-call-limits"
+export type { AiModelCallRecorderInput } from "./model-call-recorder"
+export { AiModelCallRecorder } from "./model-call-recorder"
+export {
+  isPermanentAiUsageRecoveryError,
+  recordRecoveredAiModelCall,
+} from "./model-call-recovery"
+export { enqueueAiModelCallRecovery } from "./recovery-queue"
+export type {
+  AiModelCallAccountingPayload,
+  AiModelCallRecordPayload,
+  AiModelCallRecoveryRecord,
+  ModelCallAccountingStorage,
+  RecoverAiModelCall,
+  RecoverAiModelCallInput,
+} from "./types"

package/src/models/execution/model-call-accounting.ts

@@ -0,0 +1,211 @@
+import { createHash } from "node:crypto"
+import { assertJsonObject } from "../../json"
+import type {
+  AiBillableMeter,
+  AiCostStorage,
+  AiLimitStorage,
+  AiModelCallCostRecord,
+  AiModelCallUsageRecord,
+  AiPricingContext,
+  AiUsageStorage,
+  RecordAiModelCallResult,
+  Storage,
+} from "../../storage"
+import {
+  aiModelCallCostMatchesUsage,
+  normalizeAiModelCallCostRecord,
+} from "../../storage/ai-cost/provider"
+import { normalizeAiModelCallRecord } from "../../storage/ai-usage/record"
+import type { ModelCostEstimate } from "../pricing"
+import type { ModelCallAccountingStorage, RecoverAiModelCallInput } from "./types"
+
+interface RecordAiModelCallAccountingInput extends RecoverAiModelCallInput {
+  readonly storage: Pick<ModelCallAccountingStorage, "transaction">
+}
+
+interface AiAccountingCapabilities {
+  readonly aiUsage: AiUsageStorage
+  readonly aiCosts: AiCostStorage
+  readonly aiLimits: AiLimitStorage
+}
+
+/** Atomically append one provider call's usage and the valuation captured by the model runtime. */
+export async function recordAiModelCallAccounting(
+  input: RecordAiModelCallAccountingInput
+): Promise<RecordAiModelCallResult> {
+  return input.storage.transaction(async (tx) => {
+    const { aiUsage, aiCosts, aiLimits } = requireAccountingCapabilities(tx)
+    const usage = await aiUsage.recordModelCall(input.usage)
+    // Usage deduplicates provider lifecycle replays by execution/call identity. Always attach the
+    // valuation to the canonical row it returns, not the fresh candidate ID from a replay.
+    const canonical = normalizeModelCallAccounting({
+      ...input,
+      usage: usage.record,
+      ratedAt: usage.record.recordedAt,
+    })
+    const record = modelCostRecord(canonical, usage.record.id)
+    const estimate =
+      canonical.cost.status !== "reported" || canonical.estimate === undefined
+        ? undefined
+        : modelCostRecord({ ...canonical, cost: canonical.estimate }, usage.record.id)
+    await aiCosts.recordModelCallCost({
+      ...record,
+      ...(estimate === undefined
+        ? {}
+        : {
+            estimate:
+              estimate.status === "rated"
+                ? { status: "rated", money: estimate.money, components: estimate.components }
+                : {
+                    status: "unpriceable",
+                    reason: estimate.reason,
+                    ...(estimate.missingMeters === undefined
+                      ? {}
+                      : { missingMeters: estimate.missingMeters }),
+                  },
+          }),
+    })
+    if (usage.created) {
+      await aiLimits.recordModelCallActuals({
+        projectId: usage.record.projectId,
+        usageRecordId: usage.record.id,
+        recordedAt: input.ratedAt,
+      })
+    }
+    if (input.reconcileLimitReservation) {
+      await aiLimits.reconcileModelCall({
+        projectId: usage.record.projectId,
+        executionId: usage.record.executionId,
+        attempt: usage.record.attempt,
+        callId: usage.record.callId,
+        usageRecordId: usage.record.id,
+        reconciledAt: input.ratedAt,
+      })
+    }
+    return usage
+  })
+}
+
+/** Sanitize optional enrichment before either persistence or a JSON-safe recovery handoff. */
+export function normalizeModelCallAccounting(
+  input: RecoverAiModelCallInput
+): RecoverAiModelCallInput {
+  const usage = normalizeAiModelCallRecord(input.usage)
+  return {
+    ...input,
+    cost:
+      input.cost.status === "reported" ? input.cost : validatedEstimate(input.cost, input, usage),
+    ...(input.estimate === undefined
+      ? {}
+      : { estimate: validatedEstimate(input.estimate, input, usage) }),
+  }
+}
+
+function validatedEstimate(
+  cost: ModelCostEstimate,
+  input: RecoverAiModelCallInput,
+  usage: AiModelCallUsageRecord
+): ModelCostEstimate {
+  try {
+    assertJsonObject(cost, "model cost estimate")
+    const record = normalizeAiModelCallCostRecord(modelCostRecord({ ...input, cost }, usage.id))
+    if (!aiModelCallCostMatchesUsage(record, usage)) {
+      throw new TypeError("Estimate quantities do not match recorded usage.")
+    }
+    return structuredClone(cost)
+  } catch {
+    console.warn(
+      "[SixbModels] Invalid model cost estimate; preserving call usage and provider cost."
+    )
+    return { status: "unpriceable", reason: "inconsistent-usage" }
+  }
+}
+
+function modelCostRecord(
+  input: RecoverAiModelCallInput,
+  usageRecordId: string
+): AiModelCallCostRecord {
+  const billingIdentity = {
+    providerId: input.usage.providerId,
+    modelId: input.usage.requestedModelId,
+  }
+  const pricingContext: AiPricingContext = {
+    ...(input.route?.providerId === undefined ? {} : { routedProviderId: input.route.providerId }),
+    ...(input.route?.modelId === undefined ? {} : { routedModelId: input.route.modelId }),
+  }
+  if (input.cost.status === "reported" || input.cost.status === "rated") {
+    return {
+      projectId: input.usage.projectId,
+      usageRecordId,
+      status: "rated",
+      billingIdentity,
+      pricingContext,
+      priceSource: costPriceSource(input.usage, input.cost),
+      money: input.cost.money,
+      components: input.cost.status === "rated" ? input.cost.components : [],
+      ratedAt: new Date(input.ratedAt),
+    }
+  }
+
+  const reason =
+    input.cost.reason === "missing-rate-card"
+      ? "missingRateCard"
+      : input.cost.reason === "missing-usage"
+        ? "missingUsageMeter"
+        : "invalidUsageForFormula"
+  const missingMeters =
+    reason === "missingUsageMeter" ? normalizeMissingMeters(input.cost.missingMeters) : undefined
+  return {
+    projectId: input.usage.projectId,
+    usageRecordId,
+    status: "unpriceable",
+    billingIdentity,
+    pricingContext,
+    reason,
+    ...(missingMeters === undefined ? {} : { missingMeters }),
+    ratedAt: new Date(input.ratedAt),
+  }
+}
+
+function costPriceSource(
+  usage: RecoverAiModelCallInput["usage"],
+  cost: Extract<RecoverAiModelCallInput["cost"], { status: "reported" | "rated" }>
+) {
+  if (cost.status === "reported") {
+    return {
+      sourceId: "provider-reported",
+      sourceEntryId: `${usage.providerId}/${usage.responseId}`,
+      sourceVersion: "response-v1",
+      observedAt: new Date(usage.occurredAt),
+    }
+  }
+  const rates = cost.components.map(({ meter, rateAmountNanosPerMillion }) => ({
+    meter,
+    rateAmountNanosPerMillion,
+  }))
+  const version = createHash("sha256").update(JSON.stringify(rates)).digest("hex")
+  return {
+    sourceId: "model-rate-card",
+    sourceEntryId: `${usage.providerId}/${usage.requestedModelId}`,
+    sourceVersion: `sha256:${version}`,
+    observedAt: new Date(usage.occurredAt),
+  }
+}
+
+function normalizeMissingMeters(
+  meters: Extract<RecoverAiModelCallInput["cost"], { status: "unpriceable" }>["missingMeters"]
+): readonly AiBillableMeter[] {
+  const fallback: readonly AiBillableMeter[] = ["tokens.input.total", "tokens.output.total"]
+  return [...new Set<AiBillableMeter>(meters ?? fallback)]
+}
+
+export function requireAccountingCapabilities(
+  storage: Pick<Storage, "aiUsage" | "aiCosts" | "aiLimits">
+): AiAccountingCapabilities {
+  if (!storage.aiUsage || !storage.aiCosts || !storage.aiLimits) {
+    throw new Error(
+      "[SixbModels] AI model-call accounting requires storage.aiUsage, storage.aiCosts, and storage.aiLimits."
+    )
+  }
+  return { aiUsage: storage.aiUsage, aiCosts: storage.aiCosts, aiLimits: storage.aiLimits }
+}

package/src/models/execution/model-call-admission.ts

@@ -0,0 +1,127 @@
+import type { AiModelCallReservationIdentity } from "../../storage"
+import type { ModelCostEstimator } from "../pricing"
+
+/** Default output ceiling when a call and its resolved model supply no limit. */
+export const AI_MODEL_CALL_OUTPUT_TOKEN_ALLOWANCE = 4_096
+
+export type AiModelCallInputTokenEstimate =
+  | {
+      readonly status: "estimated"
+      readonly tokens: number
+      readonly method: "utf8BytesDividedByFour"
+    }
+  | {
+      readonly status: "unavailable"
+      readonly reason: "nonTextInput" | "unserializableInput"
+    }
+
+/** Provider-neutral snapshot passed to aggregate-budget admission before a provider request. */
+export interface AiModelCallAdmissionInput {
+  readonly projectId: string
+  readonly executionId: string
+  readonly attempt: number
+  readonly requesterGroupIds: readonly string[]
+  readonly callId: string
+  readonly providerId: string
+  readonly modelId: string
+  readonly costEstimator?: ModelCostEstimator
+  readonly inputTokens: AiModelCallInputTokenEstimate
+  readonly outputTokenAllowance: number
+  readonly estimatedTotalTokens?: number
+}
+
+export interface AiModelCallAdmissionDecision {
+  /** Active means accounting must reconcile the reservation for this provider attempt. */
+  readonly reservation: "active" | "none"
+}
+
+export type BeforeAiModelCall = (
+  input: AiModelCallAdmissionInput
+) => AiModelCallAdmissionDecision | Promise<AiModelCallAdmissionDecision>
+
+export type MarkAiModelCallUnknown = (input: AiModelCallReservationIdentity) => void | Promise<void>
+
+/**
+ * Estimate the exact, prepared provider request without requiring a provider-specific tokenizer.
+ *
+ * The heuristic is intentionally explicit so reservations are reproducible. Non-text inputs are
+ * reported as unavailable; an enforced token or cost policy can then fail closed instead of
+ * pretending that an image, file, or provider-defined payload has no token cost.
+ */
+export function estimateAiModelCallInputTokens(input: {
+  readonly prompt: unknown
+  readonly tools: unknown
+  readonly responseFormat: unknown
+}): AiModelCallInputTokenEstimate {
+  if (containsNonTextInput(input.prompt)) {
+    return { status: "unavailable", reason: "nonTextInput" }
+  }
+
+  let serialized: string | undefined
+  try {
+    serialized = JSON.stringify(input)
+  } catch {
+    return { status: "unavailable", reason: "unserializableInput" }
+  }
+  if (serialized === undefined) {
+    return { status: "unavailable", reason: "unserializableInput" }
+  }
+
+  const bytes = new TextEncoder().encode(serialized).byteLength
+  return {
+    status: "estimated",
+    tokens: Math.ceil(bytes / 4),
+    method: "utf8BytesDividedByFour",
+  }
+}
+
+export function aiModelCallOutputTokenAllowance(maxOutputTokens: number | undefined): number {
+  if (maxOutputTokens === undefined) return AI_MODEL_CALL_OUTPUT_TOKEN_ALLOWANCE
+  if (!Number.isSafeInteger(maxOutputTokens) || maxOutputTokens <= 0) {
+    throw new TypeError(
+      "[SixbModels] AI model-call maxOutputTokens must be a positive safe integer."
+    )
+  }
+  return maxOutputTokens
+}
+
+export function estimatedAiModelCallTotalTokens(
+  inputTokens: AiModelCallInputTokenEstimate,
+  outputTokenAllowance: number
+): number | undefined {
+  if (inputTokens.status !== "estimated") return undefined
+  const total = inputTokens.tokens + outputTokenAllowance
+  if (!Number.isSafeInteger(total)) {
+    throw new TypeError("[SixbModels] AI model-call token estimate exceeds the safe range.")
+  }
+  return total
+}
+
+function containsNonTextInput(value: unknown, seen = new WeakSet<object>()): boolean {
+  if (value === null || typeof value !== "object") return false
+  if (
+    value instanceof URL ||
+    value instanceof ArrayBuffer ||
+    ArrayBuffer.isView(value) ||
+    (typeof Blob !== "undefined" && value instanceof Blob)
+  ) {
+    return true
+  }
+  if (seen.has(value)) return false
+  seen.add(value)
+
+  if (!Array.isArray(value)) {
+    const type = Reflect.get(value, "type")
+    if (
+      type === "image" ||
+      type === "file" ||
+      type === "reasoning-file" ||
+      type === "custom" ||
+      type === "provider-state"
+    ) {
+      return true
+    }
+  }
+
+  return Object.values(value).some((entry) => containsNonTextInput(entry, seen))
+}