@llmnative/react 2.4.0 → 3.0.0

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

@@ -3,7 +3,7 @@ export { default as App, AppProvider } from './App';
 export { useMenu } from './App';
 export type { AppProps, AppProviderProps, AppProvidersConfig, MenuConfig } from './App';
 export type { AIConfig, FirebaseConfig } from './Config';
-export type { ServicesConfig, SupabaseProviderConfig, GoogleProviderConfig, MockProviderConfig, DataDriverName, StorageDriverName, AuthDriverName, EmailDriverName, AIDriverName, } from './providers/manifest';
+export type { ServicesConfig, SupabaseProviderConfig, GoogleProviderConfig, MockProviderConfig, DataDriverName, StorageDriverName, AuthDriverName, EmailSendDriverName, AIDriverName, } from './providers/manifest';
 export type { ProxyConfig, GitHubAuthConfig } from './Config';
 export { Head, HeadProvider, DEFAULT_DOCUMENT_HEAD, DEFAULT_HEAD_APP_NAME, DEFAULT_LANGUAGE_HEAD, useAssetsHead, useDocumentHead, useHead, useHeadLinks, useLanguageHead, usePaginationHead, usePwaHead, useSchemaOrgHead, useSocialHead, } from './Head';
 export type { HeadController, AssetsHeadState, DocumentBaseHead, DocumentHeadState, DocumentHttpEquivMeta, HeadFontAsset, HeadLinkDescriptor, HeadLinksState, HeadMetaAttributes, HeadProviderProps, HeadScriptAsset, HeadStyleAsset, LanguageAlternateLink, LanguageHeadState, OpenGraphHeadState, PageMetadataState, PaginationHeadState, PwaIconLink, PwaHeadState, SchemaOrgHeadState, SchemaOrgJson, SocialHeadState, TwitterHeadState, } from './Head';
@@ -71,9 +71,20 @@ export type { GitHubSessionProfile } from './providers/auth/github/GitHubAuthPro
 export type { CredentialsAdapter } from './providers/credentials/CredentialsProvider';
 export { useCredentialsProvider } from './providers/credentials/CredentialsProviderContext';
 export { GoogleServiceAccountProvider } from './providers/credentials/google/GoogleServiceAccountProvider';
-export type { EmailProviderAdapter, EmailSendParams } from './providers/email/EmailProvider';
-export type { EmailProviderId } from './providers/email/definitions';
-export { EMAIL_PROVIDER_DEFINITIONS } from './providers/email/definitions';
+export type { EmailSendAdapter, EmailSendParams, EmailSendResult, EmailAddress, EmailRecipient } from './providers/email/EmailSend';
+export type { EmailReadAdapter, EmailMessage, EmailReadStart, EmailReadBatch, EmailReadOptions } from './providers/email/EmailRead';
+export { EmailProviderError } from './providers/email/EmailError';
+export type { EmailProviderErrorCode } from './providers/email/EmailError';
+export type { EmailSendProviderId, EmailReadProviderId } from './providers/email/definitions';
+export { EMAIL_SEND_PROVIDER_DEFINITIONS, EMAIL_READ_PROVIDER_DEFINITIONS } from './providers/email/definitions';
+export { ResendEmailSender } from './providers/email/resend/ResendEmailSender';
+export type { ResendEmailSenderConfig } from './providers/email/resend/ResendEmailSender';
+export { BrevoEmailSender } from './providers/email/brevo/BrevoEmailSender';
+export type { BrevoEmailSenderConfig } from './providers/email/brevo/BrevoEmailSender';
+export { GmailEmailSender } from './providers/email/gmail/GmailEmailSender';
+export type { GmailEmailSenderConfig } from './providers/email/gmail/GmailEmailSender';
+export { GMAIL_SCOPES } from './providers/email/gmail/gmailApi';
+export type { GmailAuth } from './providers/email/gmail/gmailApi';
 export type { BuildManifest, BuildArtifacts, DeployOptions, DeployResult, Deployment, PublishProviderAdapter } from './providers/publish/PublishProvider';
 export type { PublishProviderId } from './providers/publish/definitions';
 export { PUBLISH_PROVIDER_DEFINITIONS } from './providers/publish/definitions';
@@ -86,15 +97,13 @@ export type { AppIconProviderConfig, IconController } from './providers/icon/Ico
 export { GoogleMapsProvider, useGoogleMapsConfig } from './providers/googleMaps/GoogleMapsProviderContext';
 export { loadGoogleMaps } from './providers/googleMaps/loadGoogleMaps';
 export type { GoogleMapsConfig } from './providers/googleMaps/loadGoogleMaps';
