@tangle-network/agent-app 0.43.60 → 0.43.62

package/dist/assistant/index.d.ts

@@ -11,7 +11,7 @@ import '../sandbox-terminal-ChNEdHF8.js';
 import '../catalog/index.js';
 import '../harness/index.js';
 import '../attachment-validation-tPRp-PP1.js';
-import '../stream-normalizer-C3M--r6y.js';
+import '../stream-normalizer-BlCP_Cdd.js';
 
 /**
  * Wire + UI types for the in-app assistant panel. The wire shapes mirror the

package/dist/assistant/index.js

@@ -8,7 +8,7 @@ import "../chunk-HCOROIRT.js";
 import "../chunk-BPSV5AA2.js";
 import "../chunk-FBVLEGEG.js";
 import "../chunk-DTSPS2HV.js";
-import "../chunk-IG46XCZM.js";
+import "../chunk-BG52UKNN.js";
 import "../chunk-YKOM4ZLQ.js";
 import "../chunk-YJMCRXQQ.js";
 import "../chunk-CQZSAR77.js";

package/dist/chat-routes/index.d.ts

@@ -1,4 +1,4 @@
-import { L as ChatTurnRequestPayload, M as ChatTurnPartInput, g as ChatMessagePart, N as ChatTurnFilePartInput, a as ChatAttachmentPart, C as ChatAttachmentKind, f as ChatMentionPart } from '../parts-n9XUon0a.js';
+import { g as ChatMessagePart, L as ChatTurnRequestPayload, M as ChatTurnPartInput, N as ChatTurnFilePartInput, a as ChatAttachmentPart, C as ChatAttachmentKind, f as ChatMentionPart } from '../parts-n9XUon0a.js';
 export { O as ChatAttachmentInput, e as ChatMentionKind, P as ChatTurnInputError, Q as ChatTurnTextPartInput, R as DISPATCH_MAX_MEDIA_PARTS, T as DISPATCH_MAX_PARTS, U as DISPATCH_REQUEST_MAX_BYTES, V as DISPATCH_STRUCTURAL_RESERVE_BYTES, K as FileMention, W as FileMentionsToPartsOptions, X as INLINE_PARTS_MAX_BYTES, Y as MENTION_MAX_COUNT, Z as ProducerErrorEvent, _ as ProducerNoticeEvent, $ as ProducerPassthroughEvent, a0 as ProducerPassthroughEventType, a1 as ProducerReasoningEvent, a2 as ProducerTextEvent, a3 as ProducerToolCallEvent, a4 as ProducerToolResultEvent, a5 as ProducerUsageEvent, a6 as ProducerWireEvent, a7 as SandboxMentionPathCheck, a8 as assertPromptPartsWithinCap, a9 as base64WireLen, aa as buildMentionPromptBlock, ab as chatTurnRequestInit, ac as fileMentionsToParts, ad as formatBytes, ae as mediaTypeForMentionPath, af as mentionKindForPath, ag as parseChatTurnParts, ah as parseFileMentions, ai as promptPartsByteSize, aj as validateSandboxMentionPath } from '../parts-n9XUon0a.js';
 export { A as ALLOWED_ATTACHMENT_SNIFFED_MIMES, a as ATTACHMENT_ACCEPT, b as ATTACHMENT_MAX_COUNT, c as AttachmentTypeCheckResult, C as CreateSandboxFileIndexRouteOptions, F as FileIndexAuthorization, d as FileIndexCache, e as FileIndexReadyResponse, f as FileIndexResponse, g as FileIndexWarmingResponse, M as MAX_ATTACHMENT_TOTAL_BYTES, h as MAX_BINARY_ATTACHMENT_BYTES, i as MAX_TEXT_ATTACHMENT_BYTES, S as SandboxFileTreeSource, j as SandboxTreeFile, k as SandboxTreeResult, l as SniffResult, m as attachmentSizeErrorMessage, n as attachmentTotalSizeErrorMessage, o as checkAttachmentType, p as createSandboxFileIndexRoute, s as sanitizeAttachmentFileName, q as sniffBinary } from '../attachment-validation-tPRp-PP1.js';
 import { ChatTurnIdentity, ChatTurnProducer } from '@tangle-network/agent-runtime';
@@ -6,7 +6,7 @@ import { InteractionAnswerRoute, InteractionAnswerRouteOptions } from '../intera
 import { PersistedChatMessageForTurn } from '../stream/index.js';
 import { d as TurnEventStore } from '../turn-buffer-DGnAPKwa.js';
 export { D as DEFAULT_STALE_TURN_LOCK_GRACE_MS, a as DEFAULT_TERMINAL_TURN_LOCK_GRACE_MS, R as ReconcileStaleTurnLockOptions, b as ReconcileStaleTurnLockResult, S as StaleTurnLockSandboxProbeResult, c as StaleTurnLockSessionProbeResult, r as reconcileStaleTurnLock } from '../stale-turn-lock-DucQzvXu.js';
-import { J as JsonRecord } from '../stream-normalizer-C3M--r6y.js';
+import { J as JsonRecord } from '../stream-normalizer-BlCP_Cdd.js';
 import { SandboxExecChannel, PromptInputPart } from '../sandbox/index.js';
 import '@tangle-network/agent-interface';
 import '../contract-TjB68uqA.js';
@@ -17,6 +17,177 @@ import '../types-CBRyqijY.js';
 import '../harness/index.js';
 import '../model-DmdkIteM.js';
 
+/**
+ * Incremental ("draft") persistence of the assistant row WHILE a turn streams.
+ *
+ * Why this exists — the scale argument, not a convenience:
+ *
+ * A live turn is readable from two places. The hot path is the session
+ * gateway's in-memory/Redis event buffer, which exists so a viewer survives a
+ * network blip: it is keyed one sorted set per session, refreshed on every
+ * push, and expires on a TTL. Its memory cost is `arrival_rate x TTL x
+ * bytes_per_session` — strictly LINEAR in the TTL. Stretching that TTL to
+ * cover "a viewer who opens the tab later" is a category error: it buys memory
+ * proportional to the increase and still serves nothing to a viewer who
+ * arrives past the new horizon.
+ *
+ * So the hot buffer must stay SHORT (live delivery + reconnect only), and
+ * durable storage must serve history. That only works if durable storage
+ * actually HAS the in-flight turn — which, before this module, it did not: the
+ * assistant row was written once, after the stream drained. A viewer arriving
+ * mid-turn past the hot window read an empty transcript.
+ *
+ * This module closes that gap: the assistant row is inserted early and patched
+ * on a coalesced cadence, so the durable transcript is at most one interval
+ * (default 2 s) behind the live stream and the hot buffer never has to be the
+ * history tier.
+ *
+ * Mechanism only. It owns no vocabulary: the caller supplies the snapshot
+ * function, the store, and the deterministic row id.
+ *
+ * Four properties the cadence guarantees:
+ * - **Time-floored.** At most one write per `intervalMs`, never one per token.
+ * - **Dirty-gated.** Only content-bearing events arm a write; heartbeats,
+ *   status pings, and lifecycle envelopes never do.
+ * - **Single-flight.** A write already in flight suppresses the next trigger
+ *   instead of queueing; the final write is authoritative regardless of how
+ *   many drafts landed.
+ * - **Best-effort.** A store failure is logged and swallowed — a durability
+ *   optimization must never kill a healthy stream (the same rule
+ *   `withDurableChatProjection` already states).
+ */
+
+/** Message row shape the writer reads back when re-entering a turn. */
+interface DraftStoredMessage {
+    id: string;
+    role: 'user' | 'assistant' | 'system' | 'tool';
+    content: string;
+    parts?: ChatMessagePart[] | null;
+}
+/** Values written to the assistant row — the intersection of the append and
+ *  patch shapes, so one snapshot serves both. */
+interface AssistantRowValues {
+    content: string;
+    parts?: ChatMessagePart[];
+    model?: string | null;
+    inputTokens?: number | null;
+    outputTokens?: number | null;
+    reasoningTokens?: number | null;
+    cacheReadTokens?: number | null;
+    cacheWriteTokens?: number | null;
+    costUsd?: number | null;
+}
+/** The store capability incremental persistence needs on top of
+ *  `appendMessage`. A store without `updateMessage` cannot patch a row, so it
+ *  cannot draft at all — the caller keeps today's single-write behavior. */
+interface AssistantDraftStore {
+    listMessages(threadId: string): Promise<DraftStoredMessage[]>;
+    appendMessage(input: AssistantRowValues & {
+        id?: string;
+        threadId: string;
+        role: 'user' | 'assistant';
+    }): Promise<unknown>;
+    updateMessage?(id: string, patch: AssistantRowValues): Promise<unknown>;
+    deleteMessage?(id: string): Promise<unknown>;
+}
+/** Live snapshot of the assistant body, taken from the producer's own
+ *  accumulators. `parts` is the DRAFT projection (`draftParts()`), never the
+ *  finalized one — see `draftAssistantParts`. */
+interface AssistantDraftSnapshot {
+    content: string;
+    parts?: Array<Record<string, unknown>>;
+    usage?: ChatTurnUsage;
+    model?: string;
+}
+/** Product-tunable cadence. Defaults are stated on each field; a product with
+ *  a chattier or heavier workload moves them without forking the writer. */
+interface DraftPersistenceTuning {
+    /** Minimum wall-clock gap between draft writes, in ms. Default 2000.
+     *
+     *  Justification for 2 s, from a measured tool-heavy production run (517
+     *  stream events over ~90 s wall = ~5.7 events/s): a 2 s floor with the
+     *  dirty gate turns 517 candidate writes into <= 45, while leaving the
+     *  durable row at most 2 s stale — an order of magnitude below the time it
+     *  takes a viewer to open a tab and render, so a late viewer never perceives
+     *  the lag. Fleet arithmetic at 10k concurrent 60 s runs: <= 30 updates per
+     *  run x 167 run-starts/s = ~334 row-updates/s spread over per-tenant
+     *  shards. Lower it and write amplification grows with no perceptible
+     *  freshness gain; raise it past ~5 s and a late viewer starts seeing a
+     *  visibly truncated answer. */
+    intervalMs?: number;
+    /** Serialized-parts size (bytes) past which the interval backs off, so a
+     *  turn accumulating a megabyte-scale `parts` blob does not rewrite it every
+     *  interval. Default 262144 (256 KiB) -> interval x 2.5; ten times that ->
+     *  interval x 5. The final write is never throttled. */
+    backoffBytes?: number;
+    /** Per-tool-part output cap applied to DRAFTS ONLY (bytes). A tool returning
+     *  a large blob would otherwise be rewritten in full on every draft. The
+     *  final write always carries the untruncated value. Default 32768 (32 KiB);
+     *  0 disables truncation. */
+    maxDraftToolOutputBytes?: number;
+}
+/** Define the inputs required to construct an assistant draft writer */
+interface AssistantDraftWriterOptions extends DraftPersistenceTuning {
+    store: AssistantDraftStore;
+    threadId: string;
+    /** DETERMINISTIC row id for this turn's assistant message — the whole
+     *  idempotency mechanism. Derived from the turn's existing identity
+     *  (`deriveExecutionId` in the interactive lane, the turn id in the detached
+     *  lane), so a re-entered turn addresses the SAME row: the writer looks the
+     *  id up before its first insert and patches what it finds. */
+    messageId: string;
+    /** Read the producer's live accumulators. Returns null before the producer
+     *  is resolved (the assembly defers box resolution into the first pull). */
+    snapshot(): AssistantDraftSnapshot | null;
+    /** Pre-persist text transform (`/redact`'s `redactPII`). Applied to the
+     *  draft's scalar content AND every draft text part — parity with the final
+     *  write, or incremental persistence would re-open the at-rest PII leak that
+     *  transform closed, just seconds earlier and on every turn. */
+    transformText?(text: string): string | Promise<string>;
+    log?: (message: string, meta?: Record<string, unknown>) => void;
+}
+/** Coalescing writer that keeps one durable assistant row in step with a
+ *  streaming turn. Created per turn; not reusable. */
+interface AssistantDraftWriter {
+    /** Arm/trigger a draft write from one engine event. Synchronous by design —
+     *  the write itself is fire-and-forget so the stream is never blocked on
+     *  store latency. */
+    notify(event: {
+        type?: unknown;
+    }): void;
+    /** Stop drafting and settle any in-flight write. Called before the final
+     *  write so a late draft can never clobber the authoritative row. */
+    close(): Promise<void>;
+    /** Write the AUTHORITATIVE completion values onto this turn's row —
+     *  insert-or-patch under the same deterministic id, un-throttled and
+     *  un-truncated. Errors propagate: the final write is the one that must not
+     *  fail silently. Implies {@link close}. */
+    finalize(values: AssistantRowValues): Promise<void>;
+    /** The durable row this turn is writing, once one exists. */
+    rowId(): string | undefined;
+    /** Retract the row for a turn that produced nothing (mirrors the final
+     *  write's empty-turn skip, which leaves no row at all today). Also retracts
+     *  a row a PREVIOUS attempt left behind, so a re-entered turn that ends
+     *  empty converges on "no row" rather than a stale partial. */
+    discard(): Promise<void>;
+    /** Diagnostics: how many draft writes actually reached the store. */
+    writeCount(): number;
+}
+/** True when this event should arm a draft write. */
+declare function isDraftContentEvent(event: {
+    type?: unknown;
+}): boolean;
+/** Build the coalescing draft writer for one turn. */
+declare function createAssistantDraftWriter(options: AssistantDraftWriterOptions): AssistantDraftWriter;
+/** True when a store can support incremental persistence at all. Without
+ *  `updateMessage` a draft row could never be patched, so the caller keeps
+ *  today's exact single-write behavior. */
+declare function storeSupportsDraftPersistence(store: AssistantDraftStore): boolean;
+/** The default deterministic assistant-row id for a turn. Readable on purpose
+ *  (an operator grepping a transcript row id finds the run), and stable across
+ *  re-entries because every input already is. */
+declare function assistantRowIdForTurn(turnKey: string): string;
+
 /**
  * `createChatTurnRoutes` — the assembled server chat vertical (issue #188
  * Phase 1). One factory composing the pieces every product re-wired by hand:
@@ -80,6 +251,10 @@ interface ChatTurnMessageStore {
         parts?: ChatMessagePart[] | null;
     }>>;
     appendMessage(input: {
+        /** Caller-assigned row id. Honored by `/chat-store`'s `createChatStore`;
+         *  a product store free to ignore it (the writer then adopts whatever id
+         *  the insert returns). Set only by incremental persistence. */
+        id?: string;
         threadId: string;
         role: 'user' | 'assistant';
         content: string;
