@simulatte/doppler 0.1.8 → 0.2.0

package/src/inference/pipelines/energy-head/row-head-pipeline.js

@@ -1,491 +0,0 @@
-import { getDevice, getKernelCapabilities } from '../../../gpu/device.js';
-import { createTensor, dtypeBytes } from '../../../gpu/tensor.js';
-import { acquireBuffer, releaseBuffer, readBuffer } from '../../../memory/buffer-pool.js';
-import { runEnergyEval, runEnergyUpdate } from '../../../gpu/kernels/index.js';
-import { log } from '../../../debug/index.js';
-import { f16ToF32Array, f32ToF16Array } from '../../kv-cache/types.js';
-import { registerPipeline } from '../registry.js';
-import { applyPipelineContexts, restorePipelineContexts } from '../context.js';
-import { createInitializedPipeline } from '../factory.js';
-import { selectRuleValue } from '../../../rules/rule-registry.js';
-
-const ENERGY_ROW_HEAD_MODEL_TYPES = Object.freeze([
-  'energy_row_head',
-  'energy-row-head',
-  'dream_energy_head',
-  'dream-energy-head',
-  'd1-to2-bridge-diffusion',
-  'synthesis-mixer-diffusion',
-  'ebrm-diffusion',
-]);
-
-const DEFAULT_INFER_CONFIG = Object.freeze({
-  backend: 'auto',
-  dtype: 'f32',
-  steps: 3,
-  stepSize: 0.08,
-  gradientScale: 1,
-  energyScale: 1,
-});
-
-function isObj(value) {
-  return !!value && typeof value === 'object' && !Array.isArray(value);
-}
-
-function toFinite(value, fallback = 0) {
-  const n = Number(value);
-  return Number.isFinite(n) ? n : fallback;
-}
-
-function clamp01(value) {
-  return Math.max(0, Math.min(1, toFinite(value, 0)));
-}
-
-function sigmoid(value) {
-  if (value >= 30) return 1;
-  if (value <= -30) return 0;
-  return 1 / (1 + Math.exp(-value));
-}
-
-function dot(a, b) {
-  let out = 0;
-  for (let i = 0; i < a.length; i++) {
-    out += a[i] * b[i];
-  }
-  return out;
-}
-
-function normalizeMainHead(model) {
-  const featureIds = Array.isArray(model?.featureIds) ? model.featureIds.map(String) : [];
-  const weights = Array.isArray(model?.weights) ? model.weights.map((value) => toFinite(value, 0)) : [];
-  if (!featureIds.length || !weights.length || weights.length !== featureIds.length) {
-    throw new Error('EnergyRowHeadPipeline.loadModel: featureIds/weights mismatch.');
-  }
-  return {
-    featureIds,
-    weights: new Float32Array(weights),
-    bias: toFinite(model?.bias, 0),
-    scale: 1,
-  };
-}
-
-function normalizeAuxHead(head) {
-  const featureIds = Array.isArray(head?.featureIds) ? head.featureIds.map(String) : [];
-  const weights = Array.isArray(head?.weights) ? head.weights.map((value) => toFinite(value, 0)) : [];
-  if (!featureIds.length || !weights.length || weights.length !== featureIds.length) {
-    return null;
-  }
-  return {
-    featureIds,
-    weights: new Float32Array(weights),
-    bias: toFinite(head?.bias, 0),
-    scale: Number.isFinite(head?.scale) ? Number(head.scale) : 1,
-  };
-}
-
-function normalizeModelManifest(manifest) {
-  const modelType = String(manifest?.modelType || '');
-  if (!ENERGY_ROW_HEAD_MODEL_TYPES.includes(modelType)) {
-    throw new Error(`EnergyRowHeadPipeline.loadModel: unsupported modelType "${modelType}".`);
-  }
-
-  const mainHead = normalizeMainHead(manifest);
-  const localHead = normalizeAuxHead(manifest?.localHead);
-  const treeHead = normalizeAuxHead(manifest?.treeHead);
-  const consistencyHead = normalizeAuxHead(manifest?.consistencyHead);
-  return {
-    modelType,
-    modelId: String(manifest?.modelId || 'energy-row-head'),
-    modelHash: manifest?.modelHash || null,
-    mainHead,
-    localHead,
-    treeHead,
-    consistencyHead,
-  };
-}
-
-function resolveHead(model, headId) {
-  const id = String(headId || 'main');
-  if (id === 'main') return model.mainHead;
-  if (id === 'local') {
-    if (!model.localHead) throw new Error('EnergyRowHeadPipeline: local head unavailable in model.');
-    return model.localHead;
-  }
-  if (id === 'tree') {
-    if (!model.treeHead) throw new Error('EnergyRowHeadPipeline: tree head unavailable in model.');
-    return model.treeHead;
-  }
-  if (id === 'consistency') {
-    if (!model.consistencyHead) {
-      throw new Error('EnergyRowHeadPipeline: consistency head unavailable in model.');
-    }
-    return model.consistencyHead;
-  }
-  throw new Error(`EnergyRowHeadPipeline: unsupported head "${id}".`);
-}
-
-function resolveActivation({ modelType, headId, activation }) {
-  if (typeof activation === 'string' && activation) return activation;
-  if (String(modelType).includes('ebrm') && ['main', 'local', 'tree', 'consistency'].includes(String(headId || 'main'))) {
-    return 'linear';
-  }
-  return 'sigmoid';
-}
-
-function alignFeatureVector(row, head) {
-  if (Array.isArray(row?.features)) {
-    if (row.features.length !== head.featureIds.length) {
-      throw new Error('EnergyRowHeadPipeline.scoreRows: features length mismatch.');
-    }
-    return new Float32Array(row.features.map((value) => toFinite(value, 0)));
-  }
-  if (isObj(row?.features)) {
-    return new Float32Array(
-      head.featureIds.map((id) => toFinite(row.features[id], 0))
-    );
-  }
-  throw new Error('EnergyRowHeadPipeline.scoreRows: row.features must be array or object.');
-}
-
-function applyActivation(logit, activation) {
-  if (activation === 'linear') return logit;
-  if (activation === 'sigmoid') return sigmoid(logit);
-  throw new Error(`EnergyRowHeadPipeline: unsupported activation "${activation}".`);
-}
-
-function resolveBackend(backend) {
-  const mode = String(backend || DEFAULT_INFER_CONFIG.backend).toLowerCase();
-  if (mode === 'gpu' || mode === 'cpu') return mode;
-  const device = getDevice();
-  return device ? 'gpu' : 'cpu';
-}
-
-async function createFeatureTensor(device, values, dtype, label) {
-  const payload = dtype === 'f16' ? f32ToF16Array(values) : values;
-  const byteLength = payload.byteLength;
-  const alignedSize = Math.ceil(byteLength / 4) * 4;
-  const buffer = acquireBuffer(alignedSize, undefined, label);
-  try {
-    if (alignedSize === byteLength) {
-      device.queue.writeBuffer(buffer, 0, payload);
-    } else {
-      const bytes = payload instanceof Uint16Array
-        ? new Uint8Array(payload.buffer, payload.byteOffset, payload.byteLength)
-        : new Uint8Array(payload.buffer, payload.byteOffset, payload.byteLength);
-      const padded = new Uint8Array(alignedSize);
-      padded.set(bytes);
-      device.queue.writeBuffer(buffer, 0, padded);
-    }
-    return createTensor(buffer, dtype, [values.length], label);
-  } catch (error) {
-    releaseBuffer(buffer);
-    throw error;
-  }
-}
-
-async function readTensorF32(tensor) {
-  const byteLength = tensor.shape[0] * dtypeBytes(tensor.dtype);
-  const data = await readBuffer(tensor.buffer, byteLength);
-  if (tensor.dtype === 'f16') {
-    return f16ToF32Array(new Uint16Array(data));
-  }
-  return new Float32Array(data);
-}
-
-function scoreRowCpu({
-  features,
-  head,
-  steps,
-  stepSize,
-  gradientScale,
-  energyScale,
-  activation,
-}) {
-  const state = new Float32Array(features);
-  for (let step = 0; step < steps; step++) {
-    for (let i = 0; i < state.length; i++) {
-      const grad = (head.weights[i] - state[i]) * gradientScale;
-      state[i] += stepSize * grad;
-    }
-  }
-
-  let energy = 0;
-  for (let i = 0; i < state.length; i++) {
-    const delta = state[i] - head.weights[i];
-    energy += delta * delta;
-  }
-  energy /= state.length || 1;
-
-  const raw = dot(head.weights, state) + head.bias;
-  const logit = raw - (energyScale * energy);
-  const score = applyActivation(logit, activation) * head.scale;
-  return { score, logit, energy };
-}
-
-async function scoreRowGpu({
-  features,
-  head,
-  steps,
-  stepSize,
-  gradientScale,
-  energyScale,
-  activation,
-  dtype,
-  targetTensor = null,
-  releaseTargetTensor = true,
-}) {
-  const device = getDevice();
-  if (!device) {
-    throw new Error('EnergyRowHeadPipeline: GPU backend requested but no WebGPU device is available.');
-  }
-
-  let stateTensor = null;
-  let activeTargetTensor = targetTensor;
-  let energyTensor = null;
-  try {
-    stateTensor = await createFeatureTensor(device, features, dtype, 'dream_head_state');
-    if (!activeTargetTensor) {
-      activeTargetTensor = await createFeatureTensor(device, head.weights, dtype, 'dream_head_target');
-    }
-
-    for (let step = 0; step < steps; step++) {
-      await runEnergyUpdate(stateTensor, activeTargetTensor, {
-        count: features.length,
-        stepSize,
-        gradientScale,
-      });
-    }
-
-    energyTensor = await runEnergyEval(stateTensor, activeTargetTensor, {
-      count: features.length,
-      scale: 1,
-    });
-    const energyValues = await readTensorF32(energyTensor);
-    let energy = 0;
-    for (let i = 0; i < energyValues.length; i++) {
-      energy += energyValues[i];
-    }
-    energy /= energyValues.length || 1;
-
-    const stateValues = await readTensorF32(stateTensor);
-    const raw = dot(head.weights, stateValues) + head.bias;
-    const logit = raw - (energyScale * energy);
-    const score = applyActivation(logit, activation) * head.scale;
-    return { score, logit, energy };
-  } finally {
-    if (stateTensor?.buffer) releaseBuffer(stateTensor.buffer);
-    if (releaseTargetTensor && activeTargetTensor?.buffer) releaseBuffer(activeTargetTensor.buffer);
-    if (energyTensor?.buffer) releaseBuffer(energyTensor.buffer);
-  }
-}
-
-export class EnergyRowHeadPipeline {
-  runtimeConfig = null;
-  manifest = null;
-  model = null;
-  stats = {};
-  baseUrl = null;
-  _onProgress = null;
-
-  async initialize(contexts = {}) {
-    const { runtimeConfig } = applyPipelineContexts(this, contexts);
-    this.runtimeConfig = runtimeConfig;
-  }
-
-  async loadModel(manifest) {
-    this.manifest = manifest || null;
-    this.model = normalizeModelManifest(manifest);
-    log.info('EnergyRowHead', `Loaded model "${this.model.modelId}" (${this.model.modelType})`);
-  }
-
-  getStats() {
-    return this.stats;
-  }
-
-  getMemoryStats() {
-    return { used: 0, kvCache: null };
-  }
-
-  async unload() {
-    this.manifest = null;
-    this.model = null;
-    this.stats = {};
-    restorePipelineContexts(this);
-  }
-
-  async scoreRows(request = {}) {
-    if (!this.model) {
-      throw new Error('EnergyRowHeadPipeline.scoreRows: model is not loaded.');
-    }
-    const rows = Array.isArray(request?.rows) ? request.rows : [];
-    if (!rows.length) {
-      throw new Error('EnergyRowHeadPipeline.scoreRows: rows[] is required.');
-    }
-
-    const headId = String(request?.head || 'main');
-    const head = resolveHead(this.model, headId);
-    const activation = resolveActivation({
-      modelType: this.model.modelType,
-      headId,
-      activation: request?.activation,
-    });
-    const backend = resolveBackend(request?.backend);
-    const steps = Math.max(0, Math.floor(toFinite(request?.steps, DEFAULT_INFER_CONFIG.steps)));
-    const stepSize = toFinite(request?.stepSize, DEFAULT_INFER_CONFIG.stepSize);
-    const gradientScale = toFinite(request?.gradientScale, DEFAULT_INFER_CONFIG.gradientScale);
-    const energyScale = toFinite(request?.energyScale, DEFAULT_INFER_CONFIG.energyScale);
-
-    let caps = { hasF16: false };
-    try {
-      caps = getKernelCapabilities();
-    } catch {}
-    const requestedDtype = String(request?.dtype || DEFAULT_INFER_CONFIG.dtype).toLowerCase();
-    const dtype = selectRuleValue('inference', 'dtype', 'f16OrF32', {
-      useF16: requestedDtype === 'f16' && caps.hasF16,
-    });
-
-    const startTime = performance.now();
-    const outputRows = [];
-    let usedBackend = backend;
-    let autoBackendFailure = false;
-    let sharedGpuTargetTensor = null;
-    try {
-      if (backend === 'gpu' || backend === 'auto') {
-        const device = getDevice();
-        if (device) {
-          sharedGpuTargetTensor = await createFeatureTensor(device, head.weights, dtype, 'dream_head_target_shared');
-        }
-      }
-
-      for (let i = 0; i < rows.length; i++) {
-        const row = rows[i];
-        const rowId = String(row?.rowId ?? row?.candidateId ?? i);
-        const features = alignFeatureVector(row, head);
-
-        let scored = null;
-        if (backend === 'gpu') {
-          scored = await scoreRowGpu({
-            features,
-            head,
-            steps,
-            stepSize,
-            gradientScale,
-            energyScale,
-            activation,
-            dtype,
-            targetTensor: sharedGpuTargetTensor,
-            releaseTargetTensor: sharedGpuTargetTensor == null,
-          });
-        } else if (backend === 'cpu') {
-          scored = scoreRowCpu({
-            features,
-            head,
-            steps,
-            stepSize,
-            gradientScale,
-            energyScale,
-            activation,
-          });
-        } else if (autoBackendFailure) {
-          scored = scoreRowCpu({
-            features,
-            head,
-            steps,
-            stepSize,
-            gradientScale,
-            energyScale,
-            activation,
-          });
-        } else {
-          try {
-            scored = await scoreRowGpu({
-              features,
-              head,
-              steps,
-              stepSize,
-              gradientScale,
-              energyScale,
-              activation,
-              dtype,
-              targetTensor: sharedGpuTargetTensor,
-              releaseTargetTensor: sharedGpuTargetTensor == null,
-            });
-            usedBackend = 'gpu';
-          } catch (error) {
-            log.warn('EnergyRowHead', `GPU score fallback to CPU: ${error?.message || error}`);
-            scored = scoreRowCpu({
-              features,
-              head,
-              steps,
-              stepSize,
-              gradientScale,
-              energyScale,
-              activation,
-            });
-            usedBackend = 'cpu';
-            autoBackendFailure = true;
-          }
-        }
-
-        outputRows.push({
-          rowId,
-          score: activation === 'sigmoid'
-            ? clamp01(scored.score)
-            : toFinite(scored.score, 0),
-          logit: toFinite(scored.logit, 0),
-          energy: Math.max(0, toFinite(scored.energy, 0)),
-        });
-
-        if (this._onProgress) {
-          this._onProgress({
-            stage: 'energy_row_head',
-            percent: (i + 1) / rows.length,
-            message: `Scored ${i + 1} / ${rows.length}`,
-          });
-        }
-      }
-    } finally {
-      if (sharedGpuTargetTensor?.buffer) releaseBuffer(sharedGpuTargetTensor.buffer);
-    }
-
-    outputRows.sort((a, b) => {
-      if (a.score !== b.score) return b.score - a.score;
-      return a.rowId.localeCompare(b.rowId);
-    });
-
-    this.stats = {
-      backend: usedBackend,
-      rowCount: rows.length,
-      totalTimeMs: performance.now() - startTime,
-      steps,
-      activation,
-      head: headId,
-    };
-
-    return {
-      modelId: this.model.modelId,
-      modelHash: this.model.modelHash || null,
-      backend: usedBackend,
-      head: headId,
-      activation,
-      rows: outputRows,
-      totalTimeMs: this.stats.totalTimeMs,
-    };
-  }
-
-  async infer(request = {}) {
-    return this.scoreRows(request);
-  }
-}
-
-export async function createEnergyRowHeadPipeline(manifest, contexts = {}) {
-  return createInitializedPipeline(EnergyRowHeadPipeline, manifest, contexts);
-}
-
-for (const modelType of ENERGY_ROW_HEAD_MODEL_TYPES) {
-  registerPipeline(modelType, createEnergyRowHeadPipeline);
-}
-
-export class DreamEnergyHeadPipeline extends EnergyRowHeadPipeline {}
-
-export const createDreamEnergyHeadPipeline = createEnergyRowHeadPipeline;

