@leuduan/lagent 0.0.0-stage → 44.0.0

package/dist/providers/stream.d.ts

@@ -0,0 +1,156 @@
+import { z } from 'zod';
+import { StreamIdleError } from '../llm/client.js';
+import type { ConversationMessage, JsonObject, LLMStreamChunk, ModelResponse, ToolCall } from '../llm/primitives.js';
+import type { ModelRequest } from '../llm/request.js';
+import type { StreamingLLMResponse } from '../llm/client.js';
+/**
+ * How long one attempt may go without a single event from the provider, waiting for the first
+ * included, before it fails as `timeout`; `null` disables the deadline. Required: it is transport
+ * configuration, and a reasoning model that streams no reasoning needs a long one, or none.
+ */
+export declare const StreamIdleTimeoutSchema: z.ZodNullable<z.ZodNumber>;
+/**
+ * A tool call with its arguments as a provider hands them over: already an object, or JSON still in
+ * a string. Absent or empty arguments are an empty object. Anything that is not a JSON object is kept
+ * as the model sent it, malformed, so its call alone is answered with an error and its siblings run.
+ */
+export declare function toolCall(callId: string, name: string, value: unknown): ToolCall;
+/**
+ * Runs `work` with the idle deadline of the attempt whose transport is opening held: work the
+ * transport does on the attempt's behalf with a bound of its own, such as reading or recovering
+ * credentials, is not provider silence. Outside an attempt it runs `work` as it is.
+ */
+export declare function holdDeadline<T>(work: () => Promise<T>): Promise<T>;
+/**
+ * One attempt's lifetime, made before its transport opens: the controller its SDK call is handed
+ * (aborted with the request's signal, or when the deadline passes), the idle timer, and their
+ * cleanup. The timer starts when the request is sent and resets on every raw provider event the
+ * stream sees (`events`), including events the adapter drops, since reasoning can be visibly silent;
+ * it is held while the transport works on the attempt's behalf (`holdDeadline`). Expiry is recorded
+ * before the controller aborts, so a read that ends afterwards, by an SDK abort error or quietly, is
+ * told from the caller's own cancel; nothing the transport delivers after expiry is read. The
+ * caller's cancel clears the deadline: a cancelled attempt never times out.
+ */
+export declare class AttemptLifetime {
+    private readonly controller;
+    /** What `close()` aborts with, kept so the read it ends can tell it from a failure of the transport. */
+    private readonly closure;
+    private timer;
+    private expiredAt;
+    private holds;
+    private readonly forward;
+    private readonly provider;
+    private readonly requestSignal;
+    private readonly idleMs;
+    constructor(provider: string, requestSignal: AbortSignal | undefined, idleMs: number | null);
+    /** Runs `open` as this attempt's: what it calls can hold the deadline (`holdDeadline`). */
+    opening<T>(open: () => Promise<T>): Promise<T>;
+    /** Stops the deadline until as many `release`s as `hold`s have been made. */
+    hold(): void;
+    release(): void;
+    /** What the attempt's SDK call is given: aborted by the caller's cancel or the deadline. */
+    get signal(): AbortSignal;
+    /** Whether the deadline passed before the attempt ended. */
+    get expired(): boolean;
+    /** The failure an expired attempt reports. */
+    idleError(): StreamIdleError;
+    /**
+     * `source`, resetting the deadline on every event it yields, and ending without another once the
+     * deadline passed: an event that arrives after expiry, terminal evidence included, is not read.
+     */
+    events<T>(source: AsyncIterable<T>): AsyncGenerator<T>;
+    /**
+     * Ends the attempt for a reader that closed its stream: aborts the controller the SDK was handed,
+     * which closes the transport, then disposes. Without the abort an unread response would hold its
+     * connection open, and nothing would close it once the caller's signal is no longer followed.
+     */
+    close(): void;
+    /**
+     * Whether `error` is the abort `close()` raised: a transport read through `fetch` fails with its
+     * abort's reason, so a reader that leaves would otherwise end its own read as a failure.
+     */
+    closedBy(error: unknown): boolean;
+    /** Clears the timer and stops following the request's signal; safe to call more than once. */
+    dispose(): void;
+    private clearTimer;
+    private arm;
+}
+/**
+ * What an owner of a protocol client adds to every call it sends: headers for one call, over the
+ * client's own. It receives the call and the request the client mapped from it, so a header can
+ * derive from either; nothing rebuilds the request for it.
+ */
+export type CallHeaders = (call: ModelRequest, request: Readonly<Record<string, unknown>>) => Record<string, string>;
+/**
+ * Opens one attempt, the one place an adapter creates, ends and classifies it: the lifetime is made
+ * before `open` runs, so its deadline bounds the wait for the first event too, and `open` gets the
+ * signal its transport must carry. When `open` fails the lifetime is disposed, and the failure is
+ * the deadline's `StreamIdleError` if the deadline passed (the caller's own cancel clears the
+ * deadline, so a cancel never reads as a timeout), else `classify(error)`, which names a
+ * cancellation and a provider's overflow as the engine recognises them. On success the lifetime stays
+ * live for the stream that reads `opened`.
+ */
+export declare function openAttempt<T>(provider: string, requestSignal: AbortSignal | undefined, idleMs: number | null, open: (signal: AbortSignal) => Promise<T>, classify: (error: unknown) => unknown): Promise<{
+    readonly lifetime: AttemptLifetime;
+    readonly opened: T;
+}>;
+/**
+ * The one enforcement of the reader rules `StreamingLLMResponse` states: a response is iterated at
+ * most once, `completed()` drains a response nobody has read and otherwise reports the outcome of
+ * the read that ended, and never settles while one is under way.
+ *
+ * A transport is consumed as it is read and a reader that stops early has already closed it, so only
+ * a stream nobody has touched can be drained; asking a consumed one for the rest returns what the
+ * read left rather than resuming, which would lose the whole message — including the text the reader
+ * had already seen. Everything a cut-off stream did say is accumulated by `read`.
+ *
+ * It owns one rule for every adapter: a response counts only once the provider said it was
+ * complete. A transport that ran to its end without saying so is a `transport` failure, and one that
+ * said so with no text and no tool call is an `empty` one (see {@link ResponseSettlementError}). A
+ * stream its reader stopped early, or whose request was aborted, is neither: the caller cut it off,
+ * and gets what arrived as a cut-off reply.
+ */
+export declare abstract class ReadOnceStream implements StreamingLLMResponse {
+    /** Whether the read is claimed: by the iterator, or by `completed()` draining. */
+    private claimed;
+    /** When the read has ended, whether it ran through, was stopped early or failed. */
+    private readonly ledger;
+    /** Whether the request was aborted when the read ended: fixed then, so a later abort changes nothing. */
+    private abortedAtEnd;
+    /** Whether the transport ran to its end, rather than its reader stopping or the read failing. */
+    private drained;
+    /** Whether its reader closed it early, before or while reading. */
+    private closedByReader;
+    /** The failure the read ended on, which `completed()` throws again rather than settling a partial. */
+    private readFailure;
+    protected readonly providerName: string;
+    protected readonly signal: AbortSignal | undefined;
+    private readonly lifetime;
+    protected constructor(providerName: string, signal: AbortSignal | undefined, lifetime: AttemptLifetime);
+    /**
+     * Claims the read, so a second iterator throws here and not at its first `next()`, and reads the
+     * transport through. When the attempt's deadline passed, the read's ending (an SDK abort error, or
+     * a quiet end) is that deadline's `StreamIdleError`, unless the provider's terminal evidence had
+     * already arrived: then the response stands, as complete as the provider said it was (Chat's usage,
+     * sent after the finish, may be missing). The lifetime ends with the read, however it ends, the
+     * reader abandoning it included.
+     */
+    [Symbol.asyncIterator](): AsyncIterator<LLMStreamChunk>;
+    private readThrough;
+    /** Whether `error` is the caller's own cancellation; a failure that only coincided with one is not. */
+    private cancelled;
+    /** `error`, with what arrived before it kept beside it. */
+    private interrupted;
+    /** Reads the transport through, accumulating whatever `settle` and `partial` will need. */
+    protected abstract read(): AsyncGenerator<LLMStreamChunk>;
+    /** The response, once the provider's terminal evidence arrived; `undefined` before that. */
+    protected abstract settle(): ModelResponse | undefined;
+    /** What arrived so far: text and reasoning only, never a tool call nobody finished asking for. */
+    protected abstract partial(): {
+        message: ConversationMessage;
+        providerMetadata: JsonObject;
+    };
+    /** Remembers the failure the read ended on, and returns it to be thrown. */
+    private failed;
+    completed(): Promise<ModelResponse>;
+}