@@ -92,12 +267,35 @@ interface ChatTurnMessageStore {
         cacheWriteTokens?: number | null;
         costUsd?: number | null;
     }): Promise<unknown>;
+    /** Patch an existing row. Its PRESENCE is what enables incremental assistant
+     *  persistence — a store without it keeps today's exact single-write-on-
+     *  completion behavior, which is what makes this additive. */
+    updateMessage?(id: string, patch: {
+        content?: string;
+        parts?: ChatMessagePart[];
+        model?: string | null;
+        inputTokens?: number | null;
+        outputTokens?: number | null;
+        reasoningTokens?: number | null;
+        cacheReadTokens?: number | null;
+        cacheWriteTokens?: number | null;
+        costUsd?: number | null;
+    }): Promise<unknown>;
+    /** Remove a row. Used to retract a draft assistant row for a turn that ended
+     *  producing nothing, so the empty-turn case still leaves no row at all. */
+    deleteMessage?(id: string): Promise<unknown>;
 }
 /** `ChatTurnProducer` plus the persisted projection the assembly reads after
  *  drain. `createSandboxChatProducer` returns this; a router-lane producer
  *  may omit the optional members (finalText persists as a single text part). */
 interface ChatTurnRouteProducer extends ChatTurnProducer {
     assistantParts?(): Array<Record<string, unknown>>;
+    /** MID-STREAM snapshot of the same projection, safe to call while the turn
+     *  is running: no dangling-tool terminalization, no pending-ask settlement
+     *  (see `/stream`'s `draftAssistantParts`). Read by incremental persistence.
+     *  A producer that omits it still drafts — the scalar text — but persists no
+     *  parts until the turn completes. */
+    draftParts?(): Array<Record<string, unknown>>;
     usage?(): ChatTurnUsage;
     model?: string;
 }