package/src/inference/pipelines/factory.d.ts

@@ -1,10 +0,0 @@
-type InitializablePipeline = {
-  initialize(contexts?: Record<string, unknown>): Promise<void>;
-  loadModel(manifest: unknown): Promise<void>;
-};
-
-export declare function createInitializedPipeline<T extends InitializablePipeline>(
-  PipelineClass: new () => T,
-  manifest: unknown,
-  contexts?: Record<string, unknown>
-): Promise<T>;

package/src/inference/pipelines/factory.js

@@ -1,6 +0,0 @@
-export async function createInitializedPipeline(PipelineClass, manifest, contexts = {}) {
-  const pipeline = new PipelineClass();
-  await pipeline.initialize(contexts);
-  await pipeline.loadModel(manifest);
-  return pipeline;
-}

package/src/inference/pipelines/index.d.ts

@@ -1,22 +0,0 @@
-export { InferencePipeline, EmbeddingPipeline, createPipeline } from './text.js';
-export { DiffusionPipeline, createDiffusionPipeline } from './diffusion/pipeline.js';
-export { EnergyPipeline, createEnergyPipeline } from './energy/pipeline.js';
-export {
-  StructuredJsonHeadPipeline,
-  isStructuredJsonHeadModelType,
-  createStructuredJsonHeadPipeline,
-  DreamStructuredPipeline,
-  isDreamStructuredModelType,
-  createDreamStructuredPipeline,
-} from './structured/json-head-pipeline.js';
-export {
-  EnergyRowHeadPipeline,
-  createEnergyRowHeadPipeline,
-  DreamEnergyHeadPipeline,
-  createDreamEnergyHeadPipeline,
-} from './energy-head/row-head-pipeline.js';
-export { registerPipeline, getPipelineFactory, listPipelines } from './registry.js';
-export { createInitializedPipeline } from './factory.js';
-
-export type { GenerateOptions, GenerationResult, PipelineContexts } from './text.js';
-export type { ParsedModelConfig } from './text/config.js';

