@burdenoff/fe-libs 2026.926.5 → 2026.927.1

package/dist/shared/assistant/history/historyErrors.d.ts

@@ -0,0 +1,72 @@
+/**
+ * What a failed server-history call means, and what to do about it (BOFF-7335).
+ *
+ * ★★ The rule that matters: a queued save is DROPPED only when the server
+ * itself said this item is invalid — `BAD_USER_INPUT` carrying one of the two
+ * history i18n keys its validator raises. Everything else keeps the item:
+ *
+ * - `schema-unavailable` — the fields are not there (yet). Hive publishes the
+ *   new schema right after the image is pushed, before Flux has rolled the
+ *   pods, and a rolled-back server rejects the v2 fields the same way. A
+ *   subgraph pod without the fields fails validation in graphql-yoga, which
+ *   codes it `GRAPHQL_VALIDATION_FAILED` (the gateway forwards any coded
+ *   error); a supergraph without them fails at the gateway, whose
+ *   request-phase remap answers `BAD_USER_INPUT` with no i18n key and the
+ *   graphql-js message. Both pause; neither drops. (A gateway older than that
+ *   remap masks the latter as `INTERNAL_SERVER_ERROR` "Unexpected error." —
+ *   transient below, so the item is still kept.)
+ * - `quota` — park; the next panel open or ten minutes retries it.
+ * - `auth` — wait for the account or token to change.
+ * - `not-found` — only `myAssistantConversationEntries` raises it, and it
+ *   means "this scope never had that id". It is NEVER read as a delete.
+ * - `scope-inactive` — the request's workspace or account is not the active
+ *   one, so it was not sent at all. Hold until the scope is active again.
+ * - `transient` — anything else, including the server's own retryable
+ *   `RATE_LIMIT_EXCEEDED` (a busy scope, or the bound on tombstones for
+ *   never-seen ids), which carries `retryAfter` seconds. Backed off,
+ *   retried indefinitely: every write is idempotent.
+ */
+export type AssistantHistoryErrorClass = "schema-unavailable" | "rejected" | "quota" | "auth" | "not-found" | "scope-inactive" | "transient";
+export interface AssistantHistoryErrorVerdict {
+    class: AssistantHistoryErrorClass;
+    /** The first `extensions.code` found, for logs. */
+    code?: string;
+    /** The first `extensions.i18nKey` found, for logs. */
+    i18nKey?: string;
+    /** The server asked for at least this long before a retry (`RATE_LIMIT_EXCEEDED`'s `retryAfter`). */
+    retryAfterMs?: number;
+}
+/** The validator's two keys — the ONLY errors that drop a queued item. */
+export declare const ASSISTANT_HISTORY_REJECTION_KEYS: readonly string[];
+export declare function classifyAssistantHistoryError(error: unknown): AssistantHistoryErrorVerdict;
+/** How long a schema mismatch pauses the whole engine. */
+export declare const ASSISTANT_HISTORY_SCHEMA_PAUSE_MS: number;
+/** When a quota-parked save is retried if the panel is not opened first. */
+export declare const ASSISTANT_HISTORY_QUOTA_RETRY_MS: number;
+export declare const ASSISTANT_HISTORY_BACKOFF_BASE_MS = 1000;
+export declare const ASSISTANT_HISTORY_BACKOFF_MAX_MS: number;
+/**
+ * `drop` — this item only (and only a save); `pause` — the whole engine, for
+ * `delayMs`; `park` — this item, until the panel opens or `delayMs`; `hold` —
+ * until the scope, account or token changes; `retry` — this item after `delayMs`.
+ */
+export type AssistantHistoryRetryAction = "drop" | "pause" | "park" | "hold" | "retry";
+export interface AssistantHistoryRetryPlan {
+    action: AssistantHistoryRetryAction;
+    delayMs: number;
+}
+/** 1 s · 2^attempts, full jitter on the upper half, capped at five minutes. */
+export declare function assistantHistoryBackoffMs(attempts: number, random?: () => number): number;
+/**
+ * What to do with an outbox item after a failure.
+ *
+ * ★★ A DELETE is never dropped, whatever the server said: dropping it would
+ * let the conversation come back from the server on the next pull. A delete
+ * the validator refuses (which only a client bug can cause) is retried on the
+ * slow schedule instead, so the defect is visible rather than silent.
+ */
+export declare function planAssistantHistoryRetry(verdict: AssistantHistoryErrorVerdict, item: {
+    type: "save" | "delete";
+    attempts: number;
+}, random?: () => number): AssistantHistoryRetryPlan;
+//# sourceMappingURL=historyErrors.d.ts.map