@@ -276,6 +474,34 @@ interface CreateChatTurnRoutesOptions<TContext = void> {
     /** Pre-persist transform of the final text (e.g. `/redact`'s `redactPII`).
      *  Live stream is never altered. */
     transformFinalText?(text: string): string | Promise<string>;
+    /** Incremental persistence of the assistant row WHILE the turn streams
+     *  (`./draft-persistence`), so a viewer arriving mid-run is served from
+     *  durable storage instead of the streaming gateway's hot event buffer.
+     *
+     *  This is what lets the gateway keep that hot buffer SHORT at scale: its
+     *  Redis footprint is one sorted set per session refreshed on every push, so
+     *  memory grows LINEARLY with `ttl x concurrent sessions`. Stretching the
+     *  TTL to cover late viewers buys memory proportional to the increase and
+     *  still serves nothing past the new horizon. The buffer stays a reconnect
+     *  window; durable storage — kept at most one cadence interval stale by this
+     *  option — is the history tier.
+     *
+     *  Enabled by DEFAULT whenever `store.updateMessage` exists (every
+     *  `/chat-store` consumer); a store without it keeps today's exact
+     *  single-write behavior. Pass `false` to opt out, or an object to tune the
+     *  cadence. Wiring it against a store that cannot patch rows throws at route
+     *  construction rather than silently no-op'ing. */
+    incrementalPersistence?: false | DraftPersistenceTuning;
+    /** Deterministic durable row id for this turn's assistant message. Default
+     *  `assistant:<executionId>` — already stable across retries because
+     *  `deriveExecutionId` is. Override only if the product's message ids have a
+     *  format constraint; it MUST stay deterministic per turn or a re-entered
+     *  turn will duplicate its row instead of converging. */
+    draftMessageId?(args: {
+        identity: ChatTurnIdentity;
+        executionId: string;
+        threadId: string;
+    }): string;
     /** Post-processing after a turn settles (billing, titles, audit). Fires with
      *  `failed:true` + `failureReason` when the turn carried a terminal error
      *  event (model 402 / rate-limit / server error) instead of a clean
@@ -508,6 +734,35 @@ interface DetachedTurnOptions {
      *  Unset, a re-stream over a `running` buffer is still attempted but logged
      *  as a possible-duplication hazard. */
     resetBuffer?: (turnId: string) => Promise<void>;
+    /** Own the durable assistant row for this turn instead of returning the body
+     *  for the caller to insert — and keep it in step with the stream.
+     *
+     *  An autonomous run is exactly the case a late viewer hits: nobody is
+     *  watching when it starts, so by the time a browser opens the session the
+     *  streaming gateway's hot event buffer may already have expired it. Keeping
+     *  that buffer short is what makes it affordable at scale (its Redis
+     *  footprint is linear in `ttl x concurrent sessions`), so the durable row —
+     *  written incrementally here — is what serves the late viewer.
+     *
+     *  WIRING THIS TRANSFERS ROW OWNERSHIP: the returned {@link
+     *  DetachedTurnResult.messageId} names the row this call wrote (draft rows
+     *  during the stream, authoritative values at the end, retraction when the
+     *  turn produced nothing). The caller must NOT insert its own assistant row
+     *  for the turn. Omit the seam and nothing changes — the result is returned
+     *  and the caller persists it exactly as today.
+     *
+     *  Idempotency reuses the turn's own identity: the row id defaults to
+     *  `assistant:<turnId>`, so a durable driver re-invoking after a crash
+     *  patches the same row instead of duplicating parts. */
+    persist?: DraftPersistenceTuning & {
+        store: AssistantDraftStore;
+        threadId: string;
+        /** Deterministic row id. Default `assistant:<turnId>`. */
+        messageId?: string;
+        /** Pre-persist text transform (`/redact`), applied to drafts AND the final
+         *  write — parity with the interactive lane's `transformFinalText`. */
+        transformText?: (text: string) => string | Promise<string>;
+    };
     log?: (message: string, meta?: Record<string, unknown>) => void;
 }
 /** Describe the result of a detached turn including state, text, parts, usage, and optional error or cache flag */
