@aparte/core 0.2.0-alpha.0

package/dist/runtime/message-repository.d.ts

@@ -0,0 +1,111 @@
+/**
+ * MessageRepository — Conversation Tree Storage
+ *
+ * Manages the branching conversation tree while keeping AparteMessage pure
+ * (no topology fields on the message itself). Inspired by assistant-ui's
+ * MessageRepository but adapted for the Aparte vanilla-TS stack.
+ *
+ * Internal structure: a doubly-linked tree where each node holds a pointer
+ * to its parent (prev) and its active child (next). `children` stores all
+ * sibling IDs. `head` is always the active leaf.
+ *
+ * getMessages() walks head → root via `prev` — O(depth), not O(n).
+ */
+import type { AparteMessage } from '../types/index.js';
+/** Exported format — compatible with serialisation */
+export type ExportedMessageRepository = {
+    headId: string | null;
+    messages: Array<{
+        message: AparteMessage;
+        parentId: string | null;
+    }>;
+};
+export declare class MessageRepository {
+    private _nodes;
+    private _head;
+    private _root;
+    /** ID of the currently active leaf message */
+    get headId(): string | null;
+    /**
+     * Returns the messages on the currently active path, root → head.
+     * O(depth).
+     */
+    getMessages(): AparteMessage[];
+    /**
+     * Returns metadata about a specific message, or `undefined` if not found.
+     *
+     * Read methods (`getMessage`, `getMessageById`, `getBranches`) all return
+     * `undefined` / `[]` for unknown ids — never throw — so callers can do a
+     * single existence check at the top of a flow rather than wrapping every
+     * call in try/catch.
+     */
+    getMessage(id: string): {
+        parentId: string | null;
+        message: AparteMessage;
+        index: number;
+    } | undefined;
+    /**
+     * Returns the mutable message reference, or `undefined` if not found.
+     * Mutations to the returned object are reflected in `getMessages()`.
+     */
+    getMessageById(id: string): AparteMessage | undefined;
+    /**
+     * Returns the IDs of all siblings of `messageId`
+     * (i.e. all children of its parent, including itself).
+     * Use this to build branch-picker UI.
+     */
+    getBranches(messageId: string): string[];
+    /**
+     * Add a new message as a child of `parentId` (null = root).
+     * If a message with the same id already exists, updates its data
+     * and re-links it under the correct parent.
+     */
+    addOrUpdateMessage(parentId: string | null, message: AparteMessage): void;
+    /**
+     * Switch the active branch to `messageId`.
+     * Updates `next` on the parent chain so getMessages() reflects the change.
+     * Advances `head` to the deepest active node in the new branch.
+     *
+     * Silent no-op for unknown ids — mutation methods (`switchToBranch`,
+     * `resetHead`, `updateMessage`, `clearChildren`) never throw.
+     */
+    switchToBranch(messageId: string): void;
+    /**
+     * Remove all descendants of `messageId` (inclusive) and set `head` to
+     * the parent of `messageId`. Used by edit/truncate flows.
+     *
+     * @param messageId  The first message to remove
+     * @param newParentId  Optional explicit parent to set head to
+     */
+    resetHead(messageId: string): void;
+    /**
+     * Update a message's data without changing its position in the tree.
+     */
+    updateMessage(messageId: string, updates: Partial<AparteMessage>): void;
+    /**
+     * Remove ALL children of `parentId` (and their descendants) and set head
+     * to `parentId`. Used by edit to discard every previous response before
+     * re-generating — ensures the new response starts with sibling count = 1.
+     */
+    clearChildren(parentId: string): void;
+    /** Remove all messages and reset to empty state. */
+    clear(): void;
+    /**
+     * Import a previously-exported snapshot, rebuilding the full tree and
+     * restoring the active head. Replaces any existing content (calls `clear()`
+     * first). Messages must be in topological order (parent before child) —
+     * this is guaranteed by `export()` since `_nodes` is an insertion-order
+     * Map and parents are always inserted before their children.
+     */
+    import(exported: ExportedMessageRepository): void;
+    /**
+     * Export the full tree for serialisation or debugging.
+     * Compatible with the assistant-ui ExportedMessageRepository format.
+     */
+    export(): ExportedMessageRepository;
+    private _link;
+    private _relink;
+    private _updateLevels;
+    private _deleteDescendants;
+}
+//# sourceMappingURL=message-repository.d.ts.map