package/dist/shared/assistant/history/historyErrors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"historyErrors.d.ts","sourceRoot":"","sources":["../../../../src/shared/assistant/history/historyErrors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAQH,MAAM,MAAM,0BAA0B,GAClC,oBAAoB,GACpB,UAAU,GACV,OAAO,GACP,MAAM,GACN,WAAW,GACX,gBAAgB,GAChB,WAAW,CAAC;AAEhB,MAAM,WAAW,4BAA4B;IAC3C,KAAK,EAAE,0BAA0B,CAAC;IAClC,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,sDAAsD;IACtD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qGAAqG;IACrG,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,0EAA0E;AAC1E,eAAO,MAAM,gCAAgC,EAAE,SAAS,MAAM,EAG7D,CAAC;AAwCF,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,OAAO,GAAG,4BAA4B,CA8C1F;AAID,0DAA0D;AAC1D,eAAO,MAAM,iCAAiC,QAAa,CAAC;AAC5D,4EAA4E;AAC5E,eAAO,MAAM,gCAAgC,QAAc,CAAC;AAC5D,eAAO,MAAM,iCAAiC,OAAQ,CAAC;AACvD,eAAO,MAAM,gCAAgC,QAAa,CAAC;AAE3D;;;;GAIG;AACH,MAAM,MAAM,2BAA2B,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAEvF,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,2BAA2B,CAAC;IACpC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,+EAA+E;AAC/E,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,MAAoB,GAAG,MAAM,CAQtG;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,4BAA4B,EACrC,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,EACnD,MAAM,GAAE,MAAM,MAAoB,GACjC,yBAAyB,CAuB3B"}

package/dist/shared/assistant/history/historyErrors.js

