@genesislcap/ai-assistant 15.23.3 → 15.24.0

package/dist/esm/components/settings-modal/settings-modal.template.js

@@ -100,15 +100,26 @@ const platformContextUsageTemplate = (progressTag) => html `
       <div class="settings-context-usage" part="context-usage">
         <div class="settings-context-header">
           <span class="settings-context-label">Context window</span>
+          <!--
+            Read through the pre-formatted \`settingsContextUsage\` rather than
+            \`contextTokens\`/\`contextLimit\` directly. These bindings used to carry
+            non-null assertions, and they re-evaluate in the SAME notify batch as the
+            \`when\` above that unmounts them — so a session Clear with this tab open
+            threw \`Cannot read properties of undefined (reading 'toLocaleString')\`
+            twice per render. Optional access on a shape that can be absent cannot.
+            The \`?? ''\` fallbacks matter for the same reason: these bindings provably
+            DO evaluate while the figures are absent, so without them a lost race
+            with the guard would flash the literal text "undefined".
+          -->
           <span class="settings-context-tokens">
-            ${(x) => x.contextTokens.toLocaleString()} /
-            ${(x) => x.contextLimit.toLocaleString()} tokens
-            (${(x) => Math.round((x.contextTokens / x.contextLimit) * 100)}%)
+            ${(x) => { var _a, _b; return (_b = (_a = x.settingsContextUsage) === null || _a === void 0 ? void 0 : _a.used) !== null && _b !== void 0 ? _b : ''; }} /
+            ${(x) => { var _a, _b; return (_b = (_a = x.settingsContextUsage) === null || _a === void 0 ? void 0 : _a.limit) !== null && _b !== void 0 ? _b : ''; }} tokens
+            (${(x) => { var _a, _b; return (_b = (_a = x.settingsContextUsage) === null || _a === void 0 ? void 0 : _a.percent) !== null && _b !== void 0 ? _b : ''; }}%)
           </span>
         </div>
         <${progressTag}
           part="context-progress"
-          value="${(x) => Math.min(100, Math.round((x.contextTokens / x.contextLimit) * 100))}"
+          value="${(x) => { var _a, _b; return (_b = (_a = x.settingsContextUsage) === null || _a === void 0 ? void 0 : _a.barValue) !== null && _b !== void 0 ? _b : 0; }}"
         ></${progressTag}>
       </div>
     `)}

package/dist/esm/main/attachment-controller.js

