@leuduan/lagent 0.0.0-stage → 44.0.0

package/dist/journal/store.d.ts

@@ -0,0 +1,181 @@
+import type { JournalEvent, Seq, ThreadSummary } from '../records/journal.js';
+/**
+ * One group's write: a fresh identity, the head it was numbered from, the writer's acquisition, and
+ * the rows. Immutable once made, so a write whose answer was lost can be sent again as it was.
+ */
+export type Attempt = {
+    readonly id: string;
+    readonly baseHead: Seq;
+    readonly writer: string;
+    readonly rows: readonly JournalEvent[];
+};
+/** What an append did: wrote the rows, or found the same attempt already written and wrote nothing. */
+export type AppendOutcome = 'appended' | 'duplicate';
+/** One thread as the store indexes it, from its rows alone: where it began and how far it reaches. */
+export type ThreadIndexEntry = {
+    readonly threadId: string;
+    readonly spawnSeq: Seq;
+    readonly lastSeq: Seq;
+};
+/**
+ * The right to append: exclusive while held, with an acquisition id the store checks inside every
+ * append, so rows from a writer that lost the lease are refused rather than detected afterwards.
+ */
+export type WriterLease = {
+    /** What the lease is held on, for messages. */
+    readonly identity: string;
+    readonly acquisitionId: string;
+    release(): Promise<void>;
+};
+/**
+ * Durable backing for the journal: the rows, one thread at a time, an index of the threads, the
+ * catalog of summaries beside them, and the record of who may write. Every method is asynchronous,
+ * so a store across a network implements the same contract as SQLite; the conformance suite
+ * (`stores/testing/conformance.ts`) is what every store passes.
+ *
+ * `append` must be durable enough that a crash after it resolves still replays the rows, because
+ * nothing else records them. That is also why `read` refuses a row it cannot parse rather than
+ * skipping it: the conversation is derived from these rows, so a dropped one rewrites history.
+ *
+ * The catalog is written after the rows, by the journal, from folds that hold only durable rows; it
+ * can trail the rows by one group after a crash, and the thread index — kept in the append's own
+ * transaction — is how the journal finds the summaries to refresh when it opens.
+ */
+export declare abstract class JournalStore {
+    private opened;
+    get isOpen(): boolean;
+    /** Initializes resources and loads persisted state; idempotent. */
+    open(): Promise<void>;
+    /** Releases resources; idempotent. */
+    close(): Promise<void>;
+    /**
+     * Takes the writer lease, refused with {@link JournalBusyError} while another holds it. May be
+     * called before `open()`: a store whose exclusivity comes from the operating system takes it before
+     * reading anything.
+     */
+    abstract acquireWriter(): Promise<WriterLease>;
+    /** The highest `seq` the store holds; 0 when it holds nothing. */
+    head(): Promise<Seq>;
+    /**
+     * Writes an attempt's rows as one unit — all of them survive a crash or none do — and indexes
+     * their thread, in one transaction, checked against three things in that transaction:
+     *
+     * - an attempt with this id already written is `duplicate` when its content — head, writer and
+     *   rows — is the same, and {@link AttemptMismatchError} when it is not, before anything else is
+     *   checked, so a resend after the head or the writer moved on is still recognized; an attempt's
+     *   identity is kept as long as its rows;
+     * - the writer record must name `attempt.writer`, else {@link WriterLostError};
+     * - the head must still be `attempt.baseHead`, else {@link JournalConflictError}.
+     *
+     * The rows are one thread's, in ascending seq order above `baseHead` — consecutive as the journal
+     * writes them; a gap is allowed so a test can store a journal thinned on purpose — and a thread the
+     * index does not hold must begin with its spawn row. A thread has exactly one spawn row; a
+     * second is refused without writing any part of the attempt.
+     *
+     * A store that cannot tell whether a commit landed — a remote one whose answer was lost, say —
+     * should say so with a typed ambiguous failure: the journal can then send the same attempt again,
+     * and a `duplicate` answer proves the rows are durable, though not that this process still holds
+     * the writer lease. Neither shipped store can lose an answer, so the journal has no such resend
+     * yet; it is built with the store that needs it.
+     */
+    append(attempt: Attempt): Promise<AppendOutcome>;
+    /** One thread's own rows, in `seq` order. A fork's source is read whole; the journal bounds the lineage. */
+    read(threadId: string): Promise<JournalEvent[]>;
+    /** The row at `seq`, whichever thread it belongs to. */
+    rowAt(seq: Seq): Promise<JournalEvent | undefined>;
+    /** Every thread the store holds, in spawn order: one entry per thread, whatever the journal's length. */
+    threads(): Promise<ThreadIndexEntry[]>;
+    /** Every summary the catalog holds, in spawn order. */
+    summaries(): Promise<ThreadSummary[]>;
+    /**
+     * Writes summaries, each replacing its thread's unless the stored one already describes more of
+     * the thread (a higher `through_seq`): a late write never undoes a newer one. Checked against the
+     * writer record as an append is, else {@link WriterLostError}.
+     */
+    putSummaries(summaries: readonly ThreadSummary[], writer: string): Promise<void>;
+    /** Replaces the whole catalog in one transaction: a rebuild's write, checked against the writer record. */
+    replaceCatalog(summaries: readonly ThreadSummary[], writer: string): Promise<void>;
+    protected abstract doOpen(): Promise<void>;
+    protected abstract doClose(): Promise<void>;
+    protected abstract doHead(): Promise<Seq>;
+    /** Implements {@link append}'s checks and write in one transaction; `digest` identifies the content. */
+    protected abstract doAppend(attempt: Attempt, digest: string): Promise<AppendOutcome>;
+    protected abstract doRead(threadId: string): Promise<JournalEvent[]>;
+    protected abstract doRowAt(seq: Seq): Promise<JournalEvent | undefined>;
+    protected abstract doThreads(): Promise<ThreadIndexEntry[]>;
+    protected abstract doSummaries(): Promise<ThreadSummary[]>;
+    protected abstract doPutSummaries(summaries: readonly ThreadSummary[], writer: string): Promise<void>;
+    protected abstract doReplaceCatalog(summaries: readonly ThreadSummary[], writer: string): Promise<void>;
+    /**
+     * The event as it stands.
+     *
+     * Nothing is normalized and nothing is dropped for size: a row that reads back differently from
+     * the event in memory makes a live process and a resumed one disagree about their own history,
+     * and the fields most able to disagree are the ones this engine does not model — what a provider
+     * needs back verbatim and the arguments the model sent a tool, neither of which has a schema to
+     * restore what a tidy-up removed. `llm/request` records the prompt as a size and digest precisely
+     * so that no row ever has to be trimmed.
+     */
+    protected serialize(event: JournalEvent): string;
+    protected serializeSummary(summary: ThreadSummary): string;
+    private requireOpen;
+}
+/** The content identity of a whole attempt — head, writer and rows: what tells a resent attempt from a different one with the same id. */
+export declare function digestOf(attempt: Pick<Attempt, 'baseHead' | 'writer' | 'rows'>): string;
+export declare class JournalBusyError extends Error {
+    readonly location: string;
+    constructor(location: string);
+}
+/**
+ * A write that waited its whole budget for another connection's write lock on the store, a shell or
+ * a backup say, and gave up. Nothing of it was written.
+ */
+export declare class StoreBusyError extends Error {
+    readonly location: string;
+    readonly waitedMs: number;
+    constructor(location: string, waitedMs: number);
+}
+/** An append numbered from a head the store has moved past: another writer, or a lost answer resent as new rows. */
+export declare class JournalConflictError extends Error {
+    readonly expected: Seq;
+    readonly actual: Seq;
+    constructor(expected: Seq, actual: Seq);
+}
+/** An append by a writer the store's record no longer names: its lease was taken by another. */
+export declare class WriterLostError extends Error {
+    readonly acquisitionId: string;
+    constructor(acquisitionId: string);
+}
+/** An attempt id already written with other rows: two different writes under one identity. */
+export declare class AttemptMismatchError extends Error {
+    readonly attemptId: string;
+    constructor(attemptId: string);
+}
+/** A journal row that cannot be parsed by this build. */
+export declare class CorruptJournalError extends Error {
+    readonly payload: string;
+    readonly cause: unknown;
+    constructor(payload: string, cause: unknown);
+}
+/** Parses one stored row; `shape` turns the parsed payload into the event's wire form when the store keeps it in parts. */
+export declare function parseStoredEvent(payload: string, shape?: (stored: unknown) => unknown): JournalEvent;
+export declare function parseStoredSummary(payload: string): ThreadSummary;
+/**
+ * The journal format this build reads and writes. Bump it whenever the event alphabet or storage
+ * layout changes; a populated journal stamped with anything else is refused rather than partially read.
+ * A breaking change to persisted rows bumps it too, a plugin's extension row version bump included.
+ * Indexes enforcing existing invariants do not change the format.
+ */
+export declare const JOURNAL_VERSION = 44;
+/** A journal written by a build whose format this one cannot read. */
+export declare class IncompatibleJournalError extends Error {
+    readonly found: number;
+    readonly location: string;
+    constructor(found: number, location: string);
+}
+/**
+ * Judges a journal's version stamp on open. An empty journal is adopted whatever it says, and
+ * anything else holding rows is refused, because half a conversation is worse than none. A journal
+ * with no stamp at all reads as `0`.
+ */
+export declare function checkJournalVersion(stamped: number, hasRows: boolean, location: string): void;

