@dvina/sdk 4.1.112 → 4.1.173

package/dist/adapters/react/index.d.ts

@@ -1,10 +1,10 @@
-import { a as DvinaQueryRef } from '../../types-Chg8ASmf.js';
+import { D as DvinaQueryRef } from '../../types-BfiQdtra.js';
 import 'graphql';
 
 /**
  * React adapter for @dvina/sdk.
  *
- * Converts DvinaQueryRef (AsyncIterable) into React state via hooks.
+ * Binds a DvinaQueryRef (AsyncIterable) to React through `useSyncExternalStore`.
  *
  * @example
  * ```tsx
@@ -23,33 +23,39 @@ import 'graphql';
  * @packageDocumentation
  */
 
+/** The `useSyncExternalStore` contract over one query ref. */
+interface LiveStore<T> {
+    subscribe(onChange: () => void): () => void;
+    getSnapshot(): T | undefined;
+    /** The value together with the error the query failed with, if it did; replaced on every change. */
+    getState(): LiveQueryState<T>;
+}
+/** A live query's latest value, and the error it failed with (e.g. a record that does not exist). */
+type LiveQueryState<T> = {
+    data: T | undefined;
+    error: unknown;
+};
 /**
- * React hook that subscribes to a `DvinaQueryRef` (AsyncIterable) and
- * returns its latest value as React state.
- *
- * Accepts a **factory function** that creates the query ref, along with a
- * dependency array. The factory is memoized internally — the ref is only
- * recreated when the dependencies change, preventing infinite
- * dispose-subscribe loops that would occur with inline `.watch()` calls.
+ * Exposes a query as an external store. Each subscriber consumes the query ref
+ * through its own iterator; the ref is disposed once the last subscriber has
+ * left and none came back within the same task. React may unsubscribe and
+ * subscribe again right away (Strict Mode, concurrent rendering), so disposal
+ * is deferred; a subscriber that returns after disposal (e.g. an `<Activity>`
+ * shown again) gets a fresh ref from the factory.
+ */
+declare function createLiveStore<T>(factory: () => DvinaQueryRef<T>): LiveStore<T>;
+/**
+ * Subscribes to a query ref and returns its latest value, or `undefined`
+ * until the first value arrives.
  *
- * The component re-renders whenever the query ref emits a new value.
- * Cleanup (disposal of the subscription) happens automatically when the
- * component unmounts or when dependencies change.
+ * The factory runs again only when `deps` change (same semantics as
+ * `useMemo`); the previous ref is disposed once React no longer uses it.
  *
- * @param factory - A function that returns a DvinaQueryRef (e.g. `() => sdk.reports().watch()`)
- * @param deps - Dependency array controlling when the ref is recreated (same semantics as `useMemo`)
- * @returns The latest value from the query ref, or `undefined` if not yet loaded
+ * @param factory - Returns the query ref, e.g. `() => sdk.reports().watch()`
+ * @param deps - Values the query depends on
  *
  * @example
  * ```tsx
- * // Static query — ref created once
- * function ReportsPage() {
- *   const reports = useLiveQuery(() => sdk.reports({ first: 20 }).watch(), []);
- *   if (!reports) return <div>Loading...</div>;
- *   return <ul>{reports.nodes.map(r => <li key={r.id}>{r.name}</li>)}</ul>;
- * }
- *
- * // Reactive query — ref recreated when `id` changes
  * function ReportDetail({ id }: { id: string }) {
  *   const report = useLiveQuery(() => sdk.report({ id }).watch(), [id]);
  *   if (!report) return <div>Loading...</div>;
@@ -58,5 +64,11 @@ import 'graphql';
  * ```
  */
 declare function useLiveQuery<T>(factory: () => DvinaQueryRef<T>, deps: readonly unknown[]): T | undefined;
+/**
+ * Like `useLiveQuery`, with the query's failure: `{ data, error }`. `data` is `undefined` while loading;
+ * `error` is set when the query failed (e.g. the record does not exist), so a panel can show "not found"
+ * instead of loading forever.
+ */
+declare function useLiveQueryState<T>(factory: () => DvinaQueryRef<T>, deps: readonly unknown[]): LiveQueryState<T>;
 
