tinywebui 0.1.3 → 0.1.5

package/src/files/documents.js

@@ -5,87 +5,76 @@
  * will be .txt/.md, and there's no reason to pay pdf-parse's or mammoth's
  * load cost on every server start for the rare PDF or docx.
  */
-
 const TEXT_EXTS = new Set([
-  '.txt', '.md', '.markdown', '.csv', '.tsv', '.json', '.log',
-  '.js', '.ts', '.jsx', '.tsx', '.py', '.rb', '.go', '.rs', '.java', '.c', '.cpp', '.h',
-  '.css', '.html', '.xml', '.yaml', '.yml', '.sh', '.sql'
+    '.txt', '.md', '.markdown', '.csv', '.tsv', '.json', '.log',
+    '.js', '.ts', '.jsx', '.tsx', '.py', '.rb', '.go', '.rs', '.java', '.c', '.cpp', '.h',
+    '.css', '.html', '.xml', '.yaml', '.yml', '.sh', '.sql'
 ]);
-
 function extOf(filename) {
-  const i = filename.lastIndexOf('.');
-  return i === -1 ? '' : filename.slice(i).toLowerCase();
+    const i = filename.lastIndexOf('.');
+    return i === -1 ? '' : filename.slice(i).toLowerCase();
 }
-
 /**
  * How to hand an uploaded file back to a browser. Decided from the name alone,
  * never the client-supplied type: this is served from the app's own origin, so
  * anything a browser would run (html, svg) goes out as inert text or a download.
  */
 export function servingFor(filename) {
-  const ext = extOf(filename);
-  if (ext === '.pdf') return { type: 'application/pdf', inline: true };
-  if (TEXT_EXTS.has(ext) || ext === '') return { type: 'text/plain; charset=utf-8', inline: true };
-  return { type: 'application/octet-stream', inline: false };
+    const ext = extOf(filename);
+    if (ext === '.pdf')
+        return { type: 'application/pdf', inline: true };
+    if (TEXT_EXTS.has(ext) || ext === '')
+        return { type: 'text/plain; charset=utf-8', inline: true };
+    return { type: 'application/octet-stream', inline: false };
 }