package/dist/llm/client.d.ts

@@ -0,0 +1,135 @@
+import type { ConversationMessage, JsonObject, LLMStreamChunk, ModelResponse, ThinkingEffort } from './primitives.js';
+import type { ModelRequest } from './request.js';
+/** A model a provider offers to route selection, in the order the provider prefers them. */
+export interface ModelOption {
+    readonly id: string;
+    /** When to pick it, written for a model choosing a route: cost, speed, strengths. */
+    readonly description?: string;
+    /** The efforts it accepts, when declared. Absent means unspecified, not unrestricted. */
+    readonly thinkingEfforts?: readonly ThinkingEffort[];
+}
+/**
+ * What a provider can carry for one model, as `LLMProvider.capacity` declares it and `ctx.llm`
+ * answers it for a route. A declaration, like the told model list, never discovered from the
+ * provider at run time.
+ */
+export interface ModelCapacity {
+    /**
+     * The usable context window in tokens, or `null` when the provider declares none for the model.
+     * Shipped figures are the conservative ones a provider documents, so a consumer that trusts them
+     * errs early, never late.
+     */
+    readonly contextWindow: number | null;
+    /** Whether a request may carry provider-executed tools (`ModelRequest.providerTools`). */
+    readonly providerTools: boolean;
+    /**
+     * Whether a tool result may carry an image part: the adapter sends one and the provider accepts
+     * it. A tool that can answer with an image or in words, as `read_file` can, asks this of the route
+     * its result goes to; a thread that later moves to a route without it still sends the image it
+     * already has, and that request fails.
+     */
+    readonly toolResultImages: boolean;
+}
+/**
+ * A streamed model response: iterate for deltas, then `completed()` for what came back. A response
+ * is read once, by these rules, which an implementation enforces and a consumer may rely on.
+ * - It is iterated at most once. The read is claimed when the iterator is acquired, not at its first
+ *   `next()`, and a second `[Symbol.asyncIterator]()` throws.
+ * - `completed()` on a response nobody has read drains it, publishing nothing, and settles.
+ * - Once the read has ended, whether it ran through, its reader stopped it early (`return`) or it
+ *   failed, `completed()` returns or throws that read's outcome: a reader that left gets what
+ *   arrived as a cut-off reply, a failed read throws its failure again. The outcome is fixed when the
+ *   read ends: a cancel afterwards changes nothing.
+ * - A read ended by the caller's own cancellation (its request's abort, by the reason the signal
+ *   carries) is a cut-off, never a failure: iteration ends without throwing, and `completed()`
+ *   returns what arrived with finish `other`. A failure that only coincided with a cancel stays
+ *   the failure. This is the read only: a request cancelled before a stream exists is refused,
+ *   as `chat()` rejects with the caller's reason.
+ * - While a read is under way, from acquiring the iterator (before its first `next()` too) until it
+ *   ends, `completed()` throws rather than settle a partial. A read ends only when its last
+ *   operation, a `next` or a `return` or `throw` asked for and not yet settled, has finished; a
+ *   `next()` after a `return()` or `throw()` ends without reading.
+ */
+export type StreamingLLMResponse = AsyncIterable<LLMStreamChunk> & {
+    completed(): Promise<ModelResponse>;
+};
+/** What a model provider's client implements; a provider is offered with `registerProvider(ctx, provider, { retry })`. */
+export interface LLMClient {
+    readonly providerName: string;
+    chat(request: ModelRequest): Promise<StreamingLLMResponse>;
+    /** Optional owned transport cleanup; sessions never dispose an injected client override. */
+    dispose?(): void | Promise<void>;
+}
+/** A provider was asked for something it cannot do. Thrown, never silently dropped. */
+export declare class ProviderUnsupportedError extends Error {
+    readonly provider: string;
+    readonly feature: string;
+    constructor(provider: string, feature: string);
+}
+/**
+ * The provider refused or failed a request for exceeding the model's context window.
+ *
+ * Each provider classifies its own, from a rejected request and from a failure inside the stream,
+ * by the structured code where it has one and by its message's wording only where it has none. It
+ * carries no token count, by rule: providers state counts only in prose, if at all, and a number
+ * read from prose whose format may change is not a measurement. The provider's own error is the
+ * `cause`, so its text still reaches the journal. A failure the provider does not classify stays
+ * the error it was. A class of its own so the engine can tell this failure from every other one,
+ * as the one a shorter request can cure.
+ */
+export declare class ContextOverflowError extends Error {
+    readonly provider: string;
+    constructor(provider: string, options: {
+        cause: unknown;
+    });
+}
+/**
+ * Why a response could not be settled: `transport`, the stream ended without the provider's own
+ * evidence that the response was complete; `empty`, it completed with no text and no tool call;
+ * `length`, it had no text and no tool call because the output cap cut it (a reasoning-only reply,
+ * which a repeat would repeat); `other`, it had none for another reason the provider gave, such as a
+ * content filter; `invalid`, it settled but cannot be acted on, as when two of its calls share an id.
+ */
+export type ResponseSettlementKind = 'transport' | 'empty' | 'length' | 'other' | 'invalid';
+/**
+ * A response that cannot be taken as an answer: one the provider never finished, or finished with
+ * nothing, which an adapter's `completed()` throws (never iteration); or one the loop cannot act on,
+ * `invalid`, which the loop throws itself for any client once `completed()` returned.
+ *
+ * Each adapter decides from its provider's terminal evidence, never from a reader that stopped
+ * early: a stream its reader abandoned, or whose request was aborted, still reports what it got,
+ * as a cut-off reply. `partial` is what arrived on a `transport` or `invalid` failure — its text and
+ * reasoning, never a tool call or `provider_state` — and `null` on an `empty` one. The message starts with the
+ * kind, so the journal's error text says which it was.
+ */
+export declare class ResponseSettlementError extends Error {
+    readonly provider: string;
+    readonly kind: ResponseSettlementKind;
+    readonly partial: ConversationMessage | null;
+    readonly providerMetadata: JsonObject;
+    constructor(provider: string, kind: ResponseSettlementKind, partial: ConversationMessage | null, providerMetadata: JsonObject, detail: string);
+}
+/**
+ * A response stream that went `idleMs` without a single event from the provider: the idle deadline
+ * of one attempt, which the engine classifies as `timeout`. It bounds the wait for the first event
+ * too, from the moment the request was sent.
+ */
+export declare class StreamIdleError extends Error {
+    readonly provider: string;
+    readonly idleMs: number;
+    constructor(provider: string, idleMs: number);
+}
+/**
+ * A stream that failed while it was being read, after it had produced output: what arrived (text and
+ * reasoning, never a tool call or `provider_state`), and the failure itself as `cause`, so a reset
+ * after visible text still leaves that text on record. A stream that failed before producing
+ * anything throws its failure unwrapped.
+ */
+export declare class ResponseInterruptedError extends Error {
+    readonly provider: string;
+    readonly partial: ConversationMessage;
+    readonly providerMetadata: JsonObject;
+    constructor(provider: string, partial: ConversationMessage, providerMetadata: JsonObject, options: {
+        cause: unknown;
+    });
+}

