@xandreed/sdk 0.14.0 → 0.15.1

package/dist/agent.golden.test.d.ts

@@ -1,231 +0,0 @@
-import { Tool } from "effect/ai";
-import { Effect, Layer, Schema, Scope } from "effect";
-import { HarnessError, SessionLog } from "@xandreed/core";
-import { Agent } from "./agent.adapter.js";
-import type { AgentConfig } from "./agent.adapter.js";
-export declare const Lookup: Tool.Tool<"lookup", {
-    readonly parameters: Schema.Struct<{
-        readonly query: Schema.String;
-    }>;
-    readonly success: Schema.Struct<{
-        readonly items: Schema.$Array<Schema.Struct<{
-            readonly id: Schema.String;
-            readonly detail: Schema.String;
-        }>>;
-    }>;
-    readonly failure: Schema.Struct<{
-        readonly error: Schema.String;
-        readonly message: Schema.String;
-    }>;
-    readonly failureMode: "return";
-}, never>;
-export declare const Deliver: Tool.Tool<"deliver", {
-    readonly parameters: Schema.Struct<{
-        readonly text: Schema.String;
-    }>;
-    readonly success: Schema.Boolean;
-    readonly failure: Schema.Struct<{
-        readonly error: Schema.String;
-        readonly message: Schema.String;
-    }>;
-    readonly failureMode: "return";
-}, never>;
-export declare const goldenHost: import("@xandreed/core").Capability;
-/** The agent every composition of the golden conversation reproduces. */
-export declare const goldenConfig: AgentConfig;
-/** What one turn left: its outcome (or failure), the events its host saw and what the memory held. */
-interface Observed {
-    readonly runId: string;
-    readonly outcome: unknown;
-    readonly events: ReadonlyArray<string>;
-    readonly contextBuilt: ReadonlyArray<unknown>;
-    readonly entries: number;
-}
-/**
- * The golden conversation over `runner` — anything that runs a turn the way
- * `Agent.turn` does, acquired in the conversation's scope — under the fixed
- * clock, in one session of `log` (in memory unless given): every turn, then
- * the session's events and the memory log they hold.
- */
-export declare const runGolden: (runner: Effect.Effect<Pick<Agent, "turn">, HarnessError, Scope.Scope>, log?: Layer.Layer<SessionLog, unknown>) => Effect.Effect<{
-    turns: readonly Observed[];
-    journal: string[];
-    log: readonly {
-        readonly id: string;
-        readonly runId: string;
-        readonly turn: number;
-        readonly step: number;
-        readonly at: number;
-        readonly body: {
-            readonly _tag: "SystemPrepared";
-            readonly fingerprint: string;
-            readonly text: string;
-            readonly sections: readonly {
-                readonly id: string;
-                readonly version: string;
-                readonly fingerprint: string;
-            }[];
-        } | {
-            readonly _tag: "TurnStarted";
-            readonly prompt: string;
-            readonly attachments?: readonly {
-                readonly type: "media";
-                readonly mediaType: "image/png" | "image/jpeg" | "image/gif" | "image/webp";
-                readonly data: string;
-                readonly fingerprint: string;
-                readonly bytes: number;
-                readonly name?: string;
-                readonly alt?: string;
-            }[];
-        } | {
-            readonly _tag: "TurnContext";
-            readonly sectionId: string;
-            readonly version: string;
-            readonly text: string;
-        } | {
-            readonly _tag: "Message";
-            readonly message: {
-                readonly role: "user";
-                readonly content: string | readonly ({
-                    readonly type: "media";
-                    readonly mediaType: "image/png" | "image/jpeg" | "image/gif" | "image/webp";
-                    readonly data: string;
-                    readonly fingerprint: string;
-                    readonly bytes: number;
-                    readonly name?: string;
-                    readonly alt?: string;
-                } | {
-                    readonly type: "text";
-                    readonly text: string;
-                    readonly providerOptions?: unknown;
-                })[];
-                readonly providerOptions?: unknown;
-            } | {
-                readonly role: "assistant";
-                readonly content: readonly ({
-                    readonly type: "text";
-                    readonly text: string;
-                    readonly providerOptions?: unknown;
-                } | {
-                    readonly type: "reasoning";
-                    readonly text: string;
-                    readonly providerOptions?: unknown;
-                } | {
-                    readonly type: "tool-call";
-                    readonly input: unknown;
-                    readonly toolCallId: string;
-                    readonly toolName: string;
-                    readonly providerOptions?: unknown;
-                    readonly providerExecuted?: boolean | undefined;
-                })[];
-                readonly providerOptions?: unknown;
-            } | {
-                readonly role: "tool";
-                readonly content: readonly {
-                    readonly type: "tool-result";
-                    readonly output: unknown;
-                    readonly toolCallId: string;
-                    readonly toolName: string;
-                    readonly media?: readonly {
-                        readonly type: "media";
-                        readonly mediaType: "image/png" | "image/jpeg" | "image/gif" | "image/webp";
-                        readonly data: string;
-                        readonly fingerprint: string;
-                        readonly bytes: number;
-                        readonly name?: string;
-                        readonly alt?: string;
-                    }[];
-                    readonly providerOptions?: unknown;
-                    readonly isError?: boolean | undefined;
-                }[];
-                readonly providerOptions?: unknown;
-            };
-        } | {
-            readonly _tag: "ToolResult";
-            readonly toolCallId: string;
-            readonly toolName: string;
-            readonly isError: boolean;
-            readonly subjects: readonly {
-                readonly kind: string;
-                readonly id: string;
-                readonly label: string | null;
-                readonly data: unknown;
-            }[];
-            readonly artifacts: readonly {
-                readonly id: string;
-                readonly kind: "image" | "file";
-                readonly mediaType: string;
-                readonly url: string;
-                readonly alt: string | null;
-            }[];
-            readonly encoded: unknown;
-            readonly view: string;
-            readonly viewVersion: string;
-            readonly pinned: boolean;
-            readonly media?: readonly {
-                readonly path: readonly (string | number)[];
-                readonly fingerprint: string;
-                readonly mediaType: "image/png" | "image/jpeg" | "image/gif" | "image/webp";
-                readonly bytes: number;
-            }[];
-            readonly mediaNotes?: readonly string[];
-        } | {
-            readonly _tag: "ToolDigest";
-            readonly entry: string;
-            readonly version: string;
-            readonly mode: "select" | "summarize";
-            readonly keep: readonly string[];
-            readonly text: string;
-            readonly digester: string;
-            readonly trigger: "write" | "compaction";
-        } | {
-            readonly _tag: "StepContext";
-            readonly step: number;
-            readonly text: string;
-        } | {
-            readonly _tag: "ToolsActivated";
-            readonly skills: readonly string[];
-            readonly tools: readonly string[];
-            readonly source: "always" | "matcher" | "load_skill" | "host";
-            readonly decision: string | null;
-        } | {
-            readonly _tag: "Compaction";
-            readonly strategy: string;
-            readonly version: string;
-            readonly action: {
-                readonly _tag: "CompactViews";
-                readonly entries: readonly string[];
-                readonly texts: readonly string[];
-            } | {
-                readonly _tag: "Spill";
-                readonly entry: string;
-                readonly preview: string;
-            } | {
-                readonly _tag: "DropTurns";
-                readonly throughTurn: number;
-                readonly ledger: string;
-            } | {
-                readonly _tag: "Summarize";
-                readonly keepFromTurn: number;
-                readonly summary: string;
-            } | {
-                readonly _tag: "OmitMedia";
-                readonly entries: readonly string[];
-                readonly reason: string;
-            };
-        } | {
-            readonly _tag: "TurnEnded";
-            readonly outcome: "partial" | "completed" | "failed";
-            readonly reply: string | null;
-        };
-    }[];
-    requests: readonly unknown[];
-}, unknown, never>;
-/** The golden conversation's two halves, each as the exact text of its file. */
-export declare const goldenTexts: (result: Effect.Success<ReturnType<typeof runGolden>>) => {
-    model: string;
-    journal: string;
-};
-/** Compare a run with both golden files (and rewrite the ones the environment asks for). */
-export declare const expectGolden: (result: Effect.Success<ReturnType<typeof runGolden>>) => Promise<void>;
-export {};

