@belonguniverseai/react-sdk 0.6.32 → 0.6.34

package/dist/i18n/messages/surfaces/stream.d.ts

@@ -206,8 +206,21 @@ export declare const streamEn: {
             readonly reconnecting: "Reconnecting to Simetrik…";
         };
         readonly reconnectingBadge: "reconnecting";
-        readonly incompleteTask: "Paused — unfinished";
+        readonly pauseOutputLimit: "Paused — this answer reached its length limit. Reply to continue.";
+        readonly pauseStepLimit: "Paused — this task reached its automatic work limit. Reply to continue.";
+        readonly pauseWatchdog: "Paused — a step stopped responding or ran out of time. Reply to continue.";
+        readonly pauseRepeatedFailure: "Paused — the same step kept failing. Reply with what to change.";
+        readonly pauseQuotaExceeded: "Paused — unfinished";
+        readonly pauseGeneric: "Paused before finishing. Reply to continue.";
         readonly resumingAfterPause: "Taking longer than expected — picking it back up…";
+        readonly answerBlocked: "That answer was blocked before it finished. You can start a new conversation. If it keeps happening, contact support.";
+        readonly runErrorStoppedShort: "That answer stopped before it was finished. Ask again and it will pick up where it left off.";
+        readonly runErrorContextFull: "That answer stopped because this conversation has grown too long. Start a new chat to carry the work on there.";
+        readonly runErrorStepTooLong: "That step took too long, so it was stopped. Ask again to carry on.";
+        readonly runErrorConnectionRevoked: "A connection was turned off, so this stopped. Connect it again to continue.";
+        readonly runErrorGeneric: "Something went wrong and that answer couldn't finish. Ask again in a moment.";
+        readonly runCancelled: "Stopped";
+        readonly runThrottled: "Paused";
         readonly open: "Open";
         readonly reconnectRateLimited: "{{provider}} is busy — trying again automatically in {{seconds}}s.";
         readonly reconnectRateLimitedStill: "{{provider}} is still busy. We'll keep trying on our own.";
@@ -410,8 +423,21 @@ export declare const streamEs: {
             reconnecting: string;
         };
         reconnectingBadge: string;
-        incompleteTask: string;
+        pauseOutputLimit: string;
+        pauseStepLimit: string;
+        pauseWatchdog: string;
+        pauseRepeatedFailure: string;
+        pauseQuotaExceeded: string;
+        pauseGeneric: string;
         resumingAfterPause: string;
+        answerBlocked: string;
+        runErrorStoppedShort: string;
+        runErrorContextFull: string;
+        runErrorStepTooLong: string;
+        runErrorConnectionRevoked: string;
+        runErrorGeneric: string;
+        runCancelled: string;
+        runThrottled: string;
         open: string;
         reconnectRateLimited: string;
         reconnectRateLimitedStill: string;
@@ -614,8 +640,21 @@ export declare const streamPt: {
             reconnecting: string;
         };
         reconnectingBadge: string;
-        incompleteTask: string;
+        pauseOutputLimit: string;
+        pauseStepLimit: string;
+        pauseWatchdog: string;
+        pauseRepeatedFailure: string;
+        pauseQuotaExceeded: string;
+        pauseGeneric: string;
         resumingAfterPause: string;
+        answerBlocked: string;
+        runErrorStoppedShort: string;
+        runErrorContextFull: string;
+        runErrorStepTooLong: string;
+        runErrorConnectionRevoked: string;
+        runErrorGeneric: string;
+        runCancelled: string;
+        runThrottled: string;
         open: string;
         reconnectRateLimited: string;
         reconnectRateLimitedStill: string;
@@ -818,8 +857,21 @@ export declare const streamIt: {
             reconnecting: string;
         };
         reconnectingBadge: string;
-        incompleteTask: string;
+        pauseOutputLimit: string;
+        pauseStepLimit: string;
+        pauseWatchdog: string;
+        pauseRepeatedFailure: string;
+        pauseQuotaExceeded: string;
+        pauseGeneric: string;
         resumingAfterPause: string;