package/dist/llm/content.d.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import type { DeepReadonly } from '../util/json.js';
+export declare const ContentPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"image">;
+    url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    detail: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        low: "low";
+        high: "high";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"file">;
+    file_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    filename: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>], "type">;
+export type ContentPart = z.infer<typeof ContentPartSchema>;
+/** A part as a caller writes one, with the fields the schema defaults left out. */
+export type ContentPartInput = z.input<typeof ContentPartSchema>;
+export type ContentPartKind = ContentPart['type'];
+/** Accepts what a caller writes — a string, nothing, or parts — and yields parts. */
+export declare const ContentSchema: z.ZodPreprocess<z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"image">;
+    url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    detail: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        low: "low";
+        high: "high";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"file">;
+    file_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    filename: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>], "type">>>, unknown>;
+export declare const textPart: (text: string) => ContentPart;
+/** The text of a content list, parts joined. Non-text parts are not text and do not appear. */
+export declare const contentText: (content: readonly DeepReadonly<ContentPart>[]) => string;

package/dist/llm/failure.d.ts

@@ -0,0 +1,82 @@
+/**
+ * One vocabulary for how a model call failed, and the one place a failure is given its kind.
+ *
+ * A kind decides whether `ctx.llm` retries a call and informs a host's rerun policy; it does not prove
+ * a rerun is safe. A cancellation is never a failure kind.
+ */
+import { z } from 'zod';
+import type { StreamingLLMResponse } from './client.js';
+import type { LLMProvider } from './provider.js';
+import type { ModelRequest } from './request.js';
+/**
+ * How a model call failed. `transport`, `empty`, `length` and `invalid` come from settlement and the
+ * loop; `overflow` from a `ContextOverflowError`; the rest from the provider's `classify`. Unknown is
+ * `other`.
+ */
+export declare const FAILURE_KINDS: readonly ["rate_limit", "overloaded", "transport", "timeout", "empty", "length", "invalid", "auth", "quota", "overflow", "other"];
+export type FailureKind = (typeof FAILURE_KINDS)[number];
+export declare const FailureKindSchema: z.ZodEnum<{
+    length: "length";
+    other: "other";
+    transport: "transport";
+    empty: "empty";
+    invalid: "invalid";
+    rate_limit: "rate_limit";
+    overloaded: "overloaded";
+    timeout: "timeout";
+    auth: "auth";
+    quota: "quota";
+    overflow: "overflow";
+}>;
+/**
+ * What a provider's `classify` says of a failure it was handed: its kind, and how long the provider
+ * asked the caller to wait, read only from structured fields (a header), never from prose.
+ */
+export type FailureClassification = {
+    kind: FailureKind;
+    retryAfterMs?: number;
+};
+/**
+ * A failed model call, as `ctx.llm`'s clients throw it: the provider, the kind, how many times the
+ * client was called for it, the wait the provider asked for, and the adapter's own error as `cause`.
+ * Its kind is the one authority inside the engine; the typed adapter errors are evidence for it. Its
+ * message is the cause's, so the journal's error text stays the provider's prose; the kind is a field.
+ */
+export declare class ModelCallError extends Error {
+    readonly provider: string;
+    readonly kind: FailureKind;
+    readonly attempts: number;
+    readonly retryAfterMs: number | null;
+    constructor(provider: string, kind: FailureKind, attempts: number, retryAfterMs: number | null, options: {
+        cause: unknown;
+    });
+}
+/**
+ * One model call through `ctx.llm`, handed back before it opens: its response, and how many times
+ * the provider's client has been called for it so far, whatever becomes of it, a refusal or a
+ * cancellation included.
+ */
+export interface ModelCallHandle {
+    readonly response: Promise<StreamingLLMResponse>;
+    readonly attempts: number;
+}
+/**
+ * A client from `ctx.llm`: it retries a failed call by its provider's policy and throws
+ * `ModelCallError` for one that still fails.
+ */
+export interface ModelCallClient {
+    readonly providerName: string;
+    /** Starts one call; the handle is the caller's to keep for its attempt count. */
+    call(request: ModelRequest): ModelCallHandle;
+}
+/**
+ * The kind of a failure from `provider`'s client, from typed evidence first: a settlement failure
+ * keeps its kind, a `ContextOverflowError` is `overflow`, a `StreamIdleError` is `timeout`. Only what neither says reaches the
+ * provider's `classify` (a stream interrupted after output is classified by its cause), so a provider
+ * written from scratch cannot get overflow or settlement wrong. What `classify` returns is checked
+ * before the journal sees it: a kind outside {@link FAILURE_KINDS}, or a `classify` that throws, is
+ * `other`, and a wait that is not a finite, nonnegative number is no wait (a fraction rounds up).
+ */
+export declare function classifyFailure(provider: LLMProvider, error: unknown): FailureClassification;
+/** The first `type` in `error`'s `cause` chain, itself included; middleware may wrap what was thrown. */
+export declare function findCause<T extends Error>(error: unknown, type: abstract new (...args: never[]) => T): T | undefined;

