@llmnative/agentico 0.1.0

package/dist/types/presentation/reports/subagentReportRegistry.d.ts

@@ -0,0 +1,58 @@
+import type { ComponentType } from 'react';
+/** Booleano = includi/escludi (colori, font — un solo valore risolto per chiave, niente tra cui
+ * scegliere). Stringa = candidato scelto per uno slot con più opzioni recuperate (logo/favicon/
+ * OG image — '' significa "Nessuno"). Vedi LiquidResultReport per l'uso concreto (theme non ha
+ * più un report qui: il risultato popola direttamente il ThemeEditor aperto, vedi
+ * SubagentRunner.componentAnchors — nessuna selezione intermedia). */
+export type SubagentSelection = Record<string, boolean | string>;
+/** Un subagent "a selezione" (branding, html-to-liquid): il risultato è generato UNA volta,
+ * l'utente sceglie solo quali campi/candidati includere prima di spedirlo a una destinazione —
+ * mai una modifica diretta del contenuto del risultato. */
+export interface SelectionReportModule<TResult = any> {
+    kind: 'selection';
+    Report: ComponentType<{
+        result: TResult;
+        selection: SubagentSelection;
+        onChange: (key: string, value: boolean | string) => void;
+    }>;
+    /** Solo le chiavi per campi effettivamente presenti nel risultato — l'assenza di una chiave
+     * significa "nessuna checkbox per questo campo", non "deselezionato". Parte sempre a true
+     * (comportamento opt-out, come il vecchio flusso di import pre-AI). */
+    defaultSelection(result: TResult): SubagentSelection;
+    /** Copia di result con i campi deselezionati azzerati/filtrati — usata SOLO per alimentare
+     * ResultDestinationPicker, mai per il Report stesso (che mostra sempre il result grezzo +
+     * stato checkbox, altrimenti un campo deselezionato sparirebbe invece di restare spuntabile). */
+    applySelection(result: TResult, selection: SubagentSelection): TResult;
+}
+/** Un subagent "editabile": il risultato STESSO è l'oggetto che l'utente continua a modificare
+ * nel tempo (righe di una griglia, non un opt-in/opt-out su campi noti a priori) — non c'è nulla
+ * da "filtrare" prima di una destinazione. Il `Report` di un modulo così presuppone SEMPRE un
+ * `<Form>` vivo intorno a sé (i suoi campi editabili sono `Input`/`Select` legati a
+ * `useFormContext`) — per questo NON va registrato qui se quel Form lo possiede già un componente
+ * component-anchor sempre montato (es. redirects: `RedirectsEditor` monta il proprio Report
+ * dentro il proprio `<Form>` con un import diretto, mai tramite questo registro). Registrarlo qui
+ * lo esporrebbe ANCHE al fallback "nessun anchor vivo" di SubagentRunner (vedi sotto), che lo
+ * renderizza SENZA alcun Form intorno — crash reale osservato (`useFormContext must be used
+ * within a FormContext.Provider`, root-caused a redirects registrato qui mentre l'utente naviga
+ * via dall'editor senza salvare: un task ancora vivo con un risultato in sospeso, nessun anchor
+ * per riceverlo, fallback che monta il Report nudo). Un modulo "editabile" appartiene qui SOLO se
+ * il subagent NON garantisce un componente-anchor sempre vivo per ricevere il risultato. */
+export interface EditableReportModule<TResult = any> {
+    kind: 'editable';
+    Report: ComponentType<{
+        result: TResult;
+        onResultChange: (next: TResult) => void;
+    }>;
+}
+/** Registro presentation-side per id di subagent (stesso principio filesystem-first/id-keyed di
+ * destinationRegistry.ts) — MAI un campo su SubagentManifest: quel
+ * contratto vive nel domain layer, presentation-agnostico per design (nessun file in domain/
+ * importa React in questo repo), mentre un report è JSX puro. Un subagent senza voce qui
+ * semplicemente non mostra nessun report nel fallback "nessun anchor vivo" di SubagentRunner —
+ * comportamento identico a oggi per redirects (il suo report vive SOLO dentro RedirectsEditor,
+ * mai qui, vedi il commento su EditableReportModule sopra), mai un errore.
+ * Estendere per un futuro subagent: un modulo + una riga qui SOLO se non ha un componente-anchor
+ * sempre vivo che possa possedere il proprio Form. */
+export type SubagentReportModule<TResult = any> = SelectionReportModule<TResult> | EditableReportModule<TResult>;
+export declare function registerSubagentReports(reports: Record<string, SubagentReportModule>): void;
+export declare function getSubagentReport(subagentId: string): SubagentReportModule | undefined;

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

