@llmnative/react 1.2.1 → 1.4.0

package/dist/logHeader-Busbc8OO.mjs

@@ -0,0 +1,4 @@
+//#region src/providers/proxy/logHeader.ts
+var e = "x-llmnative-log-id";
+//#endregion
+export { e as t };

package/dist/logHeader-CbzOhx-u.js

@@ -0,0 +1 @@
+var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,n)=>{let r={};for(var i in e)t(r,i,{get:e[i],enumerable:!0});return n||t(r,Symbol.toStringTag,{value:`Module`}),r},s=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))||s.enumerable});return e},c=(n,r,a)=>(a=n==null?{}:e(i(n)),s(r||!n||!n.__esModule?t(a,`default`,{value:n,enumerable:!0}):a,n)),l=`x-llmnative-log-id`;Object.defineProperty(exports,"n",{enumerable:!0,get:function(){return o}}),Object.defineProperty(exports,"r",{enumerable:!0,get:function(){return c}}),Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return l}});

package/dist/types/src/I18n.d.ts

@@ -129,6 +129,7 @@ export interface I18nDict {
         closeEditor: string;
         editSettings: string;
         attachFiles: string;
+        dropFilesHere: string;
         attachmentsNotSupported: string;
         run: string;
         runFailed: string;

package/dist/types/src/components/blocks/Dropdown.d.ts

@@ -20,6 +20,8 @@ export interface DropdownProps extends MotionUIProps {
     /** Controlled open state. */
     open?: boolean;
     onOpenChange?: (open: boolean) => void;
+    /** Close after an official `DropdownItem` selection. Defaults to `true`. */
+    closeOnSelect?: boolean;
     /** When `true`, the menu stays open regardless of interaction. */
     staticOpen?: boolean;
     /** Horizontal alignment relative to the trigger. */
@@ -83,7 +85,7 @@ interface DropdownHeaderProps {
 interface DropdownDividerProps {
     className?: string;
 }
-export declare const Dropdown: ({ children, trigger, badge, header, footer, defaultOpen, open: controlledOpen, onOpenChange, staticOpen, position, placement, strategy, wrapperClassName, className, before, after, triggerClassName, menuClassName, badgeClassName, headerClassName, footerClassName, motion: motionConfig, }: DropdownProps) => React.JSX.Element;
+export declare const Dropdown: ({ children, trigger, badge, header, footer, defaultOpen, open: controlledOpen, onOpenChange, closeOnSelect, staticOpen, position, placement, strategy, wrapperClassName, className, before, after, triggerClassName, menuClassName, badgeClassName, headerClassName, footerClassName, motion: motionConfig, }: DropdownProps) => React.JSX.Element;
 /**
  * Async/searchable extension of Dropdown. It owns only the interaction model; applications
  * supply their own data reader and selection action (site, tenant, entity, or any resource).

package/dist/types/src/components/index.d.ts

@@ -38,6 +38,7 @@ export { default as Tab } from './ui/Tab';
 export * from './ui/Tab';
 export { default as Table } from './ui/Table';
 export type { TableProps, TableHeaderProp, TableReorderHandler, TableReorderMeta, TableSelectionChangeHandler, TableSelectionState } from './ui/Table';
+export type { RecordKeyResolver } from './ui/useStableRecordKey';
 export { default as Icon } from './ui/Icon';
 export { LayoutBuilder } from './ui/LayoutBuilder';
 export * from './ui/fields/Input';
@@ -65,6 +66,7 @@ export { default as ImageEditor } from './widgets/ImageEditor';
 export { default as MarkdownReader } from './widgets/MarkdownReader';
 export type { MarkdownReaderProps } from './widgets/MarkdownReader';
 export * from './widgets/Prompt';
+export * from './widgets/Chatbot';
 export { default as TabDynamic } from './widgets/TabDynamic';
 export { default as Component } from './Component';
 export { ComponentBlock } from './Component';

package/dist/types/src/components/ui/Table.d.ts

@@ -4,6 +4,7 @@ import { UIProps } from '../';
 import { PaginationParams } from './Pagination';
 import { type OrderConfig } from '../../libs/order';
 import { RecordSelectionState } from './useRecordSelection';
+import { type RecordKeyResolver } from './useStableRecordKey';
 export type TableHeaderProp = {
     key: string;
     label: string;
@@ -34,6 +35,12 @@ export interface TableProps extends UIProps {
     activeKey?: string | null;
     selectedKeys?: string[];
     groupBy?: string | string[];
+    /** Field name (or resolver function) for a stable per-record key — see
+     * useStableRecordKey.ts for why this matters specifically for a Table whose `records` are
+     * re-supplied with new object identities on every edit (e.g. wrapped in a `Form`, one clone
+     * per keystroke): without it, a record with no `_key` falls back to an identity-keyed cache
+     * that treats every clone as a brand-new row, remounting it. Absent = unchanged behavior. */
+    recordId?: RecordKeyResolver<RecordProps>;
     headerClassName?: string;
     bodyClassName?: string;
     footerClassName?: string;
@@ -43,5 +50,5 @@ export interface TableProps extends UIProps {
     /** Custom cell renderer. Receives the record, column key, and absolute row index. */
     renderCell?: (record: RecordProps, key: string, absoluteIndex: number) => React.ReactNode;
 }
-declare function Table({ columns, records, footer, onRowClick, onReorder, onSelectionChange, selection, sortable, pagination, activeKey, selectedKeys, groupBy, before, after, wrapperClassName, className, headerClassName, bodyClassName, footerClassName, heightClassName, scrollClassName, selectedClassName, renderCell }: TableProps): React.JSX.Element;
+declare function Table({ columns, records, footer, onRowClick, onReorder, onSelectionChange, selection, sortable, pagination, activeKey, selectedKeys, groupBy, recordId, before, after, wrapperClassName, className, headerClassName, bodyClassName, footerClassName, heightClassName, scrollClassName, selectedClassName, renderCell }: TableProps): React.JSX.Element;
 export default Table;

package/dist/types/src/components/ui/useStableRecordKey.d.ts

@@ -1,5 +1,18 @@
 type RecordWithOptionalKey = {
     _key?: string;
 };
-export declare function useStableRecordKey<TRecord extends RecordWithOptionalKey>(prefix: string): (record: TRecord, _index?: number) => string;
+/** A field name (read via bracket access) or a function computing the key directly. */
+export type RecordKeyResolver<TRecord> = string | ((record: TRecord) => string);
+export declare function useStableRecordKey<TRecord extends RecordWithOptionalKey>(prefix: string, 
+/** Explicit resolver, checked BEFORE the RECORD_KEY/WeakMap fallback below — trusted even
+ * across the new object identities a caller's own state management may produce on every
+ * edit (e.g. Form.tsx's `cloneContainer`, which clones the touched record on each keystroke
+ * but preserves this field's VALUE unchanged). Without an explicit resolver, a record with no
+ * `RECORD_KEY` gets a key from a WeakMap keyed by object identity — a fresh clone is a cache
+ * miss and gets a brand-new key, which remounts that row (and any interactive element inside
+ * it, e.g. a Form-bound `<Input>`, losing focus) on every single keystroke. Passing a
+ * resolver for a stable id field already present on the record (e.g. `"id"`) sidesteps this
+ * entirely, since the resolved value never changes across a clone. Absent = unchanged
+ * behavior (RECORD_KEY/WeakMap fallback only). */
+recordId?: RecordKeyResolver<TRecord>): (record: TRecord, _index?: number) => string;
 export {};

package/dist/types/src/components/widgets/Chatbot.d.ts

@@ -0,0 +1,75 @@
+import React from 'react';
+import { type EditorCommand } from '../ui/fields/ContextMenu';
+/**
+ * Chatbot — l'input/composer AI condiviso, estratto da `Prompt` (CR-071): textarea,
+ * slash-command, allegati, model picker, dropdown tono/stile/lingua/voce/temperatura
+ * opzionali, bottone invio/stop. NON dipende da `Form` (nessun `useFormContext`), NON
+ * conosce provider AI/variabili di template — riceve solo ciò che gli viene passato e
+ * restituisce a `onSubmit` il pacchetto risolto dell'interazione dell'utente. Chi lo usa
+ * (`Prompt` in modalità RUN, o un consumer di conversazione multi-turno come Agentico nel
+ * CMS) decide cosa fare con quel pacchetto — questa è la sua "politica", mai
+ * responsabilità di Chatbot. Non renderizza una lista messaggi/transcript: quello resta
+ * specifico di chi lo usa.
+ */
+export type ChatbotAction = {
+    key: string;
+    icon: string;
+    label?: string;
+    content?: React.ReactNode;
+};
+export interface ChatbotSubmitPayload {
+    text: string;
+    /** Grezzi — la conversione a un formato specifico (es. AIAttachment base64) resta
+     * scelta del chiamante, mai di Chatbot. */
+    files: File[];
+    model: string;
+    role?: string;
+    voice?: string;
+    style?: string;
+    language?: string;
+    temperature?: number;
+}
+export interface ChatbotModelOption {
+    label: string;
+    value: string;
+}
+export interface ChatbotProps {
+    /** Attributo `name` nativo sulla textarea sottostante — puro attributo DOM, MAI un
+     * binding a Form (Chatbot non lo legge/scrive): serve solo a chi ha bisogno di un
+     * selettore stabile (test, e2e) sull'elemento reale. */
+    name?: string;
+    value: string;
+    onChange: (value: string) => void;
+    placeholder?: string;
+    /** Turno in corso — mai usato per disabilitare il click (vedi bottone invio/stop
+     * sotto): uno stato "stopping" transitorio parte subito al click, indipendente dal
+     * vero completamento dell'abort. */
+    running?: boolean;
+    onStop?: () => void;
+    /** "Non posso inviare ora" — il motivo (AI non configurata, ecc.) resta del chiamante,
+     * Chatbot si limita a disabilitare il bottone invio. */
+    disabled?: boolean;
+    onSubmit: (payload: ChatbotSubmitPayload) => void;
+    attachments?: boolean;
+    commands?: EditorCommand[];
+    commandsTrigger?: string;
+    models?: ChatbotModelOption[];
+    selectedModel?: string;
+    onModelChange?: (id: string) => void;
+    /** Dropdown ruolo/lingua/voce/stile/temperatura — stato interno non controllato
+     * (seedato da default*), incluso nel payload di ogni submit. Default `false`: un
+     * consumer di chat libera (Agentico) non ne ha bisogno. */
+    showSettings?: boolean;
+    defaultRole?: string;
+    defaultVoice?: string;
+    defaultStyle?: string;
+    defaultLanguage?: string;
+    defaultTemperature?: number;
+    actions?: ChatbotAction[];
+    minHeight?: number;
+    maxHeight?: number;
+    wrapperClassName?: string;
+    className?: string;
+}
+export declare function Chatbot({ name, value, onChange, placeholder, running, onStop, disabled, onSubmit, attachments, commands, commandsTrigger, models, selectedModel, onModelChange, showSettings, defaultRole, defaultVoice, defaultStyle, defaultLanguage, defaultTemperature, actions, minHeight, maxHeight, wrapperClassName, className, }: ChatbotProps): React.JSX.Element;
+export default Chatbot;

package/dist/types/src/components/widgets/Prompt.d.ts

@@ -4,16 +4,14 @@ import { type AIProviderAdapter, type AIRequestOptions, type AIAttachment } from
 import { RecordProps } from '../../providers/data/DataProvider';
 import { type EditorCommand } from '../ui/fields/ContextMenu';
 import { FormFieldProps } from './Form';
+import { type ChatbotAction } from './Chatbot';
 export declare enum PromptMode {
     EDIT = "edit",
     RUN = "run"
 }
-export type PromptAction = {
-    key: string;
-    icon: string;
-    label?: string;
-    content?: React.ReactNode;
-};
+/** Alias mantenuto per compatibilità pubblica — la vera definizione vive ora in
+ * `Chatbot.tsx` (CR-071), da cui `PromptRun` la eredita passandola a `<Chatbot actions>`. */
+export type PromptAction = ChatbotAction;
 export type PromptStatusItem = 'tokensIn' | 'tokensOut' | 'contextPercent' | 'model' | 'duration' | {
     key: string;
     render: (stats: PromptRunStats) => React.ReactNode;

package/dist/types/src/libs/csv.d.ts

@@ -0,0 +1,13 @@
+export interface CsvParseResult {
+    data: Record<string, string | null | undefined>[];
+    fields: string[];
+}
+/** Parsing puro di testo CSV/TSV già in memoria — stesso motore (papaparse) di
+ * `<UploadCSV>` (ui/fields/UploadCSV.tsx), estratto qui perché un chiamante che ha già il testo
+ * (es. un allegato decodificato lato agente, non un evento `<input type="file">`) non ha un
+ * `File`/`ChangeEvent` da passare a quel componente — solo la stringa. `UploadCSV` resta
+ * l'ingresso quando l'origine è davvero un file scelto dall'utente nella UI; questa funzione è
+ * l'ingresso quando l'origine è testo già in mano al chiamante. */
+export declare function parseCsvText(text: string, opts?: {
+    delimiter?: string;
+}): CsvParseResult;

package/dist/types/src/libs/index.d.ts

@@ -4,6 +4,7 @@ export * from './converter';
 export * from './sanitizer';
 export * from './email';
 export * from './fetch';
+export * from './csv';
 export * from './utils';
 export * from './order';
 export { cn } from './cn';

package/dist/types/src/libs/promptUtils.d.ts

@@ -21,4 +21,16 @@ export declare const PromptUtils: {
      * Convert a browser File into the transport-ready attachment shape used by AI providers.
      */
     fileToAttachment(file: File): Promise<AIAttachment>;
+    /**
+     * Whether an attachment's mimetype is plain text (or a text-like format such as JSON/CSV/
+     * XML) and should therefore be decoded and inlined as a text content block by the calling
+     * provider adapter, instead of sent as a binary document/inline-data block.
+     */
+    isTextAttachment(mimeType: string): boolean;
+    /**
+     * Decodes a base64 attachment payload back to UTF-8 text — `atob` alone only yields a
+     * "binary string" (Latin-1), which corrupts multi-byte characters (accents, emoji); this
+     * re-interprets those bytes as UTF-8 first.
+     */
+    decodeBase64Text(base64: string): string;
 };

package/dist/types/src/providers/ProviderRegistryContext.d.ts

@@ -23,7 +23,7 @@ export type ProviderRegistrySnapshot = Record<string, {
  * Replaces a single named adapter in a provider registry at runtime, in ANY
  * category — one of the 6 built-in ones (typed) or an arbitrary custom one a
  * vertical registered (string). Calls the previous adapter's dispose() (if
- * defined) before swapping it in, then propagates the new registry to every
+ * defined) only when the instance changes, then propagates the new registry to every
  * useXProvider()/useProvider() consumer. If `category` didn't exist yet, it's
  * created — categories can be registered after bootstrap, not only via <App providers>.
  */

package/dist/types/src/providers/ProviderSession.d.ts

@@ -40,6 +40,13 @@ export type ProviderSessionFactory = (assignment: ProviderSessionAssignment) =>
 export declare const registerProviderSessionFactory: (category: string, type: string, factory: ProviderSessionFactory) => void;
 export type ProviderSessionSwitchOptions = {
     fetchOptions?: RequestInit;
+    /**
+     * Stable identity of the logical session being requested (for example a tenant id).
+     * Concurrent calls with the same key share one switch, including calls made by
+     * different useProviderSession() consumers. Once active, requesting that key again
+     * is a no-op until another keyed session is requested.
+     */
+    sessionKey?: string;
     /**
      * Inspect or transform the raw response before it's applied — e.g. inject an extra
      * category, filter one out, forward it to an audit log. Whatever this returns

package/dist/types/src/providers/ai/AIProvider.d.ts

@@ -73,6 +73,13 @@ export interface AICompleteRequest extends AIRequestOptions {
     tools?: AIToolDefinition[];
     /** Annulla la richiesta in corso (es. un bottone "interrompi" lato chiamante). */
     signal?: AbortSignal;
+    /** Id stabile per l'intera conversazione (generato una volta da chi possiede la sessione,
+     * es. useAgent — mai dal provider), trasportato come header `x-llmnative-log-id` verso il
+     * proxy dev di Vite: se il logging file è abilitato (`createProxyPlugin` con
+     * `ProxyLogOptions.enabled`), il proxy accoda request/response di OGNI turno con questo id
+     * allo stesso file — un file per conversazione. Assente = nessun logging per questa
+     * chiamata, comportamento identico a oggi. */
+    logId?: string;
 }
 /** Esito di una chiamata completate — testo semplice, oppure una o più richieste di tool
  * call (eventualmente accompagnate da testo, quando il modello commenta prima di invocare). */

package/dist/types/src/providers/ai/shared.d.ts

@@ -21,7 +21,7 @@ export type AIProviderDefinition = {
     credentialsHint?: string;
     capabilities?: Omit<AIProviderCapabilities, 'models'>;
     discoverModels: (apiKey: string) => Promise<string[]>;
-    complete: (apiKey: string, request: Required<Pick<AICompleteRequest, 'prompt' | 'model'>> & AIRequestOptions & Pick<AICompleteRequest, 'history' | 'tools' | 'signal'>) => Promise<AICompleteResult | null>;
+    complete: (apiKey: string, request: Required<Pick<AICompleteRequest, 'prompt' | 'model'>> & AIRequestOptions & Pick<AICompleteRequest, 'history' | 'tools' | 'signal' | 'logId'>) => Promise<AICompleteResult | null>;
     /**
      * Per-provider auth check. When omitted, the default implementation in
      * RuntimeAIProvider calls discoverModels() live (no cache) and treats any

package/dist/types/src/providers/proxy/logHeader.d.ts

@@ -0,0 +1,7 @@
+/** Nome dell'header che trasporta l'id di conversazione dal client (provider AI, via
+ * `AICompleteRequest.logId`) al proxy dev di Vite (`vite.ts`), che lo usa per accodare
+ * request/response allo stesso file di log per l'intera conversazione. File separato e
+ * privo di import Node-specific — i provider AI lato browser (anthropic.ts/gemini.ts/
+ * openaiCompatible.ts) lo importano per impostare l'header, senza portarsi dietro le
+ * dipendenze Node di vite.ts nel proprio bundle. */
+export declare const LLM_LOG_ID_HEADER = "x-llmnative-log-id";

package/dist/types/src/providers/proxy/vite.d.ts

@@ -1,3 +1,13 @@
 import type { Plugin } from 'vite';
 export declare const PROXY_PATH = "/api/proxy";
-export declare const createProxyPlugin: (route?: string) => Plugin;
+/** Logging file di richiesta/risposta LLM — SOLO dev, mai attivo di default. Un file per
+ * conversazione: il client (useAgent, CMS) genera un `logId` stabile per l'intera sessione e
+ * lo manda su ogni chiamata come header `x-llmnative-log-id`; il proxy accoda ogni turno allo
+ * stesso file, non lo sovrascrive. Vedi AICompleteRequest.logId per il lato client. */
+export interface ProxyLogOptions {
+    enabled: boolean;
+    /** Cartella di destinazione, relativa alla cwd del dev server (il progetto consumer, es.
+     * il CMS) o assoluta. Creata se assente. */
+    dir: string;
+}
+export declare const createProxyPlugin: (route?: string, logOptions?: ProxyLogOptions) => Plugin;

package/dist/vite.js

@@ -1 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});var e=`x-llmnative-proxy`,t=`/api/proxy`,n=async e=>{let t=[];for await(let n of e)t.push(Buffer.isBuffer(n)?n:Buffer.from(n));return t.length===0?void 0:Buffer.concat(t)},r=async(t,r,i)=>{let a=new URL(t.url||`/`,`http://localhost`).searchParams.get(`url`);if(t.headers[e]!==`1`){r.statusCode=403,r.setHeader(`Content-Type`,`application/json`),r.end(JSON.stringify({error:`Proxy access denied.`}));return}if(!a){r.statusCode=400,r.setHeader(`Content-Type`,`application/json`),r.end(JSON.stringify({error:`Missing "url" query parameter.`}));return}try{let o=new URL(a);if(o.pathname.startsWith(i)&&[`localhost`,`127.0.0.1`].includes(o.hostname)){r.statusCode=508,r.setHeader(`Content-Type`,`application/json`),r.end(JSON.stringify({error:`Recursive proxy target detected.`,target:a}));return}let s=await n(t),c=new Headers,l=new Set([e,`host`,`origin`,`referer`,`content-length`,`transfer-encoding`,`connection`]);Object.entries(t.headers).forEach(([e,t])=>{!t||l.has(e.toLowerCase())||c.set(e,Array.isArray(t)?t.join(`, `):t)});let u=await fetch(a,{method:t.method||`GET`,headers:c,body:s&&![`GET`,`HEAD`].includes((t.method||`GET`).toUpperCase())?Uint8Array.from(s):void 0,redirect:`follow`});r.statusCode=u.status,u.headers.forEach((e,t)=>{t.toLowerCase()!==`content-encoding`&&r.setHeader(t,e)}),r.end(Buffer.from(await u.arrayBuffer()))}catch(e){r.statusCode=502,r.setHeader(`Content-Type`,`application/json`),r.end(JSON.stringify({error:e instanceof Error?e.message:`Proxy request failed.`}))}},i=(e=t)=>({name:`llmnative-dev-proxy`,configureServer(t){t.middlewares.use(e,(t,n)=>{r(t,n,e)})},configurePreviewServer(t){t.middlewares.use(e,(t,n)=>{r(t,n,e)})}});exports.PROXY_PATH=t,exports.createProxyPlugin=i;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./logHeader-CbzOhx-u.js");let t=require("node:fs/promises"),n=require("node:path");n=e.r(n);var r=`x-llmnative-proxy`,i=`/api/proxy`,a=async e=>{let t=[];for await(let n of e)t.push(Buffer.isBuffer(n)?n:Buffer.from(n));return t.length===0?void 0:Buffer.concat(t)};function o(e){return e.replace(/[^a-zA-Z0-9_-]/g,``).slice(0,128)||`unknown`}function s(e){if(!e.trim())return`(empty body)`;try{return JSON.stringify(JSON.parse(e),null,2)}catch{return e}}async function c(e,r,i,a,c,l){try{await(0,t.mkdir)(e.dir,{recursive:!0});let u=[``,`=`.repeat(80),`Turn @ ${new Date().toISOString()}`,`Target: ${i}`,`--- REQUEST BODY ---`,s(a),`--- RESPONSE BODY (status ${c}) ---`,s(l),`=`.repeat(80),``].join(`
+`);await(0,t.appendFile)(n.default.join(e.dir,`${o(r)}.txt`),u,`utf-8`)}catch(e){console.warn(`[llmnative-dev-proxy] Failed to write LLM log:`,e)}}var l=async(t,n,i,o)=>{let s=new URL(t.url||`/`,`http://localhost`).searchParams.get(`url`);if(t.headers[r]!==`1`){n.statusCode=403,n.setHeader(`Content-Type`,`application/json`),n.end(JSON.stringify({error:`Proxy access denied.`}));return}if(!s){n.statusCode=400,n.setHeader(`Content-Type`,`application/json`),n.end(JSON.stringify({error:`Missing "url" query parameter.`}));return}try{let l=new URL(s);if(l.pathname.startsWith(i)&&[`localhost`,`127.0.0.1`].includes(l.hostname)){n.statusCode=508,n.setHeader(`Content-Type`,`application/json`),n.end(JSON.stringify({error:`Recursive proxy target detected.`,target:s}));return}let u=await a(t),d=t.headers[e.t],f=new Headers,p=new Set([r,e.t,`host`,`origin`,`referer`,`content-length`,`transfer-encoding`,`connection`]);Object.entries(t.headers).forEach(([e,t])=>{!t||p.has(e.toLowerCase())||f.set(e,Array.isArray(t)?t.join(`, `):t)});let m=await fetch(s,{method:t.method||`GET`,headers:f,body:u&&![`GET`,`HEAD`].includes((t.method||`GET`).toUpperCase())?Uint8Array.from(u):void 0,redirect:`follow`}),h=Buffer.from(await m.arrayBuffer());o?.enabled&&typeof d==`string`&&d&&c(o,d,s,u?.toString(`utf-8`)??``,m.status,h.toString(`utf-8`)),n.statusCode=m.status,m.headers.forEach((e,t)=>{t.toLowerCase()!==`content-encoding`&&n.setHeader(t,e)}),n.end(h)}catch(e){n.statusCode=502,n.setHeader(`Content-Type`,`application/json`),n.end(JSON.stringify({error:e instanceof Error?e.message:`Proxy request failed.`}))}},u=(e=i,t)=>({name:`llmnative-dev-proxy`,configureServer(n){n.middlewares.use(e,(n,r)=>{l(n,r,e,t)})},configurePreviewServer(n){n.middlewares.use(e,(n,r)=>{l(n,r,e,t)})}});exports.PROXY_PATH=i,exports.createProxyPlugin=u;

package/dist/vite.mjs

@@ -1,28 +1,64 @@
+import { t as e } from "./logHeader-Busbc8OO.mjs";
+import { appendFile as t, mkdir as n } from "node:fs/promises";
+import r from "node:path";
 //#region src/providers/proxy/vite.ts
-var e = "x-llmnative-proxy", t = "/api/proxy", n = async (e) => {
+var i = "x-llmnative-proxy", a = "/api/proxy", o = async (e) => {
 	let t = [];
 	for await (let n of e) t.push(Buffer.isBuffer(n) ? n : Buffer.from(n));
 	return t.length === 0 ? void 0 : Buffer.concat(t);
-}, r = async (t, r, i) => {
-	let a = new URL(t.url || "/", "http://localhost").searchParams.get("url");
-	if (t.headers[e] !== "1") {
-		r.statusCode = 403, r.setHeader("Content-Type", "application/json"), r.end(JSON.stringify({ error: "Proxy access denied." }));
+};
+function s(e) {
+	return e.replace(/[^a-zA-Z0-9_-]/g, "").slice(0, 128) || "unknown";
+}
+function c(e) {
+	if (!e.trim()) return "(empty body)";
+	try {
+		return JSON.stringify(JSON.parse(e), null, 2);
+	} catch {
+		return e;
+	}
+}
+async function l(e, i, a, o, l, u) {
+	try {
+		await n(e.dir, { recursive: !0 });
+		let d = [
+			"",
+			"=".repeat(80),
+			`Turn @ ${(/* @__PURE__ */ new Date()).toISOString()}`,
+			`Target: ${a}`,
+			"--- REQUEST BODY ---",
+			c(o),
+			`--- RESPONSE BODY (status ${l}) ---`,
+			c(u),
+			"=".repeat(80),
+			""
+		].join("\n");
+		await t(r.join(e.dir, `${s(i)}.txt`), d, "utf-8");
+	} catch (e) {
+		console.warn("[llmnative-dev-proxy] Failed to write LLM log:", e);
+	}
+}
+var u = async (t, n, r, a) => {
+	let s = new URL(t.url || "/", "http://localhost").searchParams.get("url");
+	if (t.headers[i] !== "1") {
+		n.statusCode = 403, n.setHeader("Content-Type", "application/json"), n.end(JSON.stringify({ error: "Proxy access denied." }));
 		return;
 	}
-	if (!a) {
-		r.statusCode = 400, r.setHeader("Content-Type", "application/json"), r.end(JSON.stringify({ error: "Missing \"url\" query parameter." }));
+	if (!s) {
+		n.statusCode = 400, n.setHeader("Content-Type", "application/json"), n.end(JSON.stringify({ error: "Missing \"url\" query parameter." }));
 		return;
 	}
 	try {
-		let o = new URL(a);
-		if (o.pathname.startsWith(i) && ["localhost", "127.0.0.1"].includes(o.hostname)) {
-			r.statusCode = 508, r.setHeader("Content-Type", "application/json"), r.end(JSON.stringify({
+		let c = new URL(s);
+		if (c.pathname.startsWith(r) && ["localhost", "127.0.0.1"].includes(c.hostname)) {
+			n.statusCode = 508, n.setHeader("Content-Type", "application/json"), n.end(JSON.stringify({
 				error: "Recursive proxy target detected.",
-				target: a
+				target: s
 			}));
 			return;
 		}
-		let s = await n(t), c = new Headers(), l = /* @__PURE__ */ new Set([
+		let u = await o(t), d = t.headers[e], f = new Headers(), p = /* @__PURE__ */ new Set([
+			i,
 			e,
 			"host",
 			"origin",
@@ -32,32 +68,32 @@ var e = "x-llmnative-proxy", t = "/api/proxy", n = async (e) => {
 			"connection"
 		]);
 		Object.entries(t.headers).forEach(([e, t]) => {
-			!t || l.has(e.toLowerCase()) || c.set(e, Array.isArray(t) ? t.join(", ") : t);
+			!t || p.has(e.toLowerCase()) || f.set(e, Array.isArray(t) ? t.join(", ") : t);
 		});
-		let u = await fetch(a, {
+		let m = await fetch(s, {
 			method: t.method || "GET",
-			headers: c,
-			body: s && !["GET", "HEAD"].includes((t.method || "GET").toUpperCase()) ? Uint8Array.from(s) : void 0,
+			headers: f,
+			body: u && !["GET", "HEAD"].includes((t.method || "GET").toUpperCase()) ? Uint8Array.from(u) : void 0,
 			redirect: "follow"
-		});
-		r.statusCode = u.status, u.headers.forEach((e, t) => {
-			t.toLowerCase() !== "content-encoding" && r.setHeader(t, e);
-		}), r.end(Buffer.from(await u.arrayBuffer()));
+		}), h = Buffer.from(await m.arrayBuffer());
+		a?.enabled && typeof d == "string" && d && l(a, d, s, u?.toString("utf-8") ?? "", m.status, h.toString("utf-8")), n.statusCode = m.status, m.headers.forEach((e, t) => {
+			t.toLowerCase() !== "content-encoding" && n.setHeader(t, e);
+		}), n.end(h);
 	} catch (e) {
-		r.statusCode = 502, r.setHeader("Content-Type", "application/json"), r.end(JSON.stringify({ error: e instanceof Error ? e.message : "Proxy request failed." }));
+		n.statusCode = 502, n.setHeader("Content-Type", "application/json"), n.end(JSON.stringify({ error: e instanceof Error ? e.message : "Proxy request failed." }));
 	}
-}, i = (e = t) => ({
+}, d = (e = a, t) => ({
 	name: "llmnative-dev-proxy",
-	configureServer(t) {
-		t.middlewares.use(e, (t, n) => {
-			r(t, n, e);
+	configureServer(n) {
+		n.middlewares.use(e, (n, r) => {
+			u(n, r, e, t);
 		});
 	},
-	configurePreviewServer(t) {
-		t.middlewares.use(e, (t, n) => {
-			r(t, n, e);
+	configurePreviewServer(n) {
+		n.middlewares.use(e, (n, r) => {
+			u(n, r, e, t);
 		});
 	}
 });
 //#endregion
-export { t as PROXY_PATH, i as createProxyPlugin };
+export { a as PROXY_PATH, d as createProxyPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llmnative/react",
-  "version": "1.2.1",
+  "version": "1.4.0",
   "description": "LLM-native React framework for deterministic UI generation. Data-driven by default, schema-driven optional. Ultra-low token consumption — built for AI agents, not just humans.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",