package/dist/llm/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `@leuduan/lagent/llm`: the model and provider contracts as the package offers them, for a provider
+ * written outside it and a host that calls a model. Every type the contract mentions, and the values
+ * a consumer uses; the schemas and helpers the engine uses itself stay in their modules, which the
+ * package imports directly.
+ *
+ * It depends on `zod` alone, so a provider client built on it works in any harness.
+ */
+export { ContextOverflowError, ProviderUnsupportedError, ResponseInterruptedError, ResponseSettlementError, StreamIdleError, } from './client.js';
+export type { LLMClient, ModelCapacity, ModelOption, ResponseSettlementKind, StreamingLLMResponse } from './client.js';
+export { contentText } from './content.js';
+export { ModelCallError } from './failure.js';
+export type { FailureClassification, FailureKind, ModelCallClient, ModelCallHandle } from './failure.js';
+export type { DeepReadonly, ReadonlyJsonValue } from '../util/json.js';
+export type { ContentPart, ContentPartInput, ContentPartKind } from './content.js';
+export { conversationMessage, LLMStreamChunkSchema, messageText, ThinkingEffortSchema } from './primitives.js';
+export type { ConversationMessage, JsonObject, LLMStreamChunk, LLMUsage, MalformedToolCall, MessageRole, ModelResponse, ParsedToolCall, ProviderCall, ProviderState, ResponseFinish, ThinkingEffort, ToolCall, ToolSpec, } from './primitives.js';
+export { renderPromptBlocks } from './prompt.js';
+export type { PromptBlock } from './prompt.js';
+export { defaultRoute } from './provider.js';
+export type { LLMProvider, ModelRoute } from './provider.js';
+export type { ModelRequest, RequestPurpose, ResponseFormat, ToolChoice } from './request.js';

package/dist/llm/index.js

@@ -0,0 +1 @@
+import{b as m,e as l}from"../chunks/G44LG6VL.js";import{A as d,d as r,f as e,o,q as t,r as n,u as p,v as s,w as f,x as a,y as x}from"../chunks/D4PQP5MA.js";export{s as ContextOverflowError,o as LLMStreamChunkSchema,l as ModelCallError,p as ProviderUnsupportedError,x as ResponseInterruptedError,f as ResponseSettlementError,a as StreamIdleError,e as ThinkingEffortSchema,r as contentText,t as conversationMessage,m as defaultRoute,n as messageText,d as renderPromptBlocks};