package/dist/records/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `@leuduan/lagent/records`: the serialized contract, what a reader of the journal or a plugin writing
+ * rows needs. Journal rows, the types a row mentions, the helpers that read and write them and the
+ * JSON types they are written in. The Zod schemas, the tables the types derive from and the
+ * hand-written agent and prompt configuration stay in their modules, which the package imports
+ * directly.
+ */
+export { isForkSpawn, isSurfaceEvent, parseJournalEvent, queuedInput, stepContribution } from './journal.js';
+export type { CancelIntent, ConfirmationDescriptor, ExtensionRecord, InboxTarget, InitialInstallation, InputRole, Installation, InstallationLifetime, InterruptionPolicy, JournalEvent, JournalEventData, JournalEventInput, JournalEventType, OriginCause, QueuedInput, ReplacementKind, ReplacementTrigger, RunChain, RunOutcomeKind, RunSettledReason, Seq, StepContribution, StepContributionInput, SurfaceEventType, ThreadEnvironment, ThreadFork, ThreadInput, ThreadOrigin, ThreadSummary, TurnEndReason, TurnRejection, WaitDescriptor, } from './journal.js';
+export { toolResultMessageContent } from './toolResult.js';
+export type { ToolResult, ToolResultPayload, ToolResultPayloadInput } from './toolResult.js';
+export { toJsonSchema } from '../util/jsonSchema.js';
+export type { DeepReadonly, JsonValue, ReadonlyJsonValue } from '../util/json.js';

package/dist/records/index.js

@@ -0,0 +1 @@
+import{a as p}from"../chunks/FJLU4UH3.js";import{f as e,l as o,m as t,q as r,r as n,s}from"../chunks/MMNNZCBO.js";import"../chunks/G44LG6VL.js";import"../chunks/D4PQP5MA.js";export{n as isForkSpawn,s as isSurfaceEvent,r as parseJournalEvent,o as queuedInput,t as stepContribution,p as toJsonSchema,e as toolResultMessageContent};