package/src/inference/pipelines/index.js

@@ -1,19 +0,0 @@
-export { InferencePipeline, EmbeddingPipeline, createPipeline } from './text.js';
-export { DiffusionPipeline, createDiffusionPipeline } from './diffusion/pipeline.js';
-export { EnergyPipeline, createEnergyPipeline } from './energy/pipeline.js';
-export {
-  StructuredJsonHeadPipeline,
-  isStructuredJsonHeadModelType,
-  createStructuredJsonHeadPipeline,
-  DreamStructuredPipeline,
-  isDreamStructuredModelType,
-  createDreamStructuredPipeline,
-} from './structured/json-head-pipeline.js';
-export {
-  EnergyRowHeadPipeline,
-  createEnergyRowHeadPipeline,
-  DreamEnergyHeadPipeline,
-  createDreamEnergyHeadPipeline,
-} from './energy-head/row-head-pipeline.js';
-export { registerPipeline, getPipelineFactory, listPipelines } from './registry.js';
-export { createInitializedPipeline } from './factory.js';

package/src/inference/pipelines/registry.d.ts

@@ -1,15 +0,0 @@
-/**
- * Pipeline Registry
- *
- * Maps modelType -> pipeline factory.
- *
- * @module inference/pipelines/registry
- */
-
-import type { ManifestSchema } from '../../config/schema/index.js';
-
-export type PipelineFactory = (manifest: ManifestSchema, contexts?: Record<string, unknown>) => Promise<unknown>;
-
-export declare function registerPipeline(modelType: string, factory: PipelineFactory): void;
-export declare function getPipelineFactory(modelType: string | null | undefined): PipelineFactory | null;
-export declare function listPipelines(): string[];