@@ -0,0 +1,74 @@
+import { classifyQuotaError as e, extensionObjectsIn as t, isQuotaExhaustedError as n } from "../quota.js";
+import { AssistantHistoryResponseError as r, AssistantHistoryScopeInactiveError as i } from "./historyApi.js";
+//#region src/shared/assistant/history/historyErrors.ts
+var a = ["assistant.errors.invalidHistoryInput", "assistant.errors.historyPayloadTooLarge"], o = /Cannot query field|Unknown argument|Unknown type|is not defined by type|Variable "\$[^"]+" got invalid/i, s = new Set(["GRAPHQL_VALIDATION_FAILED", "GRAPHQL_PARSE_FAILED"]), c = new Set(["UNAUTHENTICATED", "FORBIDDEN"]);
+function l(e) {
+	return e instanceof Error ? e.message : typeof e == "string" ? e : "";
+}
+function u(e, t) {
+	for (let n of e) {
+		let e = n[t];
+		if (typeof e == "string" && e.length > 0) return e;
+	}
+}
+function d(e) {
+	for (let t of e) {
+		let e = t.retryAfter;
+		if (typeof e == "number" && Number.isFinite(e) && e > 0) return Math.min(e, 3600) * 1e3;
+	}
+}
+function f(f) {
+	if (f instanceof i) return { class: "scope-inactive" };
+	if (f instanceof r) return { class: "schema-unavailable" };
+	let p = t(f), m = new Set(p.map((e) => e.code).filter((e) => typeof e == "string")), h = new Set(p.map((e) => e.i18nKey).filter((e) => typeof e == "string")), g = u(p, "code"), _ = u(p, "i18nKey"), v = (e) => ({
+		class: e,
+		...g ? { code: g } : {},
+		..._ ? { i18nKey: _ } : {}
+	});
+	if (m.has("BAD_USER_INPUT") && a.some((e) => h.has(e))) return v("rejected");
+	if (o.test(l(f)) || [...m].some((e) => s.has(e))) return v("schema-unavailable");
+	if (m.has("RATE_LIMIT_EXCEEDED")) {
+		let e = d(p);
+		return {
+			...v("transient"),
+			...e ? { retryAfterMs: e } : {}
+		};
+	}
+	return e(f) !== null || n(f) ? v("quota") : [...m].some((e) => c.has(e)) ? v("auth") : m.has("NOT_FOUND") ? v("not-found") : m.has("BAD_USER_INPUT") ? v("schema-unavailable") : v("transient");
+}
+var p = 5 * 6e4, m = 10 * 6e4, h = 1e3, g = 5 * 6e4;
+function _(e, t = Math.random) {
+	let n = Math.min(g, h * 2 ** Math.max(0, Math.min(e, 20))), r = n / 2 + n / 2 * Math.min(Math.max(t(), 0), 1);
+	return Math.round(r);
+}
+function v(e, t, n = Math.random) {
+	switch (e.class) {
+		case "rejected": return t.type === "save" ? {
+			action: "drop",
+			delayMs: 0
+		} : {
+			action: "retry",
+			delayMs: g
+		};
+		case "schema-unavailable": return {
+			action: "pause",
+			delayMs: p
+		};
+		case "quota": return {
+			action: "park",
+			delayMs: m
+		};
+		case "auth":
+		case "scope-inactive": return {
+			action: "hold",
+			delayMs: 0
+		};
+		case "not-found":
+		case "transient": return {
+			action: "retry",
+			delayMs: Math.max(_(t.attempts, n), e.retryAfterMs ?? 0)
+		};
+	}
+}
+//#endregion
+export { h as ASSISTANT_HISTORY_BACKOFF_BASE_MS, g as ASSISTANT_HISTORY_BACKOFF_MAX_MS, m as ASSISTANT_HISTORY_QUOTA_RETRY_MS, a as ASSISTANT_HISTORY_REJECTION_KEYS, p as ASSISTANT_HISTORY_SCHEMA_PAUSE_MS, _ as assistantHistoryBackoffMs, f as classifyAssistantHistoryError, v as planAssistantHistoryRetry };

package/dist/shared/assistant/history/historyList.d.ts

