@leuduan/lagent 0.0.0-stage → 0.1.2

package/dist/plugins/providers/shared.d.ts

@@ -0,0 +1,104 @@
+import OpenAI from 'openai';
+import { z } from 'zod';
+import type { FailureClassification } from '../../llm/index.js';
+/** Extra top-level request fields merged into every call (vendor extensions), minus the refused ones. */
+export declare const ExtraBodySchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+/**
+ * A provider's declared context windows, by model id. A model with no entry has no window: `null`,
+ * never a guess.
+ */
+export declare const contextWindowOf: (windows: Readonly<Record<string, number>>, model: string) => number | null;
+/** The structured fields of a provider error, wherever it arrived: a rejected request or the stream. */
+export type ProviderErrorFields = {
+    readonly code?: unknown;
+    readonly type?: unknown;
+    readonly message?: unknown;
+};
+/** The OpenAI-shaped code for a request over the model's context window. */
+export declare const CONTEXT_LENGTH_EXCEEDED = "context_length_exceeded";
+/**
+ * A credential problem the transport found while authorizing a request. The SDK wraps whatever a
+ * custom `fetch` throws in its connection error, so {@link classifyProviderError} hands it back as
+ * itself: a login that cannot be used reads as that login's problem, not as a failed connection.
+ */
+export declare class TransportCredentialError extends Error {
+}
+/**
+ * `error` as the failure it is, else unchanged. An SDK `APIError` has fields to read: a rejected
+ * request, or an error event the SDK raised while reading the stream. When `isOverflow` recognizes
+ * them it is the overflow, with the message the provider's own, without the SDK's status prefix.
+ * The SDK's own abort error, once the request's `signal` fired, is that signal's reason: the
+ * caller's cancellation, as the engine recognises it, whatever the SDK names its class. A connection
+ * error that carries a {@link TransportCredentialError} is that error.
+ */
+export declare function classifyProviderError(provider: string, error: unknown, isOverflow: (fields: ProviderErrorFields) => boolean, signal: AbortSignal | undefined): unknown;
+/**
+ * A failure a provider reported inside its stream (a `response.failed` or `error` event), with the
+ * structured fields it gave. There is no HTTP status: the request had already succeeded.
+ */
+export declare class ProviderStreamError extends Error {
+    readonly code: unknown;
+    readonly type: unknown;
+    constructor(fields: ProviderErrorFields, fallback: string);
+}
+/**
+ * The failure kind of an error from an OpenAI-shaped client, by structured evidence only: the HTTP
+ * status and error code of a rejected request, the code of a stream's error event, the SDK's
+ * transport errors, and socket error codes. A spent quota or usage limit is `quota` whether its name
+ * comes in the code or the type, on any status or on a failure with none; otherwise a status is read
+ * as every protocol reads it (`statusKind`). `retryAfterMs` is read from the
+ * `retry-after-ms` or `retry-after` header, never from prose. Anything unrecognised is `other`.
+ */
+export declare function classifyOpenAIFailure(error: unknown, now?: number): FailureClassification;
+/**
+ * The request option every model request carries, an injected SDK client's included: the SDK retries
+ * nothing. Retrying is the engine's (`ctx.llm`), once, before any output, by the failure's kind.
+ */
+export declare const NO_SDK_RETRIES: {
+    readonly maxRetries: 0;
+};
+/** The OpenAI API's public endpoint: the protocol default of the providers that speak to OpenAI. */
+export declare const OPENAI_API_BASE_URL = "https://api.openai.com/v1";
+/**
+ * What every OpenAI-shaped provider is configured with. Each one extends it with its own
+ * `defaultModel`, its endpoint's default, and whatever its API alone has. The credential is the
+ * host's to resolve: lagent reads no environment variable for it.
+ */
+export declare const OpenAICommonConfigSchema: z.ZodObject<{
+    apiKey: z.ZodOptional<z.ZodString>;
+    streamIdleTimeoutMs: z.ZodNullable<z.ZodNumber>;
+    baseURL: z.ZodOptional<z.ZodString>;
+    defaultHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    extraBody: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    thinkingEffort: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        high: "high";
+        none: "none";
+        medium: "medium";
+        max: "max";
+    }>>;
+}, z.core.$strip>;
+/**
+ * The SDK client for an OpenAI-shaped endpoint, the one constructor every provider here uses. The
+ * SDK fills an option left out from the process environment (`OPENAI_API_KEY`, `OPENAI_BASE_URL`,
+ * `OPENAI_ORG_ID`, `OPENAI_PROJECT_ID`, `OPENAI_ADMIN_KEY`, `OPENAI_WEBHOOK_SECRET`, `OPENAI_LOG`),
+ * so each is given here: the credential and endpoint the caller's, the log level the SDK's default,
+ * the rest, which lagent never uses, none. Its `OPENAI_CUSTOM_HEADERS` merge is undone, so a request
+ * carries the SDK's own headers, its authorization and the caller's `defaultHeaders`, and nothing
+ * from the environment.
+ */
+export declare function openAIClient(options: {
+    readonly apiKey: string;
+    readonly baseURL: string;
+    readonly defaultHeaders?: Record<string, string>;
+    readonly fetch?: typeof globalThis.fetch;
+}): OpenAI;
+/**
+ * The client a provider's adapter sends with: the one injected, else one built from its
+ * configuration, which then has to carry the credential.
+ */
+export declare function adapterClient(provider: string, config: {
+    readonly apiKey?: string | undefined;
+    readonly baseURL: string;
+    readonly defaultHeaders?: Record<string, string> | undefined;
+}, injected: OpenAI | undefined): OpenAI;