+        answerBlocked: string;
+        runErrorStoppedShort: string;
+        runErrorContextFull: string;
+        runErrorStepTooLong: string;
+        runErrorConnectionRevoked: string;
+        runErrorGeneric: string;
+        runCancelled: string;
+        runThrottled: string;
         open: string;
         reconnectRateLimited: string;
         reconnectRateLimitedStill: string;

package/dist/i18n/messages/surfaces/vault.d.ts

@@ -0,0 +1,120 @@
+export declare const vaultEn: {
+    readonly vault: {
+        readonly title: "Secrets";
+        readonly description: "Save credentials for your own use across workspaces. Only their names and references are shown to the agent.";
+        readonly add: "Add secret";
+        readonly empty: "No secrets saved.";
+        readonly loading: "Loading secrets…";
+        readonly unavailable: "Secrets are unavailable here. Remove credentials from your message before sending.";
+        readonly name: "Name";
+        readonly nameHint: "Use lowercase letters, numbers and hyphens. Names cannot be changed.";
+        readonly kind: "Kind";
+        readonly apiKey: "API key, token or password";
+        readonly pem: "PEM private key";
+        readonly value: "Secret value";
+        readonly save: "Save";
+        readonly saveSecret: "Save secret";
+        readonly captureHint: "Secret detected. Save it securely; only its reference will be included in your message.";
+        readonly saving: "Saving…";
+        readonly cancel: "Cancel";
+        readonly replace: "Replace value";
+        readonly delete: "Delete";
+        readonly deleteConfirm: "Delete {{name}}? Commands using this reference will no longer work.";
+        readonly nameTaken: "That name is already in use.";
+        readonly notFound: "This secret no longer exists. Refresh and try again.";
+        readonly invalidInput: "Check the name and secret value.";
+        readonly requestFailed: "Could not update secrets. Try again.";
+        readonly forbidden: "You do not have access to secrets.";
+        readonly pasteBlocked: "This text looks like a credential. Remove it from your message and save it as a secret.";
+    };
+};
+export declare const vaultEs: {
+    vault: {
+        title: string;
+        description: string;
+        add: string;
+        empty: string;
+        loading: string;
+        unavailable: string;
+        name: string;
+        nameHint: string;
+        kind: string;
+        apiKey: string;
+        pem: string;
+        value: string;
+        save: string;
+        saveSecret: string;
+        captureHint: string;
+        saving: string;
+        cancel: string;
+        replace: string;
+        delete: string;
+        deleteConfirm: string;
+        nameTaken: string;
+        notFound: string;
+        invalidInput: string;
+        requestFailed: string;
+        forbidden: string;
+        pasteBlocked: string;
+    };
+};
+export declare const vaultPt: {
+    vault: {
+        title: string;
+        description: string;
+        add: string;
+        empty: string;
+        loading: string;
+        unavailable: string;
+        name: string;
+        nameHint: string;
+        kind: string;
+        apiKey: string;
+        pem: string;
+        value: string;
+        save: string;
+        saveSecret: string;
+        captureHint: string;
+        saving: string;
+        cancel: string;
+        replace: string;
+        delete: string;
+        deleteConfirm: string;
+        nameTaken: string;
+        notFound: string;
+        invalidInput: string;
+        requestFailed: string;
+        forbidden: string;
+        pasteBlocked: string;
+    };
+};
+export declare const vaultIt: {
+    vault: {
+        title: string;
+        description: string;
+        add: string;
+        empty: string;
+        loading: string;
+        unavailable: string;
+        name: string;
+        nameHint: string;
+        kind: string;
+        apiKey: string;
+        pem: string;
+        value: string;
+        save: string;
+        saveSecret: string;
+        captureHint: string;
+        saving: string;
+        cancel: string;
+        replace: string;
+        delete: string;
+        deleteConfirm: string;
+        nameTaken: string;
+        notFound: string;
+        invalidInput: string;
+        requestFailed: string;
+        forbidden: string;
+        pasteBlocked: string;
+    };
+};