@@ -0,0 +1,254 @@
+import { __awaiter, __decorate } from "tslib";
+import { observable } from '@genesislcap/web-core';
+import { logger } from '../utils/logger';
+/**
+ * The image types BOTH vendors accept, and therefore the only ones sent as image blocks.
+ *
+ * A host's `acceptedFiles` may well say `image/*`, which covers HEIC, BMP, TIFF, AVIF and SVG —
+ * none of which the APIs take. Sending one fails the whole turn the user is waiting on, so
+ * anything outside this set falls through to the text branch instead: harmless for a binary, and
+ * genuinely useful for SVG, which is text a model can read.
+ *
+ * `image/jpg` is absent on purpose — `normalizeImageMime` rewrites it to `image/jpeg` at the
+ * transport, but a file arriving with that spelling is still a real JPEG, so it is accepted here.
+ */
+const VENDOR_IMAGE_MIME_TYPES = new Set([
+    'image/jpeg',
+    'image/jpg',
+    'image/png',
+    'image/gif',
+    'image/webp',
+]);
+/**
+ * Ceiling on ONE image attachment, under Anthropic's ~5MB-per-image limit with room for the ~33%
+ * base64 overhead. Refused here, with the size named, rather than at the vendor: a 400 arrives
+ * only after the user has waited out the turn.
+ *
+ * A VENDOR guard, and only that — it does not protect the session's storage quota, and the
+ * arithmetic says so: one file at this ceiling is ~4.7MB of base64, which alone can exceed a 5MB
+ * `localStorage` budget before the transcript is counted. Attachments riding into persisted
+ * storage is a real and separate problem; it is not this constant's to solve.
+ */
+const MAX_IMAGE_ATTACHMENT_BYTES = 3500000;
+/**
+ * Ceiling on ALL attachments carried by one message, across every type and every successive pick.
+ *
+ * The per-file check above is blind to the total: the picker APPENDS, so ten files each just under
+ * the per-image limit are ten passes and one ~34MB request. Sized against the vendors' request
+ * ceilings — comfortably inside the smaller of them with room for the transcript itself — so a
+ * turn that would be rejected wholesale is refused here, where the user can still act on it,
+ * naming the file that crossed the line.
+ *
+ * Like its sibling, this does NOT make attachments safe to persist — 8MB of attachments is still
+ * ~10.7MB of base64. What a persisted session should keep of its images is GENC-1531; note the
+ * transports also REPLAY history attachments on every later call, so it is a recurring cost as
+ * well as a storage one.
+ */
+const MAX_ATTACHMENTS_TOTAL_BYTES = 8000000;
+/** Base64 carries 3 bytes in every 4 characters, so decoded size is 3/4 of the encoded length. */
+const BASE64_DECODED_RATIO = 0.75;
+/** Bytes per megabyte, for the size the refusal message quotes back to the user. */
+const BYTES_PER_MB = 1000000;
+/** A rough byte size for an already-accepted attachment, for budgeting against the total cap. */
+function attachmentBytes(a) {
+    var _a, _b, _c, _d;
+    return a.kind === 'image'
+        ? Math.ceil(((_b = (_a = a.data) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) * BASE64_DECODED_RATIO)
+        : ((_d = (_c = a.content) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0);
+}
+/**
+ * The composer's file attachments: what is pending on the next message, what was
+ * rejected and why, and the reading and validation that gets a picked `File` into
+ * a {@link ChatAttachment}.
+ *
+ * @internal
+ */
+export class AttachmentController {
+    constructor(
+    /** Typed `HTMLElement` — the hidden file input is all this needs from the DOM. */
+    host, deps) {
+        this.host = host;
+        this.deps = deps;
+        /** Attachments pending on the next message. */
+        this.attachments = [];
+        /** Rejection messages for files the last pick refused. */
+        this.errors = [];
+    }
+    /** Open the OS file picker via the hidden input the template renders. */
+    triggerFileInput() {
+        var _a, _b;
+        (_b = (_a = this.host.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('.file-input')) === null || _b === void 0 ? void 0 : _b.click();
+    }
+    /** `@change` on the hidden input. Fire-and-forget; the read is async. */
+    handleFileSelect(e) {
+        void this.loadSelected(e);
+    }
+    remove(attachment) {
+        this.attachments = this.attachments.filter((a) => a !== attachment);
+    }
+    dismissError(message) {
+        const idx = this.errors.indexOf(message);
+        if (idx !== -1) {
+            this.errors = [...this.errors.slice(0, idx), ...this.errors.slice(idx + 1)];
+        }
+    }
+    /**
+     * Hand the pending attachments to a send and clear both lists in one step.
+     *
+     * Read-and-clear as one method rather than two statements: the previous inline
+     * form copied the array and then blanked the fields separately, leaving a state
+     * the element could be observed in between the two.
+     */
+    take() {
+        const pending = this.attachments.length ? [...this.attachments] : undefined;
+        this.attachments = [];
+        this.errors = [];
+        return pending;
+    }
+    /** Drop everything pending, without handing it anywhere. */
+    clear() {
+        this.attachments = [];
+        this.errors = [];
+    }
+    /** Total bytes already committed, for budgeting a further pick against the cap. */
+    pendingBytes() {
+        return this.attachments.reduce((n, a) => n + attachmentBytes(a), 0);
+    }
+    /**
+     * Read and validate a batch of files without committing them — for
+     * `submitMessage({ files })`, which must be able to refuse the whole message
+     * rather than half-attach it.
+     */
+    process(files_1) {
+        return __awaiter(this, arguments, void 0, function* (files, existingBytes = 0) {
+            // Budget the batch BEFORE reading any of it. `file.size` needs no I/O, so the verdict is
+            // deterministic and in the user's own pick order; deciding inside the parallel map below would
+            // hand the last slot to whichever read happened to finish first. `existingBytes` is what the
+            // caller has already committed to — the picker appends to a running list, so its files have to
+            // count against what is already attached rather than starting from zero each time.
+            let running = existingBytes;
+            const overBudget = new Map();
+            for (const file of files) {
+                if (running + file.size > MAX_ATTACHMENTS_TOTAL_BYTES) {
+                    overBudget.set(file, `"${file.name}" would take this message past the ` +
+                        `${MAX_ATTACHMENTS_TOTAL_BYTES / BYTES_PER_MB}MB attachment limit ` +
+                        `(${(running / BYTES_PER_MB).toFixed(1)}MB already attached).`);
+                    continue;
+                }
+                running += file.size;
+            }
+            const results = yield Promise.all(files.map((file) => __awaiter(this, void 0, void 0, function* () {
+                if (!this.isAccepted(file)) {
+                    return { ok: false, message: `"${file.name}" is not an accepted file type.` };
+                }
+                const tooMuch = overBudget.get(file);
+                if (tooMuch)
+                    return { ok: false, message: tooMuch };
+                try {
+                    // An image file becomes a real image attachment — the transports render those as
+                    // image blocks the model SEES. Reading it as text (the only path that existed)
+                    // produced mojibake the model "read" as prose: an accepted .png was worse than a
+                    // rejected one. Text stays the default for everything else.
+                    //
+                    // Only the types the vendors actually accept take this branch. `image/*` covers far
+                    // more than that, and sending one an API rejects fails the whole turn the user is
+                    // waiting on — where the text branch merely degrades. It also keeps SVG working:
+                    // SVG *is* text, and reading it as such gives the model something it can genuinely
+                    // read, which a base64 image block of it would not.
+                    if (VENDOR_IMAGE_MIME_TYPES.has(file.type.toLowerCase())) {
+                        if (file.size > MAX_IMAGE_ATTACHMENT_BYTES) {
+                            return {
+                                ok: false,
+                                message: `"${file.name}" is ${Math.ceil(file.size / BYTES_PER_MB)}MB; images are limited to ` +
+                                    `${MAX_IMAGE_ATTACHMENT_BYTES / BYTES_PER_MB}MB.`,
+                            };
+                        }
+                        const data = yield this.readAsBase64(file);
+                        return {
+                            ok: true,
+                            attachment: { kind: 'image', name: file.name, mimeType: file.type, data },
+                        };
+                    }
+                    const content = yield this.readAsText(file);
+                    return {
+                        ok: true,
+                        attachment: { name: file.name, content, mimeType: file.type || 'text/plain' },
+                    };
+                }
+                catch (readError) {
+                    logger.error('Failed to read file:', readError);
+                    this.deps.logMeta('file.read-failed', {
+                        file: file.name,
+                        message: readError instanceof Error ? readError.message : String(readError),
+                    });
+                    return { ok: false, message: `Failed to read "${file.name}".` };
+                }
+            })));
+            return {
+                attachments: results
+                    .filter((r) => r.ok)
+                    .map((r) => r.attachment),
+                errors: results
+                    .filter((r) => !r.ok)
+                    .map((r) => r.message),
+            };
+        });
+    }
+    isAccepted(file) {
+        var _a, _b;
+        const accepted = this.deps.acceptedFiles();
+        if (!accepted)
+            return false;
+        const acceptedList = accepted.split(',').map((s) => s.trim().toLowerCase());
+        const ext = `.${(_b = (_a = file.name.split('.').pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== null && _b !== void 0 ? _b : ''}`;
+        return acceptedList.some((a) => a === ext ||
+            a === file.type ||
+            (a.endsWith('/*') && file.type.startsWith(a.replace('/*', '/'))));
+    }
+    // Blob's own promise APIs, not FileReader: UTF-8 only (a `charset` parameter on the blob's
+    // type is ignored, where FileReader would honour it), and they exist in the node test runtime
+    // too — FileReader does not, so neither reader was testable before.
+    readAsText(file) {
+        return file.text();
+    }
+    /**
+     * The base64 payload of a file, without any `data:` prefix — the raw form
+     * `ChatImageAttachment.data` specifies (transports add their own framing).
+     */
+    readAsBase64(file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const bytes = new Uint8Array(yield file.arrayBuffer());
+            let binary = '';
+            const CHUNK = 0x8000;
+            for (let i = 0; i < bytes.length; i += CHUNK) {
+                binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+            }
+            return btoa(binary);
+        });
+    }
+    /** The picker path: read the picked files and APPEND whatever passed. */
+    loadSelected(e) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const input = e.target;
+            const files = Array.from((_a = input.files) !== null && _a !== void 0 ? _a : []);
+            input.value = '';
+            const { attachments, errors } = yield this.process(files, this.pendingBytes());
+            if (attachments.length) {
+                this.attachments = [...this.attachments, ...attachments];
+                this.deps.logMeta('attachment.added', {
+                    count: attachments.length,
+                    names: attachments.map((a) => a.name),
+                });
+            }
+            if (errors.length)
+                this.errors = [...this.errors, ...errors];
+        });
+    }
+}
+__decorate([
+    observable
+], AttachmentController.prototype, "attachments", void 0);
+__decorate([
+    observable
+], AttachmentController.prototype, "errors", void 0);