package/dist/plugins/providers/stream.d.ts

@@ -0,0 +1,154 @@
+import { z } from 'zod';
+import { StreamIdleError } from '../../llm/index.js';
+import type { ConversationMessage, JsonObject, LLMStreamChunk, ModelRequest, ModelResponse, StreamingLLMResponse, ToolCall } from '../../llm/index.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/plugins/routeContext.d.ts

@@ -0,0 +1,22 @@
+import type { Plugin } from '@leuduan/cordis';
+import { type ModelRoute } from '../llm/index.js';
+/**
+ * Tells an agent the route it runs on: provider, model and thinking effort.
+ *
+ * Told as a conversation message at the next model step already due whenever the turn's route
+ * differs from the latest notice the model can still see: on its first step, after a person
+ * switches its model, when a turn falls back to another provider or returns from one, and after a
+ * replacement took the notice that said it off the surface. The route is the one the turn pinned,
+ * which request middleware cannot change, so it names what lagent sends. A step whose route did not
+ * resolve is told nothing; its model call fails anyway. A fork inherits what its source was told and
+ * runs on its source's route, so it is told nothing unless the route moved.
+ *
+ * Not a prompt section: the recorded prompt must not change while the thread lives, and the route
+ * does. Mounted on the root it tells every thread; mounted through `thread.ctx` it tells that thread
+ * only.
+ */
+export declare const routeContext: Plugin.Object<undefined>;
+/** What a thread is told: its route, and the one it replaces when the model can still see another. */
+export declare function renderRouteNotice(route: ModelRoute, told: ModelRoute | null): string;
+/** A route as a model reads it; an effort of `null` is the provider's default. */
+export declare function renderRoute(route: ModelRoute): string;

package/dist/plugins/routeContext.js

@@ -0,0 +1 @@
+import{a,b,c}from"../chunks/TOOIB6J2.js";import"../chunks/DRYAN665.js";import"../chunks/2OSESBIL.js";import"../chunks/YLNJXQ3Z.js";import"../chunks/DDANMY45.js";import"../chunks/37YOGDGY.js";import"../chunks/KESCTXGO.js";import"../chunks/TYTQRLTX.js";import"../chunks/D7E6EWIE.js";export{c as renderRoute,b as renderRouteNotice,a as routeContext};

package/dist/plugins/schedules/index.d.ts

@@ -0,0 +1,21 @@
+import type { Plugin } from '@leuduan/cordis';
+import { type SchedulesConfig } from './service.js';
+/**
+ * Scheduled wakes of root threads: `schedule_wake`, `list_wakes` and `cancel_wake`, registered for
+ * a grant, and `ctx.schedules` for the host (`list`, `create`, `cancel`, and `cancelRows` for a
+ * thread `cancel` that should stop them too). A wake fires once, after `in_seconds` or `at` a time,
+ * and is created only in a person's turn or by the host; it delivers its prompt as sourced user
+ * input waiting for a turn of its own, under a `fresh` cause.
+ *
+ * Its configuration is required: the `clock`, the `timeZone` a local `at` is read in, and the
+ * bounds `maxDelayMs` and `maxPendingPerThread`.
+ *
+ * Root-only. Mounted before `ctx.threads.start`, the wakes that fell due while the process was down
+ * fire inside its barrier, judged by its startup policy; mounted after, they are new causes.
+ */
+export declare const schedules: Plugin.Object<SchedulesConfig>;
+export { readScheduledWake } from './record.js';
+export type { ScheduledWake, ScheduleStatus } from './record.js';
+export { ScheduleRefusedError } from './service.js';
+export type { ScheduleInfo, ScheduleRequest, SchedulesConfig, SchedulesService } from './service.js';
+export { SCHEDULE_TOOLS } from './tools.js';