-export { useLiveQuery };
+export { type LiveQueryState, type LiveStore, createLiveStore, useLiveQuery, useLiveQueryState };

package/dist/adapters/react/index.js

@@ -1 +1 @@
-import'../../chunk-EK7ODJWE.js';import {useMemo,useState,useRef,useEffect}from'react';function p(u,o){let n=useMemo(u,o),[c,t]=useState(n.current);if(process.env.NODE_ENV!=="production"){let e=useRef(0),r=useRef(Date.now()),s=Date.now();n!==void 0&&(s-r.current<1e3?e.current++:e.current=1,r.current=s,e.current>10&&(console.warn("useLiveQuery: query ref was recreated more than 10 times within 1 second. This usually means the dependency array is unstable (e.g. a new object/array created every render). Ensure deps contain only primitive values or stable references."),e.current=0));}return useEffect(()=>{let e=true;return t(n.current),(async()=>{try{for await(let r of n){if(!e)break;t(r);}}catch{}})(),()=>{e=false,n.dispose();}},[n]),c}export{p as useLiveQuery};
+import'../../chunk-EK7ODJWE.js';import {useMemo,useSyncExternalStore}from'react';var S=1e3;function T(r){let t=r(),e=t.current,o={data:e,error:void 0},s=(i,n)=>{o={...o,...n},e=o.data,i();},d=0,c,f=()=>{t?.dispose(),t=void 0;};return c=setTimeout(f,S),{getSnapshot:()=>e,getState:()=>o,subscribe(i){clearTimeout(c),d++;let n=t??=r(),y=n[Symbol.asyncIterator](),u=true;return (async()=>{try{for(;u;){let a=await y.next();if(a.done||!u)break;s(i,{data:a.value,error:void 0});}}catch(a){u&&s(i,{error:a});}})(),n.current!==void 0&&n.current!==e&&s(i,{data:n.current}),()=>{u=false,y.return?.(),d--,d===0&&(c=setTimeout(f,0));}}}}function b(r,t){let e=useMemo(()=>T(r),t);return useSyncExternalStore(e.subscribe,e.getSnapshot,e.getSnapshot)}function Q(r,t){let e=useMemo(()=>T(r),t);return useSyncExternalStore(e.subscribe,e.getState,e.getState)}export{T as createLiveStore,b as useLiveQuery,Q as useLiveQueryState};

package/dist/ai/index.d.ts