@@ -0,0 +1,115 @@
+import { AssistantModeConfig, Conversation, ConversationSyncStamp } from '../conversation';
+import { AssistantMode } from '../types';
+import { AssistantHistoryConvKey, AssistantHistoryHeader, AssistantHistoryScope, AssistantHistoryScopeKey, AssistantHistoryServerConversation, AssistantHistoryTombstone } from './historyTypes';
+/** The scope a stamped conversation belongs to. */
+export declare function historyScopeKeyOfStamp(sync: ConversationSyncStamp): AssistantHistoryScopeKey;
+/** A server conversation's key here: its client id, or `legacy:<id>` for a pre-v2 row. */
+export declare function historyConvKeyOf(conversation: Pick<AssistantHistoryServerConversation, "id" | "clientConversationId">): AssistantHistoryConvKey;
+/** The header the list keeps for a live server conversation. */
+export declare function historyHeaderOf(conversation: AssistantHistoryServerConversation): AssistantHistoryHeader;
+/**
+ * Has this conversation got anything to lose — so it must never be reused as
+ * a fresh draft? Messages, a live session, or a place in server history (a
+ * conversation opened from the server is empty while it loads).
+ */
+export declare function conversationHasHistory(conversation: Conversation): boolean;
+/**
+ * Saved before server history (v2): shown, deletable, never continued and
+ * never used as context — the composer is disabled while it is open, and a
+ * send that arrives anyway starts a new conversation.
+ */
+export declare function isReadOnlyHistoryConversation(conversation: Pick<Conversation, "sync"> | undefined): boolean;
+/**
+ * Stamped for another owner than a conversation created now would get
+ * (`stamp`): another account, workspace or product. Such a conversation is
+ * never continued — the list hides it and the engine closes it once nothing
+ * runs in it, and a send that reaches it anyway starts a new conversation, so
+ * its content is never carried into this workspace's turns. With no stamp
+ * (history off, or the owner unknown) there is nothing to compare with, and
+ * nothing is "other".
+ */
+export declare function isOtherScopeHistoryConversation(conversation: Pick<Conversation, "sync"> | undefined, stamp: AssistantHistoryScope | null): boolean;
+/**
+ * May `conversation` be reused as a fresh draft by a mode switch? Only an
+ * empty one with nothing to lose (`conversationHasHistory`) — and only one
+ * that belongs where the next turn will be saved: stamped for exactly the
+ * owner a new conversation would get now (`stamp`), or, with no stamp
+ * (history off, or its account, workspace or product unknown), device-only.
+ * Otherwise a draft made in another workspace would take this workspace's
+ * turns, or a device-only one would keep them off the server for good.
+ */
+export declare function isReusableHistoryDraft(conversation: Conversation, stamp: AssistantHistoryScope | null): boolean;
+/**
+ * The mode a conversation opened from the server starts in: the first mode
+ * known NOT to write — `assistant` when offered — so a reopened conversation
+ * can only read until the person chooses a write mode (through its consent).
+ */
+export declare function resolveHistoryReopenMode(modes: readonly AssistantModeConfig[]): AssistantMode;
+export interface MaterializeHistoryOptions {
+    /** The product's modes, in display order (the reopen mode is chosen from these). */
+    modes: readonly AssistantModeConfig[];
+    /** Auto is selected (the store's `autoRouting`). */
+    autoRouting: boolean;
+    /** Now, as ISO (the stamp's `openedAt`). */
+    openedAt: string;
+}
+/**
+ * A server header as a conversation of this device: no messages yet (the load
+ * fills them), no backend session (the model's memory of it is gone; a new
+ * one starts with the next message), in a mode that does not write.
+ */
+export declare function materializeHistoryHeader(convKey: AssistantHistoryConvKey, header: AssistantHistoryHeader, scope: AssistantHistoryScope, options: MaterializeHistoryOptions): Conversation;
+export interface AssistantHistoryListRow {
+    key: AssistantHistoryConvKey;
+    /** The conversation's title, or the server's; empty when neither has one (the UI names it). */
+    title: string;
+    updatedAt: string;
+    /** Held on this device (opened here, or created here). Null: a server header only. */
+    conversation: Conversation | null;
+    header: AssistantHistoryHeader | null;
+    /** Saved before v2: opens read-only. */
+    legacy: boolean;
+    /** Why its latest turns are not being saved. */
+    blocked?: ConversationSyncStamp["blocked"];
+    loading: boolean;
+}
+export interface AssistantHistoryListInput {
+    conversations: readonly Conversation[];
+    /** The active scope, or null (then nothing is "this workspace"). */
+    scopeKey: AssistantHistoryScopeKey | null;
+    /** The persisted headers of the active scope. */
+    headers: Readonly<Record<AssistantHistoryConvKey, AssistantHistoryHeader>>;
+    /** Headers paged in this page load ("Show older conversations"). */
+    olderHeaders?: Readonly<Record<AssistantHistoryConvKey, AssistantHistoryHeader>>;
+    tombstones: Readonly<Record<AssistantHistoryConvKey, AssistantHistoryTombstone>>;
+    loadingIds?: Readonly<Record<string, true>>;
+}
+export interface AssistantHistoryList {
+    workspace: AssistantHistoryListRow[];
+    device: Conversation[];
+}
+/** The two groups the list renders (see the module docblock). */
+export declare function selectAssistantHistoryList(input: AssistantHistoryListInput): AssistantHistoryList;
+/** Server-backed conversations kept on this device at most (the least recently opened go first). */
+export declare const ASSISTANT_HISTORY_MAX_CACHED_CONVERSATIONS = 25;
+export interface HistoryEvictionInput {
+    conversations: readonly Conversation[];
+    activeConversationId: string | null;
+    /** Keep at most this many server-backed conversations. */
+    max: number;
+    /**
+     * Must stay regardless: queued work, something live in it, or no header to
+     * show it by once it is gone from here.
+     */
+    isProtected: (conversation: Conversation) => boolean;
+}
+/**
+ * The server-backed conversations to evict, least recently opened first.
+ *
+ * Never evicted: device-only conversations (they exist nowhere else), the open
+ * one, one with queued saves or deletes, one with a turn or a voice session in
+ * it, one renamed here (the new name exists only here) or one whose turns are
+ * not being saved (`blocked`: its history is only here too).
+ */
+export declare function selectHistoryEvictions(input: HistoryEvictionInput): string[];
+//# sourceMappingURL=historyList.d.ts.map