package/dist/plugins/schedules/index.js

@@ -0,0 +1,5 @@
+import{a as I}from"../../chunks/C5LYCXJG.js";import{a as H,d as B}from"../../chunks/J5S4URAW.js";import{a as Q}from"../../chunks/SL2YLB2F.js";import{b as Z}from"../../chunks/RK3VP2Q4.js";import"../../chunks/74HKUGRR.js";import{a as G}from"../../chunks/QMMLQJBS.js";import{a as L}from"../../chunks/YIR5MYGU.js";import{a as y,b as z}from"../../chunks/NAOUTU7A.js";import"../../chunks/UKXMCHHT.js";import{b as T}from"../../chunks/DRYAN665.js";import{d as R}from"../../chunks/2OSESBIL.js";import{G as P}from"../../chunks/YLNJXQ3Z.js";import"../../chunks/DDANMY45.js";import"../../chunks/37YOGDGY.js";import"../../chunks/KESCTXGO.js";import"../../chunks/TYTQRLTX.js";import"../../chunks/D7E6EWIE.js";import{Service as he}from"@leuduan/cordis";import{z as A}from"zod";import{z as c}from"zod";var v=c.number().int().nonnegative(),ae=c.discriminatedUnion("op",[c.strictObject({op:c.literal("created"),id:c.string().min(1),due_at:v,prompt:c.string().min(1),reason:c.string().min(1),time_zone:c.string().min(1),created_at:v,call_seq:c.number().int().positive().nullable()}),c.strictObject({op:c.literal("fired"),id:c.string().min(1),input_id:c.string().min(1)}),c.strictObject({op:c.literal("cancelled"),id:c.string().min(1),reason:c.string()})]),g=T({plugin:"lagent:schedules",kind:"schedule",version:1,schema:ae}),w=n=>n.cancelled?"cancelled":n.delivered===null?"pending":"fired",h=g.projection({key:"schedules",onFork:"reset",init:()=>new Map,apply(n,e){if(e.op==="created")return n.has(e.id)||n.set(e.id,{created:e,delivered:null,cancelled:!1}),n;let t=n.get(e.id);return t===void 0||n.set(e.id,e.op==="fired"?{...t,delivered:e.input_id}:{...t,cancelled:!0}),n}}),j=Q({key:"lagent:schedules",version:1,schema:c.strictObject({next_wake_at:v.nullable()}),applies:()=>!0,compute(n,e){let t=null;for(let r of n.state(h,e).values())w(r)==="pending"&&(t=t===null?r.created.due_at:Math.min(t,r.created.due_at));return{next_wake_at:t}}});function O(n,e){let t=j.read(n,e);return t.status==="available"?t.value.next_wake_at:null}var ce=c.strictObject({schedule_id:c.string().min(1),due_at:v,summary:c.string()}),$=T({plugin:"lagent:schedules",kind:"wake",version:1,schema:ce}),ue=n=>$.readSource(n);function J(n){try{return new Intl.DateTimeFormat("en-US",{timeZone:n}),!0}catch{return!1}}var Y=new Map;function le(n){let e=Y.get(n);return e===void 0&&(e=new Intl.DateTimeFormat("en-US",{timeZone:n,hourCycle:"h23",year:"numeric",month:"numeric",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric"}),Y.set(n,e)),e}function M(n,e){let t={};for(let r of le(e).formatToParts(n))r.type!=="literal"&&(t[r.type]=Number(r.value));return{year:t.year,month:t.month,day:t.day,hour:t.hour,minute:t.minute,second:t.second}}function U(n,e){let t=M(n,e);return Date.UTC(t.year,t.month-1,t.day,t.hour,t.minute,t.second)-Math.floor(n/1e3)*1e3}var K=(n,e)=>n.year===e.year&&n.month===e.month&&n.day===e.day&&n.hour===e.hour&&n.minute===e.minute;function de(n,e){let t=Date.UTC(n.year,n.month-1,n.day,n.hour,n.minute),r=U(t-54e6,e),s=U(t+54e6,e),u=[...new Set([t-r,t-s])].sort((a,l)=>a-l);for(let a of u)if(K(M(a,e),n))return a;let o=Math.min(t-r,t-s),i=Math.max(t-r,t-s);for(;i-o>1e3;){let a=Math.floor((o+i)/2e3)*1e3;U(a,e)===s?i=a:o=a}return i}function V(n,e){let t=/^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2}))?(?:(Z)|([+-])(\d{2}):?(\d{2}))?$/.exec(n.trim());if(t===null)return null;let[r,s,u,o,i,a]=t.slice(1,7).map(_=>Number(_??0)),l=new Date(Date.UTC(r,s-1,u));if(l.getUTCFullYear()!==r||l.getUTCMonth()!==s-1||l.getUTCDate()!==u||o>23||i>59||a>59)return null;let[,,,,,,,d,p,S,ie]=t;if(d!==void 0||p!==void 0){let _=Number(S??0),q=Number(ie??0);if(_>14||q>59)return null;let oe=(p==="-"?-1:1)*(_*60+q)*6e4;return Date.UTC(r,s-1,u,o,i,a)-oe}let C={year:r,month:s,day:u,hour:o,minute:i},b=de(C,e);return K(M(b,e),C)?b+a*1e3:b}var X=A.number().int().positive(),me=A.strictObject({clock:H,timeZone:A.string().refine(J,"timeZone must be an IANA time zone"),maxDelayMs:X,maxPendingPerThread:X}),m=class extends Error{constructor(e){super(e),this.name="ScheduleRefusedError"}},D="Scheduled wakes are for conversations a person talks to; an agent working for another agent cannot schedule one.",fe="A scheduled wake can be created only in a turn a person started, not from a wake or a notice. Tell the person what to schedule, or ask them.",pe=n=>`sch-${n}`,ee=n=>`wake_${n}`,W=n=>n.replaceAll("&","&amp;").replaceAll('"',"&quot;").replaceAll("<","&lt;"),k=n=>new Date(n).toISOString().replace(".000Z","Z"),te=(n,e)=>`A scheduled wake may be due at most ${Math.round(n/6e4)} minutes from now, by ${k(e+n)}.`;function E(n,e,t){let{created:r}=e,s=e.delivered!==null&&!e.cancelled&&t.input(e.delivered).state==="queued";return{id:r.id,threadId:n,dueAt:r.due_at,timeZone:r.time_zone,prompt:r.prompt,reason:r.reason,status:w(e),unread:s,createdAt:r.created_at}}var x=class extends he{static inject=["threads","journal"];config;queue;inFlight=new Set;refreshed=Promise.resolve([]);armed=!1;retries;closed=!1;constructor(e,t){super(e,"schedules"),this.config=me.parse(t),this.queue=B(this.config.clock,r=>e.reportError(r)),this.retries=I(this.config.clock,r=>e.reportError(r)),e.effect(()=>e.journal.register(h)),e.effect(()=>e.journal.subscribe(r=>{this.armed&&g.read(r)!==void 0&&this.arm(r.thread_id)})),this.refreshed=j.register(e).refreshed,e.effect(()=>{let r=e.threads.registerOwner({owner:"lagent:schedules",repair:()=>this.catchUp()});return()=>r.dispose()}),L(e,()=>this.shutdown())}list({threadId:e}){let t=this.ctx.threads.view(e);return[...this.ctx.journal.state(h,e).values()].map(r=>E(e,r,t))}async create(e,t,r={}){let s=this.thread(e),u=r.callSeq===void 0?P("sch"):pe(r.callSeq),o=await s.read(l=>{let d=this.ctx.journal.state(h,e).get(u);if(d!==void 0)return E(e,d,l);if(s.origin!=null)throw new m(D);if(r.requirePersonTurn===!0&&!this.ctx.threads.chain(e).personTurn)throw new m(fe)});if(o!==void 0)return o;let i=this.createdRow(u,t,r.callSeq??null),{value:a}=await this.ctx.journal.transact(e,()=>{let l=this.ctx.journal.state(h,e);if(l.has(u))return{rows:[],value:null};let d=[...l.values()].filter(S=>w(S)==="pending").length;if(d>=this.config.maxPendingPerThread)return{rows:[],value:`This conversation already has ${d} scheduled wakes waiting, the most it may; cancel one with cancel_wake first.`};let p=this.config.clock.now();return i.due_at<=p?{rows:[],value:`${k(i.due_at)} has already passed; it is now ${k(p)}.`}:i.due_at>p+this.config.maxDelayMs?{rows:[],value:te(this.config.maxDelayMs,p)}:{rows:[g.entry({...i,created_at:p},{threadId:e})],value:null}});if(a!==null)throw new m(a);return s.read(l=>E(e,this.ctx.journal.state(h,e).get(u),l))}cancel(e,t,r="cancelled"){return this.track(async()=>{let s=this.thread(e);if(!await s.read(()=>this.ctx.journal.state(h,e).has(t)))throw new m(`No scheduled wake ${t} in this conversation.`);let o=await s.withdraw(ee(t),{rows:()=>this.ctx.journal.state(h,e).get(t).cancelled?[]:[g.entry({op:"cancelled",id:t,reason:r},{threadId:e})]});if(o.status==="refused")throw new Error(o.refusal.message);return{withdrawn:o.status==="withdrawn"}})}cancelRows(e,t="the conversation was stopped"){return[...this.ctx.journal.state(h,e).values()].filter(r=>w(r)==="pending").map(r=>g.entry({op:"cancelled",id:r.created.id,reason:t},{threadId:e}))}thread(e){let t=this.ctx.threads.get(e);if(t===void 0)throw new m(`No thread ${e}`);return t}createdRow(e,t,r){let{clock:s,timeZone:u,maxDelayMs:o}=this.config,i=s.now(),a=p=>{throw new m(p)};t.prompt.trim()===""&&a("A scheduled wake needs a prompt."),t.reason.trim()===""&&a("A scheduled wake needs a reason.");let{when:l}=t,d;return"in_seconds"in l?((!Number.isInteger(l.in_seconds)||l.in_seconds<1)&&a("in_seconds must be a whole number of at least 1."),d=i+l.in_seconds*1e3):(d=V(l.at,u)??a(`"${l.at}" is not a date and time such as 2026-10-11T14:30 or 2026-10-11T14:30+02:00.`),d<=i&&a(`${l.at} has already passed; it is now ${k(i)}.`)),d>i+o&&a(te(o,i)),{op:"created",id:e,due_at:d,prompt:t.prompt,reason:t.reason,time_zone:u,created_at:i,call_seq:r}}track(e){let t=e(),r=t.then(()=>{},()=>{});return this.inFlight.add(r),r.then(()=>this.inFlight.delete(r)),t}async catchUp(){try{await this.refreshed;let e=this.config.clock.now();await Promise.all(this.ctx.journal.summaries().filter(t=>{let r=O(this.ctx.journal,t.thread_id);return r!==null&&r<=e}).map(t=>this.check(t.thread_id)))}finally{this.armed=!0;for(let e of this.ctx.journal.summaries())this.arm(e.thread_id)}}arm(e){if(this.closed||this.retries.pending(e))return;let t=O(this.ctx.journal,e);t===null?this.queue.delete(e):this.queue.set(e,t,()=>{this.check(e)})}check(e){return this.track(()=>this.deliverDue(e))}async deliverDue(e){if(!this.closed)try{let t=this.ctx.threads.get(e);if(t===void 0)return;let r=this.config.clock.now(),s=await t.read(()=>[...this.ctx.journal.state(h,e).values()].filter(i=>w(i)==="pending"&&i.created.due_at<=r).map(i=>i.created.id)),o=(await Promise.allSettled(s.map(i=>this.fire(e,i)))).find(i=>i.status==="rejected");if(o!==void 0)throw o.reason;this.retries.succeeded(e),this.arm(e)}catch(t){if(this.ctx.reportError(t),this.closed)return;this.queue.delete(e),this.retries.failed(e,()=>{this.check(e)})}}async fire(e,t){if(this.closed)return;let r=this.thread(e),s=await r.read(()=>this.ctx.journal.state(h,e).get(t));if(s===void 0||w(s)!=="pending")return;let{created:u}=s,o=ee(t);await r.send({role:"user",content:we(u)},{id:o,source:$.record({schedule_id:t,due_at:u.due_at,summary:`${t} ${u.reason}`.slice(0,120)}),wake:{releases:!1,chain:"fresh"},target:"next-turn",rows:()=>{let i=this.ctx.journal.state(h,e).get(t);return i===void 0||w(i)!=="pending"?{refuse:{message:`Scheduled wake ${t} is no longer pending`}}:[g.entry({op:"fired",id:t,input_id:o},{threadId:e})]}})}async shutdown(){this.closed=!0,this.queue.dispose(),this.retries.dispose(),await Promise.allSettled([...this.inFlight])}};function we(n){return`<scheduled_wake ${[`schedule="${W(n.id)}"`,`due="${k(n.due_at)}"`,`time_zone="${W(n.time_zone)}"`,`reason="${W(n.reason)}"`].join(" ")}>
+${n.prompt}
+</scheduled_wake>`}import{z as f}from"zod";function N(n,e){let t=G(n.ctx,"schedules",e);if(n.ctx.threads.get(n.threadId)?.origin!=null)throw new m(D);return t}var ne=n=>`${n.id}  ${n.unread?"delivered, not read yet":n.status}  due ${k(n.dueAt)} (${n.timeZone}): ${n.reason}`,ge=f.strictObject({when:f.union([f.strictObject({in_seconds:f.number().int().min(1).describe("Seconds from now.")}),f.strictObject({at:f.string().describe("A date and time, such as 2026-10-11T14:30 (in the conversation\u2019s time zone) or 2026-10-11T14:30+02:00.")})]).describe("When: after in_seconds, or at a time."),prompt:f.string().min(1).describe("What you will be told when it fires: write it for yourself, then."),reason:f.string().min(1).describe("One line for the person, saying why.")}),F=y({name:"schedule_wake",description:"Schedule one wake of this conversation, after a delay or at a time. When it fires, you get its prompt as a new turn, even if nobody is here.",parameters:ge,onInterrupted:"rerun",executionMode:"exclusive",async execute(n,e){let t=await N(e,"schedule_wake").create(e.threadId,n,{callSeq:e.callSeq,requirePersonTurn:!0});return{output:`Scheduled ${ne(t)}`,metadata:{id:t.id,due_at:t.dueAt}}}}),re=y({name:"list_wakes",description:"List the scheduled wakes of this conversation still waiting to fire, and those that fired but whose message you have not read yet.",parameters:f.strictObject({}),onInterrupted:"rerun",executionMode:"parallel",execute:async(n,e)=>{let t=N(e,"list_wakes").list({threadId:e.threadId}),r=t.filter(s=>s.status==="pending"||s.unread);return{output:r.map(ne).join(`
+`)||"No scheduled wakes waiting.",metadata:{pending:r.filter(s=>!s.unread).length,unread:r.filter(s=>s.unread).length,total:t.length}}}}),se=y({name:"cancel_wake",description:"Cancel a scheduled wake of this conversation, or its delivery still waiting to be read.",parameters:f.strictObject({id:f.string().min(1).describe("The id schedule_wake returned, such as sch-42.")}),onInterrupted:"rerun",executionMode:"exclusive",async execute({id:n},e){let{withdrawn:t}=await N(e,"cancel_wake").cancel(e.threadId,n,"cancel_wake");return{output:`Cancelled ${n}.${t?" Its waiting delivery was withdrawn.":""}`,metadata:{id:n,withdrawn:t}}}}),ke=["schedule_wake","list_wakes","cancel_wake"];var _e=["Use schedule_wake only when the person asks for something later, never to wait for what a notice will report, such as a sub-agent or a command started with notify.","A scheduled wake fires once, and can be created only in a turn the person started: never from a wake or a notice, so do not promise follow-ups you cannot schedule then.","When a wake fires you get its prompt as user input in a <scheduled_wake> frame naming its due time; compare it with the current date, since a wake waiting behind a stop is delivered late."].join(`
+`),Ge={name:"lagent:schedules",inject:["tools","prompts","threads","journal"],async apply(n,e){R(n,"schedules"),await n.plugin(x,e);let t=[F,re,se];for(let r of t)z(n,r);Z(n,{tag:"schedules",slot:"instruction",agents:"all",render:({tools:r})=>r.some(s=>s.tool===F)?_e:null})}};export{ke as SCHEDULE_TOOLS,m as ScheduleRefusedError,ue as readScheduledWake,Ge as schedules};