@llmnative/react 1.0.0 → 1.2.0

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

@@ -27,10 +27,63 @@ export interface AIRequestOptions {
     temperature?: number;
     attachments?: AIAttachment[];
 }
+/** Definizione di un tool che il modello può scegliere di invocare — la SDK del provider
+ * riceve solo questa forma (JSON-serializzabile); l'implementazione vera resta lato
+ * chiamante (mai inviata al provider). Vedi AICompleteResult per come il modello segnala
+ * una richiesta di invocazione. */
+export interface AIToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+/** Richiesta del modello di invocare un tool con questi argomenti — il chiamante esegue
+ * `name` localmente e rimanda il risultato come AIToolResult nel turno successivo. */
+export interface AIToolCall {
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+/** Esito dell'esecuzione locale di un tool, da rimandare al modello nel turno successivo. */
+export interface AIToolResult {
+    toolCallId: string;
+    name: string;
+    output: unknown;
+    isError?: boolean;
+}
+/** Un turno della conversazione precedente a quello corrente — passato via
+ * `AICompleteRequest.history` per continuare una chat multi-turno (es. l'utente affina una
+ * richiesta AI già eseguita, o il modello ha invocato un tool e ne riceve il risultato). */
+export type AIConversationTurn = {
+    role: 'user';
+    content: string;
+} | {
+    role: 'assistant';
+    content?: string;
+    toolCalls?: AIToolCall[];
+} | {
+    role: 'tool_result';
+    results: AIToolResult[];
+};
 export interface AICompleteRequest extends AIRequestOptions {
     prompt: string;
     data?: PromptVariables;
+    /** Turni precedenti della conversazione — assente = primo turno (solo `prompt`). */
+    history?: AIConversationTurn[];
+    /** Tool che il modello può invocare a sua discrezione in questo turno. */
+    tools?: AIToolDefinition[];
+    /** Annulla la richiesta in corso (es. un bottone "interrompi" lato chiamante). */
+    signal?: AbortSignal;
 }
+/** 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). */
+export type AICompleteResult = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'tool_calls';
+    toolCalls: AIToolCall[];
+    text?: string;
+};
 export interface AIKeyValidationResult {
     valid: boolean;
     /** Human-readable error from the provider API (e.g. "Incorrect API key provided"). */
@@ -45,7 +98,7 @@ export interface AIProviderAdapter extends ProviderConfigurable {
     /** URL to the provider's API key management page. */
     dashboardUrl?: string;
     getCapabilities(forceRefresh?: boolean): Promise<AIProviderCapabilities>;
-    complete(request: AICompleteRequest): Promise<string | null>;
+    complete(request: AICompleteRequest): Promise<AICompleteResult | null>;
     /** Makes a live API call to verify the key is accepted. Never uses cache. */
     validateApiKey(): Promise<AIKeyValidationResult>;
 }

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

@@ -1,9 +1,20 @@
 import type { AIConfig } from '../../Config';
+import type { ProviderDescriptor } from '../ProviderDescriptor';
 import type { AIProviderAdapter } from './AIProvider';
 import { type AIProviderDefinition } from './shared';
-export type { AIProviderAdapter, AIKeyValidationResult, AIModelDescriptor, AIProviderCapabilities, AIRequestOptions, AIAttachment } from './AIProvider';
+export type { AIProviderAdapter, AIKeyValidationResult, AIModelDescriptor, AIProviderCapabilities, AIRequestOptions, AIAttachment, AICompleteRequest, AICompleteResult, AIConversationTurn, AIToolDefinition, AIToolCall, AIToolResult, } from './AIProvider';
 export { formatAIModelRef, parseAIModelRef } from './AIProvider';
-export type { AIModelCatalog } from './shared';
+export type { AIModelCatalog, AIProviderDefinition } from './shared';
 export { getAIModelCatalog } from './shared';
 export declare const AI_PROVIDER_DEFINITIONS: AIProviderDefinition[];
+/** Generic "connect this provider" view of an AIProviderDefinition — the shape a CMS/admin
+ * UI needs (label, description, credential fields, where to find them), independent of the
+ * runtime completion contract (discoverModels/complete) it also carries. */
+export declare const toProviderDescriptor: (definition: AIProviderDefinition) => ProviderDescriptor;
+export declare const AI_PROVIDER_DESCRIPTORS: ProviderDescriptor[];
+/** The user-configurable "bring your own endpoint" slot — metadata-only counterpart of the
+ * dynamic definition getDynamicAIProviderDefinitions() builds once a baseUrl is actually
+ * known. Not part of AI_PROVIDER_DEFINITIONS (there's nothing to build a working adapter
+ * from until the user supplies that URL), but a "connect" UI still needs to offer it. */
+export declare const OPENAI_COMPATIBLE_PROVIDER_DESCRIPTOR: ProviderDescriptor;
 export declare const createAIProviderRegistry: (aiConfig?: AIConfig) => Record<string, AIProviderAdapter>;

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

@@ -1,7 +1,9 @@
 import type { AIProviderDefinition, BuiltInAIProviderId } from './shared';
+import type { AIConversationTurn, AICompleteResult, AIToolDefinition } from './AIProvider';
 type OpenAICompatibleDefinitionOptions = {
     id: BuiltInAIProviderId;
     label: string;
+    description: string;
     configKey: string;
     requiredConfigKeys?: string[];
     defaultModel: string;
@@ -10,8 +12,30 @@ type OpenAICompatibleDefinitionOptions = {
     modelsUrl?: string;
     chatCompletionsUrl?: string;
     dashboardUrl?: string;
+    credentialsHint?: string;
     /** Override the default validateApiKey when the models endpoint is public or uses a non-standard error format. */
     validateApiKey?: AIProviderDefinition['validateApiKey'];
 };
-export declare const createOpenAICompatibleProviderDefinition: ({ id, label, configKey, requiredConfigKeys, defaultModel, fallbackModels, baseUrl, modelsUrl, chatCompletionsUrl, dashboardUrl, validateApiKey: validateApiKeyOverride, }: OpenAICompatibleDefinitionOptions) => AIProviderDefinition;
+/** Esportate per riuso da provider "chat completions"-simili ma non costruiti tramite
+ * createOpenAICompatibleProviderDefinition (vedi opencode.ts) — stesso wire format OpenAI,
+ * niente da reinventare. */
+export declare function toOpenAITool(tool: AIToolDefinition): {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+};
+/** Un turno assistant con tool_calls diventa `tool_calls` sul messaggio assistant; un turno
+ * tool_result diventa un messaggio `role: 'tool'` per ciascun risultato — stessa forma
+ * richiesta dall'API Chat Completions (OpenAI e compatibili) per continuare la conversazione
+ * dopo una tool call. */
+export declare function toOpenAIMessages(turn: AIConversationTurn): Array<Record<string, unknown>>;
+export declare function parseOpenAIResponse(response: {
+    choices?: Array<{
+        message?: Record<string, unknown>;
+    }>;
+} | null): AICompleteResult | null;
+export declare const createOpenAICompatibleProviderDefinition: ({ id, label, description, configKey, requiredConfigKeys, defaultModel, fallbackModels, baseUrl, modelsUrl, chatCompletionsUrl, dashboardUrl, credentialsHint, validateApiKey: validateApiKeyOverride, }: OpenAICompatibleDefinitionOptions) => AIProviderDefinition;
 export {};

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

@@ -1,18 +1,27 @@
 import { type ProviderConfigurationState } from '../ProviderConfiguration';
-import type { AICompleteRequest, AIKeyValidationResult, AIModelDescriptor, AIProviderAdapter, AIProviderCapabilities, AIRequestOptions } from './AIProvider';
+import type { ProviderCredentialField } from '../ProviderDescriptor';
+import type { AICompleteRequest, AICompleteResult, AIKeyValidationResult, AIModelDescriptor, AIProviderAdapter, AIProviderCapabilities, AIRequestOptions } from './AIProvider';
 export type BuiltInAIProviderId = 'openai' | 'openrouter' | 'opencode' | 'openai-compatible' | 'deepseek' | 'gemini' | 'anthropic' | 'mistral' | 'glm';
 export type AIProviderDefinition = {
     id: BuiltInAIProviderId;
     label: string;
+    /** One-line description shown in a "connect this provider" UI. */
+    description?: string;
     configKey?: string;
     requiredConfigKeys?: string[];
     defaultModel: string;
     fallbackModels: string[];
-    /** URL to the provider's API key management page (shown in UI on validation error). */
+    /** URL to the provider's API key management page (shown in UI on validation error, and
+     * surfaced as ProviderDescriptor.credentialsUrl via toProviderDescriptor()). */
     dashboardUrl?: string;
+    /** Credential fields a "connect" UI should collect (defaults to a single apiKey field
+     * when omitted — see toProviderDescriptor() in ./index.ts). */
+    credentialFields?: ProviderCredentialField[];
+    /** Short guidance on where in the dashboard to find the credential. */
+    credentialsHint?: string;
     capabilities?: Omit<AIProviderCapabilities, 'models'>;
     discoverModels: (apiKey: string) => Promise<string[]>;
-    complete: (apiKey: string, request: Required<Pick<AICompleteRequest, 'prompt' | 'model'>> & AIRequestOptions) => Promise<string | null>;
+    complete: (apiKey: string, request: Required<Pick<AICompleteRequest, 'prompt' | 'model'>> & AIRequestOptions & Pick<AICompleteRequest, 'history' | 'tools' | 'signal'>) => Promise<AICompleteResult | null>;
     /**
      * Per-provider auth check. When omitted, the default implementation in
      * RuntimeAIProvider calls discoverModels() live (no cache) and treats any
@@ -41,6 +50,6 @@ export declare class RuntimeAIProvider implements AIProviderAdapter {
     isConfigured(): boolean;
     getConfigurationState(): ProviderConfigurationState;
     getCapabilities(forceRefresh?: boolean): Promise<AIProviderCapabilities>;
-    complete(request: AICompleteRequest): Promise<string | null>;
+    complete(request: AICompleteRequest): Promise<AICompleteResult | null>;
     validateApiKey(): Promise<AIKeyValidationResult>;
 }

package/dist/types/src/providers/auth/AuthProvider.d.ts

@@ -19,4 +19,12 @@ export interface AuthProviderAdapter extends ProviderConfigurable {
     onAuthChange(callback: (user: UserProfile | null) => void): () => void;
     getAccessToken?(scopes?: string[]): Promise<string>;
     isAuthenticated?(): boolean;
+    /**
+     * Custom claims embedded in the current session's token (e.g. a JWT's payload),
+     * for providers backed by one — Firebase custom claims, a Supabase JWT, etc.
+     * Optional: providers with no token-claims concept (e.g. plain OAuth) omit it.
+     * Read-only/UI convenience — never a security boundary, the server always
+     * re-verifies the raw token itself rather than trusting client-read claims.
+     */
+    getIdTokenClaims?(): Promise<Record<string, unknown> | null>;
 }

package/dist/types/src/providers/auth/firebase/FirebaseAuthProvider.d.ts

@@ -1,5 +1,6 @@
 import type { AuthProviderAdapter, AuthSignInOptions, UserProfile } from '../AuthProvider';
 import type { ProviderConfigurationState } from '../../ProviderConfiguration';
+import type { FirebaseConfig } from '../../../Config';
 /**
  * Firebase-specific sign-in options.
  *
@@ -14,7 +15,28 @@ export interface FirebaseSignInOptions extends AuthSignInOptions {
     password?: string;
     provider?: string;
 }
+export interface FirebaseAuthProviderOptions {
+    /**
+     * Static config for this provider's own Firebase app. Omit when relying on
+     * another consumer (e.g. providers.firebase + FirebaseDataProvider, or the
+     * tenant-switching session factories in ProviderSession.tsx) to have already
+     * initialized the target app — matches the provider's original zero-arg behavior.
+     */
+    config?: FirebaseConfig;
+    /**
+     * Firebase app name this provider's session lives under. Defaults to the SDK's
+     * unnamed default app. Give this a dedicated name (e.g. 'control-plane') when a
+     * long-lived login session must coexist with the default app used by tenant
+     * switching — ProviderSession's 'data'/'storage' firebase factories reinitialize
+     * the default app on every switch, which would otherwise tear down this session.
+     */
+    appName?: string;
+}
 export declare class FirebaseAuthProvider implements AuthProviderAdapter {
+    private readonly options;
+    private readonly appName?;
+    private readonly initPromise;
+    constructor(options?: FirebaseAuthProviderOptions);
     getConfigurationState(): ProviderConfigurationState;
     isConfigured(): boolean;
     getUser(): UserProfile | null;
@@ -23,4 +45,5 @@ export declare class FirebaseAuthProvider implements AuthProviderAdapter {
     signOut(): Promise<void>;
     onAuthChange(callback: (user: UserProfile | null) => void): () => void;
     getAccessToken(): Promise<string>;
+    getIdTokenClaims(): Promise<Record<string, unknown> | null>;
 }

package/dist/types/src/providers/auth/google/auth.d.ts

@@ -1,3 +1,3 @@
 import { GoogleConfig } from "../../../Config";
 export declare const authConfig: <K extends keyof GoogleConfig>(key: K) => GoogleConfig[K] | undefined;
-export declare const getGoogleCredential: () => import("firebase/auth").OAuthCredential | null;
+export declare const getGoogleCredential: () => import("@firebase/auth").OAuthCredential | null;

package/dist/types/src/providers/data/DataProvider.d.ts

@@ -80,5 +80,13 @@ export interface DataProviderAdapter extends ProviderConfigurable {
     readShallow?(path: string, exception?: boolean): Promise<string[]>;
     /** Write `data` to `path` in batches (useful for large imports). */
     setChunks?(path: string, data: object, options?: SetChunksOptions): Promise<void>;
+    /**
+     * Releases this adapter's underlying connection/resources. Not all providers need one
+     * (e.g. a stateless REST-backed adapter has nothing to release) — implement it when the
+     * provider holds a long-lived client/channel that should stop retrying once a caller has
+     * given up on it (see FirestoreDataProvider, where a nonexistent named database otherwise
+     * keeps reconnecting with backoff forever at the SDK level).
+     */
+    dispose?(): Promise<void>;
 }
 export {};

package/dist/types/src/providers/data/firestore.d.ts

@@ -1,8 +1,26 @@
 import { DataProviderAdapter, DatabaseOptions, ReadOptions, SetChunksOptions, RecordProps } from './DataProvider';
 import type { ProviderConfigurationState } from '../ProviderConfiguration';
+export interface FirestoreDataProviderConfig {
+    /** Named database within the current app's project — omit for the "(default)" database. */
+    databaseId?: string;
+}
 export declare class FirestoreDataProvider implements DataProviderAdapter {
     private static listenerRegistered;
-    constructor();
+    private databaseId?;
+    constructor(config?: FirestoreDataProviderConfig);
+    /** Same "(default)" database as before when no databaseId was configured. */
+    private getDb;
+    /**
+     * Stops this instance's underlying network channel — call this once a caller has given up
+     * on this specific databaseId (e.g. after a timeout on a database that doesn't exist).
+     * `getFirestore(app, databaseId)` is a cached singleton per (app, databaseId); left alone,
+     * a client that can't connect keeps retrying with backoff FOREVER at the SDK level, fully
+     * independent of any one `read()`/`subscribe()` call already having given up on its own
+     * promise — this is what actually silences that. Safe to call even if never connected
+     * (Firestore no-ops); the cache entry is removed afterwards, so a later `new
+     * FirestoreDataProvider({databaseId})` for the same id gets a fresh client, not a dead one.
+     */
+    dispose: () => Promise<void>;
     getConfigurationState(): ProviderConfigurationState;
     isConfigured(): boolean;
     read: (path: string, { where, order, toArray, exception }?: ReadOptions) => Promise<any>;

package/dist/types/src/providers/email/definitions.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderDescriptor } from '../ProviderDescriptor';
+export type EmailProviderId = 'resend' | 'sendgrid' | 'mailgun' | 'postmark' | 'ses' | 'smtp';
+export declare const EMAIL_PROVIDER_DEFINITIONS: ProviderDescriptor[];

package/dist/types/src/providers/firebase-init.d.ts

@@ -2,10 +2,10 @@ import { type FirebaseApp } from 'firebase/app';
 import { type Auth } from "firebase/auth";
 import { FirebaseConfig } from "../Config";
 import { type ProviderConfigurationState } from "./ProviderConfiguration";
-export declare const setFirebaseConfigState: (config: FirebaseConfig | undefined) => void;
-export declare const getFirebaseConfigurationState: () => ProviderConfigurationState;
-export declare const getFirestoreConfigurationState: () => ProviderConfigurationState;
-export declare const getSafeAuth: () => Auth | null;
+export declare const setFirebaseConfigState: (config: FirebaseConfig | undefined, appName?: string) => void;
+export declare const getFirebaseConfigurationState: (appName?: string) => ProviderConfigurationState;
+export declare const getFirestoreConfigurationState: (appName?: string) => ProviderConfigurationState;
+export declare const getSafeAuth: (appName?: string) => Auth | null;
 export declare const getFirebaseAuthorization: () => Promise<boolean>;
 /**
  * Signs into the currently-initialized Firebase app using a custom token minted
@@ -17,5 +17,11 @@ export declare const getFirebaseAuthorization: () => Promise<boolean>;
  * Call init(config) to point the app at the right project *before* calling this.
  */
 export declare const signInWithFirebaseCustomToken: (token: string) => Promise<boolean>;
-declare const init: (config: FirebaseConfig) => Promise<FirebaseApp>;
+declare const init: (config: FirebaseConfig, appName?: string) => Promise<FirebaseApp>;
+/**
+ * Invokes a Firebase Callable Function against a given app (the SDK auto-attaches
+ * that app's current auth session's ID token — no manual header wiring). Lazily
+ * imports 'firebase/functions' so it's not bundled for apps that never call one.
+ */
+export declare function callFirebaseFunction<T = unknown>(functionName: string, data: unknown, appName?: string, region?: string): Promise<T>;
 export default init;

package/dist/types/src/providers/publish/PublishProvider.d.ts

@@ -0,0 +1,29 @@
+import type { ProviderConfigurable } from '../ProviderConfiguration';
+export interface BuildManifest {
+    pages: number;
+    sizeBytes: number;
+    generatedAt: string;
+}
+export interface BuildArtifacts {
+    buildId: string;
+    outputPath: string;
+    manifest: BuildManifest;
+}
+export type DeployOptions = Record<string, never>;
+export interface DeployResult {
+    success: boolean;
+    buildId: string;
+    url?: string;
+    error?: string;
+}
+export interface Deployment {
+    buildId: string;
+    timestamp: string;
+    status: 'success' | 'failed' | 'in_progress';
+    url?: string;
+}
+export interface PublishProviderAdapter extends ProviderConfigurable {
+    deploy(artifacts: BuildArtifacts, options?: DeployOptions): Promise<DeployResult>;
+    rollback(buildId: string): Promise<DeployResult>;
+    getDeployments(limit?: number): Promise<Deployment[]>;
+}

package/dist/types/src/providers/publish/definitions.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderDescriptor } from '../ProviderDescriptor';
+export type PublishProviderId = 'cloudflare_pages' | 'firebase_hosting' | 'supabase_storage' | 'ftp' | 'sftp' | 'netlify' | 'github_pages' | 's3_cloudfront' | 'static_export';
+export declare const PUBLISH_PROVIDER_DEFINITIONS: ProviderDescriptor[];

package/dist/types/src/providers/storage/firebase.d.ts

@@ -1,8 +1,14 @@
 import type { StorageProviderAdapter, UploadOptions, StorageOptions, DeleteOptions, MoveOptions, ListOptions, StorageFileInfo, UploadHandle } from './StorageProvider';
 import type { ProviderConfigurationState } from '../ProviderConfiguration';
+export interface FirebaseStorageProviderConfig {
+    /** Used when a call doesn't pass its own `opts.bucket` — omit for the project's default bucket. */
+    defaultBucket?: string;
+}
 export declare class FirebaseStorageProvider implements StorageProviderAdapter {
     private static listenerRegistered;
-    constructor();
+    private defaultBucket?;
+    constructor(config?: FirebaseStorageProviderConfig);
+    private resolveBucket;
     getConfigurationState(): ProviderConfigurationState;
     isConfigured(): boolean;
     upload: (file: string | File | Blob, path: string, opts?: UploadOptions) => Promise<string | undefined>;

package/dist/vite.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const u="x-llmnative-proxy",p="/api/proxy",h=async t=>{const e=[];for await(const r of t)e.push(Buffer.isBuffer(r)?r:Buffer.from(r));return e.length===0?void 0:Buffer.concat(e)},l=async(t,e,r)=>{const a=new URL(t.url||"/","http://localhost").searchParams.get("url");if(t.headers[u]!=="1"){e.statusCode=403,e.setHeader("Content-Type","application/json"),e.end(JSON.stringify({error:"Proxy access denied."}));return}if(!a){e.statusCode=400,e.setHeader("Content-Type","application/json"),e.end(JSON.stringify({error:'Missing "url" query parameter.'}));return}try{const o=new URL(a);if(o.pathname.startsWith(r)&&["localhost","127.0.0.1"].includes(o.hostname)){e.statusCode=508,e.setHeader("Content-Type","application/json"),e.end(JSON.stringify({error:"Recursive proxy target detected.",target:a}));return}const d=await h(t),f=new Headers,y=new Set([u,"host","origin","referer","content-length","transfer-encoding","connection"]);Object.entries(t.headers).forEach(([i,n])=>{!n||y.has(i.toLowerCase())||f.set(i,Array.isArray(n)?n.join(", "):n)});const c=await fetch(a,{method:t.method||"GET",headers:f,body:d&&!["GET","HEAD"].includes((t.method||"GET").toUpperCase())?d:void 0,redirect:"follow"});e.statusCode=c.status,c.headers.forEach((i,n)=>{n.toLowerCase()!=="content-encoding"&&e.setHeader(n,i)}),e.end(Buffer.from(await c.arrayBuffer()))}catch(o){e.statusCode=502,e.setHeader("Content-Type","application/json"),e.end(JSON.stringify({error:o instanceof Error?o.message:"Proxy request failed."}))}},g=(t=p)=>({name:"llmnative-dev-proxy",configureServer(e){e.middlewares.use(t,(r,s)=>{l(r,s,t)})},configurePreviewServer(e){e.middlewares.use(t,(r,s)=>{l(r,s,t)})}});exports.PROXY_PATH=p;exports.createProxyPlugin=g;
+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;

package/dist/vite.mjs

@@ -1,54 +1,63 @@
-const u = "x-llmnative-proxy", l = "/api/proxy", y = async (t) => {
-  const e = [];
-  for await (const r of t)
-    e.push(Buffer.isBuffer(r) ? r : Buffer.from(r));
-  return e.length === 0 ? void 0 : Buffer.concat(e);
-}, p = async (t, e, r) => {
-  const a = new URL(t.url || "/", "http://localhost").searchParams.get("url");
-  if (t.headers[u] !== "1") {
-    e.statusCode = 403, e.setHeader("Content-Type", "application/json"), e.end(JSON.stringify({ error: "Proxy access denied." }));
-    return;
-  }
-  if (!a) {
-    e.statusCode = 400, e.setHeader("Content-Type", "application/json"), e.end(JSON.stringify({ error: 'Missing "url" query parameter.' }));
-    return;
-  }
-  try {
-    const o = new URL(a);
-    if (o.pathname.startsWith(r) && ["localhost", "127.0.0.1"].includes(o.hostname)) {
-      e.statusCode = 508, e.setHeader("Content-Type", "application/json"), e.end(JSON.stringify({ error: "Recursive proxy target detected.", target: a }));
-      return;
-    }
-    const d = await y(t), f = new Headers(), h = /* @__PURE__ */ new Set([u, "host", "origin", "referer", "content-length", "transfer-encoding", "connection"]);
-    Object.entries(t.headers).forEach(([i, n]) => {
-      !n || h.has(i.toLowerCase()) || f.set(i, Array.isArray(n) ? n.join(", ") : n);
-    });
-    const c = await fetch(a, {
-      method: t.method || "GET",
-      headers: f,
-      body: d && !["GET", "HEAD"].includes((t.method || "GET").toUpperCase()) ? d : void 0,
-      redirect: "follow"
-    });
-    e.statusCode = c.status, c.headers.forEach((i, n) => {
-      n.toLowerCase() !== "content-encoding" && e.setHeader(n, i);
-    }), e.end(Buffer.from(await c.arrayBuffer()));
-  } catch (o) {
-    e.statusCode = 502, e.setHeader("Content-Type", "application/json"), e.end(JSON.stringify({ error: o instanceof Error ? o.message : "Proxy request failed." }));
-  }
-}, g = (t = l) => ({
-  name: "llmnative-dev-proxy",
-  configureServer(e) {
-    e.middlewares.use(t, (r, s) => {
-      p(r, s, t);
-    });
-  },
-  configurePreviewServer(e) {
-    e.middlewares.use(t, (r, s) => {
-      p(r, s, t);
-    });
-  }
+//#region src/providers/proxy/vite.ts
+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 = /* @__PURE__ */ 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);
+		});
+	}
 });
-export {
-  l as PROXY_PATH,
-  g as createProxyPlugin
-};
+//#endregion
+export { t as PROXY_PATH, i as createProxyPlugin };