package/dist/runtime/message-repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-repository.d.ts","sourceRoot":"","sources":["../../src/runtime/message-repository.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAsBvD,sDAAsD;AACtD,MAAM,MAAM,yBAAyB,GAAG;IACpC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,QAAQ,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,aAAa,CAAC;QAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC,CAAC;CACxE,CAAC;AAaF,qBAAa,iBAAiB;IAC1B,OAAO,CAAC,MAAM,CAA+B;IAC7C,OAAO,CAAC,KAAK,CAAyB;IACtC,OAAO,CAAC,KAAK,CAA0C;IAIvD,8CAA8C;IAC9C,IAAI,MAAM,IAAI,MAAM,GAAG,IAAI,CAE1B;IAED;;;OAGG;IACH,WAAW,IAAI,aAAa,EAAE;IAU9B;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG;QAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,OAAO,EAAE,aAAa,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS;IAUtG;;;OAGG;IACH,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAIrD;;;;OAIG;IACH,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE;IASxC;;;;OAIG;IACH,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI;IAkCzE;;;;;;;OAOG;IACH,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAQvC;;;;;;OAMG;IACH,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAuBlC;;OAEG;IACH,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI;IAMvE;;;;OAIG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAgBrC,oDAAoD;IACpD,KAAK,IAAI,IAAI;IAMb;;;;;;OAMG;IACH,MAAM,CAAC,QAAQ,EAAE,yBAAyB,GAAG,IAAI;IAUjD;;;OAGG;IACH,MAAM,IAAI,yBAAyB;IAanC,OAAO,CAAC,KAAK;IAUb,OAAO,CAAC,OAAO;IA0Bf,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,kBAAkB;CAW7B"}

package/dist/transport/backend-handler.d.ts