@@ -0,0 +1,570 @@
+import { UIMessage, DefaultChatTransport } from 'ai';
+import { D as DvinaSdk, C as ChatMessage, a as ChatMessageConnection } from '../_generated_sdk-7_X86mtI.js';
+import '../types-BfiQdtra.js';
+import 'graphql';
+import '../connection-ClMdDUce.js';
+import 'dexie';
+import '../error-Bk0Jmuzd.js';
+import '../billing/index.js';
+
+/** How a turn ended: `waiting` for the user's approval or answer, `incomplete` when it ended before finishing. */
+type DvinaTurnOutcome = 'done' | 'waiting' | 'incomplete' | 'failed' | 'stopped';
+/** Where the supervisor sent a user message: answered itself, relayed it to a task, or started a new task. */
+type DvinaMessageRoute = {
+    to: 'supervisor' | 'task' | 'new-task';
+    /** The task chat, for `task` and `new-task`. */
+    chatId?: string;
+    /** The supervisor's one-line reason for a relay or a new task. */
+    reason?: string;
+};
+/** A task's state as a badge shows it: running (also while queued or resuming), or how its latest turn ended. */
+type DvinaTaskStatus = 'running' | DvinaTurnOutcome;
+/** Metadata attached to every Dvina chat message. */
+type DvinaMessageMetadata = {
+    createdAt?: string;
+    /** When an assistant message finished streaming. */
+    finishedAt?: string;
+    /** The reply was stopped by the user before it finished. */
+    stopped?: boolean;
+    /** Why the model ended the reply's last step, as the AI SDK reports it (`stop`, `length`, `tool-calls`, …). */
+    finishReason?: string;
+    /**
+     * How the turn that wrote this reply ended, decided by the server. `done` only when the model ended on
+     * its own; absent on replies saved before outcomes were recorded.
+     */
+    outcome?: DvinaTurnOutcome;
+    /** Why an `incomplete` or `failed` turn ended: `budget` (step or token limit), `error`, or a finish reason. */
+    outcomeReason?: string;
+    /** Model that produced an assistant message. */
+    model?: string;
+    usage?: {
+        inputTokens: number;
+        cachedInputTokens: number;
+        outputTokens: number;
+        reasoningTokens: number;
+    };
+    threadId?: string | null;
+    inResponseToId?: string | null;
+    /** The user inputs this reply consumes together; durable wake-ups use this to avoid answering a batch twice. */
+    answeredUserMessageIds?: string[];
+    /** The part of the replied-to message the user answered, as the reply's quote shows it. */
+    inResponseToExcerpt?: string;
+    /** Task chat a supervisor message refers to. */
+    referencedChatId?: string | null;
+    /**
+     * The reply thread the message is in, from the whole chat (not what is loaded): its first message (`rootId`, the
+     * message's own id on a root) and how many replies it holds, as the app counts them (a reply of the reader's, and
+     * whatever answers a reply, at any depth). Absent when the message is in no thread.
+     */
+    replyThread?: {
+        rootId: string;
+        replyCount: number;
+    };
+    /**
+     * This message owns its task's live code card: the first of Dvina's shown replies to a hidden prompt that refers to
+     * the task chat (`referencedChatId`), in the whole chat's order.
+     */
+    ownsTaskCode?: true;
+    /** A single task's report: the message that handed exactly this one task to the task chat it reports on. */
+    handOffId?: string;
+    /**
+     * A single task's report drawn in its hand-off's thread: false when only plain replies stand between the hand-off and
+     * the report (the hand-off's own line says how the task ended), true otherwise. Decided when the report is written.
+     */
+    threadedUnderHandOff?: boolean;
+    /** An internal message (a task's result, an agent's note): the user's role, never shown as theirs. */
+    hidden?: boolean;
+    /** A message of a legacy chat moved into this one: it is read in its thread, as text. */
+    legacyChatId?: string | null;
+    /**
+     * Said in a voice call and answered by the voice itself (its user line and its answer), kept in the call's thread
+     * outside any turn: a turn's continuation or recovery looks past it.
+     */
+    spoken?: boolean;
+    /** A voice message from an older app; its text is the server's transcript. The reply is text. */
+    voiceInput?: boolean;
+    /** On a user message: sent from Dvina's bar (desktop), over whatever app the user was working in. */
+    surface?: 'bar';
+    /** On a message sent from the bar: the user let Dvina look at their screen (the bar's screen context, off by default). */
+    screenContext?: boolean;
+    /**
+     * On a user message sent while a reply was showing: how much of that reply was on screen then, so the message reads
+     * after it and the rest of the reply after the message, as written. `parts` whole parts, then `text` characters of
+     * the text part being written; without `id` the reply showed nothing yet and the message reads before it.
+     */
+    afterReply?: {
+        id?: string;
+        parts: number;
+        text?: number;
+    };
+    /** The scheduled message that sent this user message when it was due. */
+    scheduledMessageId?: string;
+    /** On a main chat user message: where the supervisor routed it (stored when its turn ends). */
+    route?: DvinaMessageRoute;
+    /**
+     * On a reply to a section of a report: the task that section is about (its badge's `chatId`). The supervisor
+     * reads it as the task the reply is for.
+     */
+    inResponseToTaskChatId?: string;
+    /**
+     * On a message a task chat received from the supervisor: the main chat user message that led to it. The task
+     * panel shows that message's own words; a message the supervisor added on its own has none.
+     */
+    triggeredBy?: string;
+    /**
+     * On an assistant reply: the user's predicted next message, shown in an empty composer (ghost text), and when
+     * it was predicted; `null` when none fits. Absent until the client asks for it.
+     */
+    nextPrompt?: {
+        text: string;
+        at: string;
+    } | null;
+    /** On a user message: it began as the predicted next message (accepted with Tab or a tap). */
+    nextPromptUsed?: boolean;
+};
+/** Custom data parts streamed alongside text and tool parts. */
+type DvinaDataParts = {
+    /** Files presented to the user; persisted with the message. */
+    artifact: {
+        id: string;
+        name: string;
+        size: number;
+        path?: string;
+        toolCallId?: string;
+        /** The artifact's file at this presentation; absent on parts saved before versioning. */
+        fileId?: string;
+        /** Version this presentation saved; presenting the same path again in a chat adds one. */
+        version?: number;
+        versionCount?: number;
+        /** `draft` while the agent is still changing the file. */
+        status?: 'ready' | 'draft';
+        /** File extension, lower case. */
+        format?: string;
+    };
+    /** An office file a script is building before it is presented; streamed only (transient), never saved. */
+    'file-draft': {
+        path: string;
+        name: string;
+        fileId: string;
+        size: number;
+    };
+    /** PII protection applied to the latest turn. */
+    privacy: {
+        maskedValueCount: number;
+        matchedTypes: string[];
+    };
+    /** Context the model reads with the user's message but the UI does not show; persisted with the message. */
+    context: {
+        text: string;
+    };
+    /** Conversations imported from another assistant into the library; written to the main chat by the server. */
+    'chat-import': {
+        /** The export's archive hash. */
+        id: string;
+        provider: 'ChatGpt' | 'Claude' | 'Grok';
+        importedCount: number;
+        skippedCount: number;
+        messageCount: number;
+        /** Library folder holding the imported documents; their `isReady` tells the indexing progress. */
+        folderPath: string;
+        firstConversationAt?: string;
+        lastConversationAt?: string;
+        /** Titles of the newest imported conversations, newest first. */
+        sampleTitles: string[];
+        importedAt: string;
+    };
+    /** One task chat messaged another; shown in the supervisor chat so the user can follow the team. */
+    'agent-message': {
+        fromChatId: string;
+        fromTitle: string;
+        toChatId: string;
+        toTitle: string;
+        /** The start of the message. */
+        gist: string;
+    };
+    /** A legacy generative UI block (StreamableUi), kept as stored: `content` is its original payload. */
+    'legacy-streamable-ui': {
+        content: string;
+        agentId?: string;
+        agentName?: string;
+    };
+    /** A legacy chat moved into the main chat: its card on the timeline, opening its thread (the message's `threadId`). */
+    'legacy-chat': {
+        chatId: string;
+        name: string;
+        messageCount: number;
+    };
+    /**
+     * A voice call (conversation mode): its card on the main chat's timeline, opening its thread (the message's
+     * `threadId`), which holds what was said in the call. Written when the call opens; the end and the counts are
+     * added when it ends. A call whose end never arrived reads as ended once it is older than the longest call.
+     */
+    'voice-call': {
+        /** When the call opened (ISO). */
+        startedAt: string;
+        /** When it ended (ISO); absent while it goes on. */
+        endedAt?: string;
+        /** Why it ended, as the server's session says (`ended`, `idle`, `expired`, `limit`…). */
+        endReason?: string;
+        durationMs?: number;
+        /** The user's and Dvina's messages in the call's thread. */
+        messageCount?: number;
+        /** Files presented in the call's thread. */
+        artifactCount?: number;
+        /** Tasks Dvina started in the call. */
+        taskCount?: number;
+    };
+    /**
+     * A chat, task or thread someone shared with the reader: its card in their main chat, at the moment it was
+     * shared, opening it read-only or as the reader's role allows. `title` and the sharer are as they were when the
+     * card was written; the item opens under its current title. `revokedAt` once the share was taken away.
+     */
+    'shared-chat': {
+        kind: 'chat' | 'task' | 'thread';
+        id: string;
+        /** The owner's chat it is read from (a thread's is the chat it is in). */
+        chatId: string;
+        title: string;
+        sharedById: string;
+        sharedByName: string;
+        revokedAt?: string | null;
+    };
+    /** A legacy content block with no other form (e.g. a tool call whose record is unreadable), kept as stored. */
+    'legacy-block': {
+        blockType: string;
+        content: string;
+        agentId?: string;
+        agentName?: string;
+    };
+    /**
+     * A task's one-line badge on a supervisor message: the message that started it (`delegate`), relayed a user
+     * message to it (`relay`), presents its result (`result`), or offers it as an answer to "which one?"
+     * (`candidate`). In a chat, a task's latest delegate/relay badge is live and follows the task. An earlier one
+     * is frozen: it shows the `previous` state of the task's next badge, or its own `state` at `at`.
+     */
+    /**
+     * "While you were away": the tasks that finished while the user was away, one row each (failures too),
+     * written when they come back. A row opens that task's result (`messageId`, in the task chat).
+     */
+    'away-summary': {
+        /** When the first of them finished (ISO). */
+        since: string;
+        items: {
+            chatId: string;
+            title: string;
+            state: DvinaTaskStatus;
+            /** One line of its result, or of what stopped it. */
+            gist: string;
+            /** When it finished (ISO). */
+            at: string;
+            messageId?: string;
+        }[];
+    };
+    'task-badge': {
+        chatId: string;
+        /** The task's name when the badge was written. */
+        title: string;
+        via: 'delegate' | 'relay' | 'result' | 'candidate';
+        /** The task's state when the badge was written. */
+        state: DvinaTaskStatus;
+        /** When the badge was written (ISO). */
+        at: string;
+        /** The task input message for this run. Shared by delegate/relay and result badges; not the reply's ID. */
+        messageId?: string;
+        /**
+         * On a relay: the task's state just before it, which the previous badge of the task shows once this one is
+         * live. A badge with no later badge for its task shows its own `state`.
+         */
+        previous?: {
+            state: DvinaTaskStatus;
+            at: string;
+        };
+        /** The task's current step, when known. */
+        step?: string;
+        progress?: {
+            done: number;
+            total: number;
+        };
+    };
+    /** Older replies: a user reply the supervisor passed to a task chat (now `task-badge`). */
+    'task-follow-up': {
+        chatId: string;
+        /** The task chat message the reply was passed as; the task's reply answers it (`metadata.inResponseToId`). */
+        messageId?: string;
+    };
+    /** A task chat's live progress line in the user's language, updated in place after each step. */
+    narration: {
+        text: string;
+    };
+    /**
+     * Something Dvina noticed on its own (proactive), in its own message, never inside a reply. The card reads the
+     * finding's live state (body, sources, status) by `itemId`; a `superseded` one folds to a line.
+     */
+    'proactive-item': {
+        itemId: string;
+        /** `meeting-prep`, `deadline`, ... */
+        detector: string;
+        title: string;
+        /** The time phrase in the user's language, e.g. "before your 2 PM". */
+        whenLabel?: string;
+        /** When it was written (ISO). */
+        at: string;
+        /** The finding this one replaces (the meeting moved). */
+        previousItemId?: string;
+    };
+    /**
+     * A weekly or monthly report that became ready, in its own message in the main chat: the card shows this snapshot
+     * and opens the report (`?aside=digest:<period>:<key>`). Everything past the digest's identity is optional, so a
+     * card written before a field existed still draws.
+     */
+    'digest-report': {
+        digestId: string;
+        period: 'week' | 'month';
+        /** The digest's period key, `2026-W41` or `2026-10`. */
+        key: string;
+        /** What mattered most, in the user's language. */
+        headline?: string;
+        /** Up to three of the report's top points. */
+        points?: string[];
+        /** How many of each the report holds, counted from its content. */
+        counts?: {
+            tasks?: number;
+            decisions?: number;
+            openEnds?: number;
+            risks?: number;
+        };
+        /** When it was written (ISO). */
+        at?: string;
+    };
+    /** A message the user scheduled; the card reads the schedule's live state by `id`. */
+    'scheduled-message': {
+        id: string;
+        title: string;
+    };
+    /** New chat title; transient. */
+    'chat-title': {
+        title: string;
+    };
+    /**
+     * A goal Dvina proposes for a task, on the task's waiting reply next to the `question` that asks to start it
+     * (`toolCallId`): an app that knows goals draws the proposal card, an older one the plain question.
+     */
+    'goal-proposal': DvinaGoal & {
+        /** The `question` call this proposal is answered through. */
+        toolCallId: string;
+    };
+    /**
+     * A round of a goal, graded: on the round's reply in the task chat. The last one says where the goal stands.
+     * Unknown to older apps, which show the task as before.
+     */
+    'goal-evaluation': DvinaGoalEvaluation;
+};
+/** What a goal's run is doing. */
+type DvinaGoalStatus = 'proposed' | 'pursuing'
+/** Waiting on the user's decision: accept the best version, adjust, one more round or stop. */
+ | 'checkpoint' | 'achieved'
+/** A limit (rounds, time, usage) ended it; the best round is the result. */
+ | 'limit'
+/** The user accepted a version that did not meet it. */
+ | 'accepted' | 'stopped'
+/** The user chose to do the work once, without the goal. */
+ | 'declined';
+type DvinaGoalCriterion = {
+    id: string;
+    title: string;
+    description?: string;
+    weight: number;
+    mustPass: boolean;
+    /** judge: a reviewer reads the result; check: a deterministic check over files and tool results; human: the user confirms. */
+    kind: 'judge' | 'check' | 'human';
+    /** A `check` criterion's deterministic check over the round's files, tool results and answer. */
+    check?: {
+        type: 'artifact' | 'tool-succeeded' | 'no-tool-errors' | 'answer-includes';
+        value?: string;
+        min?: number;
+    };
+};
+/** A task's goal: what to achieve, when it is done, how that is judged (its rubric) and the run's limits. */
+type DvinaGoal = {
+    objective: string;
+    doneWhen: string;
+    criteria: DvinaGoalCriterion[];
+    /** Weighted score needed, 0 to 1. */
+    threshold: number;
+    limits: {
+        maxRounds: number;
+        maxMinutes: number;
+        maxUsagePercent: number;
+    };
+    /** The rubric template (a skill) it follows. */
+    template?: {
+        id: string;
+        name: string;
+    } | null;
+};
+type DvinaGoalEvaluation = {
+    round: number;
+    maxRounds: number;
+    /** Weighted score, 0 to 1. */
+    score: number;
+    threshold: number;
+    verdict: 'pass' | 'revise' | 'stuck' | 'needs_human';
+    /** Where the goal stands after this round. */
+    status: DvinaGoalStatus;
+    criteria: {
+        id: string;
+        title: string;
+        /** null: waiting for the user. */
+        passed: boolean | null;
+        score: number;
+        /** One line: what in the result shows it. */
+        evidence: string;
+        fix?: string;
+    }[];
+    /** One or two sentences from the reviewer. */
+    summary: string;
+    /** The best round so far and the reply that holds it. */
+    best: {
+        round: number;
+        score: number;
+        messageId: string;
+    };
+    /** Every round's score so far, this one last. */
+    scores: number[];
+    /** When it was graded (ISO). */
+    at: string;
+};
+type DvinaUIMessage = UIMessage<DvinaMessageMetadata, DvinaDataParts>;
+/** Tool metadata carried on tool parts; set by the server for every tool. */
+type DvinaToolMetadata = {
+    toolKit?: string;
+};
+
+type DvinaChatTransportOptions = {
+    /** API origin including protocol, e.g. `https://api.dvina.ai`. */
+    apiUrl: string;
+    getToken: (options?: {
+        forceRefresh?: boolean;
+    }) => Promise<string>;
+    /** Custom fetch, e.g. the Tauri HTTP plugin. */
+    fetch?: typeof fetch;
+    /** The app's language (BCP 47, e.g. `tr`, `pt-BR`), sent as `x-preferred-language` like the GraphQL client's. */
+    getLanguage?: () => string | undefined;
+};
+/**
+ * Chat transport for `useChat` / `Chat`.
+ *
+ * - Sends only the newest message; the server owns the history.
+ * - Resumes an active stream with `GET /api/chat/:id/stream`.
+ * - Retries once with a refreshed token when the API answers 401.
+ * - Retries with backoff while the API answers 503 during a restart.
+ *
+ * A resumed stream of a continued reply starts by replaying the reply as stored. `keepsReply` says the chat already
+ * holds that reply and continues it in place (AI SDK keeps a reply whose tool waits on an approval answer or on its
+ * input); its replay is then skipped, as the legacy stream skips it, or the reply's parts would be added twice.
+ */
+declare function createDvinaChatTransport(options: DvinaChatTransportOptions, { keepsReply }?: {
+    keepsReply?: () => boolean;
+}): DefaultChatTransport<DvinaUIMessage>;
+/**
+ * Chat transport for a temporary chat (`POST /api/temporary-chat`): AI SDK's default, without persistence. The
+ * client holds the conversation and sends all of it with each turn; the server answers and stores nothing, so there
+ * is no stream to resume and stopping aborts the request.
+ */
+declare function createDvinaTemporaryChatTransport(options: DvinaChatTransportOptions): DefaultChatTransport<DvinaUIMessage>;
+
+/** The chat actions of the SDK, as the functions below call them. */
+type DvinaChatActionsSdk = Pick<DvinaSdk, 'sendChatMessageWhileRunning' | 'chatNextPrompt' | 'stopChat' | 'grantChatApproval' | 'respondChatApproval' | 'answerChatQuestion' | 'returnToMainChat' | 'startChatDay'>;
+/**
+ * Sends a user message while the chat's turn runs: the server stores it at once (every device shows it) and answers it
+ * with the chat's next turn, without cutting the running reply off. Sending it again under the same id changes nothing,
+ * so it is sent again while the API restarts. Aborting stops the waiting; a request already sent may still land.
+ */
+declare function postDvinaChatMessage(sdk: DvinaChatActionsSdk, chatId: string, message: DvinaUIMessage, signal?: AbortSignal): Promise<void>;
+/**
+ * The user's predicted next message after the chat's latest reply, for an empty composer; `null` when none fits.
+ * Ask only when it can be shown (the reply finished, the composer is empty and on screen): the server predicts it
+ * once per reply and keeps it as the reply's `metadata.nextPrompt`.
+ */
+declare function fetchDvinaNextPrompt(sdk: DvinaChatActionsSdk, chatId: string): Promise<string | null>;
+/** Stops the chat's running turn on the server; streaming clients then finish normally. */
+declare function stopDvinaChat(sdk: DvinaChatActionsSdk, chatId: string): Promise<void>;
+/**
+ * Lets a task do this tool from now on without asking (its later approvals for the tool pass on the server); the
+ * approval waiting now is still answered as usual. Only the caller's own task chats, only tools that ask.
+ */
+declare function grantDvinaTaskApproval(sdk: DvinaChatActionsSdk, taskChatId: string, toolName: string): Promise<void>;
+/** What became of an answer given outside the chat: sent, or the chat no longer waited for it (answered elsewhere). */
+type DvinaAnswerOutcome = 'sent' | 'answered-elsewhere';
+/**
+ * Answers a chat's waiting approval from outside the chat (a notification), as the chat's own card does; `always`
+ * also allows the tool for the chat from now on. The turn continues on the server.
+ */
+declare function respondDvinaApproval(sdk: DvinaChatActionsSdk, chatId: string, toolCallId: string, answer: {
+    approved: boolean;
+    always?: boolean;
+}): Promise<DvinaAnswerOutcome>;
+/** Answers a chat's waiting question from outside the chat (a notification's reply): one answer list per question. */
+declare function answerDvinaQuestion(sdk: DvinaChatActionsSdk, chatId: string, toolCallId: string, answers: string[][]): Promise<DvinaAnswerOutcome>;
+/**
+ * Tells the server the user is back (the app opened or came to the foreground): the results that finished while
+ * they were away arrive as one summary in the main chat. Idempotent within one absence.
+ */
+declare function returnToDvinaMainChat(sdk: DvinaChatActionsSdk): Promise<void>;
+/**
+ * Starts the reader's day (their local day, from `x-user-timezone`) as the app opens or comes to the foreground: the
+ * day's first call queues its work (pending day digests, the cards kept for the morning, the night's ideas); later
+ * calls are cheap. `started` is whether this call queued it.
+ */
+declare function startDvinaDay(sdk: DvinaChatActionsSdk): Promise<{
+    started: boolean;
+}>;
+
+/** What a ChatMessage node needs to be read as an AI SDK message. */
+type DvinaChatMessageNode = Pick<ChatMessage, 'id' | 'role' | 'parts' | 'metadata'>;
+/**
+ * A ChatMessage node as the AI SDK's message: a plain object of its id, role, parts and metadata, which the API
+ * already gives in the AI SDK's shape (`metadata.hidden` on an internal message).
+ */
+declare function dvinaUIMessageOf(node: DvinaChatMessageNode): DvinaUIMessage;
+/**
+ * A page of a chat, oldest to newest: its messages, whether the chat goes on before and after it, and the ids that
+ * page on (`before: startCursor` for the page before, `after: endCursor` for the one after). Pages hold whole turns,
+ * so a page may hold a few more messages than asked for.
+ */
+type DvinaMessagePage = {
+    messages: DvinaUIMessage[];
+    hasOlder: boolean;
+    hasNewer: boolean;
+    startCursor?: string;
+    endCursor?: string;
+};
+/** A `chatMessages` or `chatMessagesAround` connection, oldest first, as a page of AI SDK messages. */
+declare function dvinaMessagePageOf(connection: Pick<ChatMessageConnection, 'nodes' | 'pageInfo'>): DvinaMessagePage;
+/** The most the API gives in one page (`first` and `last` are capped there). */
+declare const MAX_MESSAGE_PAGE = 200;
+/**
+ * A whole chat, or one thread of it with the message it started from, oldest first: `chatMessages` read forward
+ * (`first` + `after`) page by page to the end. For short reads such as a thread or a task chat; long chats load by
+ * page. Each page is a one-off fetch, never a watch. A chat the caller may not read, or one not created yet, has none.
+ */
+declare function fetchAllDvinaChatMessages(sdk: Pick<DvinaSdk, 'chatMessages'>, scope: {
+    chatId: string;
+    threadId?: string;
+}, { pageSize }?: {
+    pageSize?: number;
+}): Promise<DvinaUIMessage[]>;
+
+/**
+ * A tool's output the server held back from a chat message: its size, its first 500 characters and the links in it.
+ * The whole output loads with the SDK's `chatMessageToolOutput` query when the reader opens the call.
+ */
+type DvinaLazyToolOutput = {
+    bytes: number;
+    preview: string;
+    urls: string[];
+};
+/** The held-back output a tool part carries instead of its output, or `null` for a whole output. */
+declare function lazyToolOutputOf(output: unknown): DvinaLazyToolOutput | null;
+
+export { type DvinaAnswerOutcome, type DvinaChatActionsSdk, type DvinaChatMessageNode, type DvinaChatTransportOptions, type DvinaDataParts, type DvinaGoal, type DvinaGoalCriterion, type DvinaGoalEvaluation, type DvinaGoalStatus, type DvinaLazyToolOutput, type DvinaMessageMetadata, type DvinaMessagePage, type DvinaMessageRoute, type DvinaTaskStatus, type DvinaToolMetadata, type DvinaTurnOutcome, type DvinaUIMessage, MAX_MESSAGE_PAGE, answerDvinaQuestion, createDvinaChatTransport, createDvinaTemporaryChatTransport, dvinaMessagePageOf, dvinaUIMessageOf, fetchAllDvinaChatMessages, fetchDvinaNextPrompt, grantDvinaTaskApproval, lazyToolOutputOf, postDvinaChatMessage, respondDvinaApproval, returnToDvinaMainChat, startDvinaDay, stopDvinaChat };