package/dist/shared/assistant/history/historyList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"historyList.d.ts","sourceRoot":"","sources":["../../../../src/shared/assistant/history/historyList.ts"],"names":[],"mappings":"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"}

package/dist/shared/assistant/history/historyList.js

@@ -0,0 +1,116 @@
+import { modeRequiresConfirmWrites as e } from "../api.js";
+import "../autoRouting.js";
+import { assistantHistoryScopeKey as t, legacyHistoryConvKey as n } from "./historyTypes.js";
+//#region src/shared/assistant/history/historyList.ts
+function r(e) {
+	return t({
+		actorId: e.actorId,
+		workspaceId: e.workspaceId,
+		product: e.product
+	});
+}
+function i(e) {
+	return e.clientConversationId ?? n(e.id);
+}
+function a(e) {
+	return {
+		serverId: e.id,
+		clientConversationId: e.clientConversationId,
+		title: e.title,
+		legacy: e.legacy,
+		revision: e.revision,
+		lastMessageSeq: e.lastMessageSeq,
+		createdAt: e.createdAt,
+		updatedAt: e.updatedAt
+	};
+}
+function o(e) {
+	return e.messages.length > 0 || !!e.backendSessionId || !!e.sync?.serverId || e.sync?.origin === "remote" || e.sync?.origin === "legacy";
+}
+function s(e) {
+	return e?.sync?.origin === "legacy";
+}
+function c(e, t) {
+	let n = e?.sync;
+	return !n || !t ? !1 : n.product !== t.product || n.workspaceId !== t.workspaceId || n.actorId !== t.actorId;
+}
+function l(e, t) {
+	if (o(e)) return !1;
+	let n = e.sync;
+	return !t || !n ? !t && !n : n.product === t.product && n.workspaceId === t.workspaceId && n.actorId === t.actorId;
+}
+function u(t) {
+	return t.find((t) => t.id === "assistant" || !t.writeCapable && !t.requiresAdmin && !e(t.id))?.id ?? "assistant";
+}
+function d(e, t, n, r) {
+	let i = u(r.modes), a = i === "assistant" && r.autoRouting ? "auto" : void 0;
+	return {
+		id: e,
+		title: t.title ?? "",
+		mode: i,
+		...a ? { routedBy: a } : {},
+		messages: [],
+		backendSessionId: null,
+		createdAt: t.createdAt,
+		updatedAt: t.updatedAt,
+		sync: {
+			v: 1,
+			product: n.product,
+			workspaceId: n.workspaceId,
+			actorId: n.actorId,
+			origin: t.legacy || t.clientConversationId === null ? "legacy" : "remote",
+			serverId: t.serverId,
+			revision: t.revision,
+			lastSeq: 0,
+			openedAt: r.openedAt
+		}
+	};
+}
+var f = (e, t) => e > t ? e : t;
+function p(e) {
+	let t = [], n = /* @__PURE__ */ new Map(), i = e.loadingIds ?? {};
+	for (let a of e.conversations) {
+		let o = a.sync;
+		if (!o) {
+			t.push(a);
+			continue;
+		}
+		if (e.scopeKey === null || r(o) !== e.scopeKey || a.id in e.tombstones) continue;
+		let s = e.headers[a.id] ?? e.olderHeaders?.[a.id] ?? null;
+		n.set(a.id, {
+			key: a.id,
+			title: a.title,
+			updatedAt: s ? f(a.updatedAt, s.updatedAt) : a.updatedAt,
+			conversation: a,
+			header: s,
+			legacy: o.origin === "legacy",
+			...o.blocked ? { blocked: o.blocked } : {},
+			loading: a.id in i
+		});
+	}
+	if (e.scopeKey !== null) {
+		let t = [e.headers, e.olderHeaders ?? {}];
+		for (let r of t) for (let [t, a] of Object.entries(r)) n.has(t) || a.gone || t in e.tombstones || n.set(t, {
+			key: t,
+			title: a.title ?? "",
+			updatedAt: a.updatedAt,
+			conversation: null,
+			header: a,
+			legacy: a.legacy,
+			loading: t in i
+		});
+	}
+	return {
+		workspace: [...n.values()].sort((e, t) => e.updatedAt === t.updatedAt ? e.key < t.key ? -1 : 1 : e.updatedAt < t.updatedAt ? 1 : -1),
+		device: t
+	};
+}
+var m = 25;
+function h(e) {
+	let t = e.conversations.filter((e) => !!e.sync?.serverId), n = t.length - e.max;
+	if (n <= 0) return [];
+	let r = (e) => e.sync?.openedAt ?? e.updatedAt;
+	return t.filter((t) => t.id !== e.activeConversationId && !t.sync?.titleLocked && !t.sync?.blocked && !e.isProtected(t)).sort((e, t) => r(e) === r(t) ? e.id < t.id ? -1 : 1 : r(e) < r(t) ? -1 : 1).slice(0, n).map((e) => e.id);
+}
+//#endregion
+export { m as ASSISTANT_HISTORY_MAX_CACHED_CONVERSATIONS, o as conversationHasHistory, i as historyConvKeyOf, a as historyHeaderOf, r as historyScopeKeyOfStamp, c as isOtherScopeHistoryConversation, s as isReadOnlyHistoryConversation, l as isReusableHistoryDraft, d as materializeHistoryHeader, u as resolveHistoryReopenMode, p as selectAssistantHistoryList, h as selectHistoryEvictions };

