@llmnative/agentico 0.2.0 → 0.4.0

package/dist/types/domain/agentDefinition.d.ts

@@ -1,5 +1,6 @@
 import type { z } from 'zod';
 import type { AIAttachment } from '@llmnative/react';
+import type { AgentQuestion, AgentQuestionAnswer, AgentQuestionsAnswers } from './messageParts';
 /** Rif mutabile, sempre aggiornato da useAgent.ts all'inizio di ogni turno (roundTrip 0) con
  * gli allegati grezzi (base64) di QUESTO turno — mai un valore statico catturato una volta:
  * un tool creato da getTools() (chiamato una sola volta per sessione) deve comunque vedere gli
@@ -108,10 +109,40 @@ export interface AgentExecutorTurn<TParams, TContext> {
     signal: AbortSignal;
     /** The model the person picked among `AgentExecutor.models`, if the executor offers any. */
     model?: string;
-    /** The reply so far, whole (not a delta): shown as it grows. */
-    onText(text: string): void;
-    /** A step of the agent: added the first time its id is seen, updated after. */
+    /** Present when the person answered questions of an earlier turn (CR-004): the turn carries
+     * them, structured, with `text` empty. The executor decides how to forward them (e.g. to the
+     * `question` tool of its session). Questions answered while their own turn is still running
+     * resolve the promise of `onQuestions` instead. */
+    answers?: AgentQuestionsAnswers;
+    /** The reply so far, whole (not a delta): shown as it grows, as Markdown. Without `part.id` it
+     * is the one reply of the turn (CR-003), kept below the steps and the reasoning; with an id it is
+     * a text part of its own, in the order it first arrived (CR-004). `part.done` ends its streaming. */
+    onText(text: string, part?: AgentExecutorPartOptions): void;
+    /** The reasoning of the model so far, whole (not a delta), as Markdown: shown closed behind
+     * "Reasoned for 12 s" (CR-004). Without `part.id` it is one reasoning part per turn. It ends with
+     * `part.done`, when another kind of part arrives, or with the turn; `part.duration` (seconds)
+     * replaces the time Agentico measures. */
+    onReasoning(text: string, part?: AgentExecutorPartOptions & {
+        duration?: number;
+    }): void;
+    /** A step of the agent: added the first time its id is seen, updated after. Consecutive steps
+     * are shown as one collapsible group. */
     onStep(step: AgentExecutorStep): void;