-export { useEmailProvider, EmailProvider } from './providers/email/EmailProviderContext';
-export { GmailEmailProvider } from './providers/email/google/GmailEmailProvider';
+export { useEmailSendProvider, useEmailReadProvider, EmailSendProvider, EmailReadProvider } from './providers/email/EmailProviderContext';
 export type { AIRequestOptions, AIReasoningLevel, AIAttachment, AIProviderAdapter, AIKeyValidationResult, AIModelDescriptor, AIModelPricing, DiscoveredAIModel, AIProviderCapabilities, AIModelCatalog, AIProviderDefinition, AICompleteRequest, AICompleteResult, AIConversationTurn, AIToolDefinition, AIToolCall, AIToolResult, CloudflareProviderOptions, ServerAIProviderConnection, ServerAIConnection, ModelIdentity, ModelIdentityEntry, ModelIdentityIndex, ResolvedModel, ModelOffer, ModelCost, } from './providers/ai';
 export { createAIProviderRegistry, getAIModelCatalog, formatAIModelRef, parseAIModelRef, isFreeAIModel, AI_PROVIDER_DEFINITIONS, AI_PROVIDER_DESCRIPTORS, OPENAI_COMPATIBLE_PROVIDER_DESCRIPTOR, CLOUDFLARE_PROVIDER_DESCRIPTOR, createCloudflareProviderDefinition, toProviderDescriptor, createServerCredentialAIRegistry, serverCredential, SERVER_CREDENTIAL_PREFIX, AI_PROVIDER_HOSTS, isAIProviderTarget, canonicalModelName, buildModelIdentityIndex, resolveModel, modelOffers, loadModelIdentityIndex } from './providers/ai';
 export type { ProviderDescriptor, ProviderCredentialField } from './providers/ProviderDescriptor';
 export { useAIProvider, useAIProviderRegistry, AIProvider } from './providers/ai/AIProviderContext';
 export { proxyFetch, useProxy, configureProxy, isProxyEnabled } from './providers/proxy';
 export { googleGetAccessToken } from './providers/auth/google/GoogleAuth';
-export { sendEmail } from './providers/email/google/email';
 export { getKeywordIdeas } from './providers/seo/google/keyword';
 export { getGoogleTrendsData, getGoogleTrendsRelated } from './providers/seo/google/trend';
 export { dropBox, useDropBoxConnect, DropBoxConnectButton } from './providers/storage/dropbox';

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

@@ -2,7 +2,6 @@ export { default as path } from './path';
 export * from './editorHeight';
 export * from './converter';
 export * from './sanitizer';
-export * from './email';
 export * from './fetch';
 export * from './csv';
 export * from './utils';

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

@@ -2,18 +2,20 @@ import React from 'react';
 import type { DataProviderAdapter } from './data/DataProvider';
 import type { StorageProviderAdapter } from './storage/StorageProvider';
 import type { AuthProviderAdapter } from './auth/AuthProvider';
-import type { EmailProviderAdapter } from './email/EmailProvider';
+import type { EmailSendAdapter } from './email/EmailSend';
+import type { EmailReadAdapter } from './email/EmailRead';
 import type { AIProviderAdapter } from './ai/AIProvider';
 import type { CredentialsAdapter } from './credentials/CredentialsProvider';
 export type ProviderAdapterMap = {
     data: DataProviderAdapter;
     storage: StorageProviderAdapter;
     auth: AuthProviderAdapter;
-    email: EmailProviderAdapter;
+    emailSend: EmailSendAdapter;
+    emailRead: EmailReadAdapter;
     ai: AIProviderAdapter;
     credentials: CredentialsAdapter;
 };
-/** The 6 categories the framework ships out of the box. Any other string is a valid category too — see customCategories on <App>. */
+/** The 7 categories the framework ships out of the box. Any other string is a valid category too — see customCategories on <App>. */
 export type ProviderService = keyof ProviderAdapterMap;
 export type ProviderRegistrySnapshot = Record<string, {
     registry: Record<string, unknown>;
@@ -21,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
+ * category — one of the 7 built-in ones (typed) or an arbitrary custom one a
  * vertical registered (string). Calls the previous adapter's dispose() (if
  * defined) only when the instance changes, then propagates the new registry to every
  * useXProvider()/useProvider() consumer. If `category` didn't exist yet, it's