package/dist/shared/assistant/history/historyMapping.d.ts

@@ -0,0 +1,65 @@
+import { Message } from '../conversation';
+import { AssistantHistoryEntryInput, AssistantHistoryEntryKind, AssistantHistoryServerEntry } from './historyTypes';
+/** The server's id rule for `clientConversationId` / `clientMessageId`. A local `${Date.now()}-${rand}` id always matches. */
+export declare const HISTORY_CLIENT_ID_PATTERN: RegExp;
+/** The server refuses content over this many UTF-8 bytes. */
+export declare const HISTORY_MAX_CONTENT_BYTES = 131072;
+/** What the client cuts one saved entry's content to before anything else (the server's limit, with room). */
+export declare const HISTORY_ENTRY_CONTENT_CAP_BYTES = 98304;
+/** A save request must fit under the gateway body limit with this much to spare. */
+export declare const HISTORY_REQUEST_HEADROOM_BYTES = 16384;
+/** The stored metadata envelope's limits. */
+export declare const HISTORY_METADATA_ENVELOPE_MAX_BYTES = 16384;
+/** Appended to a saved copy that had to be cut. The local message is untouched. */
+export declare const HISTORY_TRUNCATION_MARKER = "\n\n[\u2026truncated in saved history]";
+export declare function isHistoryClientId(value: unknown): value is string;
+export declare function utf8ByteLength(value: string): number;
+/** What the server stores for text it cannot keep as-is: U+0000 and unpaired surrogates become U+FFFD. */
+export declare function toStorableHistoryText(value: string): string;
+/** The metadata keys server history stores. Everything else stays on the device. */
+export declare const HISTORY_METADATA_KEYS: readonly string[];
+export interface FilteredHistoryMetadata {
+    kept: Record<string, unknown>;
+    /** Keys not kept, for logs. */
+    dropped: string[];
+}
+/**
+ * The server's allow-list, applied on this side: unknown, ill-typed,
+ * unstorable or too-deep keys are dropped (never an error), and approval data
+ * is removed from inside every kept value.
+ */
+export declare function filterHistoryMetadata(metadata: unknown): FilteredHistoryMetadata;
+/**
+ * Drop whole keys, largest first, until the stored envelope fits — the same
+ * order the server uses, so a request never depends on the server making room.
+ */
+export declare function fitHistoryMetadataEnvelope(kind: AssistantHistoryEntryKind, clientCreatedAt: string | null, metadata: Record<string, unknown>): Record<string, unknown>;
+/** The longest prefix (whole code points) that is at most `maxBytes` of UTF-8. */
+export declare function truncateUtf8(value: string, maxBytes: number): string;
+export interface HistorySaveTarget {
+    productId: string;
+    clientConversationId: string;
+    kind: AssistantHistoryEntryKind;
+}
+/** The size, in bytes, of the save request as the gateway receives it. */
+export declare function measureHistorySaveRequest(target: HistorySaveTarget, entries: AssistantHistoryEntryInput[]): number;
+/** The request budget: the gateway limit less headroom for headers the fetch layer adds. */
+export declare const HISTORY_SAVE_REQUEST_BUDGET_BYTES: number;
+/**
+ * The entries to save for `messages`, sized to fit one request.
+ *
+ * Each entry's content is first capped at {@link HISTORY_ENTRY_CONTENT_CAP_BYTES};
+ * then, while the whole request is over budget (at most three passes), the
+ * largest content is cut at a code-point boundary. A cut copy ends with
+ * {@link HISTORY_TRUNCATION_MARKER} and carries `truncated: true`.
+ */
+export declare function toHistoryEntries(messages: readonly Message[], target: HistorySaveTarget): AssistantHistoryEntryInput[];
+/** TURN / LOCAL_COMMAND are exactly [USER, ASSISTANT]; NOTE is exactly [NOTE] — the server's rule. */
+export declare function historyEntriesMatchKind(kind: AssistantHistoryEntryKind, entries: readonly AssistantHistoryEntryInput[]): boolean;
+/**
+ * A complete panel message for a server entry. The id is the client's own
+ * (`clientMessageId`), so a message saved from this device is recognised as
+ * the same message; a pre-v2 entry is `legacy:<serverId>`.
+ */
+export declare function fromHistoryEntry(entry: AssistantHistoryServerEntry): Message;
+//# sourceMappingURL=historyMapping.d.ts.map