package/dist/lib/use-tab-leadership.d.ts

@@ -2,5 +2,6 @@ import { TabRole } from './tab-leadership.ts';
 /** The persisted server id replaces a new Session's per-tab placeholder. */
 export declare const useTabLeadership: (chatId: string) => {
     readonly role: TabRole;
+    readonly ownedElsewhere: boolean;
     readonly requestControl: () => void;
 };

package/dist/routes/chat/history-cache.d.ts

@@ -39,6 +39,11 @@ export declare const refreshNewestHistoryPage: (client: QueryClient, scope: Hist
  * and not marked stale by a turn that finished since.
  */
 export declare const peekNewestHistoryPage: (client: QueryClient, scope: HistoryScope) => LoadedHistoryPage | null;
+/**
+ * A session this dock just created has no turns, so its newest page is known
+ * without asking. Opening it paints at once, with no spinner and no read.
+ */
+export declare const seedEmptyNewestHistoryPage: (client: QueryClient, scope: HistoryScope) => void;
 /** A turn finished: the cached newest page no longer holds the chat's end. */
 export declare const markNewestHistoryPageStale: (client: QueryClient, scope: HistoryScope) => void;
 /** Drop every cached page of one chat (deleted), in any workspace. */

package/dist/routes/chat/history-merge.d.ts

@@ -12,7 +12,10 @@ import { BelongUIMessage } from '../../stream/belong-data-parts.ts';
  * live lines up too), then back over the earlier rows of the page.
  *
  * Dedupe prefers the row id, then the client id the row was sent with. A
- * message with no id match yet falls back to `(role, flattened text)`. Only
+ * message with no id match yet falls back to `(role, flattened text)`; a live
+ * reply of a task whose rows nothing on screen lines up with folds into them
+ * when their text covers its own, and takes their place when it says more
+ * (`replyStanding`). Only
  * the suffix AFTER the last server-known on-screen message can be local-only.
  * Within that suffix, an assistant at the same next position as a durable
  * assistant is the same historical turn with stream-vs-folded whitespace/part

package/dist/routes/chat/question-parts.d.ts

@@ -0,0 +1,26 @@
+import { AnswerQuestionResult } from '../../api/questions.ts';
+import { BelongUIMessage, ChoiceRequestData } from '../../stream/belong-data-parts.ts';
+/**
+ * Plan 013 — rewrite the transcript's `data-choice-request` part for one
+ * question with its resolved shape, so the record reads exactly as it will
+ * after a reload (the history patch) without waiting for the wire; the live
+ * same-id part that follows overwrites it with the identical state. Every
+ * other message keeps its identity (no churn for the renderers).
+ */
+export declare const patchChoicePart: (messages: readonly BelongUIMessage[], resolved: ChoiceRequestData) => BelongUIMessage[];
+/**
+ * Plan 013 — Stop's local un-arm: the newest `pending` question flips to
+ * `cancelled`, exactly as the server's abort path flips its row. Walks the
+ * transcript itself rather than the derived card: X only HIDES a card in
+ * this tab, and a question hidden here is still cancelled by Stop — the
+ * record must read the same as it will after a reload (§41).
+ */
+export declare const cancelPendingQuestion: (messages: readonly BelongUIMessage[]) => BelongUIMessage[];
+/**
+ * Plan 013 — the part as the server's 409 says it settled: the row of record
+ * (another tab's answer / reply, a Stop's `cancelled`, a dismissal), which is
+ * what a reload would show — never an `answered` synthesised from nothing.
+ */
+export declare const rowOfRecord: (question: ChoiceRequestData, settled: Extract<AnswerQuestionResult, {
+    reason: "already_resolved";
+}>) => ChoiceRequestData;