@@ -43,7 +45,7 @@ export declare const ProviderRegistryProvider: ({ registries, setProvider, child
 export declare const useSetProvider: () => SetProviderFn;
 /**
  * Generic read access to any provider category — built-in or custom. Prefer the
- * typed useDataProvider()/useStorageProvider()/... for the 6 built-ins; reach for
+ * typed useDataProvider()/useStorageProvider()/... for the 7 built-ins; reach for
  * this when consuming a category the framework doesn't know about (registered via
  * providers.customCategories or a runtime setProvider() call).
  */

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

@@ -33,3 +33,23 @@ export type ServerCredentialResolution = {
  * placeholder can never carry a key elsewhere. A request without placeholders passes unchanged.
  */
 export declare function resolveServerCredentials(request: ServerCredentialRequest, lookup: ServerCredentialLookup): Promise<ServerCredentialResolution>;
+export { EmailProviderError } from '../email/EmailError';
+export type { EmailProviderErrorCode } from '../email/EmailError';
+export type { EmailSendAdapter, EmailSendParams, EmailSendResult, EmailAddress, EmailRecipient } from '../email/EmailSend';
+export type { EmailReadAdapter, EmailMessage, EmailReadStart, EmailReadBatch, EmailReadOptions } from '../email/EmailRead';
+export { EMAIL_SEND_PROVIDER_DEFINITIONS, EMAIL_READ_PROVIDER_DEFINITIONS } from '../email/definitions';
+export type { EmailSendProviderId, EmailReadProviderId } from '../email/definitions';
+export { ResendEmailSender } from '../email/resend/ResendEmailSender';
+export type { ResendEmailSenderConfig } from '../email/resend/ResendEmailSender';
+export { BrevoEmailSender } from '../email/brevo/BrevoEmailSender';
+export type { BrevoEmailSenderConfig } from '../email/brevo/BrevoEmailSender';
+export { GmailEmailSender } from '../email/gmail/GmailEmailSender';
+export type { GmailEmailSenderConfig } from '../email/gmail/GmailEmailSender';
+export { GmailEmailReader, decodeGmailPushNotification } from '../email/gmail/GmailEmailReader';
+export type { GmailEmailReaderConfig } from '../email/gmail/GmailEmailReader';
+export { createGmailOAuth } from '../email/gmail/gmailOAuth';
+export type { GmailOAuth, GmailOAuthConfig } from '../email/gmail/gmailOAuth';
+export { GMAIL_SCOPES } from '../email/gmail/gmailApi';
+export type { GmailAuth } from '../email/gmail/gmailApi';
+export { ImapEmailReader } from '../email/imap/ImapEmailReader';
+export type { ImapEmailReaderConfig, ImapModules } from '../email/imap/ImapEmailReader';

package/dist/types/src/providers/api/ApiProvider.d.ts

@@ -15,7 +15,7 @@ import type { ProviderConfigurable } from '../ProviderConfiguration';
  * Registered/fixed fields always win over a matching key the caller passes — same
  * authoritative-merge rule as the tenant-session handshake.
  *
- * Other category adapters (an EmailProviderAdapter for Brevo, an AIProviderAdapter for a
+ * Other category adapters (an EmailSendAdapter for an internal mail API, an AIProviderAdapter for a
  * REST-only model) call an ApiProviderAdapter internally instead of fetch()/proxyFetch()
  * directly — a vendor adapter is just a few lines of normal code, no framework-provided bridge.
  *

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

@@ -0,0 +1,27 @@
+export type EmailProviderErrorCode = 
+/** The adapter misses a setting (key, sender, client, library). */
+'not-configured'
+/** The message itself is not valid: no recipient, no body. */
+ | 'invalid-message'
+/** The provider refused the credentials (401/403, revoked token). */
+ | 'unauthorized'
+/** The provider refused the message (400/422: sender not verified, address not valid). */
+ | 'rejected' | 'rate-limited'
+/** The provider or the network did not answer. */
+ | 'unavailable' | 'unknown';
+export declare class EmailProviderError extends Error {
+    readonly code: EmailProviderErrorCode;
+    readonly provider: string;
+    readonly status?: number;
+    constructor(code: EmailProviderErrorCode, provider: string, message: string, options?: {
+        status?: number;
+        cause?: unknown;
+    });
+}
+/** The code of an HTTP status of a provider. */
+export declare const emailErrorCode: (status: number) => EmailProviderErrorCode;
+/**
+ * A JSON call to a provider: the answer, or an `EmailProviderError` with the status and the path only.
+ * A network failure is `unavailable`.
+ */
+export declare function callEmailApi<T>(provider: string, http: typeof fetch, url: string, init: RequestInit): Promise<T>;

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

@@ -1,12 +1,18 @@
 import React from 'react';
-import type { EmailProviderAdapter } from './EmailProvider';
-type EmailProviderContextValue = {
-    registry: Record<string, EmailProviderAdapter>;
+import type { EmailSendAdapter } from './EmailSend';
+import type { EmailReadAdapter } from './EmailRead';
+type Registry<T> = {
+    registry: Record<string, T>;
     defaultKey: string;
 };
-declare const EmailProviderContext: React.Context<EmailProviderContextValue | null>;
-export declare const EmailProvider: ({ registry, defaultKey, children, }: EmailProviderContextValue & {
+export declare const EmailSendProvider: ({ registry, defaultKey, children }: Registry<EmailSendAdapter> & {
     children: React.ReactNode;
 }) => React.JSX.Element;
-export declare const useEmailProvider: (name?: string) => EmailProviderAdapter | null;
-export default EmailProviderContext;
+export declare const EmailReadProvider: ({ registry, defaultKey, children }: Registry<EmailReadAdapter> & {
+    children: React.ReactNode;
+}) => React.JSX.Element;
+/** The adapter that sends (the default one, or `name`), or `null` when none is registered. */
+export declare const useEmailSendProvider: (name?: string) => EmailSendAdapter | null;
+/** The adapter that reads (the default one, or `name`), or `null` when none is registered. */
+export declare const useEmailReadProvider: (name?: string) => EmailReadAdapter | null;
+export {};

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

@@ -0,0 +1,48 @@
+import type { ProviderConfigurable } from '../ProviderConfiguration';
+export interface EmailMessage {
+    /** The id of the message in its mailbox. */
+    id: string;
+    /** The conversation: Gmail's thread, the Message-ID of the first message elsewhere. */
+    threadId: string;
+    /** The headers as text (`Ada <ada@example.com>`). */
+    from: string;
+    to: string;
+    subject: string;
+    /** When it arrived, ISO 8601. */
+    date: string;
+    /** The plain text: the text part, else the HTML without tags. */
+    text: string;
+    /** `outbound` for a message the mailbox sent itself (Gmail's SENT). */
+    direction: 'inbound' | 'outbound';
+    /**
+     * Where to read on from once this message is handled: when the app stops at a message (its handler
+     * failed), it keeps the `cursor` of the last one handled and the next reading starts with the rest.
+     * With Gmail the next reading may give again the messages of the same history record handled before it.
+     */
+    cursor: string;
+}
+export interface EmailReadStart {
+    /** Where reading goes on from: opaque, the app keeps it as it is. */
+    cursor: string;
+    /** Gmail: when its push to Pub/Sub ends; call `start()` again before. */
+    expiresAt?: string;
+}
+export interface EmailReadBatch {
+    messages: EmailMessage[];
+    /** The cursor to read on from next time. */
+    cursor: string;
+}
+export interface EmailReadOptions {
+    /** At most this many messages (default 50): the returned cursor goes on from the last one. */
+    limit?: number;
+}
+export interface EmailReadAdapter extends ProviderConfigurable {
+    /** Reading starts now: the mails already in the mailbox stay out. */
+    start(): Promise<EmailReadStart>;
+    /**
+     * The new mails since `cursor`, oldest first, and the cursor after them. A cursor the mailbox no longer
+     * knows (Gmail's history expired, IMAP's UIDVALIDITY changed) starts again from now, reading nothing old.
+     */
+    read(cursor: string, options?: EmailReadOptions): Promise<EmailReadBatch>;
+}
+export declare const DEFAULT_EMAIL_READ_LIMIT = 50;

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

@@ -0,0 +1,54 @@
+import type { ProviderConfigurable } from '../ProviderConfiguration';
+/** An address, with the name shown to who reads it. */
+export type EmailAddress = {
+    email: string;
+    name?: string;
+};
+/** An address as text (`ada@example.com`) or with its name. */
+export type EmailRecipient = string | EmailAddress;
+export interface EmailSendParams {
+    /** The sender; without it, the adapter's own `from`. */
+    from?: EmailRecipient;
+    to: EmailRecipient | EmailRecipient[];
+    cc?: EmailRecipient | EmailRecipient[];
+    bcc?: EmailRecipient | EmailRecipient[];
+    replyTo?: EmailRecipient;
+    subject: string;
+    /** The body as HTML, as text, or both (the reader's client picks). At least one. */
+    html?: string;
+    text?: string;
+    /** Gmail: the conversation the message joins. The other providers ignore it. */
+    threadId?: string;
+}
+export interface EmailSendResult {
+    /** The id the provider gave the message. */
+    id: string;
+    threadId?: string;
+}
+export interface EmailSendAdapter extends ProviderConfigurable {
+    send(params: EmailSendParams): Promise<EmailSendResult>;
+}
+/** An address as `{ email, name? }`. */
+export declare const toEmailAddress: (recipient: EmailRecipient) => EmailAddress;
+/** One or more addresses as a list, without the empty ones. */
+export declare const toEmailAddresses: (recipients: EmailRecipient | EmailRecipient[] | undefined) => EmailAddress[];
+/** An address as a header shows it: `Ada <ada@example.com>`, or the bare address. */
+export declare const formatEmailAddress: ({ email, name }: EmailAddress) => string;
+/**
+ * The message an adapter sends: sender and recipients as addresses, at least one recipient and one body.
+ * Throws `invalid-message` or (no sender, when the provider needs one) `not-configured`.
+ */
+export declare function prepareEmail(provider: string, params: EmailSendParams, defaultFrom: EmailRecipient | undefined, { fromRequired }?: {
+    fromRequired?: boolean | undefined;
+}): {
+    from: EmailAddress | undefined;
+    to: EmailAddress[];
+    cc: EmailAddress[];
+    bcc: EmailAddress[];
+    replyTo: EmailAddress | undefined;
+    subject: string;
+    html: string | undefined;
+    text: string | undefined;
+    threadId: string | undefined;
+};
+export type PreparedEmail = ReturnType<typeof prepareEmail>;

package/dist/types/src/providers/email/brevo/BrevoEmailSender.d.ts

@@ -0,0 +1,21 @@
+import { type ProviderConfigurationState } from '../../ProviderConfiguration';
+import { type EmailRecipient, type EmailSendAdapter, type EmailSendParams, type EmailSendResult } from '../EmailSend';
+export declare const BREVO_EMAIL_URL = "https://api.brevo.com/v3/smtp/email";
+export type BrevoEmailSenderConfig = {
+    apiKey: string;
+    /** The default sender, a sender or domain verified in Brevo. */
+    from?: EmailRecipient;
+    /** The `fetch` to use (a proxy, a test). */
+    fetch?: typeof fetch;
+};
+/**
+ * Sends with Brevo's transactional API (CR-130). The key is a secret: use it on a server, not in a
+ * browser bundle.
+ */
+export declare class BrevoEmailSender implements EmailSendAdapter {
+    private readonly config;
+    constructor(config: BrevoEmailSenderConfig);
+    getConfigurationState(): ProviderConfigurationState;
+    isConfigured(): boolean;
+    send(params: EmailSendParams): Promise<EmailSendResult>;
+}

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

@@ -1,3 +1,5 @@
 import type { ProviderDescriptor } from '../ProviderDescriptor';
-export type EmailProviderId = 'resend' | 'sendgrid' | 'mailgun' | 'postmark' | 'ses' | 'smtp';
-export declare const EMAIL_PROVIDER_DEFINITIONS: ProviderDescriptor[];
+export type EmailSendProviderId = 'resend' | 'brevo' | 'gmail' | 'sendgrid' | 'mailgun' | 'postmark' | 'ses' | 'smtp';
+export type EmailReadProviderId = 'gmail' | 'imap';
+export declare const EMAIL_SEND_PROVIDER_DEFINITIONS: ProviderDescriptor[];
+export declare const EMAIL_READ_PROVIDER_DEFINITIONS: ProviderDescriptor[];

package/dist/types/src/providers/email/gmail/GmailEmailReader.d.ts

@@ -0,0 +1,37 @@
+import type { ProviderConfigurationState } from '../../ProviderConfiguration';
+import { type EmailReadAdapter, type EmailReadBatch, type EmailReadOptions, type EmailReadStart } from '../EmailRead';
+import { type GmailAuth } from './gmailApi';
+export type GmailEmailReaderConfig = {
+    auth: GmailAuth;
+    /**
+     * The Pub/Sub topic Gmail notifies (`projects/<project>/topics/<name>`, with `roles/pubsub.publisher` to
+     * `gmail-api-push@system.gserviceaccount.com`). Without it `start()` registers no push: the app reads by polling.
+     */
+    topic?: string;
+    /** The label read (default `INBOX`). */
+    labelId?: string;
+    fetch?: typeof fetch;
+};
+/**
+ * Reads a Gmail mailbox (CR-130) by its history: the cursor is a `historyId`. With a `topic`, `start()` also
+ * asks Gmail to notify the topic of every change (the push lasts 7 days: call `start()` again before
+ * `expiresAt`); a notification (`decodeGmailPushNotification`) tells the app when to `read()`.
+ * Scope `GMAIL_SCOPES.read`.
+ */
+export declare class GmailEmailReader implements EmailReadAdapter {
+    private readonly config;
+    constructor(config: GmailEmailReaderConfig);
+    getConfigurationState(): ProviderConfigurationState;
+    isConfigured(): boolean;
+    private session;
+    start(): Promise<EmailReadStart>;
+    read(cursor: string, { limit }?: EmailReadOptions): Promise<EmailReadBatch>;
+}
+/**
+ * The notification Gmail publishes on the topic: the `data` of the Pub/Sub message (base64 JSON) as
+ * `{ emailAddress, historyId }`, or `null` when it is not one.
+ */
+export declare function decodeGmailPushNotification(data: string | undefined | null): {
+    emailAddress: string;
+    historyId: string;
+} | null;

package/dist/types/src/providers/email/gmail/GmailEmailSender.d.ts

@@ -0,0 +1,21 @@
+import type { ProviderConfigurationState } from '../../ProviderConfiguration';
+import { type EmailRecipient, type EmailSendAdapter, type EmailSendParams, type EmailSendResult } from '../EmailSend';
+import { type GmailAuth } from './gmailApi';
+export type GmailEmailSenderConfig = {
+    auth: GmailAuth;
+    /** The sender shown; without it Gmail uses the address of the account (an alias must be set in Gmail). */
+    from?: EmailRecipient;
+    fetch?: typeof fetch;
+};
+/**
+ * Sends from a Gmail mailbox (CR-130): with the browser's Google sign-in (`auth.accessToken`), or on a server
+ * with the app's OAuth client and the mailbox's refresh token (scope `GMAIL_SCOPES.send`). `threadId` keeps a
+ * reply in its conversation.
+ */
+export declare class GmailEmailSender implements EmailSendAdapter {
+    protected readonly config: GmailEmailSenderConfig;
+    constructor(config: GmailEmailSenderConfig);
+    getConfigurationState(): ProviderConfigurationState;
+    isConfigured(): boolean;
+    send(params: EmailSendParams): Promise<EmailSendResult>;
+}

package/dist/types/src/providers/email/gmail/browser.d.ts

@@ -0,0 +1,10 @@
+import { type ProviderConfigurationState } from '../../ProviderConfiguration';
+import { GmailEmailSender } from './GmailEmailSender';
+/**
+ * The `gmail` driver of the `google` provider (CR-130): sends as the user signed in with Google in the
+ * browser, so it is configured when `google.oAuth2.clientId` is.
+ */
+export declare class BrowserGmailEmailSender extends GmailEmailSender {
+    constructor();
+    getConfigurationState(): ProviderConfigurationState;
+}

package/dist/types/src/providers/email/gmail/gmailApi.d.ts

@@ -0,0 +1,53 @@
+import { type ProviderConfigurationState } from '../../ProviderConfiguration';
+import { type PreparedEmail } from '../EmailSend';
+import type { EmailMessage } from '../EmailRead';
+export declare const GMAIL_API = "https://gmail.googleapis.com/gmail/v1/users/me";
+export declare const GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token";
+/** The scopes of Gmail: read the mailbox, send from it. */
+export declare const GMAIL_SCOPES: {
+    readonly read: "https://www.googleapis.com/auth/gmail.readonly";
+    readonly send: "https://www.googleapis.com/auth/gmail.send";
+};
+/**
+ * How a Gmail adapter gets its access token: a function (the browser's Google sign-in), or the OAuth client
+ * of the app and the refresh token of the mailbox (a server).
+ */
+export type GmailAuth = {
+    accessToken: () => Promise<string>;
+} | {
+    clientId: string;
+    clientSecret: string;
+    refreshToken: string;
+};
+export declare const PROVIDER = "Gmail";
+/** Whether the auth has what it needs. */
+export declare function gmailConfigurationState(name: string, auth: GmailAuth | undefined): ProviderConfigurationState;
+/** A fresh access token: from the function, or exchanging the refresh token. */
+export declare function gmailAccessToken(auth: GmailAuth, http: typeof fetch): Promise<string>;
+export declare const base64Url: (text: string) => string;
+export declare const fromBase64Url: (data: string) => string;
+/** The raw message (RFC 2822) in base64url, as `messages.send` takes it. */
+export declare function gmailRawMessage(mail: PreparedEmail): string;
+type GmailPart = {
+    mimeType?: string;
+    body?: {
+        data?: string;
+    };
+    parts?: GmailPart[];
+};
+export type GmailApiMessage = {
+    id: string;
+    threadId?: string;
+    labelIds?: string[];
+    snippet?: string;
+    internalDate?: string;
+    payload?: GmailPart & {
+        headers?: {
+            name: string;
+            value: string;
+        }[];
+    };
+};
+/** A message of the API (`format=full`) as an `EmailMessage`, with the cursor after it. */
+export declare function toEmailMessage(message: GmailApiMessage, cursor: string): EmailMessage;
+export {};

package/dist/types/src/providers/email/gmail/gmailOAuth.d.ts

@@ -0,0 +1,25 @@
+export type GmailOAuthConfig = {
+    clientId: string;
+    clientSecret: string;
+    /** Where Google comes back with the code: a route of the app's server. */
+    redirectUri: string;
+    fetch?: typeof fetch;
+};
+export type GmailOAuth = {
+    /** The consent page of Google, with a refresh token (offline, consent asked again). */
+    authorizationUrl(options: {
+        state: string;
+        scopes: string[];
+        loginHint?: string;
+    }): string;
+    /** The code Google came back with → the address of the mailbox and its refresh token. */
+    exchangeCode(code: string): Promise<{
+        email: string;
+        refreshToken: string;
+    }>;
+};
+/**
+ * Connecting a Gmail mailbox from a server (CR-130): the consent page, then the refresh token the Gmail
+ * adapters take as `auth`. The client secret and the refresh token stay on the server.
+ */
+export declare function createGmailOAuth(config: GmailOAuthConfig): GmailOAuth;

package/dist/types/src/providers/email/imap/ImapEmailReader.d.ts

@@ -0,0 +1,70 @@
+import { type ProviderConfigurationState } from '../../ProviderConfiguration';
+import { type EmailReadAdapter, type EmailReadBatch, type EmailReadOptions, type EmailReadStart } from '../EmailRead';
+export type ImapEmailReaderConfig = {
+    host: string;
+    /** Default 993. */
+    port?: number;
+    /** TLS from the start (default `true`, port 993); `false` for STARTTLS or plain (port 143). */
+    secure?: boolean;
+    user: string;
+    /** The password, or an app password where the provider has them. */
+    password: string;
+    /** Default `INBOX`. */
+    mailbox?: string;
+};
+/** The parts of `imapflow` and `mailparser` the reader uses: injectable for tests. */
+export type ImapModules = {
+    ImapFlow: new (options: Record<string, unknown>) => ImapClient;
+    simpleParser: (source: Buffer) => Promise<ParsedMail>;
+};
+type ImapClient = {
+    connect(): Promise<void>;
+    mailboxOpen(path: string, options?: {
+        readOnly?: boolean;
+    }): Promise<{
+        uidValidity: bigint | number;
+        uidNext: number;
+    }>;
+    fetch(range: string, query: {
+        uid?: boolean;
+        source?: boolean;
+    }, options?: {
+        uid?: boolean;
+    }): AsyncIterable<{
+        uid: number;
+        source?: Buffer;
+    }>;
+    logout(): Promise<void>;
+};
+type ParsedAddress = {
+    text?: string;
+};
+type ParsedMail = {
+    messageId?: string;
+    from?: ParsedAddress;
+    to?: ParsedAddress | ParsedAddress[];
+    subject?: string;
+    date?: Date;
+    text?: string;
+    html?: string | false;
+};
+/**
+ * Reads a mailbox with IMAP (CR-130), for the providers without push: the app calls `read()` every few
+ * minutes. The cursor is the UIDVALIDITY of the mailbox and the last UID read; a new UIDVALIDITY (the
+ * mailbox renumbered) starts again from now. Server only: it opens a TCP connection. Needs the optional
+ * packages `imapflow` and `mailparser`, loaded on the first read.
+ */
+export declare class ImapEmailReader implements EmailReadAdapter {
+    private readonly config;
+    private readonly options;
+    constructor(config: ImapEmailReaderConfig, options?: {
+        modules?: () => Promise<ImapModules>;
+    });
+    getConfigurationState(): ProviderConfigurationState;
+    isConfigured(): boolean;
+    /** Opens the mailbox read-only, runs `work`, logs out whatever happens. */
+    private withMailbox;
+    start(): Promise<EmailReadStart>;
+    read(cursor: string, { limit }?: EmailReadOptions): Promise<EmailReadBatch>;
+}
+export {};

package/dist/types/src/providers/email/resend/ResendEmailSender.d.ts

@@ -0,0 +1,20 @@
+import { type ProviderConfigurationState } from '../../ProviderConfiguration';
+import { type EmailRecipient, type EmailSendAdapter, type EmailSendParams, type EmailSendResult } from '../EmailSend';
+export declare const RESEND_EMAIL_URL = "https://api.resend.com/emails";
+export type ResendEmailSenderConfig = {
+    apiKey: string;
+    /** The default sender, on a domain verified in Resend. */
+    from?: EmailRecipient;
+    /** The `fetch` to use (a proxy, a test). */
+    fetch?: typeof fetch;
+};
+/**
+ * Sends with Resend (CR-130). The key is a secret: use it on a server, not in a browser bundle.
+ */
+export declare class ResendEmailSender implements EmailSendAdapter {
+    private readonly config;
+    constructor(config: ResendEmailSenderConfig);
+    getConfigurationState(): ProviderConfigurationState;
+    isConfigured(): boolean;
+    send(params: EmailSendParams): Promise<EmailSendResult>;
+}

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

@@ -5,12 +5,13 @@ import type { AIProviderAdapter } from './ai/AIProvider';
 import type { DataProviderAdapter } from './data/DataProvider';
 import type { StorageProviderAdapter } from './storage/StorageProvider';
 import type { AuthProviderAdapter } from './auth/AuthProvider';
-import type { EmailProviderAdapter } from './email/EmailProvider';
+import type { EmailSendAdapter } from './email/EmailSend';
+import type { EmailReadAdapter } from './email/EmailRead';
 import type { AIConfig, DropboxConfig, FirebaseConfig, GitHubAuthConfig, GoogleOAuth2, GoogleServiceAccount, SupabaseConfig } from '../Config';
 import type { ProviderService } from './ProviderRegistryContext';
-/** The 6 built-in categories — alias of ProviderService (ProviderRegistryContext.tsx), derived from ProviderAdapterMap so the two can't drift. */
+/** The 7 built-in categories — alias of ProviderService (ProviderRegistryContext.tsx), derived from ProviderAdapterMap so the two can't drift. */
 export type ServiceCategory = ProviderService;
-type AnyAdapter = DataProviderAdapter | StorageProviderAdapter | AuthProviderAdapter | EmailProviderAdapter | AIProviderAdapter | CredentialsAdapter;
+type AnyAdapter = DataProviderAdapter | StorageProviderAdapter | AuthProviderAdapter | EmailSendAdapter | EmailReadAdapter | AIProviderAdapter | CredentialsAdapter;
 export interface DriverDescriptor<TConfig = unknown> {
     service: ServiceCategory;
     create: (config: TConfig) => AnyAdapter;
@@ -38,14 +39,15 @@ export declare const PROVIDER_MANIFESTS: Record<string, DriverManifest<any>>;
 export type DataDriverName = 'dbRealtime' | 'firestoreDb' | 'supabaseDb' | 'mock';
 export type StorageDriverName = 'firestorage' | 'supabaseStorage';
 export type AuthDriverName = 'googleAuth' | 'firebaseAuth' | 'dropboxAuth' | 'supabaseAuth' | 'githubAuth' | 'mockAuth';
-export type EmailDriverName = 'gmail';
+export type EmailSendDriverName = 'gmail';
 export type AIDriverName = 'openai' | 'openrouter' | 'opencode' | 'opencode-go' | 'openai-compatible' | 'deepseek' | 'gemini' | 'anthropic' | 'mistral' | 'cloudflare' | 'groq';
 export type CredentialsDriverName = 'googleServiceAccount';
 export type ServicesConfig = {
     data?: DataDriverName | string;
     storage?: StorageDriverName | string;
     auth?: AuthDriverName | string;
-    email?: EmailDriverName | string;
+    emailSend?: EmailSendDriverName | string;
+    emailRead?: string;
     ai?: AIDriverName | string;
     credentials?: CredentialsDriverName | string;
 };

package/dist/vite.js

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

package/dist/vite.mjs

@@ -1,5 +1,5 @@
 import { t as e } from "./logHeader-Busbc8OO.mjs";
-import { t } from "./server-CiWwr3Zg.mjs";
+import { t } from "./server-B430eH0y.mjs";
 import { appendFile as n, mkdir as r } from "node:fs/promises";
 import i from "node:path";
 //#region src/providers/proxy/vite.ts