@simulatte/doppler 0.1.0

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

@@ -0,0 +1,487 @@
+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 } 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);
+
+  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);
+}
+
+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 = {};
+  }
+
+  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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,15 @@
+/**
+ * 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

@@ -0,0 +1,23 @@
+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

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

package/src/inference/pipelines/rng.js

@@ -0,0 +1,17 @@
+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

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

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

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

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

@@ -0,0 +1,58 @@
+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;