package/dist/routes/chat/queued-delivery.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { BelongChatTransport } from '../../stream/belong-chat-transport.ts';
+import { QuotaNoticeData } from '../../stream/belong-data-parts.ts';
+import { QueuedMessageOutboxEntry } from '../../stream/queued-message-outbox.ts';
+declare const postMessageResponseSchema: z.ZodObject<{
+    messageId: z.ZodString;
+    taskId: z.ZodString;
+    runId: z.ZodString;
+    idempotent: z.ZodBoolean;
+}, z.core.$strip>;
+type QueuedMessageAccepted = z.infer<typeof postMessageResponseSchema> & {
+    readonly kind: "accepted";
+};
+export type QueuedMessagePostOwner = {
+    readonly kind: "queued-message-post-owner";
+};
+export declare const releaseQueuedMessagePostOwner: (owner: QueuedMessagePostOwner) => void;
+export declare const persistAndPostQueuedMessage: (apiBaseUrl: string, entry: QueuedMessageOutboxEntry, owner: QueuedMessagePostOwner, onFailure: () => void, onAccepted?: (result: QueuedMessageAccepted) => void, onQuotaRefused?: (notice: QuotaNoticeData) => void) => void;
+export declare const persistNewQueuedMessage: (apiBaseUrl: string, entry: QueuedMessageOutboxEntry, owner: QueuedMessagePostOwner, replayedIds: Set<string>, onFailure: () => void, onQuotaRefused: (notice: QuotaNoticeData) => void, timingTransport?: BelongChatTransport) => void;
+export {};

package/dist/routes/chat/queued-messages.d.ts

@@ -0,0 +1,15 @@
+import { BelongUIMessage, QuotaNoticeData } from '../../stream/belong-data-parts.ts';
+export type QueuedMessage = {
+    readonly clientId: string;
+    readonly text: string;
+    readonly submittedAt: number;
+} & ({
+    readonly state: "queued" | "failed";
+} | {
+    readonly state: "quota_refused";
+    readonly notice: QuotaNoticeData;
+});
+export declare const queuedTurnHasReply: (history: readonly BelongUIMessage[], text: string) => boolean;
+export declare const dropQueuedLandedIn: (history: readonly BelongUIMessage[]) => (prev: readonly QueuedMessage[]) => readonly QueuedMessage[];
+export declare const markQueuedFailed: (clientId: string) => (prev: readonly QueuedMessage[]) => readonly QueuedMessage[];
+export declare const markQueuedQuotaRefused: (clientId: string, notice: QuotaNoticeData) => (prev: readonly QueuedMessage[]) => readonly QueuedMessage[];

package/dist/routes/chat/session-api.d.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import { ActiveRunLookup } from './use-catch-up-on-return.ts';
+import { BelongChatTransport, RecalledQueuedMessage } from '../../stream/belong-chat-transport.ts';
+type SessionApiResult = {
+    readonly ok: true;
+    readonly body: unknown;
+} | {
+    readonly ok: false;
+    readonly status: number | null;
+    readonly body: unknown;
+};
+export declare const sessionApiFetch: (apiBaseUrl: string, sessionId: string, path: "messages" | "compact" | "clear" | "active-run", init?: RequestInit, query?: URLSearchParams) => Promise<SessionApiResult>;
+declare const activeRunResponseSchema: z.ZodUnion<readonly [z.ZodNull, z.ZodObject<{
+    runId: z.ZodString;
+    status: z.ZodEnum<{
+        queued: "queued";
+        waiting_for_approval: "waiting_for_approval";
+        running: "running";
+        waiting_for_user: "waiting_for_user";
+        waiting_for_ui_action: "waiting_for_ui_action";
+        recovering: "recovering";
+        cancelling: "cancelling";
+    }>;
+}, z.core.$strip>]>;
+type ActiveRunInfo = z.infer<typeof activeRunResponseSchema>;
+export declare const loadActiveRun: (apiBaseUrl: string, sessionId: string) => Promise<ActiveRunInfo>;
+export declare const lookUpActiveRun: (apiBaseUrl: string, sessionId: string) => Promise<ActiveRunLookup>;
+export declare const cancelRunForStop: (input: {
+    readonly apiBaseUrl: string;
+    readonly transport: BelongChatTransport;
+    readonly runId: string | null;
+    readonly sessionId: string | null;
+}) => Promise<readonly RecalledQueuedMessage[]>;
+type CompactOutcome = {
+    readonly status: "compacted";
+    readonly messagesCompacted: number;
+} | {
+    readonly status: "noop";
+} | {
+    readonly status: "busy";
+} | {
+    readonly status: "error";
+};
+export declare const compactSession: (apiBaseUrl: string, sessionId: string) => Promise<CompactOutcome>;
+export declare const compactNoticeText: (outcome: CompactOutcome) => string;
+type ClearOutcome = {
+    readonly status: "cleared";
+} | {
+    readonly status: "error";
+};
+export declare const clearSession: (apiBaseUrl: string, sessionId: string) => Promise<ClearOutcome>;
+export {};

