@llmnative/agentico 0.1.0 → 0.2.0

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

@@ -80,4 +80,52 @@ export interface AgentDefinition<TParams, TContext, TResult> {
      * agente: qui si dichiara solo QUALI si vogliono, mai il loro testo. Assente o [] =
      * nessuno. */
     microPromptIds?: string[];
+    /** Present = the turns of this agent are answered by the host, not by the AI provider of
+     * Agentico (CR-003): a remote agent with its own memory, for example an opencode session on
+     * a server. `useAgent` then builds no prompt, needs no model and never falls back: it gives
+     * the executor the text of the person and shows what it reports. `buildPrompt`,
+     * `buildFollowUpPrompt`, `parseResponse` and `fallback` stay required by the type but are not
+     * called. */
+    executor?: AgentExecutor<TParams, TContext, TResult>;
+}
+/** One step of a remote agent, shown as a line of the activity log and updated by `id`
+ * (e.g. "wrote GLOSSARY.md"). */
+export interface AgentExecutorStep {
+    id: string;
+    label: string;
+    status: 'running' | 'done' | 'error';
+}
+/** One turn given to an `AgentExecutor`. */
+export interface AgentExecutorTurn<TParams, TContext> {
+    params: TParams;
+    context: TContext;
+    /** What the person wrote: the opening message on the first turn (possibly empty), then
+     * each follow-up, as typed — never a prompt built by Agentico. */
+    text: string;
+    /** true on the turn of `run()`, false on every follow-up. */
+    first: boolean;
+    /** Aborted when the person stops the turn. */
+    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. */
+    onStep(step: AgentExecutorStep): void;
+}
+/** The host side of a remote agent: one call per turn, resolved when its reply is complete. */
+export interface AgentExecutor<TParams, TContext, TResult> {
+    turn(turn: AgentExecutorTurn<TParams, TContext>): Promise<{
+        text: string;
+        result?: TResult;
+    }>;
+    /** The models the person can pick in the composer, at any time: what one means is the host's
+     * (e.g. the model of the remote session from the next message). Absent = no picker. */
+    models?(params: TParams): Array<{
+        label: string;
+        value: string;
+        group?: string;
+    }>;
+    /** The model picked at first, e.g. the one the remote session runs with. */
+    defaultModel?(params: TParams): string | undefined;
 }

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

@@ -46,3 +46,7 @@ export declare function removeEntityChat(scopeId: string, subagentId: string, en
  * (Agentico.tsx), che le mescola across subagent (theme, redirects, html-to-liquid) in un'unica
  * lista ordinata per data. */
 export declare function listEntityChats(scopeId: string): EntityChatSnapshot[];
+/** The id of the Agentico task of the chat of an entity: the same when the chat is resumed from
+ * the history and when a page starts it again (AgenticoContext.startSubagent), so it stays one
+ * task (CR-003). */
+export declare const entityChatTaskId: (subagentId: string, entityId: string) => string;

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

@@ -157,6 +157,20 @@ export interface SubagentManifest<TParams = any, TContext = any, TResult = any>
      * orchestratorHint/humanSummary* per il vecchio meccanismo a livello di pagina, ancora usato
      * da redirects/html-to-liquid finché non vengono migrati). */
     componentContexts?: Record<string, SubagentComponentContext>;
+    /** The entity a chat of this subagent belongs to, from its raw params (e.g. the project it
+     * designs): when set, SubagentRunner saves the chat after every turn under it (see
+     * entityChatStore), so it is in the history and can be resumed on that entity (CR-003).
+     * Absent = saved only when the host commits it (commitEntityChat), as before. */
+    chatEntityId?(params: Record<string, unknown>): string | undefined;
+    /** true = the orchestrator offers this subagent only when the conversation is scoped to it,
+     * i.e. a component anchored to it is on the page (CR-003): a subagent that makes sense on
+     * one page only (e.g. the design of the project open there). Absent = offered everywhere. */
+    onlyWhenAnchored?: boolean;
+    /** Archiving a chat of this subagent from the history (CR-003): what the host does besides
+     * taking it off the history, e.g. close the remote session. A rejection keeps the chat. */
+    onArchive?(entityId: string, params: Record<string, unknown>): Promise<void> | void;
+    /** The question asked before archiving, if any (e.g. "close it without a pull request?"). */
+    confirmArchive?(entityId: string, params: Record<string, unknown>): Promise<string | undefined> | string | undefined;
 }
 /** Coppia di messaggi per UN punto di ancoraggio componente↔subagent (vedi
  * SubagentManifest.componentContexts) — due pubblici diversi per lo stesso aggancio, mai lo

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

@@ -39,6 +39,8 @@ export interface AgenticoDict {
     messagePlaceholder: string;
     unsavedConversationConfirm: string;
     noSavedChats: string;
+    /** Archives a chat of the history (CR-003). */
+    archiveChat: string;
     noResults: string;
     retry: string;
     /** User message sent to the model by the retry button */

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
 import './i18n/types';