@@ -0,0 +1,50 @@
+import type { AparteAIProvider } from '../types/model-provider.js';
+export interface AparteChatHandlerOptions {
+    /**
+     * Your server-side format adapters, keyed by the `providerId` the client
+     * sends. The same adapters as the browser (`@aparte/provider-*`), running here
+     * so the vendor key never leaves the server.
+     */
+    providers: Record<string, AparteAIProvider>;
+    /**
+     * Optional gate run on EVERY request before any work — this endpoint spends
+     * your server-held vendor key, so put your own auth in front of it. Return
+     * `false` to reject with 401, a `Response` to reject with your own status/body
+     * (e.g. 403 + a message), or `true` to proceed. Reads cookies/headers via `req`.
+     */
+    authorize?: (req: Request) => boolean | Response | Promise<boolean | Response>;
+    /**
+     * Resolve the vendor API key for a providerId — from env / a secret store.
+     * Runs server-side only. Return `undefined` for keyless/local providers.
+     */
+    resolveKey?: (providerId: string) => string | undefined | Promise<string | undefined>;
+    /**
+     * The `fetch` used to call the vendor. Defaults to the global `fetch`
+     * (Node 18+, Deno, Bun, Workers). Override in tests or to add a proxy.
+     */
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Build a framework-free `/api/chat` handler for {@link BackendTransport} — the
+ * server counterpart that keeps the key off the client.
+ *
+ * The returned handler speaks the Web `fetch` API (`Request` → `Response`), so
+ * it drops into a Next.js route handler, Deno, Bun, or a Cloudflare Worker
+ * unchanged. It reads `{ providerId, request }`, runs the matching format
+ * adapter **server-side** (buildRequest → auth → vendor fetch → parseStream),
+ * and streams back normalized `AparteStreamEvent`s as NDJSON — the exact wire
+ * format `BackendTransport` expects. The vendor key is injected here and never
+ * travels to the browser.
+ *
+ * ```ts
+ * // app/api/chat/route.ts (Next.js)
+ * import { createAparteChatHandler } from '@aparte/core';
+ * import { createOpenAICompatProvider, presets } from '@aparte/provider-openai-compat';
+ * export const POST = createAparteChatHandler({
+ *   providers: { openai: createOpenAICompatProvider(presets.OPENAI) },
+ *   resolveKey: (id) => process.env[`${id.toUpperCase()}_KEY`],
+ * });
+ * ```
+ */
+export declare function createAparteChatHandler(options: AparteChatHandlerOptions): (req: Request) => Promise<Response>;
+//# sourceMappingURL=backend-handler.d.ts.map

package/dist/transport/backend-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend-handler.d.ts","sourceRoot":"","sources":["../../src/transport/backend-handler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAGnE,MAAM,WAAW,wBAAwB;IACrC;;;;OAIG;IACH,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC5C;;;;;OAKG;IACH,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC,OAAO,GAAG,QAAQ,CAAC,CAAC;IAC/E;;;OAGG;IACH,UAAU,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IACtF;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,uBAAuB,CACnC,OAAO,EAAE,wBAAwB,GAClC,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CA4GrC"}

package/dist/transport/backend-transport.d.ts

@@ -0,0 +1,39 @@
+import type { AparteChatRequest, AparteChatResponse } from '../types/chat.js';
+import type { AparteAIProvider } from '../types/model-provider.js';
+import type { AparteTransport, AparteTransportContext } from './types.js';
+export interface BackendTransportOptions {
+    /** Your backend chat endpoint, e.g. `/api/chat`. */
+    endpoint: string;
+    /** Extra headers to send with each request (session cookie is automatic). */
+    headers?: Record<string, string>;
+    /**
+     * Override how the request is serialised to your backend. Default body is
+     * `{ providerId, request }`. Return any JSON-serialisable value.
+     */
+    buildBody?: (request: AparteChatRequest, providerId: string) => unknown;
+}
+/**
+ * Backend-proxied transport — RECOMMENDED for production.
+ *
+ * POSTs `{ providerId, request }` to YOUR endpoint. The backend resolves the API
+ * key server-side, calls the vendor, runs the vendor parser **server-side**, and
+ * streams back already-normalized `AparteStreamEvent`s as NDJSON (one JSON object
+ * per line). The key never reaches the browser and — unlike a raw proxy — the
+ * client stays fully vendor-agnostic (it never runs the vendor's `parseStream`,
+ * so switching the server-side provider needs no client change). Non-streaming
+ * requests get a JSON `{ text }` reply.
+ *
+ * This is NOT the Vercel AI SDK Data Stream Protocol; the wire format is a plain
+ * NDJSON of `AparteStreamEvent` (see `parseAparteEventStream`).
+ *
+ * The matching `/api/chat` handler ships as a real, framework-free function —
+ * {@link createAparteChatHandler} (Web `fetch` API, same @aparte adapters run
+ * server-side, key held server-side). Drop it into a Next.js route handler,
+ * Deno, Bun, or a Worker rather than hand-rolling one.
+ */
+export declare class BackendTransport implements AparteTransport {
+    private readonly options;
+    constructor(options: BackendTransportOptions);
+    chat(_provider: AparteAIProvider, request: AparteChatRequest, _auth: string | Record<string, string> | undefined, ctx: AparteTransportContext): Promise<AparteChatResponse>;
+}
+//# sourceMappingURL=backend-transport.d.ts.map

package/dist/transport/backend-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend-transport.d.ts","sourceRoot":"","sources":["../../src/transport/backend-transport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC9E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,KAAK,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAI1E,MAAM,WAAW,uBAAuB;IACpC,oDAAoD;IACpD,QAAQ,EAAE,MAAM,CAAC;IACjB,6EAA6E;IAC7E,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC;;;OAGG;IACH,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC;CAC3E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,gBAAiB,YAAW,eAAe;IACxC,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,uBAAuB;IAEvD,IAAI,CACN,SAAS,EAAE,gBAAgB,EAC3B,OAAO,EAAE,iBAAiB,EAC1B,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EAClD,GAAG,EAAE,sBAAsB,GAC5B,OAAO,CAAC,kBAAkB,CAAC;CA4BjC"}

package/dist/transport/direct-transport.d.ts

@@ -0,0 +1,36 @@
+import type { AparteChatRequest, AparteChatResponse } from '../types/chat.js';
+import type { AparteAIProvider } from '../types/model-provider.js';
+import type { AparteTransport, AparteTransportContext } from './types.js';
+/** Options for {@link DirectTransport}. */
+export interface DirectTransportOptions {
+    /**
+     * Set when the key is the end-user's own (BYOK) or the model runs locally —
+     * i.e. you *intend* the credential to live in the browser. This silences the
+     * one-time insecure-key warning. Leave it unset for keys that must stay
+     * server-side, and use `BackendTransport` for those instead.
+     */
+    byok?: boolean;
+}
+/**
+ * Browser-direct transport (BYOK / local / prototyping) — the DEFAULT.
+ *
+ * Calls the vendor endpoint straight from the browser, injecting the resolved
+ * key via the adapter's `authHeaders`. This is the pre-refactor behaviour and
+ * is only safe when the user brings their own key or the model runs locally.
+ * Production apps that must keep a key server-side should use `BackendTransport`.
+ *
+ * When a real key is sent straight from the browser and the transport was not
+ * flagged `{ byok: true }`, a one-time `console.warn` names the exposure — the
+ * default should be loud, not silent. Local providers (no key) never warn.
+ *
+ * Legacy providers (still exposing `chat()` rather than the adapter surface) are
+ * delegated to untouched, so the migration can proceed provider-by-provider.
+ */
+export declare class DirectTransport implements AparteTransport {
+    private readonly byok;
+    private warnedBrowserKey;
+    constructor(options?: DirectTransportOptions);
+    chat(provider: AparteAIProvider, request: AparteChatRequest, auth: string | Record<string, string> | undefined, ctx: AparteTransportContext): Promise<AparteChatResponse>;
+    private warnBrowserKeyOnce;
+}
+//# sourceMappingURL=direct-transport.d.ts.map

package/dist/transport/direct-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"direct-transport.d.ts","sourceRoot":"","sources":["../../src/transport/direct-transport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC9E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,KAAK,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAG1E,2CAA2C;AAC3C,MAAM,WAAW,sBAAsB;IACnC;;;;;OAKG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,eAAgB,YAAW,eAAe;IACnD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAU;IAC/B,OAAO,CAAC,gBAAgB,CAAS;gBAErB,OAAO,GAAE,sBAA2B;IAI1C,IAAI,CACN,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,EAAE,iBAAiB,EAC1B,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EACjD,GAAG,EAAE,sBAAsB,GAC5B,OAAO,CAAC,kBAAkB,CAAC;IAoD9B,OAAO,CAAC,kBAAkB;CAU7B"}

package/dist/transport/index.d.ts

@@ -0,0 +1,6 @@
+export type { AparteTransport, AparteTransportContext, AparteFormatAdapter, AparteVendorRequest, } from './types.js';
+export { isFormatAdapter, readAuth } from './types.js';
+export { DirectTransport, type DirectTransportOptions } from './direct-transport.js';
+export { BackendTransport, type BackendTransportOptions } from './backend-transport.js';
+export { createAparteChatHandler, type AparteChatHandlerOptions } from './backend-handler.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/transport/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/transport/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACR,eAAe,EACf,sBAAsB,EACtB,mBAAmB,EACnB,mBAAmB,GACtB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,KAAK,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AACrF,OAAO,EAAE,gBAAgB,EAAE,KAAK,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACxF,OAAO,EAAE,uBAAuB,EAAE,KAAK,wBAAwB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/transport/types.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Transport seam — separates the two concerns that providers used to bundle:
+ *
+ *   • **Format adapter** (`AparteFormatAdapter`): the vendor-specific concern —
+ *     how to shape the HTTP request and how to parse the response stream into
+ *     unified `AparteStreamEvent`s. No network, no auth, no key.
+ *   • **Transport** (`AparteTransport`): WHERE the call goes and how auth is
+ *     handled — straight to the vendor from the browser (`DirectTransport`,
+ *     BYOK/local) or via your own backend that holds the key
+ *     (`BackendTransport`, recommended for production).
+ *
+ * A "provider" is migrating from a monolithic `chat()` (fetch + key + parse) to
+ * a pure format adapter. During the migration a provider may expose EITHER the
+ * adapter surface OR a legacy `chat()`; the transports handle both.
+ */
+import type { AparteChatRequest, AparteChatResponse, AparteStreamEvent } from '../types/chat.js';
+import type { AparteAIProvider } from '../types/model-provider.js';
+/** A vendor HTTP request built from an Aparte request — auth is injected separately. */
+export interface AparteVendorRequest {
+    /** Appended to the transport's endpoint, e.g. `/chat/completions`. */
+    path: string;
+    /** Vendor-shaped JSON body. */
+    body: unknown;
+    /** Content headers (NOT auth — the transport adds auth). */
+    headers?: Record<string, string>;
+}
+/** The vendor-format concern, with no transport/auth coupling. */
+export interface AparteFormatAdapter {
+    id: string;
+    /** Base URL for browser-direct calls (overridable per request via config). */
+    defaultEndpoint: string;
+    /** Map an Aparte request to the vendor HTTP request (without auth). */
+    buildRequest(request: AparteChatRequest): AparteVendorRequest;
+    /** Vendor auth headers for a resolved key (browser-direct only). Most vendors. */
+    authHeaders?(key: string): Record<string, string>;
+    /** Vendor auth as URL query params for a resolved key (e.g. Gemini `?key=`). */
+    authQuery?(key: string): Record<string, string>;
+    /** Parse a streaming vendor response body into unified events. */
+    parseStream(body: ReadableStream<Uint8Array>): ReadableStream<AparteStreamEvent>;
+    /** Extract text from a non-streaming vendor JSON response. */
+    parseText?(json: unknown): string;
+}
+export interface AparteTransportContext {
+    providerId: string;
+    signal?: AbortSignal;
+}
+/**
+ * Decides where a chat request goes and how auth is handled. Given a provider
+ * (adapter or legacy), the request, and the already-resolved auth, it returns
+ * unified events (streaming) or a string (non-streaming).
+ */
+export interface AparteTransport {
+    chat(provider: AparteAIProvider, request: AparteChatRequest, auth: string | Record<string, string> | undefined, ctx: AparteTransportContext): Promise<AparteChatResponse>;
+}
+/** True once a provider has been refactored to the format-adapter surface. */
+export declare function isFormatAdapter(p: AparteAIProvider): p is AparteAIProvider & Required<Pick<AparteFormatAdapter, 'buildRequest' | 'parseStream' | 'defaultEndpoint'>>;
+/** Read an api key / endpoint out of the legacy `string | Record` auth shape. */
+export declare function readAuth(auth: string | Record<string, string> | undefined): {
+    key?: string;
+    endpoint?: string;
+};
+/** Best-effort human message from a non-ok vendor/backend JSON error response. */
+export declare function vendorErrorMessage(response: Response, label?: string): Promise<string>;
+/**
+ * Resolve a non-streaming response to text via the adapter's `parseText`.
+ * Both transports use this so `stream: false` behaves identically (previously
+ * DirectTransport returned '' and BackendTransport returned raw JSON when
+ * `parseText` was missing — now both fail loud).
+ */
+export declare function parseNonStreamText(provider: {
+    parseText?: (json: unknown) => string;
+}, response: Response, providerId: string): Promise<string>;
+//# sourceMappingURL=types.d.ts.map

package/dist/transport/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/transport/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACjG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAEnE,wFAAwF;AACxF,MAAM,WAAW,mBAAmB;IAChC,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,IAAI,EAAE,OAAO,CAAC;IACd,4DAA4D;IAC5D,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC;AAED,kEAAkE;AAClE,MAAM,WAAW,mBAAmB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,8EAA8E;IAC9E,eAAe,EAAE,MAAM,CAAC;IACxB,uEAAuE;IACvE,YAAY,CAAC,OAAO,EAAE,iBAAiB,GAAG,mBAAmB,CAAC;IAC9D,kFAAkF;IAClF,WAAW,CAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClD,gFAAgF;IAChF,SAAS,CAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChD,kEAAkE;IAClE,WAAW,CAAC,IAAI,EAAE,cAAc,CAAC,UAAU,CAAC,GAAG,cAAc,CAAC,iBAAiB,CAAC,CAAC;IACjF,8DAA8D;IAC9D,SAAS,CAAC,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC;CACrC;AAED,MAAM,WAAW,sBAAsB;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,WAAW,CAAC;CACxB;AAED;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC5B,IAAI,CACA,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,EAAE,iBAAiB,EAC1B,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EACjD,GAAG,EAAE,sBAAsB,GAC5B,OAAO,CAAC,kBAAkB,CAAC,CAAC;CAClC;AAED,8EAA8E;AAC9E,wBAAgB,eAAe,CAC3B,CAAC,EAAE,gBAAgB,GACpB,CAAC,IAAI,gBAAgB,GAAG,QAAQ,CAAC,IAAI,CAAC,mBAAmB,EAAE,cAAc,GAAG,aAAa,GAAG,iBAAiB,CAAC,CAAC,CAOjH;AAED,iFAAiF;AACjF,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,GAAG;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAI/G;AAED,kFAAkF;AAClF,wBAAsB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAK5F;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACpC,QAAQ,EAAE;IAAE,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,MAAM,CAAA;CAAE,EACnD,QAAQ,EAAE,QAAQ,EAClB,UAAU,EAAE,MAAM,GACnB,OAAO,CAAC,MAAM,CAAC,CAMjB"}

package/dist/types/chat.d.ts

@@ -0,0 +1,223 @@
+/**
+ * Aparte Chat Request & Stream Types
+ */
+import type { AparteTool, AparteToolCall } from './tools.js';
+import type { AparteSegment } from './segments.js';
+/** Plain text content part */
+export interface AparteTextPart {
+    type: 'text';
+    text: string;
+}
+/**
+ * Image content part.
+ * `image` must be a base64 data URL: `data:image/png;base64,...`
+ * The data URL encodes the MIME type, making it consumable by all providers.
+ */
+export interface AparteImagePart {
+    type: 'image';
+    image: string;
+    mimeType?: string;
+}
+/**
+ * File content part — reserved for future PDF/audio support.
+ * `data` must be a base64 data URL.
+ */
+export interface AparteFilePart {
+    type: 'file';
+    data: string;
+    mimeType: string;
+    name?: string;
+}
+/** Discriminated union of all content part types */
+export type AparteContentPart = AparteTextPart | AparteImagePart | AparteFilePart;
+/**
+ * Extract plain text from a `string | AparteContentPart[]` content value.
+ * Use this in providers and app-layer code whenever you need the text-only representation.
+ */
+export declare function contentToText(content: string | AparteContentPart[]): string;
+export interface AparteChatMessage {
+    role: 'user' | 'assistant' | 'system' | 'tool_call' | 'tool_result';
+    /**
+     * Message content — either a plain string (backward compatible) or an array
+     * of typed content parts for multimodal messages (text + images + files).
+     *
+     * Use `contentToText(content)` to extract the text-only representation.
+     */
+    content: string | AparteContentPart[];
+    /** For role='tool_call': tool calls made by the assistant in this turn */
+    toolCalls?: AparteToolCall[];
+    /** For role='tool_result': id of the tool call this responds to */
+    toolCallId?: string;
+    /** For role='tool_call': text streamed before the tool call in the same turn */
+    precedingText?: string;
+}
+export interface AparteChatRequest {
+    messages: AparteChatMessage[];
+    modelId: string;
+    temperature?: number;
+    maxTokens?: number;
+    stream?: boolean;
+    /** Tools the AI is allowed to call */
+    tools?: AparteTool[];
+    /**
+     * Random seed for reproducibility / diversity.
+     * Automatically set to a random integer on every `aparte-retry` so the
+     * provider generates a different response even with the same history.
+     * Supported by OpenAI, OpenRouter, LM Studio, Mistral, Ollama, and Gemini.
+     * Anthropic does not expose a seed parameter — ignored silently there.
+     */
+    seed?: number;
+    /**
+     * Controls which tool the model must call — mirrors OpenAI tool_choice / Anthropic tool_choice.
+     * - 'auto'        : model decides (default when tools are present)
+     * - 'none'        : no tools injected this turn — model answers directly
+     * - { name }      : model MUST call this tool (provider injects a strong directive)
+     * - { name, input }: synthetic call — the agent loop (inline `_streamLoop`
+     *                    or the injected `runStreamAgent`) bypasses the LLM
+     *                    entirely and runs the handler directly with the provided
+     *                    input, then re-calls the LLM with the tool_result in history.
+     */
+    toolChoice?: 'auto' | 'none' | {
+        name: string;
+        input?: Record<string, unknown>;
+    };
+    /**
+     * Optional prefill string applied after the chat template's generation
+     * prompt — the model continues from the end of this string. Provider- and
+     * model-specific; core prescribes no syntax (the consuming app/orchestrator
+     * decides what control tokens, if any, to inject). Providers that support a
+     * "continue final message" mode apply it; others MAY ignore this field.
+     */
+    prefill?: string;
+    /**
+     * Verbatim system message to use INSTEAD of the provider building its own
+     * (e.g. the transformers provider's tool-system-message). Generic transport
+     * field : when set, the provider uses this string as the system message
+     * as-is. `tools` may still be passed (for the tool-call parser/dispatch)
+     * but is NOT re-rendered into the system prompt. Used to feed a fine-tuned
+     * model its EXACT training system prompt (anti-OOD). Providers that build no
+     * system message MAY ignore it.
+     */
+    systemOverride?: string;
+    /**
+     * Hint : stream tokens AS THEY ARRIVE (bypass the provider's flush-throttle).
+     * Default throttling coalesces UI paints to protect WebGPU decode speed ;
+     * a short codegen turn that drives a live preview (e.g. xlsx_ops ops) opts
+     * in so the consumer can render progressively. Providers MAY ignore it.
+     */
+    fastStream?: boolean;
+    /**
+     * Opaque metadata bag threaded through the request pipeline (e.g. from a
+     * requestInterceptor to the `_streamLoop` post-processor). Never sent to the
+     * AI provider — stripped before the network call. The well-known keys are
+     * typed; see {@link AparteRequestMeta}.
+     */
+    _meta?: AparteRequestMeta;
+}
+/** One phase of a multi-turn `_meta.pipeline` run: each phase is a single LLM
+ *  turn whose reply becomes context for the next. */
+export type ApartePipelinePhase = {
+    mode: 'text';
+    system: string;
+} | {
+    mode: 'thinking';
+    system: string;
+    label?: string;
+} | {
+    mode: 'artifact';
+    system: string;
+    mimeType: string;
+    kind: string;
+};
+/** A `{ mimeType, kind }` artifact hint for the `_meta` artifact modes. */
+export interface AparteArtifactHint {
+    mimeType: string;
+    kind: string;
+}
+/**
+ * Well-known keys of {@link AparteChatRequest._meta}, typed for discoverability.
+ * The index signature keeps it an open channel for consumer-specific context.
+ * None of these reach the provider — they're stripped before the network call.
+ */
+export interface AparteRequestMeta {
+    /** Multi-phase run — each phase is one LLM turn; reply N is context for N+1. */
+    pipeline?: ApartePipelinePhase[];
+    /** Segments injected into the bubble before streaming (e.g. a plan thinking block). */
+    prefixSegments?: AparteSegment[];
+    /** Promote the first code fence in the reply to an artifact (for small models that ignore `<artifact>` XML). */
+    artifactHint?: AparteArtifactHint;
+    /** Treat the WHOLE reply as a raw artifact of this kind. */
+    artifactRaw?: AparteArtifactHint;
+    /** Parse an `<artifact>` XML block of this kind out of the stream. */
+    artifactXml?: AparteArtifactHint;
+    /** Consumer-specific context (open channel). */
+    [key: string]: unknown;
+}
+/**
+ * Token usage reported by the AI provider after a completed response.
+ */
+export interface AparteUsage {
+    /** Tokens in the prompt / conversation history sent to the model */
+    inputTokens: number;
+    /** Tokens generated by the model */
+    outputTokens: number;
+    /** Total tokens (inputTokens + outputTokens). Populated when the provider reports it. */
+    totalTokens?: number;
+    /** Tokens read from the provider's prompt cache (Anthropic, OpenAI). */
+    cacheReadTokens?: number;
+    /** Wall-clock generation time in milliseconds (provider-measured). Used to compute tokens/sec. */
+    durationMs?: number;
+    /** Time to first token in ms — the prefill / TTFT phase. */
+    ttftMs?: number;
+    /** Decode-phase wall time in ms (≈ durationMs − ttftMs). */
+    decodeMs?: number;
+    /** Tokens emitted during the decode phase (outputTokens minus the first). */
+    decodeTokens?: number;
+    /** Total turn wall-clock time in ms, measured client-side across all phases. */
+    wallMs?: number;
+    /** Id of the model / aparteni that produced this response. */
+    modelId?: string;
+    /** Compute device used for this response ('webgpu' | 'wasm' | …). */
+    device?: string;
+    /**
+     * Per-call breakdown when a single turn used several provider calls
+     * (e.g. a tool-use round-trip or an aparteni hot-swap). Absent for a plain
+     * single-call turn. Each entry is the AparteUsage of one provider call.
+     */
+    phases?: AparteUsage[];
+}
+/**
+ * Normalized stream event map — extensible via declaration merging.
+ *
+ * @example
+ * // In a plugin or app:
+ * declare module '@aparte/core' {
+ *   interface AparteStreamEventMap {
+ *     tool_call: { name: string; arguments: string }
+ *   }
+ * }
+ */
+export interface AparteStreamEventMap {
+    text: {
+        delta: string;
+    };
+    thinking: {
+        delta: string;
+    };
+    /** Emitted when the stream ends. May carry token usage reported by the provider. */
+    done: {
+        usage?: AparteUsage;
+    };
+    error: {
+        message: string;
+    };
+    tool_use: AparteToolCall;
+}
+/** Discriminated union derived from AparteStreamEventMap — stays in sync automatically. */
+export type AparteStreamEvent = {
+    [K in keyof AparteStreamEventMap]: {
+        type: K;
+    } & AparteStreamEventMap[K];
+}[keyof AparteStreamEventMap];
+export type AparteChatResponse = ReadableStream<AparteStreamEvent> | string;
+//# sourceMappingURL=chat.d.ts.map

package/dist/types/chat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat.d.ts","sourceRoot":"","sources":["../../src/types/chat.ts"],"names":[],"mappings":"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"}

package/dist/types/errors.d.ts

@@ -0,0 +1,25 @@
+export declare enum AparteErrorCode {
+    CONFIG_NO_PROVIDER = "CONFIG_NO_PROVIDER",
+    CONFIG_MISSING_KEY = "CONFIG_MISSING_KEY",
+    CONFIG_INVALID_MODEL = "CONFIG_INVALID_MODEL",
+    USAGE_RATE_LIMIT = "USAGE_RATE_LIMIT",// HTTP 429
+    USAGE_CONTEXT_EXCEEDED = "USAGE_CONTEXT_EXCEEDED",// HTTP 400
+    USAGE_BAD_REQUEST = "USAGE_BAD_REQUEST",// HTTP 400
+    NET_OFFLINE = "NET_OFFLINE",
+    NET_TIMEOUT = "NET_TIMEOUT",
+    NET_ERROR = "NET_ERROR",
+    PROVIDER_ERROR = "PROVIDER_ERROR",// HTTP 5xx
+    PROVIDER_UNAVAILABLE = "PROVIDER_UNAVAILABLE",// HTTP 503
+    PROVIDER_POLICY = "PROVIDER_POLICY",// Moderation / Policy
+    UNKNOWN_ERROR = "UNKNOWN_ERROR"
+}
+export declare class AparteError extends Error {
+    message: string;
+    code: AparteErrorCode;
+    data?: Record<string, unknown> | undefined;
+    originalError?: unknown | undefined;
+    httpStatus?: number | undefined;
+    constructor(message: string, code: AparteErrorCode, data?: Record<string, unknown> | undefined, originalError?: unknown | undefined, httpStatus?: number | undefined);
+    static from(error: unknown, defaultCode?: AparteErrorCode, defaultStatus?: number): AparteError;
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/types/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/types/errors.ts"],"names":[],"mappings":"AACA,oBAAY,eAAe;IAEvB,kBAAkB,uBAAuB;IACzC,kBAAkB,uBAAuB;IACzC,oBAAoB,yBAAyB;IAG7C,gBAAgB,qBAAqB,CAAQ,WAAW;IACxD,sBAAsB,2BAA2B,CAAE,WAAW;IAC9D,iBAAiB,sBAAsB,CAAM,WAAW;IAGxD,WAAW,gBAAgB;IAC3B,WAAW,gBAAgB;IAC3B,SAAS,cAAc;IAGvB,cAAc,mBAAmB,CAAY,WAAW;IACxD,oBAAoB,yBAAyB,CAAE,WAAW;IAC1D,eAAe,oBAAoB,CAAU,sBAAsB;IAGnE,aAAa,kBAAkB;CAClC;AAED,qBAAa,WAAY,SAAQ,KAAK;IAEd,OAAO,EAAE,MAAM;IACxB,IAAI,EAAE,eAAe;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC9B,aAAa,CAAC,EAAE,OAAO;IACvB,UAAU,CAAC,EAAE,MAAM;gBAJV,OAAO,EAAE,MAAM,EACxB,IAAI,EAAE,eAAe,EACrB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,YAAA,EAC9B,aAAa,CAAC,EAAE,OAAO,YAAA,EACvB,UAAU,CAAC,EAAE,MAAM,YAAA;IAM9B,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,WAAW,kBAAgC,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,WAAW;CAUhH"}

package/dist/types/event-map.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Global typing for aparté custom events. Once `@aparte/core` is in a consumer's
+ * TypeScript program, `element.addEventListener('aparte-retry', e => e.detail)`
+ * types `e` as `CustomEvent<AparteRetryEventDetail>` with a typed `e.detail` — no
+ * manual `(e as CustomEvent<…>).detail` cast.
+ *
+ * Covers the public bubble / lifecycle / artifact / tool events whose detail type
+ * lives in the types layer. Internal component/primitive events (composer-submit,
+ * select-change, optgroup-toggle, …) intentionally fall back to the DOM's default
+ * `Event` — they carry no cross-package detail contract.
+ *
+ * All names are kebab-case (`aparte-*`) so every framework can bind them in a
+ * template (Angular parses a `:` in an event name as a `target:event` selector,
+ * so a colon name could never be `(aparte:x)`-bound there).
+ */
+import type { AparteSendEventDetail, AparteRetryEventDetail, AparteEditEventDetail, AparteActionEventDetail, ApartePathChangedEventDetail, AparteBranchNavigateEventDetail, AparteFeedbackEventDetail, AparteMessageInfoEventDetail, AparteMessageDoneEventDetail, AparteModelChangeEventDetail, AparteArtifactStartEventDetail, AparteArtifactDeltaEventDetail, AparteArtifactReadyEventDetail, AparteArtifactOpenEventDetail } from './events.js';
+import type { AparteToolDecisionDetail, AparteToolApprovalRequestDetail } from './tools.js';
+import type { AparteComposerChangeEventDetail } from '../components/composer/aparte-composer.js';
+declare global {
+    interface HTMLElementEventMap {
+        'aparte-send': CustomEvent<AparteSendEventDetail>;
+        'aparte-retry': CustomEvent<AparteRetryEventDetail>;
+        'aparte-edit': CustomEvent<AparteEditEventDetail>;
+        'aparte-action': CustomEvent<AparteActionEventDetail>;
+        'aparte-path-changed': CustomEvent<ApartePathChangedEventDetail>;
+        'aparte-branch-navigate': CustomEvent<AparteBranchNavigateEventDetail>;
+        'aparte-feedback': CustomEvent<AparteFeedbackEventDetail>;
+        'aparte-message-info': CustomEvent<AparteMessageInfoEventDetail>;
+        'aparte-message-done': CustomEvent<AparteMessageDoneEventDetail>;
+        'aparte-model-change': CustomEvent<AparteModelChangeEventDetail>;
+        'aparte-artifact-start': CustomEvent<AparteArtifactStartEventDetail>;
+        'aparte-artifact-delta': CustomEvent<AparteArtifactDeltaEventDetail>;
+        'aparte-artifact-ready': CustomEvent<AparteArtifactReadyEventDetail>;
+        'aparte-artifact-open': CustomEvent<AparteArtifactOpenEventDetail>;
+        'aparte-tool-decision': CustomEvent<AparteToolDecisionDetail>;
+        'aparte-tool-approval-request': CustomEvent<AparteToolApprovalRequestDetail>;
+        'aparte-composer-change': CustomEvent<AparteComposerChangeEventDetail>;
+    }
+}
+export {};
+//# sourceMappingURL=event-map.d.ts.map