@@ -0,0 +1,9 @@
+import type { AIModelDescriptor } from '@llmnative/react';
+export interface UseAIModelCatalogResult {
+    hasProviders: boolean;
+    modelsByProvider: Record<string, AIModelDescriptor[]>;
+    modelsLoading: boolean;
+    selectedModel: string;
+    setSelectedModel: (id: string) => void;
+}
+export declare function useAIModelCatalog(): UseAIModelCatalogResult;

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

@@ -0,0 +1,140 @@
+import type { AIConversationTurn, AIModelDescriptor } from '@llmnative/react';
+import type { AgentDefinition } from '../domain/agentDefinition';
+/** 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
+ * generato chiedendo al modello di narrare se stesso, name+input sono già strutturati nella
+ * risposta del provider — stesso approccio degli IDE agentici, che renderizzano le tool call
+ * dal client, non dal testo del modello), o un turno "sto pensando" (una chiamata al modello,
+ * testo libero in `detail` — QUESTO è l'unico testo scritto davvero dal modello nel log,
+ * collassato a una riga dal chiamante). */
+export interface AgentActivityEntry {
+    id: string;
+    /** 'user' = il testo passato a sendMessage(), mostrato come bolla di chat (vedi
+     * AgentActivityLog). 'thinking' = una chiamata al modello (etichetta transitoria, vedi
+     * AgentActivityLog: "Sto pensando…" mentre gira, sostituita da un'anteprima di `detail` a
+     * risposta arrivata — mai testo che persiste invariato). 'tool' = una tool call,
+     * etichetta sempre statica (AgentTool.describeInvocation). */
+    kind: 'user' | 'thinking' | 'tool';
+    label: string;
+    status: 'running' | 'done' | 'error' | 'stopped';
+    /** Sui turni "sto pensando" — il testo che il modello ha scritto in quel turno (commento
+     * prima di un tool_calls, o la risposta finale). Sui messaggi utente — il testo inviato
+     * a sendMessage(), integrale (non troncato, non collassabile: è già quello che l'utente
+     * ha scritto, non c'è "ragionamento" da nascondere dietro un collapse). */
+    detail?: string;
+    /** Solo sui turni "sto pensando" che hanno richiesto tool_calls SENZA testo libero
+     * (`detail` assente) — le frasi discorsive (deterministiche, vedi AgentTool.describeIntent)
+     * sullo SCOPO GENERALE dei tool che quel turno sta per invocare (mai i parametri della
+     * chiamata specifica, quelli sono già sulla riga della tool call sotto — vedi
+     * describeIntent per il perché) cosi la UI dice qualcosa di concreto invece del generico
+     * "Richiesta di eseguire dei tool" (vedi thinkingDisplayLabel in AgentActivityLog.tsx). */
+    toolNames?: string[];
+    /** Solo su 'user' — nomi dei file allegati a QUESTO messaggio (run()/sendMessage()
+     * opts.attachments), mostrati come pillole sopra il testo (vedi AgentActivityLog) — senza,
+     * l'utente non ha modo di verificare "ho davvero attaccato quel file?" scorrendo indietro,
+     * doveva fidarsi a memoria (bug osservato: un allegato sembrava "sparito" perché non
+     * c'era traccia visiva che fosse mai arrivato). */
+    attachmentNames?: string[];
+}
+/** Stato di gating/selezione — non generico, condiviso dal componente <AgentControls />
+ * (che non ha bisogno di conoscere TParams/TResult, solo di disegnare switch + select). */
+export interface AgentControlState {
+    enabled: boolean;
+    setEnabled: (v: boolean) => void;
+    hasProviders: boolean;
+    selectedModel: string;
+    setSelectedModel: (id: string) => void;
+    modelsByProvider: Record<string, AIModelDescriptor[]>;
+    modelsLoading: boolean;
+}
+export interface UseAgentResult<TParams, TResult> extends AgentControlState {
+    running: boolean;
+    error: string | null;
+    /** 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;
+    /** Log delle tool call della sessione corrente, più recenti in fondo — azzerato a ogni
+     * run(), accumulato attraverso i sendMessage() successivi. */
+    activity: AgentActivityEntry[];
+    /** Esegue il controller (sempre) e, se abilitato e disponibile un provider, il prompt
+     * dell'agente. Ritorna `null` solo se il controller stesso fallisce (es. fetch di rete) —
+     * in ogni altro caso ritorna almeno il fallback deterministico dell'agente. Avvia una
+     * nuova sessione conversazionale (azzera la history di eventuali run precedenti).
+     * `opts.attachments` — file allegati dall'utente al messaggio di apertura, convertiti in
+     * `AIAttachment` (`PromptUtils.fileToAttachment`) e passati al provider — è il provider
+     * stesso (react/src/providers/ai/*) a decidere se un mimetype testuale va decodificato e
+     * inserito come blocco di testo o trattato come documento nativo (CR-071bis): questo hook
+     * non fa più quella distinzione, per non duplicare una logica che deve restare unica e
+     * per-provider dentro il framework. `opts.model` — sovrascrive
+     * `selectedModel` SOLO per questa chiamata (mai una `setSelectedModel` seguita subito da
+     * `run()`: lo stato React non sarebbe ancora committato nello stesso tick — vedi Chatbot
+     * in Agentico.tsx, che riporta il modello scelto nel payload di ogni submit invece di
+     * affidarsi a un `setSelectedModel` sincrono). `opts.openingMessage` — testo da mostrare
+     * SUBITO come bolla "Tu" in cima all'activity log (stesso trattamento del testo di
+     * sendMessage(), vedi sotto): senza, il messaggio che ha avviato la conversazione (es. il
+     * goal scritto nel composer "starter" di Agentico, magari con un allegato) non appariva mai
+     * nel log — solo i turni di sendMessage() successivi lo facevano, rendendo il primo
+     * messaggio "invisibile" e facile da dimenticare fosse mai stato inviato (bug osservato).
+     * Opzionale perché non ogni chiamante di run() è una chat (es. i subagent lanciati da
+     * modale/form come theme/html-to-liquid non hanno un "messaggio utente" testuale da
+     * mostrare). */
+    run: (params: TParams, opts?: {
+        attachments?: File[];
+        model?: string;
+        openingMessage?: string;
+    }) => Promise<TResult | null>;
+    /** Continua la conversazione avviata da run() con un messaggio dell'utente — il modello
+     * può invocare i tool dell'agente con i parametri suggeriti nel messaggio. Richiede che
+     * run() sia già stato eseguito con AI abilitata (altrimenti `error` viene impostato).
+     * `opts` — stesso trattamento di run(), vedi sopra. */
+    sendMessage: (text: string, opts?: {
+        attachments?: File[];
+        model?: string;
+    }) => Promise<TResult | null>;
+    /** Interrompe il turno in corso (run() o sendMessage()) — annulla la chiamata AI
+     * attualmente in volo. Nessun effetto se non c'è nulla in corso. Le tool call già in
+     * esecuzione in quel momento completano comunque (sono fetch brevi); il turno si ferma
+     * al prossimo checkpoint (subito se si stava aspettando il modello, altrimenti dopo che
+     * il round di tool in corso ha finito). */
+    stop: () => void;
+    /** Ricarica una sessione già esistente (vedi entityChatStore/AgenticoContext.resumeEntityChat)
+     * invece di iniziarne una nuova — NON invia alcun prompt al modello, si limita a ricostruire
+     * context/tools (via buildContext/getTools, come run()) e a installare `seed.history`/
+     * `seed.activity` cosi un sendMessage() successivo continui esattamente come se la
+     * conversazione non fosse mai stata interrotta. `params` deve avere la stessa forma con cui
+     * la sessione originale era stata avviata (lo stesso TParams grezzo salvato nello snapshot). */
+    resume: (params: TParams, seed: {
+        history: AIConversationTurn[];
+        activity: AgentActivityEntry[];
+    }) => Promise<void>;
+    /** Esegue direttamente il fallback deterministico dell'agente, bypassando l'AI — per il
+     * bottone "Continua senza AI" mostrato accanto a "Riprova" quando la chiamata al modello
+     * fallisce (rete/provider giù, non una risposta non valida: quel caso ricade già da solo
+     * sul fallback dentro runTurn). Richiede che run() sia già stato eseguito almeno una volta
+     * in questa sessione (altrimenti non c'è `params`/`context` da cui derivarlo) — `null` se
+     * chiamato prima. Sincrono: `AgentDefinition.fallback` non è mai una Promise (è sempre
+     * derivato da `buildContext`, già risolto a questo punto). */
+    runFallback: () => TResult | null;
+    /** Foto corrente, serializzabile, della conversazione — `history` (turni grezzi
+     * `AIConversationTurn[]`, dato puro senza funzioni/riferimenti al provider) più `activity`
+     * (lo stesso log mostrato in UI). Usata da AgenticoContext.commitEntityChat per persistere
+     * la chat che ha prodotto un'entità appena salvata (vedi entityChatStore) — a differenza di
+     * `activity` da solo, `history` è ciò che serve per un vero resume (un nuovo giro può
+     * continuare la conversazione col modello, non solo mostrarne il transcript in sola
+     * lettura). `null` se run() non è mai stato eseguito in questa sessione. Una funzione, non
+     * un valore memoizzato: deve leggere `sessionRef`/`activity` correnti al momento della
+     * chiamata (tipicamente un click su Salva, molto dopo l'ultimo turno), mai una chiusura
+     * stantia catturata al mount. */
+    snapshot: () => {
+        history: AIConversationTurn[];
+        activity: AgentActivityEntry[];
+    } | 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' | '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/dist/types/presentation/useAgenticoPageContext.d.ts

@@ -0,0 +1,12 @@
+import type { SubagentUsageCard } from '../domain/subagentUsageCard';
+/** Registra "dove si trova l'utente adesso" per Agentico — stesso pattern effect-based di
+ * usePageBreadcrumb/usePageLeading (PageActionsContext.tsx): si registra al mount, si toglie da
+ * solo allo smontaggio. Più istanze possono essere montate insieme (es. ToolsPage generico +
+ * ToolHistoryPanel specifico sopra) — vince l'ultima registrata, vedi AgenticoContext.setPageContext.
+ * `text === null` non registra nulla (utile per un contesto calcolato che a volte non è pronto).
+ * `card` — opzionale, SOLO per la UI del pannello Agentico (vedi Agentico.tsx): quando presente
+ * rimpiazza il paragrafo di prosa con una card strutturata (campi richiesti/opzionali), mentre
+ * `text` resta comunque quello che arriva al prompt dell'orchestratore (vedi
+ * AgenticoContext.pageContext) — due destinazioni diverse dello stesso "dove si trova l'utente",
+ * mai lo stesso testo forzato a servire entrambe. */
+export declare function useAgenticoPageContext(text: string | null, card?: SubagentUsageCard | null): void;

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

@@ -0,0 +1,44 @@
+/** Registra "questo componente è il subagent X" per Agentico — chiamato DAL componente
+ * portabile stesso (es. ThemeIndexList/ThemeEditor), mai dalla pagina che lo ospita: chi monta
+ * il componente ottiene gratis il contesto/hint/scoping corretto, senza ricostruirlo pagina per
+ * pagina (vedi ../domain/subagentManifest.ts SubagentManifest.componentContexts per
+ * dove vivono `agenticoHint`/`userMessage`).
+ *
+ * `componentKey` deve combaciare con una chiave di `manifest.componentContexts` — se non
+ * combacia, l'anchor si registra comunque (per `onResult`) ma senza hint/messaggio (nessun
+ * crash, solo nessun aggancio di prosa per l'LLM/l'utente).
+ *
+ * `onResult`, opzionale — chiamato da SubagentRunner quando arriva un risultato per questo
+ * `subagentId` MENTRE questo componente è montato: il componente popola se stesso (Form/stato
+ * locale), mai un salvataggio automatico — l'utente resta libero di rivedere e premere Salva
+ * come per un edit manuale. `meta` è il TParams con cui il subagent è stato lanciato (es.
+ * `{ url }` per theme) — utile quando il risultato stesso non porta un dato che serve per
+ * popolare il componente (es. l'URL sorgente, per derivare un nome di default). `taskId` è l'id
+ * del task Agentico che ha prodotto questo risultato — un componente che vuole poter persistere
+ * la chat al proprio salvataggio (vedi AgenticoContext.commitEntityChat) lo tiene da parte in un
+ * ref, altrimenti può ignorarlo. Anche una pagina
+ * non-portabile (es. SiteEditorPage, per i soli campi di site-branding dentro lo stesso
+ * risultato) può chiamare questo hook con lo stesso `subagentId` di un componente già montato —
+ * più listener indipendenti sullo stesso risultato, ciascuno responsabile della propria fetta di
+ * dati. */
+export declare function useSubagentComponentContext(subagentId: string, componentKey: string, onResult?: (result: unknown, meta: Record<string, unknown>, taskId: string) => void, 
+/** Fatti live sull'entità che QUESTA istanza ha aperta ORA (es. `Il tema aperto si chiama
+ * "ducatimilano.it".`) — accodati all'agenticoHint statico del manifest nel prompt
+ * dell'orchestratore (vedi AgenticoContext.anchorTexts), cosi un "estrai il tema" senza URL
+ * esplicito può dedurlo dal nome/hostname già noto invece di richiederlo sempre da capo.
+ * Assente/undefined = comportamento invariato. A differenza di `onResult` (in un ref, mai
+ * causa di ri-registrazione) QUESTO è una dipendenza vera dell'effect sotto: deve
+ * ri-registrare quando cambia (es. il nome dell'entità arriva dopo un fetch asincrono). */
+contextInfo?: string, 
+/** `false` = non registra nulla (o smonta l'anchor già registrato) — per un componente che
+ * resta montato anche quando "non è più lui" ad ancorarsi (es. RedirectsIndexList, che non
+ * smonta quando mostra il dettaglio di un host: senza questo, il suo anchor 'indexList'
+ * resterebbe attivo ANCHE mentre RedirectsEditor registra 'editor' per lo stesso
+ * subagentId, consegnando un risultato a entrambi). Default `true` — comportamento invariato
+ * per chi non lo passa. */
+enabled?: boolean, 
+/** Id dell'entità a cui QUESTA istanza è vincolata (es. l'hostId di RedirectsEditor) — vedi
+ * ComponentAnchor.pinnedEntityId per il perché (backstop deterministico contro un salvataggio
+ * su un'entità sbagliata, non solo un'istruzione nel prompt). Assente = nessun vincolo,
+ * comportamento invariato. */
+pinnedEntityId?: string): void;

package/llms.txt

@@ -0,0 +1,35 @@
+# @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?

package/package.json

@@ -0,0 +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"
+  }
+}