-export type { AgentDefinition, AgentTool, LatestAttachmentsRef } from './domain/agentDefinition';
+export type { AgentDefinition, AgentTool, LatestAttachmentsRef, AgentExecutor, AgentExecutorTurn, AgentExecutorStep } from './domain/agentDefinition';
 export type { SubagentCommand, SubagentManifest, SubagentComponentContext } from './domain/subagentManifest';
 export { defineSubagent } from './domain/defineSubagent';
 export { registerSubagents, getSubagentRegistry, findSubagentManifest } from './domain/subagentRegistry';
@@ -14,7 +14,7 @@ export { extractJsonBlock } from './domain/extractJsonBlock';
 export type { ResultDestination, DestinationContext, ResultDestinationOutcome } from './domain/resultDestination';
 export { jsonExportDestination, JSON_EXPORT_DESTINATION_ID } from './domain/jsonExportDestination';
 export { registerDestinations, getDestinationRegistry } from './domain/destinationRegistry';
-export { configureEntityChatStore, saveEntityChat, getEntityChat, listEntityChats, removeEntityChat, type EntityChatSnapshot, } from './domain/entityChatStore';
+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 { AgenticoToggle } from './presentation/AgenticoToggle';
@@ -23,3 +23,4 @@ export { useAgent, type AgentActivityEntry, type AgentConversation, type UseAgen
 export { useAgenticoPageContext } from './presentation/useAgenticoPageContext';
 export { useSubagentComponentContext } from './presentation/useSubagentComponentContext';
 export { registerSubagentReports, getSubagentReport, type EditableReportModule, type SubagentReportModule, type SubagentSelection, } from './presentation/reports/subagentReportRegistry';
+export { registerSubagentControls, getSubagentControls, type SubagentControls, type SubagentControlsProps, type UseSubagentControls } from './presentation/subagentControls';

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

@@ -1,5 +1,5 @@
 import React from 'react';
-import type { AIModelDescriptor, DataProviderAdapter, StorageProviderAdapter } from '@llmnative/react';
+import type { AIModelDescriptor, ChatbotAction, DataProviderAdapter, StorageProviderAdapter } from '@llmnative/react';
 import type { AgentActivityEntry, AgentConversation } from './useAgent';
 import type { ResultDestination } from '../domain/resultDestination';
 import type { SubagentUsageCard } from '../domain/subagentUsageCard';
@@ -94,6 +94,11 @@ export interface AgenticoTask<TResult = unknown> {
      * top=vecchio/bottom=nuovo (bug segnalato). Assente = comportamento invariato, sempre in
      * fondo (equivalente a passare la lunghezza corrente del log). */
     panelExtraAnchorIndex?: number;
+    /** What the host shows at the bottom of the panel, above the composer, while the task is open
+     * (see registerSubagentControls, CR-003). */
+    panelActions?: React.ReactNode;
+    /** Buttons of the host in the composer (see registerSubagentControls, CR-003). */
+    composerActions?: ChatbotAction[];
     /** Chiamato quando questo task viene sostituito da uno nuovo (vedi openTask) o quando
      * l'utente lo interrompe — SEMPRE definito da chi possiede il task
      * (OrchestratorRunner/SubagentRunner), mai un fallback generico su closeTask: quel
@@ -296,6 +301,22 @@ interface AgenticoContextValue {
      * indietro", niente eccezione per un task ancora in corso (deliberatamente semplice,
      * raffinabile in seguito). No-op se non c'è alcun task. */
     dismissForeignTask: () => void;
+    /** Starts a subagent from a page, without the orchestrator (CR-003): it replaces the current
+     * task. `taskId` keeps one task per entity (start it again = the same task); `openingMessage`
+     * is shown as the first message of the person and given to the first turn. */
+    startSubagent: (subagentId: string, params: Record<string, unknown>, options?: {
+        taskId?: string;
+        openingMessage?: string;
+    }) => void;
+    /** Present = a startSubagent() is pending, read by Agentico.tsx to mount its SubagentRunner. */
+    pendingStart: {
+        subagentId: string;
+        params: Record<string, unknown>;
+        taskId?: string;
+        openingMessage?: string;
+    } | null;
+    /** Changes at every startSubagent() — React `key` of that SubagentRunner. */
+    startRunId: string | null;
 }
 export declare function AgenticoProvider({ children, scope }: {
     children: React.ReactNode;

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

@@ -2,20 +2,7 @@ import type { AIConversationTurn } from '@llmnative/react';
 import { type AgentActivityEntry } from './useAgent';
 import type { SubagentManifest } from '../domain/subagentManifest';
 import type { ResultDestination } from '../domain/resultDestination';
-/** Monta il vero subagent (useAgent(manifest.definition)) e lo esegue una volta al mount con i
- * parametri già raccolti dall'orchestratore Agentico — nessun passo utente aggiuntivo, la
- * conversazione di raccolta parametri è già avvenuta a monte (vedi Agentico.tsx). Si registra
- * nel pannello Agentico con id stabile via useRef + cleanup closeTask allo smontaggio, con il
- * transcript dell'orchestratore (`precedingActivity`) prepeso al proprio log — l'utente vede
- * UNA chat continua, mai due task distinti da switchare (vedi OrchestratorRunner).
- *
- * Con `resumeSeed` valorizzato, il primo giro chiama `agent.resume(...)` invece di
- * `agent.run(...)` — riprende una chat già salvata (vedi entityChatStore/
- * AgenticoContext.resumeEntityChat) invece di avviarne una nuova. Tutto il resto (consegna del
- * risultato ai componentAnchors, ResultDestinationPicker di riserva, registrazione del task) è
- * IDENTICO a un run normale — un follow-up dopo un resume produce un risultato esattamente come
- * un follow-up dopo un run, nessuna duplicazione di logica per il caso "ripreso". */
-export declare function SubagentRunner({ manifest, params, extraDestinations, precedingActivity, taskId: taskIdProp, resumeSeed, model, }: {
+export declare function SubagentRunner({ manifest, params, extraDestinations, precedingActivity, taskId: taskIdProp, resumeSeed, model, openingMessage, }: {
     manifest: SubagentManifest<any, any, any>;
     params: Record<string, unknown>;
     /** Destinazioni scoped alla pagina che ha avviato questo run (es. "Applica a questo Site
@@ -45,4 +32,7 @@ export declare function SubagentRunner({ manifest, params, extraDestinations, pr
      * OrchestratorRunner — vedi il commento lì). Non passato per un `resumeSeed` — lì non c'è una
      * scelta "di questo giro" da propagare, si continua semplicemente la chat salvata così com'era. */
     model?: string;
+    /** The first message of the person, when a page starts the subagent directly
+     * (AgenticoContext.startSubagent, CR-003): shown in the log and given to the first turn. */
+    openingMessage?: string;
 }): null;

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

@@ -0,0 +1,28 @@
+import type { ReactNode } from 'react';
+import type { ChatbotAction } from '@llmnative/react';
+/** What the controls of a subagent receive (CR-003). */
+export interface SubagentControlsProps {
+    /** The raw params the subagent was started with. */
+    params: Record<string, unknown>;
+    /** The id of the task in the Agentico panel. */
+    taskId: string;
+    /** A turn is running: actions that would interrupt it should wait. */
+    running: boolean;
+    /** Ends the task (stops a running turn and closes it). */
+    close: () => void;
+}
+/** The controls of a task: actions of the prompt, and what the host shows above it (a modal, a message). */
+export interface SubagentControls {
+    /** Buttons of the composer, next to the attachments (`ChatbotAction` with `onClick`). */
+    actions?: ChatbotAction[];
+    /** Shown above the composer while the task is open. */
+    content?: ReactNode;
+}
+/**
+ * A React hook of the host: called by the runner of each task of its subagent, on every render.
+ * Its `actions` and `content` must keep their identity while nothing changes (`useMemo`): a new
+ * one registers the task again, and a new one at every render would never stop.
+ */
+export type UseSubagentControls = (props: SubagentControlsProps) => SubagentControls;
+export declare function registerSubagentControls(controls: Record<string, UseSubagentControls>): void;
+export declare function getSubagentControls(subagentId: string): UseSubagentControls | undefined;

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

@@ -54,6 +54,15 @@ export interface UseAgentResult<TParams, TResult> extends AgentControlState {
     /** true dopo che run() ha eseguito almeno un turno con AI abilitata — solo allora la
      * conversazione ha una history su cui sendMessage() può continuare. */
     canContinue: boolean;
+    /** true when the turns go to `AgentDefinition.executor` (CR-003): no attachments, no
+     * deterministic fallback; the models are the executor's (`remoteModels`), not the catalog. */
+    remote: boolean;
+    /** The models a remote executor offers (`AgentExecutor.models`); `selectedModel` is one of them. */
+    remoteModels: Array<{
+        label: string;
+        value: string;
+        group?: string;
+    }>;
     /** Log delle tool call della sessione corrente, più recenti in fondo — azzerato a ogni
      * run(), accumulato attraverso i sendMessage() successivi. */
     activity: AgentActivityEntry[];
@@ -134,7 +143,7 @@ export interface UseAgentResult<TParams, TResult> extends AgentControlState {
 /** 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' | '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'>;
 export declare function useAgent<TParams, TContext, TResult>(definition: AgentDefinition<TParams, TContext, TResult>, options?: {
     defaultEnabled?: boolean;
 }): UseAgentResult<TParams, TResult>;

package/llms.txt

@@ -1,35 +1,39 @@
-# @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.
-- `registerDestinations({ id: ResultDestination })` — apply(result, { scopeId, dataProvider, storageProvider, proxyFetch }, meta).
-- `registerSubagentReports({ subagentId: SubagentReportModule })`.
-- `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)`, `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?
+# @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`.

package/package.json

@@ -1,79 +1,79 @@
-{
-  "name": "@llmnative/agentico",
-  "version": "0.1.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.20.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.20.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.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"
+  }
+}