chore: deploy chat app 838143e

flutter_bootstrap.js

@@ -42,6 +42,6 @@ _flutter.buildConfig = {"engineRevision":"5d531788691ec3404cac0cee66ead4007b1773
 
 _flutter.loader.load({
   serviceWorkerSettings: {
-    serviceWorkerVersion: "2510919536" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
+    serviceWorkerVersion: "1025218781" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
   }
 });

index.html

@@ -211,7 +211,7 @@
       typeof configuredRepo === 'string' && configuredRepo.length > 0
         ? configuredRepo
         : 'leehack/llama-web-bridge-assets';
-    const defaultBridgeAssetsTag = 'v0.1.44';
+    const defaultBridgeAssetsTag = 'v0.1.47';
     const defaultBridgeLlamaCppTag = 'v0.4.1';
     const bridgeAssetsTag =
       typeof configuredTag === 'string' && configuredTag.length > 0

llamadart-build.json

@@ -1 +1 @@
-{"commit":"03bca335fe499104a6067ec3515ac06208d048a1","tree":"18f9680b97ee5110cab6e4c9db133c0ae77e1493","base_href":"/","target":"lib/main.dart","flutter_version":"3.47.1"}
+{"commit":"838143e3eb8160cd03ce8cf2758a99e03c249ffc","tree":"b07164124f1115bcae6de9ba399f5fef1577ece4","base_href":"/","target":"lib/main.dart","flutter_version":"3.47.1"}

webgpu_bridge/llama_webgpu_bridge.d.ts

@@ -143,6 +143,48 @@ export interface TextToSpeechResult {
   truncated: boolean;
 }
 
+export interface DecisionCapabilities {
+  apiVersion: number;
+  supported: boolean;
+  /** Why the loaded model cannot run decision heads; absent when supported. */
+  reason?: string;
+}
+
+export interface DecisionHeadOptions {
+  /** Laya `rl_agent_config.json` text; omit to read the head's `laya.config` metadata. */
+  configJson?: string | null;
+  /** Download progress of a URL head, in bytes. */
+  onProgress?: (progress: { loaded: number; total: number }) => void;
+}
+
+export interface DecisionHeadInfo {
+  apiVersion: number;
+  handle: number;
+  hiddenSize: number;
+  clsToken: number;
+  sepToken: number;
+  maskToken: number;
+  maskText: string;
+  configJson: string;
+  deviceName: string;
+}
+
+/** 0 = choice, 1 = score, 2 = noul. */
+export type DecisionQuestionType = 0 | 1 | 2;
+
+export interface DecisionSequence {
+  tokens: Int32Array | readonly number[];
+  /** Token indexes of the option markers, in option order. */
+  markers: Int32Array | readonly number[];
+  questionType: DecisionQuestionType;
+}
+
+export interface DecisionOutput {
+  /** One raw logit per marker. */
+  logits: Float32Array;
+  actLogits: Float32Array;
+}
+
 export type ModelMetadata = Record<string, unknown>;
 
 export interface StateLoadResult {
@@ -189,6 +231,13 @@ export class LlamaWebGpuBridge {
   supportsAudio(): boolean;
   getTextToSpeechCapabilities(): Promise<TextToSpeechCapabilities>;
   synthesizeSpeech(options: TextToSpeechOptions): Promise<TextToSpeechResult>;
+  getDecisionCapabilities(): Promise<DecisionCapabilities>;
+  loadDecisionHead(
+    source: string | ArrayBuffer | ArrayBufferView,
+    options?: DecisionHeadOptions,
+  ): Promise<DecisionHeadInfo>;
+  runDecision(handle: number, sequences: readonly DecisionSequence[]): Promise<DecisionOutput[]>;
+  freeDecisionHead(handle: number): Promise<void>;
 
   getModelMetadata(): ModelMetadata | null;
   getContextSize(): number;

webgpu_bridge/llama_webgpu_bridge.js

@@ -8,6 +8,8 @@ var defaultModelCacheName = "llamadart-webgpu-model-cache-v1";
 var BRIDGE_DISPOSED_MESSAGE = "Bridge has been disposed.";
 var GENERATION_ALREADY_ACTIVE_RC = -7;
 var GENERATION_ALREADY_ACTIVE_MESSAGE = "Generation is already active on this bridge runtime.";
+var DECISION_API_VERSION = 1;
+var DECISION_WORKER_TIMEOUT_PER_SEQUENCE_MS = 60 * 1e3;
 function createAbortError(message) {
   if (typeof DOMException === "function") {
     return new DOMException(message, "AbortError");
@@ -332,8 +334,7 @@ async function writeResponseToFsFileWithProgress(response, fs, filePath, progres
   const useBigIntPosition = writeOptions.useBigIntPosition === true;
   const startOffset = parsePositiveInteger(writeOptions.startOffset);
   const preservePartialOnError = writeOptions.preservePartialOnError === true;
-  const allowAppend = writeOptions.allowAppend === true || startOffset > 0;
-  const appendMode = allowAppend && startOffset > 0;
+  const appendMode = startOffset > 0;
   const chunkTimeoutMs = parsePositiveInteger(writeOptions.chunkTimeoutMs);
   const signal = writeOptions.signal || null;
   const abortMessage = writeOptions.abortMessage || "Model transfer was cancelled.";
@@ -503,6 +504,120 @@ function toFloat32Array(value) {
   }
   return null;
 }
+function isInt32(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= -2147483648 && value <= 2147483647;
+}
+function decisionHandleFrom(handle) {
+  if (!isInt32(handle) || handle <= 0) {
+    throw new TypeError(`Decision head handle must be a positive integer, got ${String(handle)}.`);
+  }
+  return handle;
+}
+function decisionHeadBytes(source) {
+  if (source instanceof ArrayBuffer) {
+    return new Uint8Array(source);
+  }
+  if (ArrayBuffer.isView(source)) {
+    return new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+  }
+  return null;
+}
+function decisionIntegerList(value, label) {
+  const isList = Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
+  if (!isList) {
+    throw new TypeError(`${label} must be an array or typed array of integers.`);
+  }
+  const list = (
+    /** @type {ArrayLike<unknown>} */
+    value
+  );
+  const out = new Int32Array(list.length);
+  for (let index = 0; index < list.length; index += 1) {
+    const item = list[index];
+    if (!isInt32(item)) {
+      throw new TypeError(`${label}[${index}] is ${String(item)}; expected a 32-bit integer.`);
+    }
+    out[index] = /** @type {number} */
+    item;
+  }
+  return out;
+}
+function normalizeDecisionSequences(sequences) {
+  if (!Array.isArray(sequences)) {
+    throw new TypeError("Decision sequences must be an array.");
+  }
+  return sequences.map((sequence, index) => {
+    const label = `Decision sequence ${index}`;
+    if (!sequence || typeof sequence !== "object") {
+      throw new TypeError(`${label} must be an object with tokens, markers and questionType.`);
+    }
+    const tokens = decisionIntegerList(sequence.tokens, `${label} tokens`);
+    const markers = decisionIntegerList(sequence.markers, `${label} markers`);
+    const questionType = sequence.questionType;
+    if (!isInt32(questionType)) {
+      throw new TypeError(
+        `${label} questionType is ${String(questionType)}; expected 0 (choice), 1 (score) or 2 (noul).`
+      );
+    }
+    return { tokens, markers, questionType: (
+      /** @type {number} */
+      questionType
+    ) };
+  });
+}
+function encodeDecisionSequences(sequences) {
+  const encoded = normalizeDecisionSequences(sequences);
+  let words = 1;
+  for (const sequence of encoded) {
+    words += 3 + sequence.tokens.length + sequence.markers.length;
+  }
+  const bytes = new Uint8Array(words * 4);
+  const view = new DataView(bytes.buffer);
+  let offset = 0;
+  const put = (value) => {
+    view.setInt32(offset, value, true);
+    offset += 4;
+  };
+  put(encoded.length);
+  for (const sequence of encoded) {
+    put(sequence.questionType);
+    put(sequence.tokens.length);
+    put(sequence.markers.length);
+    sequence.tokens.forEach(put);
+    sequence.markers.forEach(put);
+  }
+  return bytes;
+}
+function decodeDecisionOutputs(bytes, count) {
+  const malformed = () => new Error("Decision output from the WebGPU core is malformed.");
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let offset = 0;
+  const floats = (length) => {
+    const values = new Float32Array(length);
+    for (let index = 0; index < length; index += 1) {
+      values[index] = view.getFloat32(offset, true);
+      offset += 4;
+    }
+    return values;
+  };
+  const outputs = [];
+  for (let index = 0; index < count; index += 1) {
+    if (bytes.byteLength - offset < 8) {
+      throw malformed();
+    }
+    const logitCount = view.getInt32(offset, true);
+    const actCount = view.getInt32(offset + 4, true);
+    offset += 8;
+    if (logitCount < 0 || actCount < 0 || (logitCount + actCount) * 4 > bytes.byteLength - offset) {
+      throw malformed();
+    }
+    outputs.push({ logits: floats(logitCount), actLogits: floats(actCount) });
+  }
+  if (offset !== bytes.byteLength) {
+    throw malformed();
+  }
+  return outputs;
+}
 async function decodeImageBytesToRgb(bytes, options = {}) {
   const sourceBytes = toUint8Array(bytes);
   if (!sourceBytes || sourceBytes.length === 0) {
@@ -602,6 +717,37 @@ async function decodeImageBytesToRgb(bytes, options = {}) {
     }
   }
 }
+function logLevelForName(level) {
+  switch (level) {
+    case "debug":
+      return 0;
+    case "log":
+    case "info":
+      return 1;
+    case "warn":
+      return 2;
+    case "error":
+      return 3;
+    default:
+      return 1;
+  }
+}
+function logThresholdForConfiguredLevel(level) {
+  switch (level) {
+    case 0:
+      return 99;
+    case 1:
+      return 0;
+    case 2:
+      return 1;
+    case 3:
+      return 2;
+    case 4:
+      return 3;
+    default:
+      return 1;
+  }
+}
 function serializeWorkerError(error) {
   if (!error) {
     return "Unknown worker error";
@@ -861,6 +1007,29 @@ function installBridgeWorkerHost() {
         );
         return;
       }
+      if (method === "loadDecisionHead") {
+        const options = args[1] && typeof args[1] === "object" ? { ...args[1] } : {};
+        options.onProgress = (progress) => {
+          self.postMessage({ type: "event", id, event: "progress", payload: progress || {} });
+        };
+        const value2 = await bridge.loadDecisionHead(args[0], options);
+        self.postMessage({ type: "result", id, value: value2 });
+        return;
+      }
+      if (method === "runDecision") {
+        const value2 = await bridge.runDecision(args[0], args[1]);
+        const transfers = [];
+        for (const output of Array.isArray(value2) ? value2 : []) {
+          for (const values of [output?.logits, output?.actLogits]) {
+            const buffer = values?.buffer;
+            if (buffer instanceof ArrayBuffer && !transfers.includes(buffer)) {
+              transfers.push(buffer);
+            }
+          }
+        }
+        self.postMessage({ type: "result", id, value: value2 }, transfers);
+        return;
+      }
       if (method === "unloadMultimodalProjector") {
         const value2 = await bridge.unloadMultimodalProjector();
         self.postMessage({ type: "result", id, value: value2, state: snapshotBridgeState(bridge) });
@@ -1059,7 +1228,7 @@ var BridgeWorkerProxy = class {
   async call(method, args, onEvent, transferList = [], operationMeta = null) {
     await this._ready;
     const id = this._nextId++;
-    const timeoutMs = this._resolveRequestTimeoutMs(method);
+    const timeoutMs = this._resolveRequestTimeoutMs(method, args);
     const transfers = Array.isArray(transferList) ? transferList.filter((item) => item != null) : [];
     return new Promise((resolve, reject) => {
       let timeoutHandle = null;
@@ -1127,7 +1296,7 @@ var BridgeWorkerProxy = class {
       }
     }, timeoutMs);
   }
-  _resolveRequestTimeoutMs(method) {
+  _resolveRequestTimeoutMs(method, args = []) {
     const explicitGlobal = Number(this._config.workerRequestTimeoutMs);
     const clamp = (value, fallback) => {
       if (!Number.isFinite(value) || value <= 0) {
@@ -1147,6 +1316,13 @@ var BridgeWorkerProxy = class {
     if (method === "synthesizeSpeech") {
       return clamp(Number(this._config.workerTextToSpeechTimeoutMs), clamp(explicitGlobal, 20 * 60 * 1e3));
     }
+    if (method === "loadDecisionHead") {
+      return clamp(explicitGlobal, 10 * 60 * 1e3);
+    }
+    if (method === "runDecision") {
+      const sequences = Array.isArray(args?.[1]) ? args[1].length : 0;
+      return clamp(explicitGlobal, 10 * 60 * 1e3 + sequences * DECISION_WORKER_TIMEOUT_PER_SEQUENCE_MS);
+    }
     return clamp(explicitGlobal, 12e4);
   }
   async dispose() {
@@ -1191,6 +1367,7 @@ var LlamaWebGpuBridgeRuntime = class {
     this._mmSupportsAudio = false;
     this._mediaFileCounter = 0;
     this._stateFileCounter = 0;
+    this._decisionFileCounter = 0;
     this._stagedMediaPaths = [];
     this._nCtx = 4096;
     this._abortRequested = false;
@@ -1485,49 +1662,18 @@ var LlamaWebGpuBridgeRuntime = class {
     return () => {
     };
   }
-  _logLevelForName(level) {
-    switch (level) {
-      case "debug":
-        return 0;
-      case "log":
-      case "info":
-        return 1;
-      case "warn":
-        return 2;
-      case "error":
-        return 3;
-      default:
-        return 1;
-    }
-  }
-  _logThresholdForConfiguredLevel(level) {
-    switch (level) {
-      case 0:
-        return 99;
-      case 1:
-        return 0;
-      case 2:
-        return 1;
-      case 3:
-        return 2;
-      case 4:
-        return 3;
-      default:
-        return 1;
-    }
-  }
   _shouldEmitLoggerLevel(level) {
     const current = Number(this._logLevel);
     if (!Number.isFinite(current) || current < 0) {
       return true;
     }
-    const threshold = this._logThresholdForConfiguredLevel(
+    const threshold = logThresholdForConfiguredLevel(
       Math.max(0, Math.min(4, Math.trunc(current)))
     );
     if (threshold > 3) {
       return false;
     }
-    return this._logLevelForName(level) >= threshold;
+    return logLevelForName(level) >= threshold;
   }
   _emitLogger(level, message) {
     if (!this._shouldEmitLoggerLevel(level)) {
@@ -1762,19 +1908,7 @@ var LlamaWebGpuBridgeRuntime = class {
     ];
   }
   _nativeLoadOptionTypes() {
-    return [
-      "number",
-      "number",
-      "number",
-      "number",
-      "number",
-      "number",
-      "number",
-      "number",
-      "number",
-      "number",
-      "number"
-    ];
+    return this._nativeLoadOptionValues().map(() => "number");
   }
   async _tryLoadModelFromRemoteFetchBackend(core, url, options = {}) {
     if (!this._canUseRemoteFetchBackend(options)) {
@@ -2060,6 +2194,15 @@ var LlamaWebGpuBridgeRuntime = class {
       }
     }
   }
+  _unlinkDecisionFile(path) {
+    if (!this._core || typeof path !== "string" || path.length === 0) {
+      return;
+    }
+    try {
+      this._core.FS.unlink(path);
+    } catch (_) {
+    }
+  }
   _deleteFsFile(path) {
     if (!this._core || typeof path !== "string" || path.length === 0) {
       return false;
@@ -2704,7 +2847,6 @@ var LlamaWebGpuBridgeRuntime = class {
                 {
                   useBigIntPosition: this._coreVariant === "wasm64",
                   startOffset: resumeOffset,
-                  allowAppend: resumeOffset > 0,
                   preservePartialOnError: true,
                   totalBytes: knownTotalBytes,
                   chunkTimeoutMs: streamChunkTimeoutMs,
@@ -3288,6 +3430,201 @@ var LlamaWebGpuBridgeRuntime = class {
       this._textToSpeechDone = null;
     }
   }
+  getDecisionCapabilities() {
+    const unsupported = (reason) => ({
+      apiVersion: DECISION_API_VERSION,
+      supported: false,
+      reason
+    });
+    const core = this._core;
+    if (!core) {
+      return unsupported("WebGPU core is not initialized");
+    }
+    if (typeof core._llamadart_webgpu_decision_capabilities_json !== "function") {
+      return unsupported("This WebGPU core build does not include decision heads.");
+    }
+    const coreVersion = Number(
+      core.ccall("llamadart_webgpu_decision_api_version", "number", [], [])
+    );
+    if (coreVersion !== DECISION_API_VERSION) {
+      return unsupported(
+        `The WebGPU core implements decision API version ${coreVersion}; this bridge needs version ${DECISION_API_VERSION}.`
+      );
+    }
+    const raw = core.ccall(
+      "llamadart_webgpu_decision_capabilities_json",
+      "string",
+      [],
+      []
+    ) || "{}";
+    try {
+      return JSON.parse(raw);
+    } catch (_) {
+      return unsupported("WebGPU decision capability response is invalid");
+    }
+  }
+  _ensureDecisionDir() {
+    try {
+      this._core.FS.mkdir("/decision");
+    } catch (_) {
+    }
+  }
+  async _stageDecisionHeadFromUrl(url, headPath, onProgress) {
+    const fetchTimeoutMs = this._resolveFetchTimeoutMs({}, 18e4);
+    const chunkTimeoutMs = this._resolveStreamChunkTimeoutMs({}, 9e4);
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        const response = await this._fetchWithTimeout(
+          url,
+          { cache: "no-store" },
+          fetchTimeoutMs
+        );
+        if (!response.ok) {
+          throw new Error(
+            `Failed to fetch decision head: ${response.status} ${response.statusText}`
+          );
+        }
+        await writeResponseToFsFileWithProgress(
+          response,
+          this._core.FS,
+          headPath,
+          typeof onProgress === "function" ? onProgress : null,
+          {
+            useBigIntPosition: this._coreVariant === "wasm64",
+            chunkTimeoutMs
+          }
+        );
+        return;
+      } catch (error) {
+        this._unlinkDecisionFile(headPath);
+        if (!isRetryableStreamNetworkError(error) || attempt >= 1) {
+          throw error;
+        }
+        this._runtimeNotes.push(`decision_head_fetch_retry:${attempt + 1}`);
+      }
+    }
+  }
+  /**
+   * @param {string | ArrayBuffer | ArrayBufferView} source
+   * @param {{ configJson?: string | null, onProgress?: (progress: { loaded: number, total: number }) => void }} [options]
+   */
+  async loadDecisionHead(source, options = {}) {
+    if (!this._core || this._modelBytes <= 0) {
+      throw new Error("No model loaded. Call loadModelFromUrl first.");
+    }
+    const configJson = options?.configJson ?? null;
+    if (configJson !== null && typeof configJson !== "string") {
+      throw new TypeError("Decision head configJson must be a string.");
+    }
+    let bytes = null;
+    if (typeof source === "string") {
+      if (source.length === 0) {
+        throw new Error("Decision head URL is empty.");
+      }
+    } else {
+      bytes = decisionHeadBytes(source);
+      if (!bytes) {
+        throw new TypeError("Decision head source must be a URL string, an ArrayBuffer or a typed array.");
+      }
+      if (bytes.byteLength === 0) {
+        throw new Error("Decision head bytes are empty.");
+      }
+    }
+    const capabilities = this.getDecisionCapabilities();
+    if (capabilities.supported !== true) {
+      throw new Error(
+        capabilities.reason || "The loaded model does not support decision heads."
+      );
+    }
+    const core = this._core;
+    this._ensureDecisionDir();
+    const taskId = `${Date.now()}_${++this._decisionFileCounter}`;
+    const headPath = `/decision/head_${taskId}.safetensors`;
+    const configPath = configJson === null ? null : `/decision/config_${taskId}.json`;
+    try {
+      let label = "decision head bytes";
+      if (bytes) {
+        core.FS.writeFile(headPath, bytes);
+      } else {
+        label = basenameFromUrl(source).slice(0, 256);
+        await this._stageDecisionHeadFromUrl(source, headPath, options?.onProgress);
+      }
+      if (configPath !== null) {
+        core.FS.writeFile(configPath, textEncoder.encode(configJson));
+      }
+      const handle = Number(
+        await core.ccall(
+          "llamadart_webgpu_decision_load",
+          "number",
+          ["string", "string", "string"],
+          [headPath, label, configPath],
+          { async: true }
+        )
+      );
+      if (handle <= 0) {
+        throw new Error(this._coreErrorMessage("Failed to load decision head", handle));
+      }
+      const raw = core.ccall(
+        "llamadart_webgpu_decision_head_info_json",
+        "string",
+        ["number"],
+        [handle]
+      ) || "{}";
+      return JSON.parse(raw);
+    } finally {
+      this._unlinkDecisionFile(headPath);
+      this._unlinkDecisionFile(configPath);
+    }
+  }
+  /**
+   * @param {number} handle
+   * @param {unknown} sequences
+   */
+  async runDecision(handle, sequences) {
+    const nativeHandle = decisionHandleFrom(handle);
+    const input = encodeDecisionSequences(sequences);
+    if (!this._core || this._modelBytes <= 0) {
+      throw new Error("No model loaded. Call loadModelFromUrl first.");
+    }
+    const core = this._core;
+    this._ensureDecisionDir();
+    const taskId = `${Date.now()}_${++this._decisionFileCounter}`;
+    const inputPath = `/decision/input_${taskId}.bin`;
+    const outputPath = `/decision/output_${taskId}.bin`;
+    try {
+      core.FS.writeFile(inputPath, input);
+      const count = Number(
+        await core.ccall(
+          "llamadart_webgpu_decision_run",
+          "number",
+          ["number", "string", "string"],
+          [nativeHandle, inputPath, outputPath],
+          { async: true }
+        )
+      );
+      if (count < 0) {
+        throw new Error(this._coreErrorMessage("Decision run failed", count));
+      }
+      return decodeDecisionOutputs(core.FS.readFile(outputPath), count);
+    } finally {
+      this._unlinkDecisionFile(inputPath);
+      this._unlinkDecisionFile(outputPath);
+    }
+  }
+  /** @param {number} handle */
+  async freeDecisionHead(handle) {
+    const nativeHandle = decisionHandleFrom(handle);
+    if (!this._core) {
+      return;
+    }
+    await this._core.ccall(
+      "llamadart_webgpu_decision_free",
+      "number",
+      ["number"],
+      [nativeHandle],
+      { async: true }
+    );
+  }
   _clearStagedMediaFiles() {
     if (!this._core || this._stagedMediaPaths.length === 0) {
       this._stagedMediaPaths = [];
@@ -3993,6 +4330,8 @@ var LlamaWebGpuBridge = class {
     this._disposed = false;
     this._disposePromise = null;
     this._disposalWaiters = /* @__PURE__ */ new Set();
+    this._decisionHeads = /* @__PURE__ */ new Map();
+    this._nextDecisionHandle = 1;
     if (this._shouldUseWorker()) {
       try {
         this._workerProxy = new BridgeWorkerProxy({
@@ -4526,7 +4865,7 @@ var LlamaWebGpuBridge = class {
   }
   _isRecoverableWorkerFsError(error) {
     const text = serializeWorkerError(error).toLowerCase();
-    return text.includes("fs error") || text.includes("no such file") || text.includes("not found") || text.includes("invalid argument") || text.includes("worker request timeout") || text.includes("timed out");
+    return text.includes("fs error") || text.includes("no such file") || text.includes("not found") || text.includes("invalid argument") || text.includes("timed out");
   }
   _isWorkerRequestTimeoutError(error) {
     const text = serializeWorkerError(error).toLowerCase();
@@ -4610,9 +4949,6 @@ var LlamaWebGpuBridge = class {
     const text = serializeWorkerError(error).toLowerCase();
     return text.includes("worker completion stalled") || text.includes("worker createcompletion stalled") || text.includes("worker timed out") || text.includes("worker timeout");
   }
-  _isForcedCpuMultimodalFallbackError(error) {
-    return error && typeof error === "object" && error.llamadartForceCpuMultimodal === true;
-  }
   _isCpuModelMode() {
     const requestedLayers = Number(this._loadedModelOptions?.nGpuLayers);
     if (Number.isFinite(requestedLayers)) {
@@ -4655,12 +4991,11 @@ var LlamaWebGpuBridge = class {
     const multimodalRuntimeRequired = mediaPartsRequested || textToSpeechRequested;
     const shouldEnsureMultimodalInRuntime = multimodalRuntimeRequired && typeof this._loadedMmProjUrl === "string" && this._loadedMmProjUrl.length > 0;
     const workerTimedOut = this._isWorkerTimeoutError(fallbackError);
-    const forcedCpuFallback = this._isForcedCpuMultimodalFallbackError(fallbackError);
     const dispatchWorkgroupFallback = this._isDispatchWorkgroupLimitError(fallbackError);
     const loadedGpuLayers = Number(this._loadedModelOptions?.nGpuLayers);
     const metadataGpuLayers = Number(this._metadata?.["llamadart.webgpu.n_gpu_layers"]);
     const modelLoadedWithGpu = Number.isFinite(loadedGpuLayers) ? loadedGpuLayers !== 0 : Number.isFinite(metadataGpuLayers) ? metadataGpuLayers !== 0 : true;
-    const shouldUseCpuMultimodalFallback = multimodalRuntimeRequired && modelLoadedWithGpu && (dispatchWorkgroupFallback || forcedCpuFallback || workerTimedOut);
+    const shouldUseCpuMultimodalFallback = multimodalRuntimeRequired && modelLoadedWithGpu && (dispatchWorkgroupFallback || workerTimedOut);
     try {
       if (Number(this._runtime?._modelBytes) > 0 && !forceReloadRequested && !shouldUseCpuMultimodalFallback) {
         if (shouldEnsureMultimodalInRuntime) {
@@ -4689,10 +5024,6 @@ var LlamaWebGpuBridge = class {
           this._emitBridgeWarn(
             "llamadart: retrying text-to-speech once with CPU fallback after WebGPU failure."
           );
-        } else if (forcedCpuFallback) {
-          this._emitBridgeWarn(
-            "llamadart: using CPU fallback for multimodal generation stability."
-          );
         } else if (workerTimedOut) {
           this._emitBridgeWarn(
             "llamadart: retrying multimodal generation with CPU fallback after worker timeout."
@@ -4884,44 +5215,13 @@ var LlamaWebGpuBridge = class {
     }
     return 2;
   }
-  _bridgeLogLevelForName(level) {
-    switch (level) {
-      case "debug":
-        return 0;
-      case "log":
-      case "info":
-        return 1;
-      case "warn":
-        return 2;
-      case "error":
-        return 3;
-      default:
-        return 1;
-    }
-  }
-  _bridgeLogThresholdForConfiguredLevel(level) {
-    switch (level) {
-      case 0:
-        return 99;
-      case 1:
-        return 0;
-      case 2:
-        return 1;
-      case 3:
-        return 2;
-      case 4:
-        return 3;
-      default:
-        return 1;
-    }
-  }
   _shouldEmitBridgeLevel(level) {
     const configured = this._resolvedBridgeLogLevel();
-    const threshold = this._bridgeLogThresholdForConfiguredLevel(configured);
+    const threshold = logThresholdForConfiguredLevel(configured);
     if (threshold > 3) {
       return false;
     }
-    return this._bridgeLogLevelForName(level) >= threshold;
+    return logLevelForName(level) >= threshold;
   }
   _shouldSuppressBridgeWarn(message) {
     const text = String(message || "").trim();
@@ -4959,21 +5259,14 @@ var LlamaWebGpuBridge = class {
     }
   }
   _disableWorkerFallback(error) {
-    const forcedCpuMultimodal = this._isForcedCpuMultimodalFallbackError(error);
-    const reason = forcedCpuMultimodal ? "multimodal_stability_mode" : serializeWorkerError(error);
+    const reason = serializeWorkerError(error);
     this._workerFallbackReason = reason;
     if (typeof globalThis !== "undefined") {
       globalThis.__llamadartBridgeWorkerFallbackReason = reason;
     }
-    if (forcedCpuMultimodal) {
-      this._emitBridgeWarn(
-        "llamadart: switching multimodal pipeline to main-thread runtime for stability."
-      );
-    } else {
-      this._emitBridgeWarn(
-        `llamadart: bridge worker unavailable, falling back to main thread (${reason})`
-      );
-    }
+    this._emitBridgeWarn(
+      `llamadart: bridge worker unavailable, falling back to main thread (${reason})`
+    );
     if (this._workerProxy) {
       const workerProxy = this._workerProxy;
       this._advanceWorkerGeneration();
@@ -4991,9 +5284,6 @@ var LlamaWebGpuBridge = class {
     }
     if (this._runtime && Array.isArray(this._runtime._runtimeNotes) && typeof reason === "string" && reason.length > 0) {
       this._runtime._runtimeNotes.push(`worker_fallback:${reason}`);
-      if (forcedCpuMultimodal) {
-        this._runtime._runtimeNotes.push("worker_fallback_forced_multimodal");
-      }
     }
   }
   async _callWorker(method, args, onEvent, transferList = []) {
@@ -5517,6 +5807,203 @@ var LlamaWebGpuBridge = class {
       throw error;
     }
   }
+  /** @returns {Map<number, { owner: object, handle: number }>} */
+  _decisionHeadMap() {
+    if (!(this._decisionHeads instanceof Map)) {
+      this._decisionHeads = /* @__PURE__ */ new Map();
+      this._nextDecisionHandle = 1;
+    }
+    return this._decisionHeads;
+  }
+  _registerDecisionHead(owner, info) {
+    const heads = this._decisionHeadMap();
+    const handle = this._nextDecisionHandle++;
+    heads.set(handle, { owner, handle: Number(info?.handle) });
+    return { ...info, handle };
+  }
+  _decisionOwner() {
+    return this._workerProxy || this._runtime || null;
+  }
+  _staleDecisionHeadError(handle) {
+    return new Error(
+      `Decision head ${handle} is not loaded; it was freed, its model was unloaded, or the bridge runtime restarted. Load the decision head again.`
+    );
+  }
+  /** @param {number} handle */
+  _resolveDecisionHead(handle) {
+    decisionHandleFrom(handle);
+    const heads = this._decisionHeadMap();
+    const entry = heads.get(handle);
+    if (!entry) {
+      return null;
+    }
+    if (entry.owner !== this._decisionOwner()) {
+      heads.delete(handle);
+      return null;
+    }
+    return entry;
+  }
+  _requireDecisionRuntime() {
+    if (!this._runtime) {
+      throw new Error("No model loaded. Call loadModelFromUrl first.");
+    }
+    return this._runtime;
+  }
+  /**
+   * Moves a failed worker's work to the main-thread runtime. Heads the worker
+   * held are gone with it; the model is reloaded so later calls keep working.
+   */
+  async _recoverDecisionWorker(error) {
+    this._disableWorkerFallback(error);
+    await this._waitForWorkerDisposal();
+    await this._ensureRuntimeReadyAfterWorkerFallback({}, error);
+  }
+  async getDecisionCapabilities() {
+    return this._runExclusive(
+      () => this._getDecisionCapabilitiesUnlocked(),
+      { kind: "decision-capabilities" }
+    );
+  }
+  async _getDecisionCapabilitiesUnlocked() {
+    if (!this._workerProxy) {
+      return this._runtime ? this._runtime.getDecisionCapabilities() : { apiVersion: DECISION_API_VERSION, supported: false, reason: "WebGPU core is not initialized" };
+    }
+    try {
+      return await this._callWorker("getDecisionCapabilities", []);
+    } catch (error) {
+      this._throwIfOperationCancelled(error, "Decision capability probe was cancelled.");
+      if (!this._shouldFallbackToMainThread(error)) {
+        throw error;
+      }
+      await this._recoverDecisionWorker(error);
+      return this._requireDecisionRuntime().getDecisionCapabilities();
+    }
+  }
+  /**
+   * @param {string | ArrayBuffer | ArrayBufferView} source
+   * @param {{ configJson?: string | null, onProgress?: (progress: { loaded: number, total: number }) => void }} [options]
+   */
+  async loadDecisionHead(source, options = {}) {
+    return this._runExclusive(
+      () => this._loadDecisionHeadUnlocked(source, options),
+      { kind: "decision-head-load" }
+    );
+  }
+  /**
+   * @param {string | ArrayBuffer | ArrayBufferView} source
+   * @param {{ configJson?: string | null, onProgress?: (progress: { loaded: number, total: number }) => void }} [options]
+   */
+  async _loadDecisionHeadUnlocked(source, options = {}) {
+    const loadInRuntime = async () => {
+      const runtime = this._requireDecisionRuntime();
+      return this._registerDecisionHead(
+        runtime,
+        await runtime.loadDecisionHead(source, options)
+      );
+    };
+    if (!this._workerProxy) {
+      return loadInRuntime();
+    }
+    const proxy = this._workerProxy;
+    const workerOptions = { configJson: options?.configJson ?? null };
+    let workerSource = source;
+    const transferList = [];
+    if (typeof source === "string") {
+      workerSource = source.length > 0 ? normalizeAbsoluteUrl(source) : source;
+    } else {
+      const bytes = decisionHeadBytes(source);
+      if (bytes) {
+        const copy = new Uint8Array(bytes);
+        workerSource = copy;
+        transferList.push(copy.buffer);
+      }
+    }
+    try {
+      const info = await this._callWorker(
+        "loadDecisionHead",
+        [workerSource, workerOptions],
+        (event) => {
+          if (event.event === "progress") {
+            options?.onProgress?.(event.payload || {});
+          }
+        },
+        transferList
+      );
+      return this._registerDecisionHead(proxy, info);
+    } catch (error) {
+      this._throwIfOperationCancelled(error, "Decision head load was cancelled.");
+      if (!this._shouldFallbackToMainThread(error)) {
+        throw error;
+      }
+      await this._recoverDecisionWorker(error);
+      return loadInRuntime();
+    }
+  }
+  /**
+   * @param {number} handle
+   * @param {readonly import('./llama_webgpu_bridge.d.ts').DecisionSequence[]} sequences
+   */
+  async runDecision(handle, sequences) {
+    return this._runExclusive(
+      () => this._runDecisionUnlocked(handle, sequences),
+      { kind: "decision-run" }
+    );
+  }
+  /**
+   * @param {number} handle
+   * @param {readonly import('./llama_webgpu_bridge.d.ts').DecisionSequence[]} sequences
+   */
+  async _runDecisionUnlocked(handle, sequences) {
+    const entry = this._resolveDecisionHead(handle);
+    if (!entry) {
+      throw this._staleDecisionHeadError(handle);
+    }
+    const normalized = normalizeDecisionSequences(sequences);
+    if (!this._workerProxy) {
+      return this._requireDecisionRuntime().runDecision(entry.handle, normalized);
+    }
+    try {
+      return await this._callWorker("runDecision", [entry.handle, normalized]);
+    } catch (error) {
+      this._throwIfOperationCancelled(error, "Decision run was cancelled.");
+      if (!this._shouldFallbackToMainThread(error)) {
+        throw error;
+      }
+      this._decisionHeadMap().delete(handle);
+      await this._recoverDecisionWorker(error);
+      throw new Error(
+        `Decision head ${handle} was lost when the bridge worker failed (${serializeWorkerError(error)}). Load the decision head again.`
+      );
+    }
+  }
+  /** @param {number} handle */
+  async freeDecisionHead(handle) {
+    return this._runExclusive(
+      () => this._freeDecisionHeadUnlocked(handle),
+      { kind: "decision-head-free" }
+    );
+  }
+  /** @param {number} handle */
+  async _freeDecisionHeadUnlocked(handle) {
+    const entry = this._resolveDecisionHead(handle);
+    if (!entry) {
+      return;
+    }
+    this._decisionHeadMap().delete(handle);
+    if (!this._workerProxy) {
+      await this._requireDecisionRuntime().freeDecisionHead(entry.handle);
+      return;
+    }
+    try {
+      await this._callWorker("freeDecisionHead", [entry.handle]);
+    } catch (error) {
+      this._throwIfOperationCancelled(error, "Decision head free was cancelled.");
+      if (!this._shouldFallbackToMainThread(error)) {
+        throw error;
+      }
+      await this._recoverDecisionWorker(error);
+    }
+  }
   async tokenize(text, addSpecial = true) {
     return this._runExclusive(
       () => this._tokenizeUnlocked(text, addSpecial),
@@ -5793,6 +6280,7 @@ var LlamaWebGpuBridge = class {
       this._loadedMmProjUrl = null;
       this._workerFallbackReason = null;
       this._multimodalWorkerCpuMode = false;
+      this._decisionHeads?.clear();
       this._lifecycleState = "disposed";
     }
   }

webgpu_bridge/llama_webgpu_core.wasm

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f643e79520ac97bc150db6806735b9b73a98b07eb1b2fa4146bb773944315c71
-size 8918014
+oid sha256:4c2e81f5c44808367aa3f484776e7e4faa9f3841511d6a7ad2a39e6ec063d4a9
+size 9170142

webgpu_bridge/llama_webgpu_core_mem64.wasm

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:aaf399050af09af0c44b55ecf9d665e8f6e18df6f6deada3feab07677ddd7233
-size 9145549
+oid sha256:a6de570070c13c73d90666e903c4770f5eeb2d24be7fc630444de6d6609133a9
+size 9410357

webgpu_bridge/manifest.json

@@ -1,37 +1,37 @@
 {
   "artifacts": {
     "llama_webgpu_bridge.d.ts": {
-      "sha256": "be584430457c76cf991c39ebfd19f771424f86f6304899840bf9e50f1b32cafc",
-      "size_bytes": 6330
+      "sha256": "d8fa58ab587bb79c44dff40714fa8fa130da8ead160c8aa33f9254ed75055837",
+      "size_bytes": 7810
     },
     "llama_webgpu_bridge.js": {
-      "sha256": "a704115fe87d3defff4a02c5a2b1d1bf0ab3bc1f00de3f40ed2c9b2d5983fd73",
-      "size_bytes": 210601
+      "sha256": "eaa670759e559ca7ee7182fe8d5440872b6861aa6c3a5e8b7ec7f6e55c604254",
+      "size_bytes": 227520
     },
     "llama_webgpu_bridge_worker.js": {
       "sha256": "47bbfa0fe897e708455b9497e9aa41d2e94489c329300c33b12936fb3169deca",
       "size_bytes": 257
     },
     "llama_webgpu_core.js": {
-      "sha256": "67bade52aad19471ee96a7180db691e1f6b4e87d4254adaa3e5d9a31f6206ed1",
-      "size_bytes": 113847
+      "sha256": "7e0617766b459bd1d1e398705716730e472bdfc0147f54212a5eb113b75b8a43",
+      "size_bytes": 114678
     },
     "llama_webgpu_core.wasm": {
-      "sha256": "f643e79520ac97bc150db6806735b9b73a98b07eb1b2fa4146bb773944315c71",
-      "size_bytes": 8918014
+      "sha256": "4c2e81f5c44808367aa3f484776e7e4faa9f3841511d6a7ad2a39e6ec063d4a9",
+      "size_bytes": 9170142
     },
     "llama_webgpu_core_mem64.js": {
-      "sha256": "6575880ad6a631b6a8f9aaaebb9a5c3f1cc2910f59700ce529d3de6077276337",
-      "size_bytes": 130764
+      "sha256": "3f9c7e8738588b043ba69688df836feefd1a95a211a281d9ae5ba6ac181f3bb2",
+      "size_bytes": 131595
     },
     "llama_webgpu_core_mem64.wasm": {
-      "sha256": "aaf399050af09af0c44b55ecf9d665e8f6e18df6f6deada3feab07677ddd7233",
-      "size_bytes": 9145549
+      "sha256": "a6de570070c13c73d90666e903c4770f5eeb2d24be7fc630444de6d6609133a9",
+      "size_bytes": 9410357
     }
   },
   "assets_repository": "leehack/llama-web-bridge-assets",
-  "bridge_assets_tag": "v0.1.44",
-  "bridge_commit": "89178be67c3c84300bc1b129182bd5bc5a8e21fc",
+  "bridge_assets_tag": "v0.1.47",
+  "bridge_commit": "64ba8250871bf2472cc2064c6a00fff050783f02",
   "bridge_repository": "leehack/llama-web-bridge",
   "capabilities": {
     "memory64": true,
@@ -62,43 +62,43 @@
   "emscripten_version": "6.0.8",
   "files": {
     "llama_webgpu_bridge.d.ts": {
-      "sha256": "be584430457c76cf991c39ebfd19f771424f86f6304899840bf9e50f1b32cafc",
-      "size_bytes": 6330
+      "sha256": "d8fa58ab587bb79c44dff40714fa8fa130da8ead160c8aa33f9254ed75055837",
+      "size_bytes": 7810
     },
     "llama_webgpu_bridge.js": {
-      "sha256": "a704115fe87d3defff4a02c5a2b1d1bf0ab3bc1f00de3f40ed2c9b2d5983fd73",
-      "size_bytes": 210601
+      "sha256": "eaa670759e559ca7ee7182fe8d5440872b6861aa6c3a5e8b7ec7f6e55c604254",
+      "size_bytes": 227520
     },
     "llama_webgpu_bridge_worker.js": {
       "sha256": "47bbfa0fe897e708455b9497e9aa41d2e94489c329300c33b12936fb3169deca",
       "size_bytes": 257
     },
     "llama_webgpu_core.js": {
-      "sha256": "67bade52aad19471ee96a7180db691e1f6b4e87d4254adaa3e5d9a31f6206ed1",
-      "size_bytes": 113847
+      "sha256": "7e0617766b459bd1d1e398705716730e472bdfc0147f54212a5eb113b75b8a43",
+      "size_bytes": 114678
     },
     "llama_webgpu_core.wasm": {
-      "sha256": "f643e79520ac97bc150db6806735b9b73a98b07eb1b2fa4146bb773944315c71",
-      "size_bytes": 8918014
+      "sha256": "4c2e81f5c44808367aa3f484776e7e4faa9f3841511d6a7ad2a39e6ec063d4a9",
+      "size_bytes": 9170142
     },
     "llama_webgpu_core_mem64.js": {
-      "sha256": "6575880ad6a631b6a8f9aaaebb9a5c3f1cc2910f59700ce529d3de6077276337",
-      "size_bytes": 130764
+      "sha256": "3f9c7e8738588b043ba69688df836feefd1a95a211a281d9ae5ba6ac181f3bb2",
+      "size_bytes": 131595
     },
     "llama_webgpu_core_mem64.wasm": {
-      "sha256": "aaf399050af09af0c44b55ecf9d665e8f6e18df6f6deada3feab07677ddd7233",
-      "size_bytes": 9145549
+      "sha256": "a6de570070c13c73d90666e903c4770f5eeb2d24be7fc630444de6d6609133a9",
+      "size_bytes": 9410357
     }
   },
-  "github_run_id": "35075283754",
-  "github_run_url": "https://github.com/leehack/llama-web-bridge/actions/runs/35075283754",
+  "github_run_id": "35904377401",
+  "github_run_url": "https://github.com/leehack/llama-web-bridge/actions/runs/35904377401",
   "llama_cpp_commit": "b29c606e28a01b1bc8c1351026a0fa6e616bf6c4",
   "llama_cpp_tag": "v0.4.1",
   "native_commit": "a4ee6b9fa71127d6cdf625e26d82ca5ab7b1d102",
   "native_manifest_sha256": "d8dc86fcb55e566ee04aa9ed235716bd0e7a48cdaecb17822c098b074ec33d3e",
   "native_release_tag": "v0.4.1",
   "native_repository": "leehack/llamadart-native",
-  "orchestrator_correlation_id": "auto-stable-v0.4.1-d8dc86fcb55e566e-build-89178be67c3c8430",
+  "orchestrator_correlation_id": "auto-stable-v0.4.1-d8dc86fcb55e566e-build-64ba8250871bf247",
   "qualification_gates": {
     "multimodal": "passed",
     "speech_to_text": "required-automated-qualification",
@@ -107,9 +107,9 @@
   },
   "release_channel": "stable",
   "release_rebuild": 0,
-  "release_tag": "v0.1.44",
+  "release_tag": "v0.1.47",
   "schema_version": 2,
-  "source_commit": "89178be67c3c84300bc1b129182bd5bc5a8e21fc",
+  "source_commit": "64ba8250871bf2472cc2064c6a00fff050783f02",
   "source_repository": "leehack/llama-web-bridge",
   "unproven_capabilities": {
     "hardware_gpu_acceleration": "unavailable-on-hosted-runners",

webgpu_bridge/sha256sums.txt

@@ -1,7 +1,7 @@
-a704115fe87d3defff4a02c5a2b1d1bf0ab3bc1f00de3f40ed2c9b2d5983fd73  llama_webgpu_bridge.js
-67bade52aad19471ee96a7180db691e1f6b4e87d4254adaa3e5d9a31f6206ed1  llama_webgpu_core.js
-f643e79520ac97bc150db6806735b9b73a98b07eb1b2fa4146bb773944315c71  llama_webgpu_core.wasm
+eaa670759e559ca7ee7182fe8d5440872b6861aa6c3a5e8b7ec7f6e55c604254  llama_webgpu_bridge.js
+7e0617766b459bd1d1e398705716730e472bdfc0147f54212a5eb113b75b8a43  llama_webgpu_core.js
+4c2e81f5c44808367aa3f484776e7e4faa9f3841511d6a7ad2a39e6ec063d4a9  llama_webgpu_core.wasm
 47bbfa0fe897e708455b9497e9aa41d2e94489c329300c33b12936fb3169deca  llama_webgpu_bridge_worker.js
-be584430457c76cf991c39ebfd19f771424f86f6304899840bf9e50f1b32cafc  llama_webgpu_bridge.d.ts
-6575880ad6a631b6a8f9aaaebb9a5c3f1cc2910f59700ce529d3de6077276337  llama_webgpu_core_mem64.js
-aaf399050af09af0c44b55ecf9d665e8f6e18df6f6deada3feab07677ddd7233  llama_webgpu_core_mem64.wasm
+d8fa58ab587bb79c44dff40714fa8fa130da8ead160c8aa33f9254ed75055837  llama_webgpu_bridge.d.ts
+3f9c7e8738588b043ba69688df836feefd1a95a211a281d9ae5ba6ac181f3bb2  llama_webgpu_core_mem64.js
+a6de570070c13c73d90666e903c4770f5eeb2d24be7fc630444de6d6609133a9  llama_webgpu_core_mem64.wasm