package/dist/routes/chat/session-history-api.d.ts

@@ -0,0 +1,9 @@
+import { QueryClient } from '@tanstack/react-query';
+import { HistoryPageResult, HistoryScope } from './history-cache.ts';
+export declare const loadSessionHistory: (apiBaseUrl: string, sessionId: string, before?: string) => Promise<HistoryPageResult>;
+/**
+ * Read a chat's newest page ahead of opening it (the Chats list's
+ * `SessionIntentContext`), so it opens painted from the cache. A chat kept
+ * live needs no read; a page read in the last 30 s is not read again.
+ */
+export declare const prefetchChatHistory: (queryClient: QueryClient, apiBaseUrl: string, scope: HistoryScope) => void;

package/dist/routes/chat/transcript-update.d.ts

@@ -0,0 +1,45 @@
+import { BelongUIMessage } from '../../stream/belong-data-parts.ts';
+import { LoadedHistoryPage } from './history-cache.ts';
+import { HistoryPaging } from './history-paging.ts';
+export type TranscriptEvent = {
+    readonly kind: "history_restored";
+    readonly page: LoadedHistoryPage;
+    readonly onScreen: readonly BelongUIMessage[];
+} | {
+    readonly kind: "caught_up";
+    readonly page: LoadedHistoryPage;
+    readonly caughtUp: BelongUIMessage[];
+} | {
+    readonly kind: "compacted";
+    readonly page: LoadedHistoryPage;
+} | {
+    readonly kind: "quota_stopped";
+    readonly page: LoadedHistoryPage;
+} | {
+    readonly kind: "queued_reply_landed";
+    readonly history: readonly BelongUIMessage[];
+    /** Asked when React applies the update: a Clear or a new turn may come first. */
+    readonly canApply: () => boolean;
+} | {
+    readonly kind: "older_page_loaded";
+    readonly page: LoadedHistoryPage;
+    readonly expectedFirstId: string;
+} | {
+    readonly kind: "cleared";
+} | {
+    readonly kind: "unsaved_chat_cleared";
+};
+type CursorUpdate = {
+    readonly kind: "keep";
+} | {
+    readonly kind: "set";
+    readonly id: string | null;
+};
+export type TranscriptUpdate = {
+    readonly messages: BelongUIMessage[] | ((current: BelongUIMessage[]) => BelongUIMessage[]);
+    readonly paging: HistoryPaging | ((paging: HistoryPaging) => HistoryPaging) | null;
+    readonly historyThrough: CursorUpdate;
+    readonly spokenThrough: CursorUpdate;
+};
+export declare const transcriptUpdateFor: (event: TranscriptEvent) => TranscriptUpdate;
+export {};

package/dist/routes/chat/use-catch-up-on-return.d.ts

@@ -66,5 +66,12 @@ export declare const useCatchUpOnReturn: (input: {
     readonly controlRequestId?: number;
     readonly prepareControl?: (sessionId: string) => Promise<void>;
     readonly onControlReady?: (ready: boolean) => void;
+    /**
+     * This mount shows a session this tab created a moment ago. Its first
+     * promotion has nothing to catch up on, so writing is not held for the reads.
+     * Only the first: if control ever moves to another tab and back, this tab
+     * catches up like any other.
+     */
+    readonly justCreated?: boolean;
     readonly returnOptions?: Parameters<typeof useReturnToPage>[1];
 }) => void;