package/dist/agent.trace.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/events-guide.test.d.ts

@@ -1,207 +0,0 @@
-import { Context, Duration, Effect, Layer, Option, Schema, Scope, Stream } from "effect";
-import { LanguageModel, Tool } from "effect/ai";
-import { Agent, ConversationId, HarnessError, Sessions, TurnEvents } from "@xandreed/sdk";
-import type { Capability, SessionAddress, SessionLog, Turn, TurnEvent, TurnEventOf, TurnEventsService, TurnOutcome } from "@xandreed/sdk";
-import type { FeedOptions, FeedProjection, SsePeer } from "@xandreed/plugin-render";
-/** What a server instance is built from. */
-export interface HostOptions {
-    /** The session store every instance shares (your database; `SessionLogMemoryLive` is one process's). */
-    readonly log: Layer.Layer<SessionLog>;
-    /** From `@xandreed/plugin-models`, or any effect/ai provider. */
-    readonly model: LanguageModel.LanguageModel;
-    readonly capabilities?: ReadonlyArray<Capability>;
-    readonly feed?: FeedOptions;
-}
-/**
- * One server instance: the agent, the services it was given (the Sessions
- * it writes through, and their activity probe), the journal feed and the model.
- */
-export declare const makeHost: (options: HostOptions) => Effect.Effect<{
-    agent: Agent;
-    services: Context.Context<Sessions | import("@xandreed/core").TurnActivity>;
-    sessions: {
-        readonly create: (input: {
-            readonly owner: string;
-            readonly id?: ConversationId;
-            readonly origin?: string;
-            readonly meta?: import("@xandreed/core").JsonObject;
-        }) => Effect.Effect<import("@xandreed/core").SessionView, import("@xandreed/core").SessionExists | import("@xandreed/core").SessionLogError>;
-        readonly fork: (parent: SessionAddress, input: {
-            readonly id?: ConversationId;
-            readonly origin: string;
-            readonly meta?: import("@xandreed/core").JsonObject;
-            readonly inherit: boolean;
-        }) => Effect.Effect<import("@xandreed/core").SessionView, import("@xandreed/core").SessionExists | import("@xandreed/core").SessionMissing | import("@xandreed/core").SessionLogError>;
-        readonly get: (address: SessionAddress) => Effect.Effect<import("@xandreed/core").SessionView, import("@xandreed/core").SessionMissing | import("@xandreed/core").SessionLogError>;
-        readonly list: (query: {
-            readonly owner: string;
-            readonly limit?: number;
-            readonly before?: import("@xandreed/core").SessionListCursor;
-            readonly parent?: ConversationId;
-        }) => Effect.Effect<import("@xandreed/core").SessionPage, import("@xandreed/core").SessionLogError>;
-        readonly remove: (address: SessionAddress) => Effect.Effect<void, import("@xandreed/core").SessionMissing | import("@xandreed/core").SessionLogError>;
-        readonly read: (address: SessionAddress, query?: {
-            readonly after?: number;
-            readonly kinds?: ReadonlyArray<string>;
-            readonly limit?: number;
-        }) => Effect.Effect<ReadonlyArray<import("@xandreed/core").SessionLogEvent>, import("@xandreed/core").SessionMissing | import("@xandreed/core").SessionLogError>;
-        readonly changes: (address: SessionAddress) => Stream.Stream<void>;
-        readonly lookup: (address: SessionAddress, key: string) => Effect.Effect<Option.Option<number>, import("@xandreed/core").SessionMissing | import("@xandreed/core").SessionLogError>;
-        readonly transact: <A, E>(address: SessionAddress, decide: (view: import("@xandreed/core").SessionView) => Effect.Effect<import("@xandreed/core").Decision<A>, E>) => Effect.Effect<import("@xandreed/core").Decided<A>, E | import("@xandreed/core").ReservedKind | import("@xandreed/core").SessionMissing | import("@xandreed/core").SessionLogError>;
-        readonly cancel: (address: SessionAddress, turn: number) => Effect.Effect<{
-            readonly cancelled: boolean;
-            readonly pending: number;
-        }, import("@xandreed/core").SessionMissing | import("@xandreed/core").SessionLogError>;
-        readonly begin: (address: SessionAddress, input: import("@xandreed/core").BeginTurn) => Effect.Effect<import("@xandreed/core").TurnWriter, import("@xandreed/core").AttachmentRejected | import("@xandreed/core").SessionBusy | import("@xandreed/core").TurnDuplicate | import("@xandreed/core").KeyConflict | import("@xandreed/core").NothingPending | import("@xandreed/core").NotResumable | import("@xandreed/core").TurnRefused | import("@xandreed/core").SessionMissing | import("@xandreed/core").SessionLogError, Scope.Scope>;
-        readonly deliver: (address: SessionAddress, item: import("@xandreed/core").InboxItem) => Effect.Effect<{
-            readonly delivered: boolean;
-            readonly pending: number;
-        }, import("@xandreed/core").InboxFull | import("@xandreed/core").SessionMissing | import("@xandreed/core").SessionLogError>;
-        readonly drain: <E, R>(address: SessionAddress, run: (writer: import("@xandreed/core").TurnWriter) => Effect.Effect<void, E, R>, options?: {
-            readonly maxTurns?: number;
-            readonly meta?: import("@xandreed/core").JsonObject;
-        }) => Effect.Effect<{
-            readonly turns: number;
-        }, import("@xandreed/core").SessionMissing | import("@xandreed/core").SessionLogError, R>;
-    };
-    feed: {
-        readonly frames: (feed: import("@xandreed/plugin-render").FeedScope, after: number, project: FeedProjection) => Stream.Stream<import("@xandreed/plugin-render").FeedFrame, import("@xandreed/plugin-render").RenderError>;
-    };
-    model: LanguageModel.LanguageModel;
-}, HarnessError, Scope.Scope>;
-export type Host = Effect.Success<ReturnType<typeof makeHost>>;
-/** Built once per server instance (a module-level promise in Next.js); its scope is never closed. */
-export declare const startHost: (options: HostOptions) => Promise<Host>;
-/** One SSE frame for the client: an event name and its JSON data. */
-export interface Frame {
-    readonly event: string;
-    readonly data: Readonly<Record<string, unknown>>;
-}
-/** The bus events a client is shown, as frames; `None` skips one. Tool input and output stay on the server. */
-export declare const progressOf: (event: TurnEvent) => Option.Option<Frame>;
-/** Sends one frame to the client. It must never fail (see `clientPush`). */
-export type Push = (frame: Frame) => Effect.Effect<void>;
-/**
- * `use` for a turn streamed to a client: one background subscription (one
- * ordered lane, off the loop's path) for every frame, each tagged with the
- * turn's number, then the run.
- */
-export declare const streamTo: (push: Push) => (turn: Turn) => Effect.Effect<TurnOutcome, HarnessError, Scope.Scope>;
-/** Whether the client took `bytes` within `timeout`: a write still waiting then, or one that failed (the client left), was not. */
-export declare const writeWithin: (writer: WritableStreamDefaultWriter<Uint8Array>, bytes: Uint8Array, timeout: Duration.Input) => Effect.Effect<boolean, never, never>;
-/**
- * Ends a client's stream without waiting: a stream aborted while a write
- * still waits settles neither until the client reads again or leaves.
- */
-export declare const closeStream: (writer: WritableStreamDefaultWriter<Uint8Array>) => Effect.Effect<Promise<undefined>, never, never>;
-/**
- * A client's stream as a `Push` that never fails and never holds the turn
- * up: a write the client has not taken within `timeout` marks it gone and
- * aborts the stream, and every later frame is dropped. A handler that fails
- * fails the turn; one that never returns keeps it from recording its reply.
- */
-export declare const clientPush: (writer: WritableStreamDefaultWriter<Uint8Array>, timeout?: Duration.Input) => Effect.Effect<Push, never, never>;
-/** For the turn's `layer`: a subscription there sees `turn.started` (with `meta` and `resumes`), which `use` never does. */
-export declare const onTurnStarted: (handle: (event: TurnEventOf<"turn.started">) => Effect.Effect<void>) => Layer.Layer<never, never, TurnEvents>;
-/**
- * From `use`: a subscription moved into `outer`, a scope the caller keeps
- * open past the turn, the only kind that sees `turn.ended`. Its handler runs
- * after the turn's own scopes have closed, and must not fail.
- */
-export declare const onTurnEnded: (outer: Scope.Scope, handle: (event: TurnEventOf<"turn.ended">) => Effect.Effect<void>) => (turn: Turn) => Effect.Effect<void, never, never>;
-export declare const Lookup: Tool.Tool<"lookup", {
-    readonly parameters: Schema.Struct<{
-        readonly query: Schema.String;
-    }>;
-    readonly success: Schema.Struct<{
-        readonly found: Schema.Number;
-    }>;
-    readonly failure: Schema.Struct<{
-        readonly error: Schema.String;
-        readonly message: Schema.String;
-    }>;
-    readonly failureMode: "return";
-}, never>;
-/** Typed reactions to `lookup`'s successful calls, and a line for every call refused or failed. */
-export declare const watchTools: (turn: Turn, report: (line: string) => Effect.Effect<void>) => Effect.Effect<void, never, Scope.Scope>;
-/** The application's own event: typed by its schema, journaled under its name, seen by the session's followers. */
-export declare const Progress: {
-    name: string;
-    make: (data: {
-        readonly stage: string;
-        readonly done: number;
-    }) => Effect.Effect<TurnEvent, HarnessError>;
-    select: (event: TurnEvent) => Option.Option<{
-        readonly stage: string;
-        readonly done: number;
-    }>;
-    publish: (events: TurnEventsService, data: {
-        readonly stage: string;
-        readonly done: number;
-    }) => Effect.Effect<void, HarnessError, never>;
-    on: <R>(handle: (data: {
-        readonly stage: string;
-        readonly done: number;
-    }) => Effect.Effect<void, HarnessError, R>, options?: import("@xandreed/core").SubscribeOptions) => import("@xandreed/core").Subscription<R>;
-};
-/** Publish it from `use` (`turn.events`), a task, a tool (`RunContext.events`) or a session plugin (`TurnEvents`). */
-export declare const reportStage: (events: TurnEventsService, stage: string, done: number) => Effect.Effect<void, HarnessError, never>;
-/** The events stored after `cursor`, oldest first, and the cursor to read from next. */
-export declare const readAfter: (sessions: typeof Sessions.Service, address: SessionAddress, cursor: number) => Effect.Effect<{
-    events: readonly {
-        readonly session: string & import("effect/Brand").Brand<"ConversationId">;
-        readonly seq: number;
-        readonly turn: Option.Option<number>;
-        readonly kind: string;
-        readonly at: number;
-        readonly data: {
-            readonly [x: string]: unknown;
-        };
-    }[];
-    cursor: number;
-}, import("@xandreed/core").SessionMissing | import("@xandreed/core").SessionLogError, never>;
-/** How each turn of a session ended, as stored: the reason and, when it failed, the failing error's code. */
-export declare const endingsOf: (sessions: typeof Sessions.Service, address: SessionAddress) => Effect.Effect<{
-    turn: number | null;
-    reason: "partial" | "completed" | "failed" | "cancelled" | "interrupted";
-    code: string | null;
-}[], Schema.SchemaError | import("@xandreed/core").SessionMissing | import("@xandreed/core").SessionLogError, never>;
-/** How a turn ended and what it replied, as the journal has it. */
-export interface StoredAnswer {
-    readonly turn: number;
-    readonly reason: string;
-    readonly reply: string | null;
-}
-/** What the turn begun with `key` answered, from the journal: none until that turn has ended. */
-export declare const storedAnswer: (sessions: typeof Sessions.Service, address: SessionAddress, key: string) => Effect.Effect<Option.None<StoredAnswer> | Option.Some<StoredAnswer>, Schema.SchemaError | import("@xandreed/core").SessionMissing | import("@xandreed/core").SessionLogError, never>;
-/** The journal as a client sees it: each shown record with its turn, and the app's own `app.*` events as they are. */
-export declare const clientProjection: FeedProjection;
-export declare const statusOf: (code: string) => number;
-export declare const problem: (status: number, code: string) => Response;
-/**
- * POST /sessions/:id/turns, `{ text, resumes? }` with an `Idempotency-Key`
- * header: the turn as SSE frames, `started` first and `done` last. A turn
- * that cannot begin is answered with its code's status before anything
- * streams. `waitUntil` keeps the turn running after the client leaves.
- */
-export declare const turnRoute: (host: Host, owner: string, id: string, request: Request, waitUntil: (work: Promise<unknown>) => void) => Promise<Response>;
-/**
- * POST /sessions, `{ id? }`: a new session, 201. A client that names the id
- * may retry: its own session again is 200, an id another owner holds is 409.
- */
-export declare const createSessionRoute: (host: Host, owner: string, request: Request) => Promise<Response>;
-/**
- * An SSE peer over a Web stream: a write never fails, and `closed` completes
- * when the client leaves, or once a write has waited `timeout` on a client
- * that stopped reading: the stream is then aborted, and the feed stops.
- */
-export declare const webSsePeer: (writer: WritableStreamDefaultWriter<Uint8Array>, signal: AbortSignal, timeout?: Duration.Input) => SsePeer;
-/**
- * GET /sessions/:id/events: the session's journal from the client's cursor
- * as SSE (`id: <seq>`, `event: <kind>`), polled, and woken by this
- * instance's own commits, until the feed's `maxDurationMs` or a client that
- * stopped reading is dropped; EventSource then reconnects with `Last-Event-ID`.
- */
-export declare const eventsRoute: (host: Host, owner: string, id: string, request: Request, waitUntil: (work: Promise<unknown>) => void) => Promise<Response>;
-/** GET /ping: what this instance has in flight, for a load balancer, or a deploy waiting to stop it. */
-export declare const pingRoute: (host: Host) => Promise<Response>;

package/dist/journal-compat.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/memory.conformance.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/models-plugin.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/plugin-stack.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/resume.journey.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/testing.port.d.ts

@@ -1,16 +0,0 @@
-import { Context } from "effect";
-import type { Ref } from "effect";
-declare const Tally_base: Context.ServiceClass<Tally, "test/Tally", {
-    readonly runId: string;
-    readonly seen: Ref.Ref<ReadonlyArray<string>>;
-}>;
-/** A per-turn host service for the agent tests: built by the turn's layer, read by use, tools and subscriptions. */
-export declare class Tally extends Tally_base {
-}
-declare const Stamp_base: Context.ServiceClass<Stamp, "test/Stamp", {
-    readonly label: string;
-}>;
-/** A service a turn-dependent plugin provides in the agent tests, read by the host's layer. */
-export declare class Stamp extends Stamp_base {
-}
-export {};

package/dist/testing.port.js

@@ -1,7 +0,0 @@
-import { Context } from "effect";
-
-export class Tally extends Context.Service()("test/Tally") {
-}
-
-export class Stamp extends Context.Service()("test/Stamp") {
-}

package/dist/turn-composition.test.d.ts

@@ -1 +0,0 @@
-export {};