package/src/inference/pipelines/registry.js

@@ -1,23 +0,0 @@
-const registry = new Map();
-
-export function registerPipeline(
-  modelType,
-  factory
-) {
-  if (!modelType || typeof modelType !== 'string') {
-    throw new Error('Pipeline registry requires a modelType string.');
-  }
-  if (typeof factory !== 'function') {
-    throw new Error(`Pipeline registry requires a factory function for "${modelType}".`);
-  }
-  registry.set(modelType, factory);
-}
-
-export function getPipelineFactory(modelType) {
-  if (!modelType) return null;
-  return registry.get(modelType) ?? null;
-}
-
-export function listPipelines() {
-  return Array.from(registry.keys());
-}

package/src/inference/pipelines/rng.d.ts

@@ -1,2 +0,0 @@
-export declare function createRng(seed: number): () => number;
-export declare function sampleNormal(rng: () => number): number;

package/src/inference/pipelines/rng.js

@@ -1,17 +0,0 @@
-export function createRng(seed) {
-  let state = seed >>> 0;
-  if (!state) state = 0x6d2b79f5;
-  return () => {
-    state |= 0;
-    state = (state + 0x6d2b79f5) | 0;
-    let t = Math.imul(state ^ (state >>> 15), 1 | state);
-    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
-    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-  };
-}
-
-export function sampleNormal(rng) {
-  const u = Math.max(rng(), 1e-6);
-  const v = rng();
-  return Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
-}