package/dist/routes/chat/use-next-step-suggestion.d.ts

@@ -0,0 +1,38 @@
+import { UseChatHelpers } from '@ai-sdk/react';
+import { NextStepSuggestion } from '../../api/suggestions.ts';
+import { GoalStatus } from '../../api/goals.ts';
+import { BelongUIMessage } from '../../stream/belong-data-parts.ts';
+type ChatStatus = UseChatHelpers<BelongUIMessage>["status"];
+export type UseNextStepSuggestionInput = {
+    readonly apiBaseUrl: string;
+    readonly sessionId: string | null;
+    readonly locale: string;
+    readonly status: ChatStatus;
+    readonly lastMessage: {
+        readonly role: string;
+    } | null;
+    readonly draftEmpty: boolean;
+    /** False when this tab cannot act on the session (follower tab, read-only run). */
+    readonly enabled: boolean;
+};
+export type UseNextStepSuggestion = {
+    readonly suggestion: NextStepSuggestion | null;
+    readonly dismiss: () => void;
+    /** Call before Stop: the turn about to end was cut short, so nothing is suggested for it. */
+    readonly suppressNextFinish: () => void;
+};
+export declare const useNextStepSuggestion: (input: UseNextStepSuggestionInput) => UseNextStepSuggestion;
+/**
+ * The suggestion as the screen shows it: the card and the composer ghost read
+ * this one value, so they always agree. It yields to the two rows that already
+ * sit above the composer — an open question card is the agent's own ask, and a
+ * live goal's row is where the hand already is. A finished or cleared goal has
+ * no row, so it hides nothing.
+ */
+export declare const nextStepOnScreen: (suggestion: NextStepSuggestion | null, context: {
+    readonly questionOpen: boolean;
+    readonly goalStatus: GoalStatus | null;
+}) => NextStepSuggestion | null;
+/** The composer's ghost: the welcome question on a new chat, else the recommended reply. */
+export declare const composerGhost: (welcome: string | null, nextStep: NextStepSuggestion | null) => string | null;
+export {};

package/dist/routes/chat/use-quota-notice.d.ts

@@ -0,0 +1,29 @@
+import { TFunction } from 'i18next';
+import { QuotaRefusal } from '../../api/quota-refusal.ts';
+import { BelongUIMessage } from '../../stream/belong-data-parts.ts';
+/**
+ * Re-key the refused message's optimistic bubble to the server's id and
+ * append the notice. Pure and idempotent: a second application (a duplicate
+ * `onError`, a replayed refusal) changes nothing further.
+ */
+export declare const applyQuotaRefusal: (messages: readonly BelongUIMessage[], refusal: QuotaRefusal) => BelongUIMessage[];
+/**
+ * What a finished assistant message says out loud (the live call and the
+ * speaker's batch TTS). A quota notice says the card's words: live it has no
+ * text part, and its history row's fallback text is never shown, so both
+ * renders speak the same sentence under the same id — spoken once, on time.
+ */
+export declare const assistantSpokenText: (message: BelongUIMessage, t: TFunction, locale: string) => string;
+/**
+ * `handleQuotaError(error)` answers a quota refusal and reports `true`, or
+ * reports `false` and leaves the error to the caller's other paths. The
+ * chat's error state is cleared on a microtask: `useChat` calls `onError`
+ * BEFORE it parks `status: "error"`, and `clearError` is a no-op until then
+ * (the same deferral the goal refusal uses).
+ */
+export declare const useQuotaNotice: ({ setMessages, clearError, }: {
+    readonly setMessages: (update: (messages: BelongUIMessage[]) => BelongUIMessage[]) => void;
+    readonly clearError: () => void;
+}) => {
+    readonly handleQuotaError: (error: unknown) => boolean;
+};

package/dist/routes/chat/use-quota-stop-refresh.d.ts