+    /** Questions to the person, answered with a click (CR-004). The promise resolves with the
+     * answers if they come while this turn is still running (e.g. the session waits for them);
+     * once the turn has ended (or the chat was reloaded), the answers arrive as a new turn with
+     * `answers` instead. It rejects when the person stops the turn. `part.id` names the set
+     * (default: made up by Agentico) and is the `answers.id` of that later turn. */
+    onQuestions(questions: AgentQuestion[], part?: {
+        id?: string;
+    }): Promise<AgentQuestionAnswer[]>;
+}
+/** Which part an `onText`/`onReasoning` call updates, and whether it is complete. */
+export interface AgentExecutorPartOptions {
+    /** The part to update: created the first time it is seen. */
+    id?: string;
+    /** The part is complete: no longer streaming. */
+    done?: boolean;
 }
 /** The host side of a remote agent: one call per turn, resolved when its reply is complete. */
 export interface AgentExecutor<TParams, TContext, TResult> {

package/dist/types/domain/entityChatStore.d.ts

@@ -1,4 +1,5 @@
 import type { AIConversationTurn } from '@llmnative/react';
+import type { AgentMessagePart } from './messageParts';
 /** Stessa forma di AgentActivityEntry (agentico/presentation/useAgent.ts) — ridefinita qui invece
  * di importata: il domain layer non dipende dal presentation layer, e questi campi sono
  * semplici dati (mai funzioni), quindi TypeScript accetta un AgentActivityEntry[] ovunque sia
@@ -10,6 +11,10 @@ export interface EntityChatActivityEntry {
     status: 'running' | 'done' | 'error' | 'stopped';
     detail?: string;
     toolNames?: string[];
+    attachmentNames?: string[];
+    /** The message in parts (CR-004): saved and reloaded as they are. Absent in chats saved before
+     * 0.3.0, which show `detail` as before. */
+    parts?: AgentMessagePart[];
 }
 export interface EntityChatSnapshot {
     /** Host scope (tenant, company…) the chat belongs to — see AgenticoScope. */

package/dist/types/domain/messageParts.d.ts

@@ -0,0 +1,79 @@
+/** A choice of a question (the shape of the `question` tool of opencode and of MCP elicitation). */
+export interface AgentQuestionOption {
+    /** What the answer says: it is the value returned when chosen. */
+    label: string;
+    /** A line under the label. */
+    description?: string;
+}
+/** A question of the agent to the person. */
+export interface AgentQuestion {
+    /** Returned with the answer, to match it to the question. */
+    id?: string;
+    /** Short title: the label of its tab. */
+    header?: string;
+    question: string;
+    /** The choices. Without them the question takes a free-text answer. */
+    options?: AgentQuestionOption[];
+    /** More than one choice. */
+    multiple?: boolean;
+    /** The choice the agent recommends: its index (from 0) or its label. */
+    recommended?: number | string;
+    /** Offers "Other" with a free-text answer (default: yes). */
+    custom?: boolean;
+}
+/** The answer to one question: the chosen labels and/or the free text, in the order of the questions. */
+export interface AgentQuestionAnswer {
+    id?: string;
+    header?: string;
+    values: string[];
+}
+/** The answers to a set of questions, as a turn gives them to the executor. `id` is the id of the
+ * questions part (the one given to `onQuestions`, or the one Agentico made up). */
+export interface AgentQuestionsAnswers {
+    id: string;
+    answers: AgentQuestionAnswer[];
+}
+/** Text of the reply, as Markdown. `streaming` while it is still arriving. */
+export interface AgentTextPart {
+    type: 'text';
+    id: string;
+    text: string;
+    streaming?: boolean;
+}
+/** The reasoning of the model, as Markdown, shown closed behind "Reasoned for 12 s". */
+export interface AgentReasoningPart {
+    type: 'reasoning';
+    id: string;
+    text: string;
+    streaming?: boolean;
+    /** Seconds the model reasoned: given by the executor, or measured by Agentico. */
+    duration?: number;
+}
+/** A step of the agent (a tool it ran, a file it wrote). Consecutive steps are shown as one group. */
+export interface AgentToolPart {
+    type: 'tool';
+    id: string;
+    label: string;
+    status: 'running' | 'done' | 'error' | 'stopped';
+}
+/** Questions to the person, answered with a click. `answers` once answered (shown read-only). */
+export interface AgentQuestionsPart {
+    type: 'questions';
+    id: string;
+    questions: AgentQuestion[];
+    answers?: AgentQuestionAnswer[];
+}
+export type AgentMessagePart = AgentTextPart | AgentReasoningPart | AgentToolPart | AgentQuestionsPart;
+/** The id of the text part of an executor that calls `onText` without an id (the reply of CR-003). */
+export declare const DEFAULT_TEXT_PART_ID = "text";
+/** The id of the reasoning part of an executor that calls `onReasoning` without an id. */
+export declare const DEFAULT_REASONING_PART_ID = "reasoning";
+/** Adds `part`, or replaces the part of the same type and id. A new step or reasoning goes above the
+ * default text part, so the reply (as in CR-003) stays below the work that led to it; anything else
+ * is appended. `closeReasoning` closes the reasoning still streaming when a part of another type
+ * arrives (the model moved on), with its duration. */
+export declare function upsertMessagePart(parts: AgentMessagePart[], part: AgentMessagePart, closeReasoning?: (part: AgentReasoningPart) => AgentReasoningPart): AgentMessagePart[];
+/** The text of a message: its text parts, one paragraph each (what `AgentActivityEntry.detail` holds). */
+export declare function messagePartsText(parts: readonly AgentMessagePart[]): string;
+/** The answers as one line per question ("Database: Postgres"), for the history of the chat. */
+export declare function formatQuestionAnswers(questions: readonly AgentQuestion[], answers: readonly AgentQuestionAnswer[]): string;

package/dist/types/i18n/types.d.ts

@@ -31,6 +31,12 @@ export interface AgenticoDict {
     tooManyToolTurns: string;
     aiDisabledFallback: string;
     continueWithoutAiFallback: string;
+    /** The group of the steps of the agent, when it holds one step. */
+    oneStep: string;
+    /** The group of the steps of the agent. `{count}` = number of steps */
+    steps: string;
+    /** Accessible name of the group of the steps. */
+    stepsLabel: string;
     /** `{label}` = subagent label */
     newInstance: string;
     chatHistory: string;
@@ -49,6 +55,14 @@ export interface AgenticoDict {
     resumeWithAi: string;
     openPanel: string;
     closePanel: string;
+    /** Accessible name of the edge that resizes the panel. */
+    resizePanel: string;
+    /** Tooltip of that edge. */
+    resizePanelHint: string;
+    /** Accessible name of the questions docked at the bottom of the panel. */
+    pendingQuestions: string;
+    /** Stops the turn while its questions are docked (the composer, with its stop button, is hidden). */
+    stop: string;
 }
 declare module '@llmnative/react' {
     interface I18nDict {

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
 import './i18n/types';
-export type { AgentDefinition, AgentTool, LatestAttachmentsRef, AgentExecutor, AgentExecutorTurn, AgentExecutorStep } from './domain/agentDefinition';
+export type { AgentDefinition, AgentTool, LatestAttachmentsRef, AgentExecutor, AgentExecutorTurn, AgentExecutorStep, AgentExecutorPartOptions } from './domain/agentDefinition';
+export { DEFAULT_TEXT_PART_ID, DEFAULT_REASONING_PART_ID, upsertMessagePart, messagePartsText, formatQuestionAnswers, type AgentMessagePart, type AgentTextPart, type AgentReasoningPart, type AgentToolPart, type AgentQuestionsPart, type AgentQuestion, type AgentQuestionOption, type AgentQuestionAnswer, type AgentQuestionsAnswers, } from './domain/messageParts';
 export type { SubagentCommand, SubagentManifest, SubagentComponentContext } from './domain/subagentManifest';
 export { defineSubagent } from './domain/defineSubagent';
 export { registerSubagents, getSubagentRegistry, findSubagentManifest } from './domain/subagentRegistry';
@@ -16,7 +17,8 @@ export { jsonExportDestination, JSON_EXPORT_DESTINATION_ID } from './domain/json
 export { registerDestinations, getDestinationRegistry } from './domain/destinationRegistry';
 export { configureEntityChatStore, saveEntityChat, getEntityChat, listEntityChats, removeEntityChat, entityChatTaskId, type EntityChatSnapshot, } from './domain/entityChatStore';
 export { agenticoTranslations, agenticoEn, agenticoIt, agenticoDe, useAgenticoI18n, type AgenticoDict } from './i18n';
-export { Agentico, AGENTICO_WIDTH } from './presentation/Agentico';
+export { Agentico, AGENTICO_WIDTH, type AgenticoProps } from './presentation/Agentico';
+export { AGENTICO_MIN_WIDTH, AGENTICO_MAX_WIDTH, AGENTICO_WIDTH_STORAGE_KEY, type AgenticoPanelSize } from './presentation/panelWidth';
 export { AgenticoToggle } from './presentation/AgenticoToggle';
 export { AgenticoProvider, useAgentico, ORCHESTRATOR_TASK_ID, type AgenticoScope, type AgenticoTask, type ComponentAnchor, } from './presentation/AgenticoContext';
 export { useAgent, type AgentActivityEntry, type AgentConversation, type UseAgentResult } from './presentation/useAgent';

package/dist/types/presentation/AgentActivityLog.d.ts

@@ -1,9 +1,45 @@
-import React from 'react';
 import type { AgentActivityEntry } from './useAgent';
+import type { AgentQuestionAnswer, AgentQuestionsPart } from '../domain/messageParts';
+/** What the log needs to let the person answer questions (CR-004): the entries of the live
+ * conversation (`canAnswer`) and where the answers go. Without it, unanswered questions are shown
+ * disabled. */
+export interface AgentActivityLogQuestions {
+    canAnswer: (entryId: string) => boolean;
+    onAnswer: (entryId: string, partId: string, answers: AgentQuestionAnswer[]) => Promise<unknown>;
+}
+/** The questions part shown docked at the bottom of the panel instead of in the thread (CR-005). */
+export interface DockedQuestions {
+    entry: AgentActivityEntry;
+    part: AgentQuestionsPart;
+}
+/** The questions waiting for an answer in the latest message of the agent (CR-005): the last
+ * questions part without answers of the last entry, when that entry is a message in parts of a turn
+ * that did not stop or fail, and the person can answer it. Otherwise nothing is docked and the
+ * questions stay in the thread (read-only once answered). */
+export declare function findDockedQuestions(activity: readonly AgentActivityEntry[], canAnswer: (entryId: string) => boolean): DockedQuestions | null;
+/** A questions part of the agent with `ChatQuestions`: answerable while the entry is live and it has
+ * no answers, read-only with its answers, disabled otherwise. */
+export declare function QuestionsPart({ entry, part, questions, autoFocus, className }: {
+    entry: AgentActivityEntry;
+    part: AgentQuestionsPart;
+    questions?: AgentActivityLogQuestions;
+    autoFocus?: boolean;
+    className?: string;
+}): import("react").JSX.Element;
 /** Il log di attività di un agente, usato dal pannello globale (Agentico) — ogni agente ora
  * ci passa attraverso, il pannello embedded legacy (AgentFollowUp) è stato ritirato una volta
  * migrato anche l'ultimo consumer (import HTML/JSX, vedi ComponentEditPage.tsx). Un solo posto
- * per l'icon-system e la logica "sto pensando" transitorio/collassabile. */
-export declare function AgentActivityLog({ activity }: {
+ * per l'icon-system e la logica "sto pensando" transitorio/collassabile.
+ *
+ * One `<li>` per turn (CR-004): the message of the person, sticky at the top while its turn
+ * scrolls, then what the agent did and said. Entries before the first message of the person
+ * (an opening without text) form a turn of their own, without a bubble. */
+export declare function AgentActivityLog({ activity, questions, docked, pinUserMessages }: {
     activity: AgentActivityEntry[];
-}): React.JSX.Element | null;
+    questions?: AgentActivityLogQuestions;
+    /** Questions docked at the bottom of the panel (CR-005): left out of the thread. */
+    docked?: DockedQuestions | null;
+    /** The message of the person sticks at the top while its turn scrolls (default). Off while
+     * questions are docked, so the thread has more room. */
+    pinUserMessages?: boolean;
+}): import("react").JSX.Element | null;

package/dist/types/presentation/Agentico.d.ts

@@ -1,7 +1,17 @@
 import React from 'react';
-/** Larghezza fissa del pannello — passata anche come `rightInset` alle Modal che devono
- * lasciargli spazio invece di sovrapporlo (vedi Modal.rightInset nel framework). */
-export declare const AGENTICO_WIDTH = 420;
+import { AGENTICO_WIDTH, type AgenticoPanelSize } from './panelWidth';
+export { AGENTICO_WIDTH };
+/** Props of the panel (CR-005): its width, which the person changes by dragging its inner edge. */
+export interface AgenticoProps {
+    /** Width when nothing is stored, and after a double click on the edge. Default `AGENTICO_WIDTH` (420 px). */
+    defaultWidth?: number;
+    /** Narrowest width, in px. Default 320. */
+    minWidth?: number;
+    /** Widest width: px, or a share of the viewport (`'60vw'`, the default). */
+    maxWidth?: AgenticoPanelSize;
+    /** The current width, whenever it changes (e.g. for the `rightInset` of a Modal beside the panel). */
+    onWidthChange?: (width: number) => void;
+}
 /** Agentico — il pannello globale, persistente e non-overlay per le sessioni agente — affianca
  * il CMS (che si stringe) invece di coprirlo, cosi la modale che ha avviato l'agente resta
  * aperta e utilizzabile accanto. Header: titolo dell'UNICO task attivo (mai una tab bar — "una
@@ -20,4 +30,4 @@ export declare const AGENTICO_WIDTH = 420;
  * (AgenticoContext), il suo toggle (AgenticoToggle) — non degli agenti verticali che esegue
  * (theme-import, html-to-liquid, ...), che restano nel proprio dominio senza questo
  * prefisso: sono contenuto che Agentico orchestra, non parte della sua identità. */
-export declare function Agentico(): React.JSX.Element;
+export declare function Agentico({ defaultWidth, minWidth, maxWidth, onWidthChange }?: AgenticoProps): React.JSX.Element;

package/dist/types/presentation/AgenticoResizeHandle.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+/** The inner edge of the Agentico column (CR-005), the one facing the page: dragged with the
+ * pointer it resizes the panel; focused, the arrow keys do (Shift for bigger steps, Home/End for
+ * the minimum/maximum); a double click goes back to the default width. The framework has no
+ * splitter primitive, so this one is drawn with theme tokens only: a thin line in the primary
+ * colour on hover, focus and while dragging. The panel sits on the right, so moving the edge to
+ * the left makes it wider. */
+export declare function AgenticoResizeHandle({ width, min, max, onResize, onCommit, onReset }: {
+    width: number;
+    min: number;
+    max: number;
+    /** A new width while it changes (clamped by the caller). */
+    onResize: (width: number) => void;
+    /** The width the person settled on: stored. */
+    onCommit: (width: number) => void;
+    onReset: () => void;
+}): React.JSX.Element;

package/dist/types/presentation/panelWidth.d.ts

@@ -0,0 +1,32 @@
+/** Default width of the panel, in px. Also the `rightInset` a host can give a Modal that must leave it room. */
+export declare const AGENTICO_WIDTH = 420;
+/** Default minimum width of the panel, in px. */
+export declare const AGENTICO_MIN_WIDTH = 320;
+/** Default maximum width of the panel: a share of the viewport. */
+export declare const AGENTICO_MAX_WIDTH = "60vw";
+/** Where the width chosen by the person is kept, per browser. */
+export declare const AGENTICO_WIDTH_STORAGE_KEY = "agentico:panel-width";
+/** One arrow key press, in px (with Shift: four times as much). */
+export declare const AGENTICO_WIDTH_STEP = 16;
+/** A width in px, or a share of the viewport (`'60vw'`). */
+export type AgenticoPanelSize = number | `${number}vw`;
+/** A size in px: a number as it is, `'<n>vw'` as that share of `viewportWidth`. */
+export declare function resolvePanelSize(size: AgenticoPanelSize, viewportWidth: number): number;
+/** `width` kept between `min` and `max` (a max below the min gives way to the min). */
+export declare function clampPanelWidth(width: number, min: number, max: number): number;
+export interface PanelWidthOptions {
+    defaultWidth?: number;
+    minWidth?: number;
+    maxWidth?: AgenticoPanelSize;
+    onWidthChange?: (width: number) => void;
+}
+/** The width of the panel: the stored one or the default, clamped to the current viewport. `set`
+ * changes it (clamped), `commit` stores it, `reset` goes back to the default and forgets it. */
+export declare function usePanelWidth({ defaultWidth, minWidth, maxWidth, onWidthChange }: PanelWidthOptions): {
+    width: number;
+    min: number;
+    max: number;
+    set: (next: number) => void;
+    commit: (next: number) => void;
+    reset: () => void;
+};

package/dist/types/presentation/useAgent.d.ts

@@ -1,5 +1,6 @@
 import type { AIConversationTurn, AIModelDescriptor } from '@llmnative/react';
 import type { AgentDefinition } from '../domain/agentDefinition';
+import { type AgentMessagePart, type AgentQuestionAnswer } from '../domain/messageParts';
 /** Una voce del log di attività — o un messaggio dell'utente (il testo di sendMessage(),
  * mostrato subito com'è, mai "sto pensando" perché non è il modello a scriverlo), o una tool
  * call (etichetta SEMPRE deterministica/locale, vedi AgentTool.describeInvocation: mai testo
@@ -36,6 +37,10 @@ export interface AgentActivityEntry {
      * doveva fidarsi a memoria (bug osservato: un allegato sembrava "sparito" perché non
      * c'era traccia visiva che fosse mai arrivato). */
     attachmentNames?: string[];
+    /** On the turns of a remote agent (CR-004): the message in parts (text, reasoning, steps,
+     * questions), in the order they arrived. `detail` still holds its text. Absent on the turns of
+     * the AI provider and on chats saved before 0.3.0, shown from `detail` as before. */
+    parts?: AgentMessagePart[];
 }
 /** Stato di gating/selezione — non generico, condiviso dal componente <AgentControls />
  * (che non ha bisogno di conoscere TParams/TResult, solo di disegnare switch + select). */
@@ -139,11 +144,17 @@ export interface UseAgentResult<TParams, TResult> extends AgentControlState {
         history: AIConversationTurn[];
         activity: AgentActivityEntry[];
     } | null;
+    /** Answers the questions part `partId` of the entry `entryId` (CR-004). If the turn that asked
+     * is still waiting, its `onQuestions` promise resolves; otherwise a new turn of the executor
+     * carries them (`AgentExecutorTurn.answers`, with empty `text`). Either way the part keeps the
+     * answers and shows them read-only. Resolves with the result of that new turn, if any; rejects
+     * (leaving the form open) when another turn is running or the entry is not of this conversation. */
+    answerQuestions: (entryId: string, partId: string, answers: AgentQuestionAnswer[]) => Promise<TResult | null>;
 }
 /** Solo la fetta di UseAgentResult che serve a un consumer del pannello globale (Agentico.tsx)
  * per continuare una conversazione già avviata da run() — TParams non compare in nessuno dei
  * membri qui sotto, quindi `never` è innocuo. */
-export type AgentConversation<TResult> = Pick<UseAgentResult<never, TResult>, 'canContinue' | 'remote' | 'remoteModels' | 'running' | 'error' | 'activity' | 'sendMessage' | 'stop' | 'runFallback' | 'snapshot'>;
+export type AgentConversation<TResult> = Pick<UseAgentResult<never, TResult>, 'canContinue' | 'remote' | 'remoteModels' | 'running' | 'error' | 'activity' | 'sendMessage' | 'stop' | 'runFallback' | 'snapshot' | 'answerQuestions'>;
 export declare function useAgent<TParams, TContext, TResult>(definition: AgentDefinition<TParams, TContext, TResult>, options?: {
     defaultEnabled?: boolean;
 }): UseAgentResult<TParams, TResult>;

package/llms.txt

@@ -25,6 +25,8 @@
 </AgenticoProvider>
 ```
 
+`<Agentico defaultWidth? minWidth? maxWidth? onWidthChange? />` (0.4.0): the column is resized by dragging its inner edge (a `role="separator"`: arrows by 16 px, Shift ×4, Home/End, double click = default), clamped to `minWidth` (320) … `maxWidth` (px or `'<n>vw'`, default `'60vw'`), stored per browser under `agentico:panel-width`. Defaults `AGENTICO_WIDTH` (420), `AGENTICO_MIN_WIDTH`, `AGENTICO_MAX_WIDTH`. Unanswered questions of the latest agent message (turn not stopped/failed) are docked at the bottom in place of the composer (scroll inside, Stop while the turn runs), the person's message is not pinned meanwhile; once answered they are back in the thread, read-only. Questions of a reloaded chat are answerable (docked) too.
+
 ## Hooks
 
 - `useAgentico()` — panel state, `startOrchestrator(goal, opts)`, `startSubagent(subagentId, params, { taskId?, openingMessage? })` (use `entityChatTaskId(subagentId, entityId)` as taskId), `resumeEntityChat`, `commitEntityChat(subagentId, entityId, taskId, scopeId, params, title)`, `scope`.
@@ -37,3 +39,5 @@
 buildContext (always runs) · buildPrompt · buildFollowUpPrompt · parseResponse (null → fallback) · fallback (required) · describeFallback? · getTools? · microPromptIds? · executor?
 
 `executor.turn({ params, context, text, first, signal, model?, onText(whole reply so far), onStep({ id, label, status }) }) → { text, result? }`; `executor.models(params)` / `defaultModel(params)` put the models of the executor in the composer: the turns go to the host instead of the AI provider; `text` is what the person typed (opening message on the first turn). The conversation is `remote: true`: no attachments, no fallback; the picker shows `remoteModels`.
+
+Message parts (0.3.0): the turn also has `onText(text, { id?, done? })` (without id: the one reply, kept below steps and reasoning; with id: a text part of its own), `onReasoning(text, { id?, done?, duration? })` (whole text so far; shown closed, "Reasoned for N s", duration measured if not given), `onQuestions(questions, { id? }) → Promise<answers>` (questions `{ id?, header?, question, options?: [{ label, description? }], multiple?, recommended?, custom? }`; answers `[{ id?, header?, values: string[] }]`). Answers given while the turn runs resolve that promise; given later (or after a reload) they start a new turn with `text: ''` and `answers: { id, answers }` (id = the questions part id, default `questions-N`). Parts are kept in `AgentActivityEntry.parts` (`text` | `reasoning` | `tool` | `questions`, `detail` = the text) and saved with the chat; old chats without parts show `detail`. Rendered with `ChatMarkdown`, `ChatReasoning`, steps grouped in a `Tree`, `ChatQuestions` (needs `@llmnative/react` 1.34). `useAgent().answerQuestions(entryId, partId, answers)`.

package/package.json

@@ -1,79 +1,79 @@
-{
-  "name": "@llmnative/agentico",
-  "version": "0.2.0",
-  "description": "Agentic chat orchestrator for @llmnative/react apps: a persistent panel that talks with the user and hands the work to host-registered subagents.",
-  "main": "dist/index.js",
-  "module": "dist/index.mjs",
-  "types": "dist/types/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/types/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist",
-    "llms.txt"
-  ],
-  "sideEffects": false,
-  "scripts": {
-    "build": "vite build && tsc -p tsconfig.build.json",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "prepublishOnly": "npm run build",
-    "release:check": "node scripts/release/check-release.mjs"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/sherpadvisorylab/llmnative-agentico.git"
-  },
-  "bugs": {
-    "url": "https://github.com/sherpadvisorylab/llmnative-agentico/issues"
-  },
-  "homepage": "https://github.com/sherpadvisorylab/llmnative-agentico#readme",
-  "keywords": [
-    "llmnative",
-    "agent",
-    "orchestrator",
-    "subagent",
-    "ai",
-    "react"
-  ],
-  "author": "wolfgan",
-  "license": "Apache-2.0",
-  "engines": {
-    "node": ">=24.18.0 <25"
-  },
-  "packageManager": "npm@11.11.0",
-  "peerDependencies": {
-    "@llmnative/react": "^1.31.0",
-    "react": "^19.2.0",
-    "react-dom": "^19.2.0",
-    "zod": "^3.24.1"
-  },
-  "dependencies": {
-    "zod-to-json-schema": "^3.24.1"
-  },
-  "devDependencies": {
-    "@llmnative/react": "^1.31.0",
-    "@phosphor-icons/react": "^2.1.10",
-    "@testing-library/jest-dom": "^7.0.1",
-    "@testing-library/react": "^16.3.3",
-    "@types/react": "^19.3.0",
-    "@types/react-dom": "^19.3.0",
-    "happy-dom": "^20.14.5",
-    "lucide-react": "^1.52.0",
-    "react": "^19.3.0",
-    "react-dom": "^19.3.0",
-    "react-router-dom": "^7.18.4",
-    "typescript": "^7.0.2",
-    "vite": "^8.3.2",
-    "vitest": "^5.0.3",
-    "zod": "^3.24.1"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
-}
+{
+  "name": "@llmnative/agentico",
+  "version": "0.4.0",
+  "description": "Agentic chat orchestrator for @llmnative/react apps: a persistent panel that talks with the user and hands the work to host-registered subagents.",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "llms.txt"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "vite build && tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build",
+    "release:check": "node scripts/release/check-release.mjs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sherpadvisorylab/llmnative-agentico.git"
+  },
+  "bugs": {
+    "url": "https://github.com/sherpadvisorylab/llmnative-agentico/issues"
+  },
+  "homepage": "https://github.com/sherpadvisorylab/llmnative-agentico#readme",
+  "keywords": [
+    "llmnative",
+    "agent",
+    "orchestrator",
+    "subagent",
+    "ai",
+    "react"
+  ],
+  "author": "wolfgan",
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=24.18.0 <25"
+  },
+  "packageManager": "npm@11.11.0",
+  "peerDependencies": {
+    "@llmnative/react": "^1.34.0",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "zod": "^3.24.1"
+  },
+  "dependencies": {
+    "zod-to-json-schema": "^3.24.1"
+  },
+  "devDependencies": {
+    "@llmnative/react": "^1.34.0",
+    "@phosphor-icons/react": "^2.1.10",
+    "@testing-library/jest-dom": "^7.0.1",
+    "@testing-library/react": "^16.3.3",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "happy-dom": "^20.14.5",
+    "lucide-react": "^1.52.0",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
+    "react-router-dom": "^7.18.4",
+    "typescript": "^7.0.2",
+    "vite": "^8.3.2",
+    "vitest": "^5.0.3",
+    "zod": "^3.24.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}