package/dist/shared/assistant/history/historyMapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"historyMapping.d.ts","sourceRoot":"","sources":["../../../../src/shared/assistant/history/historyMapping.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,KAAK,EAMV,OAAO,EACR,MAAM,iBAAiB,CAAC;AAUzB,OAAO,KAAK,EACV,0BAA0B,EAC1B,yBAAyB,EAEzB,2BAA2B,EAC5B,MAAM,gBAAgB,CAAC;AAKxB,8HAA8H;AAC9H,eAAO,MAAM,yBAAyB,QAAwC,CAAC;AAC/E,6DAA6D;AAC7D,eAAO,MAAM,yBAAyB,SAAU,CAAC;AACjD,8GAA8G;AAC9G,eAAO,MAAM,+BAA+B,QAAS,CAAC;AACtD,oFAAoF;AACpF,eAAO,MAAM,8BAA8B,QAAS,CAAC;AACrD,6CAA6C;AAC7C,eAAO,MAAM,mCAAmC,QAAS,CAAC;AAwB1D,mFAAmF;AACnF,eAAO,MAAM,yBAAyB,2CAAsC,CAAC;AAE7E,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAEjE;AAMD,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEpD;AAsCD,0GAA0G;AAC1G,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAI3D;AAmGD,oFAAoF;AACpF,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EAAmC,CAAC;AAEvF,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,+BAA+B;IAC/B,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,OAAO,GAAG,uBAAuB,CAkBhF;AAQD;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,yBAAyB,EAC/B,eAAe,EAAE,MAAM,GAAG,IAAI,EAC9B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAkBzB;AAyGD,kFAAkF;AAClF,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAWpE;AAgBD,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,IAAI,EAAE,yBAAyB,CAAC;CACjC;AAED,0EAA0E;AAC1E,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,iBAAiB,EACzB,OAAO,EAAE,0BAA0B,EAAE,GACpC,MAAM,CAkBR;AAED,4FAA4F;AAC5F,eAAO,MAAM,iCAAiC,QACW,CAAC;AAE1D;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,SAAS,OAAO,EAAE,EAC5B,MAAM,EAAE,iBAAiB,GACxB,0BAA0B,EAAE,CA+C9B;AAED,sGAAsG;AACtG,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,yBAAyB,EAC/B,OAAO,EAAE,SAAS,0BAA0B,EAAE,GAC7C,OAAO,CAWT;AAqJD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,2BAA2B,GAAG,OAAO,CAc5E"}