@@ -0,0 +1,27 @@
+import { BelongUIMessage } from '../../stream/belong-data-parts.ts';
+import { HistoryPageResult } from './history-cache.ts';
+export declare const signalQuotaStop: (sessionId: string) => void;
+/**
+ * The newest quota-stop signal of the turn on screen, as a stable key, or
+ * `null`. Restored history is never a signal (it already carries its card),
+ * and the scan stops at the turn's user message.
+ */
+export declare const quotaStopSignalKey: (messages: readonly BelongUIMessage[]) => string | null;
+export declare const useQuotaStopRefresh: ({ messages, idle, isBusy, resolveSessionId, refreshNewestHistory, applyHistoryPage, sleepMs, }: {
+    readonly messages: readonly BelongUIMessage[];
+    /** No turn is streaming into the chat right now (reactive; re-runs the hook). */
+    readonly idle: boolean;
+    /** Read at apply time: a turn is in flight or the transport holds a live stream. */
+    readonly isBusy: () => boolean;
+    /** The chat's session, read when a refresh starts and between attempts. */
+    readonly resolveSessionId: () => string | null;
+    readonly refreshNewestHistory: (sessionId: string) => Promise<HistoryPageResult>;
+    /** Merge the page into the conversation (the `/compact` merge). */
+    readonly applyHistoryPage: (page: Extract<HistoryPageResult, {
+        ok: true;
+    }>) => void;
+    /** Injectable delay (§25). */
+    readonly sleepMs?: (ms: number) => Promise<void>;
+}) => {
+    readonly refreshForQuotaStop: () => void;
+};

package/dist/routes/chat/use-session-goal.d.ts

@@ -227,6 +227,12 @@ export type SessionGoalInput = {
      *  objective back to the composer through the SAME door
      *  `useGoalReceipt`'s follow-ups already use. */
     readonly setDraft: (value: string) => void;
+    /**
+     * Console P1 — a resume or edit answered `budget_limited`: the monthly
+     * token quota may have stopped it, and the cell persisted an orange notice
+     * the chat reads from history (`use-quota-stop-refresh.ts`).
+     */
+    readonly onGoalQuotaStop?: (() => void) | undefined;
 };
 export declare const useSessionGoal: (input: SessionGoalInput) => SessionGoalApi;
 export {};

package/dist/routes/chat.d.ts

@@ -1,21 +1,15 @@
-import { QueryClient } from '@tanstack/react-query';
-import { HistoryScope } from './chat/history-cache.ts';
-export type QueuedMessage = {
-    readonly clientId: string;
-    readonly text: string;
-    readonly submittedAt: number;
-    readonly state: "queued" | "failed";
-};
-/**
- * Read a chat's newest page ahead of opening it (the Chats list's
- * `SessionIntentContext`), so it opens painted from the cache. A chat kept
- * live needs no read; a page read in the last 30 s is not read again.
- */
-export declare const prefetchChatHistory: (queryClient: QueryClient, apiBaseUrl: string, scope: HistoryScope) => void;
-export declare const ChatRoute: ({ sessionId, draftId, reconcileBackgroundRun, onOpenGoalView, onOpenFilesView, projectRunReadOnly, }?: {
+export declare const ChatRoute: ({ sessionId, draftId, reconcileBackgroundRun, sessionPending, justCreated, onOpenGoalView, onOpenFilesView, projectRunReadOnly, }?: {
     readonly sessionId?: string;
     readonly draftId?: string;
     readonly reconcileBackgroundRun?: boolean;
+    /**
+     * The rail's "+" shows this new chat while its session is still being created
+     * (BelongDock remounts onto that session when it exists). Nothing may be
+     * written here until then: it would land outside the new agent.
+     */
+    readonly sessionPending?: boolean;
+    /** This tab created the session a moment ago: it opens with nothing to catch up on. */
+    readonly justCreated?: boolean;
     /** Put the Goal view on screen (the dock owns navigation — same path the
      *  header pill takes). Omitted in tests and stories, where the row's
      *  Details simply does nothing. */