@llmnative/agentico 0.2.0 → 0.3.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;

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';

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

@@ -1,9 +1,21 @@
-import React from 'react';
 import type { AgentActivityEntry } from './useAgent';
+import type { AgentQuestionAnswer } 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>;
+}
 /** 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 }: {
     activity: AgentActivityEntry[];
-}): React.JSX.Element | null;
+    questions?: AgentActivityLogQuestions;
+}): import("react").JSX.Element | null;

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

@@ -1,39 +1,41 @@
-# @llmnative/agentico
-
-> Agentic chat orchestrator for @llmnative/react apps. A persistent panel: the orchestrator
-> collects parameters in conversation and hands the work to host-registered subagents. Every
-> subagent has a deterministic fallback. Agentico knows nothing concrete about the host.
-
-## Host responsibilities (startup)
-
-- `registerSubagents(manifests)` — SubagentManifest: id, label, icon, description, indexPath, commands (name, summary, Zod inputSchema, describeOutput), definition (AgentDefinition), toParams, destinationIds, optional crossAgentToolIds, withCollected, manualEntry, componentContexts, chatEntityId (chat saved at every turn under that entity), onlyWhenAnchored (offered by the orchestrator only when scoped to it).
-- `registerDestinations({ id: ResultDestination })` — apply(result, { scopeId, dataProvider, storageProvider, proxyFetch }, meta).
-- `registerSubagentReports({ subagentId: SubagentReportModule })`.
-- `registerSubagentControls({ subagentId: useControls })` — a hook of the host per task (props: params, taskId, running, close) returning `{ actions?: ChatbotAction[] (with onClick), content?: ReactNode }`, memoized: actions in the prompt, content above it.
-- `SubagentManifest.onArchive(entityId, params)` / `confirmArchive(entityId, params)` — archiving a chat from the history (hover icon).
-- `registerCrossAgentTools((ctx) => AgentTool[])` — ctx: attachmentsRef, collected (per-conversation scratchpad), proxyFetch.
-- `configureAgenticoPrompts(partial)` — model-facing pack; `agenticoPromptsEn` (default) / `agenticoPromptsIt`.
-- `configureEntityChatStore({ storageKey })`.
-- i18n: merge `agenticoTranslations.<locale>` into `<App i18n={{ translations }}>`; override any `agentico.*` key.
-
-## Mount
-
-```tsx
-<AgenticoProvider scope={{ id, dataProvider, storageProvider } | null}>
-  <AgenticoToggle />
-  <Agentico />
-</AgenticoProvider>
-```
-
-## 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`.
-- `useAgenticoPageContext(text, card?)` — what the user is looking at.
-- `useSubagentComponentContext(subagentId, componentKey)` — anchor a component to a subagent.
-- `useAgent(definition)` — run an AgentDefinition directly.
-
-## AgentDefinition
-
-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`.
+# @llmnative/agentico
+
+> Agentic chat orchestrator for @llmnative/react apps. A persistent panel: the orchestrator
+> collects parameters in conversation and hands the work to host-registered subagents. Every
+> subagent has a deterministic fallback. Agentico knows nothing concrete about the host.
+
+## Host responsibilities (startup)
+
+- `registerSubagents(manifests)` — SubagentManifest: id, label, icon, description, indexPath, commands (name, summary, Zod inputSchema, describeOutput), definition (AgentDefinition), toParams, destinationIds, optional crossAgentToolIds, withCollected, manualEntry, componentContexts, chatEntityId (chat saved at every turn under that entity), onlyWhenAnchored (offered by the orchestrator only when scoped to it).
+- `registerDestinations({ id: ResultDestination })` — apply(result, { scopeId, dataProvider, storageProvider, proxyFetch }, meta).
+- `registerSubagentReports({ subagentId: SubagentReportModule })`.
+- `registerSubagentControls({ subagentId: useControls })` — a hook of the host per task (props: params, taskId, running, close) returning `{ actions?: ChatbotAction[] (with onClick), content?: ReactNode }`, memoized: actions in the prompt, content above it.
+- `SubagentManifest.onArchive(entityId, params)` / `confirmArchive(entityId, params)` — archiving a chat from the history (hover icon).
+- `registerCrossAgentTools((ctx) => AgentTool[])` — ctx: attachmentsRef, collected (per-conversation scratchpad), proxyFetch.
+- `configureAgenticoPrompts(partial)` — model-facing pack; `agenticoPromptsEn` (default) / `agenticoPromptsIt`.
+- `configureEntityChatStore({ storageKey })`.
+- i18n: merge `agenticoTranslations.<locale>` into `<App i18n={{ translations }}>`; override any `agentico.*` key.
+
+## Mount
+
+```tsx
+<AgenticoProvider scope={{ id, dataProvider, storageProvider } | null}>
+  <AgenticoToggle />
+  <Agentico />
+</AgenticoProvider>
+```
+
+## 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`.
+- `useAgenticoPageContext(text, card?)` — what the user is looking at.
+- `useSubagentComponentContext(subagentId, componentKey)` — anchor a component to a subagent.
+- `useAgent(definition)` — run an AgentDefinition directly.
+
+## AgentDefinition
+
+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.3.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"
+  }
+}