@@ -526,6 +781,10 @@ interface DetachedTurnResult {
     /** True when a prior buffer meant this call returned a cached/finished result
      *  WITHOUT re-streaming (durable-driver retry after a crash). */
     cached: boolean;
+    /** The durable assistant row this call wrote, when `persist` was wired.
+     *  `null` when the turn produced nothing and the row was retracted. Absent
+     *  when the caller owns persistence (today's behavior). */
+    messageId?: string | null;
 }
 /**
  * Stream a detached turn into the live turn-event buffer, durably.
@@ -1051,4 +1310,4 @@ interface PromoteAgentFilePartOptions {
 /** Promote a part of an agent file with optional byte limits and MIME type detection */
 declare function promoteAgentFilePart(options: PromoteAgentFilePartOptions): Promise<PromoteFilePartResult>;
 
-export { type AttachmentPathArgs, type AttachmentPathCheck, type AttachmentReadResult, type AttachmentUploadAuthorization, type AttachmentWriteResult, type BuildDispatchPartsInput, ChatAttachmentKind, type ChatRouteDurableProjection, type ChatRouteDurableProjectionLogger, type ChatTurnAuthorization, type ChatTurnAuthorizeArgs, ChatTurnFilePartInput, type ChatTurnGateResult, type ChatTurnHeartbeat, type ChatTurnInputPatch, type ChatTurnLifecycle, type ChatTurnLifecycleComplete, type ChatTurnLifecycleError, type ChatTurnLifecycleStart, type ChatTurnLock, type ChatTurnLockResult, type ChatTurnMessageStore, ChatTurnPartInput, type ChatTurnProduceArgs, ChatTurnRequestPayload, type ChatTurnRouteProducer, type ChatTurnRoutes, type ChatTurnUsage, type CreateAttachmentUploadRouteOptions, type CreateChatTurnRoutesOptions, type CreateUploadRouteOptions, type DetachedTurnFinal, type DetachedTurnOptions, type DetachedTurnParts, type DetachedTurnResult, type DispatchPartsOutcome, type FilePartPromotionOutcome, PROMOTE_MAX_FILE_BYTES, type PromoteAgentFilePartOptions, type PromoteFilePartResult, PromptInputPart, type RawAgentFilePart, type ReadAttachmentFn, type ReadSandboxMentionFn, type ResolveChatAttachmentsOptions, type ResolveChatAttachmentsResult, type SandboxChatProducerOptions, type SandboxUploadSink, UPLOAD_INLINE_MAX_BYTES, UPLOAD_MAX_FILE_BYTES, type UploadAuthorization, type UploadedChatFile, type WriteAttachmentFn, buildDispatchParts, bytesToBase64, createAttachmentUploadRoute, createChatTurnRoutes, createSandboxChatProducer, createUploadRoute, defaultValidateAttachmentPath, promoteAgentFilePart, resolveChatAttachments, runDetachedTurn, sanitizeUploadFilename, sniffMimeFromName, withDurableChatProjection };
+export { type AssistantDraftSnapshot, type AssistantDraftStore, type AssistantDraftWriter, type AssistantDraftWriterOptions, type AssistantRowValues, type AttachmentPathArgs, type AttachmentPathCheck, type AttachmentReadResult, type AttachmentUploadAuthorization, type AttachmentWriteResult, type BuildDispatchPartsInput, ChatAttachmentKind, type ChatRouteDurableProjection, type ChatRouteDurableProjectionLogger, type ChatTurnAuthorization, type ChatTurnAuthorizeArgs, ChatTurnFilePartInput, type ChatTurnGateResult, type ChatTurnHeartbeat, type ChatTurnInputPatch, type ChatTurnLifecycle, type ChatTurnLifecycleComplete, type ChatTurnLifecycleError, type ChatTurnLifecycleStart, type ChatTurnLock, type ChatTurnLockResult, type ChatTurnMessageStore, ChatTurnPartInput, type ChatTurnProduceArgs, ChatTurnRequestPayload, type ChatTurnRouteProducer, type ChatTurnRoutes, type ChatTurnUsage, type CreateAttachmentUploadRouteOptions, type CreateChatTurnRoutesOptions, type CreateUploadRouteOptions, type DetachedTurnFinal, type DetachedTurnOptions, type DetachedTurnParts, type DetachedTurnResult, type DispatchPartsOutcome, type DraftPersistenceTuning, type DraftStoredMessage, type FilePartPromotionOutcome, PROMOTE_MAX_FILE_BYTES, type PromoteAgentFilePartOptions, type PromoteFilePartResult, PromptInputPart, type RawAgentFilePart, type ReadAttachmentFn, type ReadSandboxMentionFn, type ResolveChatAttachmentsOptions, type ResolveChatAttachmentsResult, type SandboxChatProducerOptions, type SandboxUploadSink, UPLOAD_INLINE_MAX_BYTES, UPLOAD_MAX_FILE_BYTES, type UploadAuthorization, type UploadedChatFile, type WriteAttachmentFn, assistantRowIdForTurn, buildDispatchParts, bytesToBase64, createAssistantDraftWriter, createAttachmentUploadRoute, createChatTurnRoutes, createSandboxChatProducer, createUploadRoute, defaultValidateAttachmentPath, isDraftContentEvent, promoteAgentFilePart, resolveChatAttachments, runDetachedTurn, sanitizeUploadFilename, sniffMimeFromName, storeSupportsDraftPersistence, withDurableChatProjection };