-
-/**
- * @param {Buffer} buf raw file bytes
- * @param {string} filename original filename, used only to pick a parser
- * @returns {Promise<string>} extracted plain text
- */
+/** Extracted plain text. `filename` is used only to pick a parser. */
 export async function extractText(buf, filename) {
-  const ext = extOf(filename);
-
-  if (ext === '.pdf') {
-    // unpdf ships its own serverless PDF.js build and needs no native canvas
-    // binary for plain text extraction, unlike pdf-parse v2 (which pulls in
-    // @napi-rs/canvas even when nothing here ever renders a page).
-    let text;
-    try {
-      const { extractText, getDocumentProxy } = await import('unpdf');
-      const pdf = await getDocumentProxy(new Uint8Array(buf));
-      ({ text } = await extractText(pdf, { mergePages: true }));
-    } catch (err) {
-      // pdf.js's own exception names (PasswordException, and a handful of
-      // "invalid structure" variants for anything that isn't a well-formed
-      // PDF) are not something a user should have to decode -- the two cases
-      // worth telling apart are password protection and a file that just
-      // isn't a readable PDF at all.
-      if (err?.name === 'PasswordException' || /password/i.test(err?.message || '')) {
-        throw new Error('this PDF is password-protected -- remove the password and re-upload');
-      }
-      throw new Error(`could not read this PDF (${err?.message || 'corrupt file, or not actually a PDF'})`);
+    const ext = extOf(filename);
+    if (ext === '.pdf') {
+        // unpdf ships its own serverless PDF.js build and needs no native canvas
+        // binary for plain text extraction, unlike pdf-parse v2 (which pulls in
+        // @napi-rs/canvas even when nothing here ever renders a page).
+        let text;
+        try {
+            const { extractText, getDocumentProxy } = await import('unpdf');
+            const pdf = await getDocumentProxy(new Uint8Array(buf));
+            ({ text } = await extractText(pdf, { mergePages: true }));
+        }
+        catch (err) {
+            // pdf.js's own exception names (PasswordException, and a handful of
+            // "invalid structure" variants for anything that isn't a well-formed
+            // PDF) are not something a user should have to decode -- the two cases
+            // worth telling apart are password protection and a file that just
+            // isn't a readable PDF at all.
+            if (err?.name === 'PasswordException' || /password/i.test(err?.message || '')) {
+                throw new Error('this PDF is password-protected -- remove the password and re-upload');
+            }
+            throw new Error(`could not read this PDF (${err?.message || 'corrupt file, or not actually a PDF'})`);
+        }
+        if (!text.trim()) {
+            // Parsed cleanly but yielded nothing: near-certainly a scanned or
+            // image-only PDF. There is no OCR here, so say that plainly instead of
+            // leaving it to read like the upload itself failed.
+            throw new Error('no extractable text -- this looks like a scanned or image-only PDF, which needs OCR that this app does not do');
+        }
+        return text;
+    }
+    if (ext === '.docx') {
+        let value;
+        try {
+            const { extractRawText } = await import('mammoth');
+            ({ value } = await extractRawText({ buffer: buf }));
+        }
+        catch (err) {
+            throw new Error(`could not read this .docx (${err?.message || 'corrupt file, or not actually a .docx'})`);
+        }
+        return value;
     }
-    if (!text.trim()) {
-      // Parsed cleanly but yielded nothing: near-certainly a scanned or
-      // image-only PDF. There is no OCR here, so say that plainly instead of
-      // leaving it to read like the upload itself failed.
-      throw new Error(
-        'no extractable text -- this looks like a scanned or image-only PDF, which needs OCR that this app does not do'
-      );
+    if (ext === '.doc') {
+        throw new Error('legacy .doc is not supported -- save it as .docx or .pdf and re-upload');
     }
-    return text;
-  }
-
-  if (ext === '.docx') {
-    let value;
-    try {
-      const { extractRawText } = await import('mammoth');
-      ({ value } = await extractRawText({ buffer: buf }));
-    } catch (err) {
-      throw new Error(`could not read this .docx (${err?.message || 'corrupt file, or not actually a .docx'})`);
+    if (TEXT_EXTS.has(ext) || ext === '') {
+        return buf.toString('utf8');
     }
-    return value;
-  }
-
-  if (ext === '.doc') {
-    throw new Error('legacy .doc is not supported -- save it as .docx or .pdf and re-upload');
-  }
-
-  if (TEXT_EXTS.has(ext) || ext === '') {
-    return buf.toString('utf8');
-  }
-
-  throw new Error(`unsupported file type "${ext || filename}"`);
+    throw new Error(`unsupported file type "${ext || filename}"`);
 }

package/src/files/images.js

@@ -3,60 +3,59 @@ import { fileURLToPath } from 'node:url';
 import heicConvert from 'heic-convert';
 import decodeAvif, { init as initAvif } from '@jsquash/avif/decode.js';
 import jpeg from 'jpeg-js';
-
 // @jsquash/avif is built for the browser and fetches its own .wasm by URL on
 // init; Node's fetch can't load a file: URL, so the module is compiled and
 // handed to it directly instead. Compiled once, lazily, and reused.
 let avifReady;
 function ensureAvif() {
-  if (!avifReady) {
-    const wasmPath = fileURLToPath(import.meta.resolve('@jsquash/avif/codec/dec/avif_dec.wasm'));
-    avifReady = WebAssembly.compile(readFileSync(wasmPath)).then((mod) => initAvif(mod));
-  }
-  return avifReady;
+    if (!avifReady) {
+        const wasmPath = fileURLToPath(import.meta.resolve('@jsquash/avif/codec/dec/avif_dec.wasm'));
+        // The typings describe browser init options; handing it the compiled module works the same.
+        avifReady = WebAssembly.compile(readFileSync(wasmPath)).then((mod) => initAvif(mod));
+    }
+    return avifReady;
 }
-
 /** Formats every OpenAI-compatible vision endpoint accepts on the wire. */
 const WIRE_MIMES = new Set(['image/jpeg', 'image/png', 'image/webp', 'image/gif']);
-
 /**
  * Browser-reported mime for HEIC/AVIF is unreliable -- Chrome often reports
  * an empty string for HEIC, and some pickers report generic octet-stream for
  * both. Sniffing the ISO-BMFF ftyp brand is what actually tells them apart.
  */
 function sniff(buf) {
-  if (buf.length < 12 || buf.toString('ascii', 4, 8) !== 'ftyp') return null;
-  const brand = buf.toString('ascii', 8, 12);
-  if (['avif', 'avis'].includes(brand)) return 'avif';
-  if (['heic', 'heix', 'hevc', 'hevx', 'heim', 'heis', 'hevm', 'hevs', 'mif1', 'msf1'].includes(brand)) return 'heic';
-  return null;
+    if (buf.length < 12 || buf.toString('ascii', 4, 8) !== 'ftyp')
+        return null;
+    const brand = buf.toString('ascii', 8, 12);
+    if (['avif', 'avis'].includes(brand))
+        return 'avif';
+    if (['heic', 'heix', 'hevc', 'hevx', 'heim', 'heis', 'hevm', 'hevs', 'mif1', 'msf1'].includes(brand))
+        return 'heic';
+    return null;
 }
-
 async function fromHeic(buf) {
-  const out = await heicConvert({ buffer: buf, format: 'JPEG', quality: 0.9 });
-  return Buffer.from(out);
+    const out = await heicConvert({ buffer: buf, format: 'JPEG', quality: 0.9 });
+    return Buffer.from(out);
 }
-
 async function fromAvif(buf) {
-  await ensureAvif();
-  const image = await decodeAvif(buf);
-  const out = jpeg.encode(image, 90);
-  return Buffer.from(out.data);
+    await ensureAvif();
+    const image = await decodeAvif(buf);
+    const out = jpeg.encode(image, 90);
+    return Buffer.from(out.data);
 }
-
 /**
  * Normalizes one uploaded image to a wire-safe mime, converting HEIC/AVIF to
  * JPEG in place. Returns null for anything else unrecognized rather than
  * forwarding a format the provider can't decode.
  */
 export async function normalizeImage(buf, reportedMime) {
-  const declared = String(reportedMime || '').toLowerCase();
-  if (WIRE_MIMES.has(declared)) return { mime: declared, data: buf };
-
-  const kind = sniff(buf) || (declared === 'image/heic' || declared === 'image/heif' ? 'heic'
-    : declared === 'image/avif' ? 'avif' : null);
-
-  if (kind === 'heic') return { mime: 'image/jpeg', data: await fromHeic(buf) };
-  if (kind === 'avif') return { mime: 'image/jpeg', data: await fromAvif(buf) };
-  return null;
+    const declared = String(reportedMime || '').toLowerCase();
+    if (WIRE_MIMES.has(declared))
+        return { mime: declared, data: buf };
+    const kind = sniff(buf) || (declared === 'image/heic' || declared === 'image/heif' ? 'heic'
+        : declared === 'image/avif' ? 'avif' : null);
+    if (kind === 'heic')
+        return { mime: 'image/jpeg', data: await fromHeic(buf) };
+    if (kind === 'avif')
+        return { mime: 'image/jpeg', data: await fromAvif(buf) };
+    return null;
 }

package/src/harness/agent.js

@@ -27,61 +27,58 @@ import { EVENT } from '../../public/shared/events.js';
  * Returns the messages appended during the run, in transcript order.
  */
 export async function runAgentLoop({ messages, maxRounds, runtime, signal }) {
-  const working = [...messages];
-  const appended = [];
-  const emit = runtime.onEvent || (() => {});
-
-  // One extra pass past the budget: tools are mechanically refused there, so the
-  // model spends it writing an answer instead of leaving the turn unfinished.
-  for (let round = 0; round <= maxRounds; round++) {
-    const lastCall = round === maxRounds;
-    if (lastCall) {
-      emit({
-        type: EVENT.NOTICE,
-        text: `Tool budget spent (${maxRounds} rounds) — answering with what was gathered.`
-      });
+    const working = [...messages];
+    const appended = [];
+    const emit = runtime.onEvent || (() => { });
+    // One extra pass past the budget: tools are mechanically refused there, so the
+    // model spends it writing an answer instead of leaving the turn unfinished.
+    for (let round = 0; round <= maxRounds; round++) {
+        const lastCall = round === maxRounds;
+        if (lastCall) {
+            emit({
+                type: EVENT.NOTICE,
+                text: `Tool budget spent (${maxRounds} rounds) — answering with what was gathered.`
+            });
+        }
+        const assistant = await runtime.streamTurn({ messages: working, round, lastCall, signal });
+        // A provider that ignores tool_choice could still emit calls here. Dropping
+        // them keeps history valid, since nothing will produce their results.
+        if (lastCall)
+            delete assistant.tool_calls;
+        working.push(assistant);
+        appended.push(assistant);
+        const take = async () => {
+            const input = (await runtime.pendingInput?.({ round })) || [];
+            for (const { wire, message } of input) {
+                working.push(wire);
+                appended.push(message);
+            }
+            return input.length > 0;
+        };
+        const calls = assistant.tool_calls || [];
+        // The last pass takes no input: nothing would answer it. It stays queued.
+        if (lastCall)
+            return appended;
+        if (!calls.length) {
+            if (await take())
+                continue;
+            return appended;
+        }
+        const results = await runtime.executeToolBatch(calls, { messages: working, round, lastCall, signal });
+        for (const { wire, message } of results) {
+            working.push(wire);
+            appended.push(message);
+        }
+        // Checked only now: a Stop mid-batch still gets every call its result.
+        if (signal?.aborted)
+            throw new Error('Stopped.');
+        if (runtime.shouldContinue && !(await runtime.shouldContinue({ round, assistant, results }))) {
+            return appended;
+        }
+        await take();
     }
-
-    const assistant = await runtime.streamTurn({ messages: working, round, lastCall, signal });
-    // A provider that ignores tool_choice could still emit calls here. Dropping
-    // them keeps history valid, since nothing will produce their results.
-    if (lastCall) delete assistant.tool_calls;
-    working.push(assistant);
-    appended.push(assistant);
-
-    const take = async () => {
-      const input = (await runtime.pendingInput?.({ round })) || [];
-      for (const { wire, message } of input) {
-        working.push(wire);
-        appended.push(message);
-      }
-      return input.length > 0;
-    };
-
-    const calls = assistant.tool_calls || [];
-    // The last pass takes no input: nothing would answer it. It stays queued.
-    if (lastCall) return appended;
-    if (!calls.length) {
-      if (await take()) continue;
-      return appended;
-    }
-
-    const results = await runtime.executeToolBatch(calls, { messages: working, round, lastCall, signal });
-    for (const { wire, message } of results) {
-      working.push(wire);
-      appended.push(message);
-    }
-    // Checked only now: a Stop mid-batch still gets every call its result.
-    if (signal?.aborted) throw new Error('Stopped.');
-
-    if (runtime.shouldContinue && !(await runtime.shouldContinue({ round, assistant, results }))) {
-      return appended;
-    }
-    await take();
-  }
-  return appended;
+    return appended;
 }
-
 /**
  * Lifecycle hooks: small internal seams at the tool and turn boundaries, so
  * cross-cutting policy (approvals, audit, result shaping, stopping early)
@@ -105,11 +102,14 @@ export async function runAgentLoop({ messages, maxRounds, runtime, signal }) {
  * swallowed here; the caller turns it into a visible outcome.
  */
 export async function runHooks(list, ctx, each = () => false) {
-  for (const hook of list || []) {
-    if (ctx.signal?.aborted) throw new Error('Stopped.');
-    const out = await hook(ctx);
-    if (ctx.signal?.aborted) throw new Error('Stopped.');
-    if (out && each(out)) return true;
-  }
-  return false;
+    for (const hook of list || []) {
+        if (ctx.signal?.aborted)
+            throw new Error('Stopped.');
+        const out = await hook(ctx);
+        if (ctx.signal?.aborted)
+            throw new Error('Stopped.');
+        if (out && each(out))
+            return true;
+    }
+    return false;
 }

package/src/harness/attribution.js

@@ -1,75 +1,83 @@
 import { inputTokens, outputTokens, cacheReads } from '../../public/shared/usage.js';
-
 // Counts only: never retain another copy of prompts, schemas or tool output.
 // The char/4 estimator matches compact.js; it is not provider tokenization.
 const estimate = (value) => Math.ceil((typeof value === 'string' ? value : JSON.stringify(value ?? '')).length / 4);
 const count = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : null;
-const bucket = (category, tokens, source = 'estimated', capability = null) => ({ category, tokens, source, ...(capability ? { capability } : {}) });
+const bucket = (category, tokens, source = 'estimated', capability) => ({ category, tokens, source, ...(capability ? { capability } : {}) });
 const sum = (buckets) => buckets.reduce((n, b) => n + b.tokens, 0);
 const text = (content) => typeof content === 'string' ? content : Array.isArray(content)
-  ? content.filter((p) => p.type === 'text').map((p) => p.text || '').join('') : '';
-
+    ? content.filter((p) => p.type === 'text').map((p) => p.text || '').join('') : '';
 export function attributeRequest(body, { systemParts = [], owner = () => 'built-ins' } = {}) {
-  const buckets = [];
-  const add = (category, value, capability) => {
-    if (value) buckets.push(bucket(category, estimate(value), 'estimated', capability));
-  };
-  let systemAttributed = false;
-  for (const message of body.messages || []) {
-    if (message.role === 'system') {
-      const actual = text(message.content);
-      if (!systemAttributed && actual === systemParts.map((p) => p.text).filter(Boolean).join('\n\n')) {
-        for (const part of systemParts) add(part.category, part.text, part.capability);
-        systemAttributed = true;
-      } else add('system_other', actual);
-      continue;
+    const buckets = [];
+    const add = (category, value, capability) => {
+        if (value)
+            buckets.push(bucket(category, estimate(value), 'estimated', capability));
+    };
+    let systemAttributed = false;
+    for (const message of body.messages || []) {
+        if (message.role === 'system') {
+            const actual = text(message.content);
+            if (!systemAttributed && actual === systemParts.map((p) => p.text).filter(Boolean).join('\n\n')) {
+                for (const part of systemParts)
+                    add(part.category, part.text, part.capability);
+                systemAttributed = true;
+            }
+            else
+                add('system_other', actual);
+            continue;
+        }
+        const category = message.role === 'user' ? 'user_messages'
+            : message.role === 'tool' ? 'tool_results' : 'assistant_history';
+        add(category, text(message.content));
+        for (const part of Array.isArray(message.content) ? message.content : []) {
+            if (part.type === 'image_url')
+                buckets.push(bucket('image_allowance', 1500));
+            else if (part.type !== 'text')
+                add('attachments_other', part);
+        }
+        if (message.tool_calls)
+            add('tool_history', message.tool_calls);
+        if (message.reasoning_details)
+            add('reasoning_history', message.reasoning_details);
+        if (message.reasoning_content)
+            add('reasoning_history', message.reasoning_content);
     }
-    const category = message.role === 'user' ? 'user_messages'
-      : message.role === 'tool' ? 'tool_results' : 'assistant_history';
-    add(category, text(message.content));
-    for (const part of Array.isArray(message.content) ? message.content : []) {
-      if (part.type === 'image_url') buckets.push(bucket('image_allowance', 1500));
-      else if (part.type !== 'text') add('attachments_other', part);
+    for (const tool of body.tools || [])
+        add('tool_schemas', tool, owner(tool.function?.name));
+    const compact = new Map();
+    for (const b of buckets) {
+        const key = JSON.stringify([b.category, b.source, b.capability]);
+        const entry = compact.get(key) || { ...b, tokens: 0 };
+        entry.tokens += b.tokens;
+        compact.set(key, entry);
     }
-    if (message.tool_calls) add('tool_history', message.tool_calls);
-    if (message.reasoning_details) add('reasoning_history', message.reasoning_details);
-    if (message.reasoning_content) add('reasoning_history', message.reasoning_content);
-  }
-  for (const tool of body.tools || []) add('tool_schemas', tool, owner(tool.function?.name));
-  const compact = new Map();
-  for (const b of buckets) {
-    const key = JSON.stringify([b.category, b.source, b.capability]);
-    const entry = compact.get(key) || { ...b, tokens: 0 };
-    entry.tokens += b.tokens;
-    compact.set(key, entry);
-  }
-  return { buckets: [...compact.values()], estimatedTotal: sum(buckets) };
+    return { buckets: [...compact.values()], estimatedTotal: sum(buckets) };
 }
-
 function reconcile(buckets, total) {
-  return { total, source: total === null ? 'unreported' : 'provider', buckets: total === null ? buckets
-    : [...buckets, bucket('provider_delta', total - sum(buckets), 'estimated')] };
+    return { total, source: total === null ? 'unreported' : 'provider', buckets: total === null ? buckets
+            : [...buckets, bucket('provider_delta', total - sum(buckets), 'estimated')] };
 }
-
 export function completeAttribution(input, usage, { content = '', reasoning = '', toolCalls = [], details = [] } = {}) {
-  const output = [];
-  const reportedReasoning = count(usage?.completion_tokens_details?.reasoning_tokens ?? usage?.output_tokens_details?.reasoning_tokens ?? usage?.reasoning_tokens);
-  if (reportedReasoning !== null) output.push(bucket('reasoning', reportedReasoning, 'provider'));
-  else {
-    const visibleReasoning = reasoning || details.map((d) => d.text || d.summary || '').join('');
-    if (visibleReasoning) output.push(bucket('reasoning', estimate(visibleReasoning)));
-  }
-  if (toolCalls.length) output.push(bucket('tool_generation', estimate(toolCalls.map((c) => c.function))));
-  if (content) output.push(bucket('intermediate_text', estimate(content)));
-  return {
-    version: 1, estimator: 'characters/4; images 1500 tokens each',
-    input: reconcile(input.buckets, inputTokens(usage)),
-    output: reconcile(output, outputTokens(usage)),
-    cached: cacheReads(usage)
-  };
+    const output = [];
+    const reportedReasoning = count(usage?.completion_tokens_details?.reasoning_tokens ?? usage?.output_tokens_details?.reasoning_tokens ?? usage?.reasoning_tokens);
+    if (reportedReasoning !== null)
+        output.push(bucket('reasoning', reportedReasoning, 'provider'));
+    else {
+        const visibleReasoning = reasoning || details.map((d) => d.text || d.summary || '').join('');
+        if (visibleReasoning)
+            output.push(bucket('reasoning', estimate(visibleReasoning)));
+    }
+    if (toolCalls.length)
+        output.push(bucket('tool_generation', estimate(toolCalls.map((c) => c.function))));
+    if (content)
+        output.push(bucket('intermediate_text', estimate(content)));
+    return {
+        version: 1, estimator: 'characters/4; images 1500 tokens each',
+        input: reconcile(input.buckets, inputTokens(usage)),
+        output: reconcile(output, outputTokens(usage)),
+        cached: cacheReads(usage)
+    };
 }
-
 export function markFinal(attribution) {
-  return { ...attribution, output: { ...attribution.output, buckets: attribution.output.buckets.map((b) =>
-    b.category === 'intermediate_text' ? { ...b, category: 'final_text' } : b) } };
+    return { ...attribution, output: { ...attribution.output, buckets: attribution.output.buckets.map((b) => b.category === 'intermediate_text' ? { ...b, category: 'final_text' } : b) } };
 }