package/src/inference/pipelines/structured/index.d.ts

@@ -1,8 +0,0 @@
-export {
-  StructuredJsonHeadPipeline,
-  isStructuredJsonHeadModelType,
-  createStructuredJsonHeadPipeline,
-  DreamStructuredPipeline,
-  isDreamStructuredModelType,
-  createDreamStructuredPipeline,
-} from './json-head-pipeline.js';

package/src/inference/pipelines/structured/index.js

@@ -1,8 +0,0 @@
-export {
-  StructuredJsonHeadPipeline,
-  isStructuredJsonHeadModelType,
-  createStructuredJsonHeadPipeline,
-  DreamStructuredPipeline,
-  isDreamStructuredModelType,
-  createDreamStructuredPipeline,
-} from './json-head-pipeline.js';

package/src/inference/pipelines/structured/json-head-pipeline.d.ts

@@ -1,58 +0,0 @@
-import { InferencePipeline } from '../text.js';
-import type { GenerateOptions } from '../text/types.js';
-
-export type StructuredJsonHeadModelType =
-  | 'structured_json_head'
-  | 'structured-json-head'
-  | 'dream_structured'
-  | 'dream_intent_posterior_head'
-  | 'dream_d1_to2_bridge'
-  | 'dream_synthesis'
-  | 'dream_energy_compose'
-  | 'dream-intent-posterior-head'
-  | 'dream-d1-to2-bridge'
-  | 'dream-synthesis'
-  | 'dream-energy-compose';
-
-export interface StructuredJsonHeadInferJSONRequest {
-  prompt?: string;
-  text?: string;
-  nowIso?: string;
-  maxTokens?: number;
-  temperature?: number;
-  maxOutputChars?: number;
-  options?: GenerateOptions;
-}
-
-export interface StructuredJsonHeadInferJSONResult {
-  output: Record<string, unknown>;
-  rawText: string;
-  createdAt: string;
-  modelId: string;
-  modelHash: unknown;
-  promptHash: { alg: 'sha256'; hex: string };
-}
-
-export declare class StructuredJsonHeadPipeline extends InferencePipeline {
-  inferJSON(request?: StructuredJsonHeadInferJSONRequest): Promise<StructuredJsonHeadInferJSONResult>;
-  infer(request?: StructuredJsonHeadInferJSONRequest): Promise<Record<string, unknown>>;
-}
-
-export declare function isStructuredJsonHeadModelType(modelType: string | null | undefined): boolean;
-
-export declare function createStructuredJsonHeadPipeline(
-  manifest: Record<string, unknown>,
-  contexts?: Record<string, unknown>
-): Promise<StructuredJsonHeadPipeline>;
-
-export type DreamStructuredModelType = StructuredJsonHeadModelType;
-
-export type DreamInferJSONRequest = StructuredJsonHeadInferJSONRequest;
-
-export type DreamInferJSONResult = StructuredJsonHeadInferJSONResult;
-
-export declare class DreamStructuredPipeline extends StructuredJsonHeadPipeline {}
-
-export declare const isDreamStructuredModelType: typeof isStructuredJsonHeadModelType;
-
-export declare const createDreamStructuredPipeline: typeof createStructuredJsonHeadPipeline;