sakura-agent 0.1.0 → 0.1.2

package/dist/packages/session/src/file-log.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { appendFile, mkdir, open, readFile, rm, truncate, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
-import { projectMessages } from "./projection.js";
+import { createLog } from "./log-core.js";
 import { createTree } from "./tree.js";
 const FORMAT_VERSION = 1;
 function isProcessAlive(pid) {
@@ -34,6 +34,7 @@ function parseFile(text) {
     const complete = lines.slice(0, -1); // the last piece has no trailing newline: it is empty or a torn write
     let header;
     const entries = [];
+    let rewoundTo;
     let validBytes = 0;
     for (const [index, line] of complete.entries()) {
         let value;
@@ -50,14 +51,18 @@ function parseFile(text) {
             if (header.version > FORMAT_VERSION)
                 throw new Error(`session file version ${header.version} is newer than supported`);
         }
+        else if (value.type === "rewind") {
+            rewoundTo = value.to;
+        }
         else {
             entries.push(value);
+            rewoundTo = undefined;
         }
         validBytes += Buffer.byteLength(line) + 1;
     }
     if (!header)
         throw new Error("corrupt session file: missing header");
-    return { header, entries, validBytes };
+    return { header, entries, validBytes, ...(rewoundTo !== undefined ? { rewoundTo } : {}) };
 }
 /**
  * One JSONL file per session: a header line, then one complete entry per line.
@@ -71,6 +76,8 @@ export async function openFileLog(path, options = {}) {
     await acquireLock(lockPath);
     let header;
     let entries;
+    let rewoundTo;
+    let size; // bytes of the file that are known to be good
     try {
         const existing = await readFile(path, "utf8").catch((error) => {
             if (error.code === "ENOENT")
@@ -79,15 +86,19 @@ export async function openFileLog(path, options = {}) {
         });
         if (existing === undefined || existing === "") {
             header = { type: "header", version: FORMAT_VERSION, id: newId(), cwd: options.cwd ?? process.cwd(), ts: now() };
-            await writeFile(path, `${JSON.stringify(header)}\n`);
+            const line = `${JSON.stringify(header)}\n`;
+            await writeFile(path, line);
             entries = [];
+            size = Buffer.byteLength(line);
         }
         else {
             const parsed = parseFile(existing);
             header = parsed.header;
             entries = parsed.entries;
-            if (parsed.validBytes < Buffer.byteLength(existing))
-                await truncate(path, parsed.validBytes);
+            rewoundTo = parsed.rewoundTo;
+            size = parsed.validBytes;
+            if (size < Buffer.byteLength(existing))
+                await truncate(path, size);
         }
     }
     catch (error) {
@@ -95,29 +106,38 @@ export async function openFileLog(path, options = {}) {
         throw error;
     }
     const tree = createTree(entries);
-    let writing = Promise.resolve();
+    if (rewoundTo !== undefined && (rewoundTo === null || entries.some((entry) => entry.id === rewoundTo)))
+        tree.moveLeaf(rewoundTo);
+    // A write that fails can leave half a line behind. The next write first cuts the file back to what is known to be good, so that half line
+    // never ends up in the middle of the file where it would make the whole session unreadable.
+    let damaged = false;
+    async function write(line) {
+        try {
+            if (damaged) {
+                await truncate(path, size);
+                damaged = false;
+            }
+            await appendFile(path, line);
+            size += Buffer.byteLength(line);
+        }
+        catch (error) {
+            damaged = true;
+            throw error;
+        }
+    }
+    const log = createLog(tree, {
+        saveEntry: (entry) => write(`${JSON.stringify(entry)}\n`),
+        saveRewind: (to) => write(`${JSON.stringify({ type: "rewind", to })}\n`),
+    }, options);
     return {
         header,
-        async append(body) {
-            const entry = { ...body, id: newId(), parentId: tree.leaf(), ts: now() };
-            tree.add(entry);
-            writing = writing.then(() => appendFile(path, `${JSON.stringify(entry)}\n`));
-            await writing;
-            return entry;
-        },
-        async branch() {
-            return tree.branch();
-        },
-        async project(upTo) {
-            const branch = tree.branch();
-            return projectMessages(upTo === undefined
-                ? branch
-                : branch.slice(0, Math.max(0, branch.findIndex((entry) => entry.id === upTo))));
-        },
-        rewindTo: (entryId) => tree.moveLeaf(entryId),
-        leaf: () => tree.leaf(),
+        append: log.append,
+        branch: log.branch,
+        project: log.project,
+        rewindTo: log.rewindTo,
+        leaf: log.leaf,
         async close() {
-            await writing;
+            await log.settled();
             await rm(lockPath, { force: true });
         },
     };

package/dist/packages/session/src/fork.d.ts

@@ -0,0 +1,16 @@
+import type { Log } from "../../kernel/src/index.js";
+import type { SessionHeader } from "./file-log.js";
+export interface ForkOptions {
+    /** The last entry to copy, an id from `log.branch()`. Left out, the whole current branch is copied. */
+    upTo?: string;
+    /** The working directory to record in the new session. Default: this process's. */
+    cwd?: string;
+    /** The id of the session the log comes from, if it has one; recorded so that the new session says where it came from. */
+    sessionId?: string;
+}
+/**
+ * Copies the conversation up to a point into a new session file, which is then a session of its own: its entries are the same entries (same ids, same
+ * parents), so what the model is sent from it is exactly what it was sent from the original at that point, and a provider's prompt cache still applies.
+ * The source is only read. The file appears whole or not at all, and an existing file is never replaced.
+ */
+export declare function forkLog(log: Log, path: string, options?: ForkOptions): Promise<SessionHeader>;

package/dist/packages/session/src/fork.js

@@ -0,0 +1,70 @@
+import { randomUUID } from "node:crypto";
+import { link, mkdir, unlink, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+/** Where to stop copying so that no turn is cut in two: after the results that answer the calls of the last assistant message that was copied. */
+function endOfTurn(branch, last) {
+    let assistant = -1;
+    for (let index = last; index >= 0; index--) {
+        const entry = branch[index];
+        if (entry?.type === "message" && entry.message.role === "assistant") {
+            assistant = index;
+            break;
+        }
+    }
+    const opened = assistant >= 0 ? branch[assistant] : undefined;
+    if (opened?.type !== "message")
+        return last;
+    const open = new Set(opened.message.content.flatMap((part) => (part.type === "tool_call" ? [part.id] : [])));
+    for (let index = assistant + 1; index <= last; index++) {
+        const entry = branch[index];
+        if (entry?.type === "message" && entry.message.toolCallId)
+            open.delete(entry.message.toolCallId);
+    }
+    let end = last;
+    while (open.size > 0 && end + 1 < branch.length) {
+        const next = branch[end + 1];
+        if (next.type === "message" && next.message.role !== "tool")
+            break; // a new turn begins: calls that were never answered stay as they were in the source
+        end++;
+        if (next.type === "message" && next.message.toolCallId)
+            open.delete(next.message.toolCallId);
+    }
+    return end;
+}
+/**
+ * Copies the conversation up to a point into a new session file, which is then a session of its own: its entries are the same entries (same ids, same
+ * parents), so what the model is sent from it is exactly what it was sent from the original at that point, and a provider's prompt cache still applies.
+ * The source is only read. The file appears whole or not at all, and an existing file is never replaced.
+ */
+export async function forkLog(log, path, options = {}) {
+    const branch = await log.branch();
+    let last = branch.length - 1;
+    if (options.upTo !== undefined) {
+        last = branch.findIndex((entry) => entry.id === options.upTo);
+        if (last === -1)
+            throw new Error(`entry ${options.upTo} is not on the current branch`);
+    }
+    const copied = branch.slice(0, endOfTurn(branch, last) + 1);
+    const header = {
+        type: "header",
+        version: 1,
+        id: randomUUID().slice(0, 8),
+        cwd: options.cwd ?? process.cwd(),
+        ts: Date.now(),
+        ...(copied.length > 0 ? { forkedFrom: { entry: copied.at(-1).id, ...(options.sessionId !== undefined ? { session: options.sessionId } : {}) } } : {}),
+    };
+    const text = [header, ...copied].map((line) => `${JSON.stringify(line)}\n`).join("");
+    await mkdir(dirname(path), { recursive: true });
+    const temporary = `${path}.${randomUUID().slice(0, 8)}.tmp`;
+    try {
+        await writeFile(temporary, text, { flag: "wx" });
+        // a hard link fails if the target exists, so a session that is there is never replaced, and the new one never shows up half written
+        await link(temporary, path).catch((error) => {
+            throw error.code === "EEXIST" ? new Error(`${path} already exists`) : error;
+        });
+    }
+    finally {
+        await unlink(temporary).catch(() => undefined);
+    }
+    return header;
+}

package/dist/packages/session/src/index.d.ts

@@ -1,4 +1,6 @@
 export { createMemoryLog } from "./memory-log.js";
 export type { LogOptions, RewindableLog } from "./memory-log.js";
 export { openFileLog } from "./file-log.js";
+export { forkLog } from "./fork.js";
+export type { ForkOptions } from "./fork.js";
 export type { FileLog, SessionHeader } from "./file-log.js";

package/dist/packages/session/src/index.js

@@ -1,2 +1,3 @@
 export { createMemoryLog } from "./memory-log.js";
 export { openFileLog } from "./file-log.js";
+export { forkLog } from "./fork.js";

package/dist/packages/session/src/log-core.d.ts

@@ -0,0 +1,37 @@
+import type { EntryBody, Log, LogEntry } from "../../kernel/src/index.js";
+import type { createTree } from "./tree.js";
+export interface LogOptions {
+    now?: () => number;
+    newId?: () => string;
+}
+/** A session log that can go back to an earlier entry and carry on from there. */
+export interface RewindableLog extends Log {
+    /** Moves the end of the conversation back to an earlier entry (or to the very start with null). Later entries start a new branch. */
+    rewindTo(entryId: string | null): void;
+    /** Id of the entry the next one will follow. */
+    leaf(): string | null;
+}
+/** Where a log keeps its entries. A memory log keeps them nowhere else. */
+export interface Storage {
+    /** Makes the entry durable. If this fails the entry is not part of the log. */
+    saveEntry(entry: LogEntry): Promise<void>;
+    /** Records that the end of the conversation moved. Best effort: the next entry carries the same information, so a lost record only matters if nothing follows. */
+    saveRewind(to: string | null): Promise<void>;
+}
+/**
+ * The one implementation of "a log": entries in a tree, one leaf, appends in order. The log is only as durable as its storage, and a log and its
+ * storage never disagree: an entry joins the tree after it is saved, and an append that fails changes nothing and does not stop the ones after it.
+ */
+export declare function createLog(tree: ReturnType<typeof createTree>, storage: Storage, options?: LogOptions): {
+    /** Resolves when everything started so far has been saved or has failed. */
+    settled: () => Promise<undefined>;
+    append(body: EntryBody): Promise<LogEntry>;
+    branch(): Promise<LogEntry[]>;
+    project(upTo?: string): Promise<import("../../kernel/src/index.js").Message[]>;
+    /**
+     * Takes effect at once. Entries that were already waiting to be saved follow the new end, so do not rewind while appends are in flight
+     * (the kernel does not: one run at a time, and it waits for each append).
+     */
+    rewindTo(entryId: string | null): void;
+    leaf: () => string | null;
+};

package/dist/packages/session/src/log-core.js

@@ -0,0 +1,47 @@
+import { randomUUID } from "node:crypto";
+import { projectMessages } from "./projection.js";
+/**
+ * The one implementation of "a log": entries in a tree, one leaf, appends in order. The log is only as durable as its storage, and a log and its
+ * storage never disagree: an entry joins the tree after it is saved, and an append that fails changes nothing and does not stop the ones after it.
+ */
+export function createLog(tree, storage, options = {}) {
+    const now = options.now ?? Date.now;
+    const newId = options.newId ?? (() => randomUUID().slice(0, 8));
+    // Appends run one after another, each starting from where the one before ended. A failed one is reported to its caller and not to the next.
+    let queue = Promise.resolve();
+    return {
+        /** Resolves when everything started so far has been saved or has failed. */
+        settled: () => queue.then(() => undefined, () => undefined),
+        append(body) {
+            const run = queue.then(async () => {
+                const entry = { ...body, id: newId(), parentId: tree.leaf(), ts: now() };
+                await storage.saveEntry(entry);
+                tree.add(entry);
+                return entry;
+            });
+            queue = run.catch(() => undefined);
+            return run;
+        },
+        async branch() {
+            return tree.branch();
+        },
+        async project(upTo) {
+            const branch = tree.branch();
+            return projectMessages(upTo === undefined
+                ? branch
+                : branch.slice(0, Math.max(0, branch.findIndex((entry) => entry.id === upTo))));
+        },
+        /**
+         * Takes effect at once. Entries that were already waiting to be saved follow the new end, so do not rewind while appends are in flight
+         * (the kernel does not: one run at a time, and it waits for each append).
+         */
+        rewindTo(entryId) {
+            const before = tree.leaf();
+            tree.moveLeaf(entryId);
+            if (entryId === before)
+                return;
+            queue = queue.then(() => storage.saveRewind(entryId)).catch(() => undefined);
+        },
+        leaf: () => tree.leaf(),
+    };
+}

package/dist/packages/session/src/memory-log.d.ts

@@ -1,15 +1,6 @@
-import type { Log, LogEntry } from "../../kernel/src/index.js";
-export interface LogOptions {
-    now?: () => number;
-    newId?: () => string;
-}
-/** A session log that can go back to an earlier entry and carry on from there. */
-export interface RewindableLog extends Log {
-    /** Moves the end of the conversation back to an earlier entry (or to the very start with null). Later entries start a new branch. */
-    rewindTo(entryId: string | null): void;
-    /** Id of the entry the next one will follow. */
-    leaf(): string | null;
-}
+import type { LogEntry } from "../../kernel/src/index.js";
+import type { LogOptions, RewindableLog } from "./log-core.js";
+export type { LogOptions, RewindableLog } from "./log-core.js";
 /** A log that lives only in memory (or wraps entries that were loaded elsewhere). */
 export declare function createMemoryLog(options?: LogOptions & {
     entries?: readonly LogEntry[];

package/dist/packages/session/src/memory-log.js

@@ -1,27 +1,7 @@
-import { randomUUID } from "node:crypto";
-import { projectMessages } from "./projection.js";
+import { createLog } from "./log-core.js";
 import { createTree } from "./tree.js";
 /** A log that lives only in memory (or wraps entries that were loaded elsewhere). */
 export function createMemoryLog(options = {}) {
-    const now = options.now ?? Date.now;
-    const newId = options.newId ?? (() => randomUUID().slice(0, 8));
-    const tree = createTree(options.entries ?? []);
-    return {
-        async append(body) {
-            const entry = { ...body, id: newId(), parentId: tree.leaf(), ts: now() };
-            tree.add(entry);
-            return entry;
-        },
-        async branch() {
-            return tree.branch();
-        },
-        async project(upTo) {
-            const branch = tree.branch();
-            return projectMessages(upTo === undefined
-                ? branch
-                : branch.slice(0, Math.max(0, branch.findIndex((entry) => entry.id === upTo))));
-        },
-        rewindTo: (entryId) => tree.moveLeaf(entryId),
-        leaf: () => tree.leaf(),
-    };
+    const { settled: _settled, ...log } = createLog(createTree(options.entries ?? []), { saveEntry: async () => undefined, saveRewind: async () => undefined }, options);
+    return log;
 }

package/dist/packages/session/src/projection.js

@@ -1,4 +1,6 @@
 import { COMPACTION_PREFIX } from "../../kernel/src/index.js";
+/** The message that tells the model about its goal. It is the one pinned message that does not sit in front: see `projectMessages`. */
+const isGoalStatement = (entry) => entry?.type === "custom_message" && entry.customType === "goal";
 function entryToMessage(entry) {
     if (entry.type === "message")
         return entry.message;
@@ -55,25 +57,42 @@ function orderToolResults(messages) {
     }
     return ordered;
 }
+/** The goal statement still in force that lies before `start` (so the compaction took it out of the visible history), as a message. */
+function goalCompactedAway(branch, start, edits) {
+    for (let index = start - 1; index >= 0; index--) {
+        const entry = branch[index];
+        if (!entry || !isGoalStatement(entry))
+            continue;
+        return edits.get(entry.id) === null ? undefined : entryToMessage(entry);
+    }
+    return undefined;
+}
 export function projectMessages(branch) {
     const { start, summary, compactedAt } = findStart(branch);
     const edits = collectEdits(branch);
     const messages = [];
-    // Pinned entries (project instructions) stay in front even after compaction.
+    // Pinned entries (project instructions) stay in front even after compaction. They are written once, at the start, so the front never changes.
+    // The goal is pinned too, but it is set in the middle of a conversation: in front it would change everything after it and cost the provider's
+    // prompt cache. It stays where it was written, and after a compaction it follows the summary.
     for (let index = 0; index < branch.length; index++) {
         const entry = branch[index];
-        if (entry?.type !== "custom_message" || !entry.pinned)
+        if (entry?.type !== "custom_message" || !entry.pinned || isGoalStatement(entry))
             continue;
+        if (edits.get(entry.id) === null)
+            continue; // a pinned message can be withdrawn too
         const message = entryToMessage(entry);
         if (message)
             messages.push(message);
     }
     if (summary !== undefined) {
         messages.push({ role: "user", content: [{ type: "text", text: `${COMPACTION_PREFIX}\n\n${summary}` }], ts: 0 });
+        const carried = goalCompactedAway(branch, start, edits);
+        if (carried)
+            messages.push(carried);
     }
     for (let index = start; index < branch.length; index++) {
         const entry = branch[index];
-        if (!entry || (entry.type === "custom_message" && entry.pinned))
+        if (!entry || (entry.type === "custom_message" && entry.pinned && !isGoalStatement(entry)))
             continue;
         const message = entryToMessage(entry);
         if (!message)

package/dist/packages/testing/src/faux.d.ts

@@ -0,0 +1,36 @@
+import type { LlmClient, LlmRequest, ProviderError, StopReason, Usage } from "../../kernel/src/index.js";
+export interface FauxTurn {
+    text?: string;
+    reasoning?: string;
+    toolCalls?: Array<{
+        name: string;
+        args: unknown;
+        id?: string;
+    }>;
+    /** Cut the output off in the middle of this tool call (finish_reason "length"). */
+    truncatedToolCall?: {
+        name: string;
+        id?: string;
+    };
+    usage?: Partial<Usage>;
+    stop?: StopReason;
+    /** Fail the request instead of answering. */
+    error?: ProviderError;
+    /** Never answer; wait until the request is aborted. */
+    hang?: boolean;
+    /** Send this text, then a restart (as an adapter does after a dropped connection), then the real reply. */
+    droppedFirst?: string;
+    /** Split text into pieces of this many characters (default: one piece). */
+    chunkSize?: number;
+}
+export type FauxScript = FauxTurn[] | ((request: LlmRequest, index: number) => FauxTurn);
+export interface FauxClient extends LlmClient {
+    /** Every request received, in order. */
+    requests: LlmRequest[];
+}
+export interface FauxOptions {
+    contextWindow?: number;
+    supportsImages?: boolean;
+}
+/** A scripted stand-in for a model: replays the given turns, one per request. */
+export declare function createFauxClient(script: FauxScript, options?: FauxOptions): FauxClient;

package/dist/packages/testing/src/faux.js

@@ -0,0 +1,69 @@
+function abortError() {
+    const error = new Error("aborted");
+    error.name = "AbortError";
+    return error;
+}
+function waitForAbort(signal) {
+    return new Promise((_, reject) => {
+        if (signal.aborted)
+            reject(abortError());
+        signal.addEventListener("abort", () => reject(abortError()), { once: true });
+    });
+}
+function estimateTokens(value) {
+    return Math.ceil(JSON.stringify(value).length / 4);
+}
+function* pieces(value, size) {
+    if (!size || size >= value.length) {
+        yield value;
+        return;
+    }
+    for (let start = 0; start < value.length; start += size)
+        yield value.slice(start, start + size);
+}
+/** A scripted stand-in for a model: replays the given turns, one per request. */
+export function createFauxClient(script, options = {}) {
+    const requests = [];
+    let callCount = 0;
+    return {
+        requests,
+        model: { id: "faux", contextWindow: options.contextWindow ?? 100_000, supportsImages: options.supportsImages ?? true },
+        async *stream(request, signal) {
+            requests.push(request);
+            const index = callCount++;
+            const turn = typeof script === "function" ? script(request, index) : script[index];
+            if (!turn)
+                throw new Error(`faux script has no turn for request ${index + 1}`);
+            if (signal.aborted)
+                throw abortError();
+            if (turn.error)
+                throw turn.error;
+            if (turn.hang)
+                await waitForAbort(signal);
+            if (turn.droppedFirst) {
+                yield { type: "text_delta", delta: turn.droppedFirst };
+                yield { type: "restart" };
+            }
+            if (turn.reasoning)
+                yield { type: "reasoning_delta", delta: turn.reasoning };
+            if (turn.text)
+                for (const piece of pieces(turn.text, turn.chunkSize))
+                    yield { type: "text_delta", delta: piece };
+            let toolCount = 0;
+            for (const call of turn.toolCalls ?? []) {
+                toolCount++;
+                yield { type: "tool_call", call: { id: call.id ?? `call_${index + 1}_${toolCount}`, name: call.name, args: call.args } };
+            }
+            if (turn.truncatedToolCall) {
+                yield { type: "tool_call_truncated", id: turn.truncatedToolCall.id ?? `call_${index + 1}_cut`, name: turn.truncatedToolCall.name };
+            }
+            const output = estimateTokens([turn.text, turn.reasoning, turn.toolCalls]);
+            yield {
+                type: "usage",
+                usage: { input: estimateTokens(request.messages), output, cacheRead: 0, cacheWrite: 0, ...turn.usage },
+            };
+            const stop = turn.stop ?? (turn.truncatedToolCall ? "length" : toolCount > 0 ? "tool_use" : "stop");
+            yield { type: "done", stop };
+        },
+    };
+}

package/dist/packages/testing/src/index.d.ts

@@ -0,0 +1,4 @@
+export { createRng } from "./rng.js";
+export type { Rng } from "./rng.js";
+export { createFauxClient } from "./faux.js";
+export type { FauxClient, FauxOptions, FauxScript, FauxTurn } from "./faux.js";

package/dist/packages/testing/src/index.js

@@ -0,0 +1,2 @@
+export { createRng } from "./rng.js";
+export { createFauxClient } from "./faux.js";

package/dist/packages/testing/src/rng.d.ts

@@ -0,0 +1,7 @@
+export interface Rng {
+    next(): number;
+    int(minInclusive: number, maxInclusive: number): number;
+    pick<T>(items: readonly T[]): T;
+    chance(probability: number): boolean;
+}
+export declare function createRng(seed: number): Rng;

package/dist/packages/testing/src/rng.js

@@ -0,0 +1,17 @@
+// Small seeded random generator (mulberry32) so generated test cases are reproducible.
+export function createRng(seed) {
+    let state = seed >>> 0;
+    const next = () => {
+        state = (state + 0x6d2b79f5) >>> 0;
+        let t = state;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+    return {
+        next,
+        int: (min, max) => min + Math.floor(next() * (max - min + 1)),
+        pick: (items) => items[Math.floor(next() * items.length)],
+        chance: (probability) => next() < probability,
+    };
+}

package/dist/sdk/index.d.ts

@@ -1,10 +1,18 @@
 export { buildSystemPrompt, bundle, compose, CompositionError, corePlugins, createAgent } from "../packages/agent/src/index.js";
 export type { Agent, AgentConfig, Composable, ModelConfig } from "../packages/agent/src/index.js";
-export { createLocalEnvironment, createRemoteEnvironment } from "../packages/env/src/index.js";
-export type { RemoteRunner } from "../packages/env/src/index.js";
-export type { Content, Environment, Event, LlmClient, Plugin, RunHandle, RunResult, Tool, ToolContext, ToolResult } from "../packages/kernel/src/index.js";
+export { createLocalEnvironment, createRemoteEnvironment, createSshEnvironment, OutsideDirectoryError, RemoteConnectionError } from "../packages/env/src/index.js";
+export type { LocalOptions, RemoteRunner, SshOptions } from "../packages/env/src/index.js";
+export type { CompactionConfig, Content, ContextStatus, Decision, EntryBody, Environment, Event, EventTransform, ExecResult, FileInfo, GoalRecord, GoalStatus, HookContext, HookName, Hooks, LlmClient, LlmEvent, LlmRequest, Log, LogEntry, Message, ModelInfo, PauseReason, Plugin, PluginApi, PrepareContext, ProcessHandle, Prompts, ProviderErrorKind, Role, RunEndReason, RunHandle, RunOptions, RunResult, StopReason, ThinkingLevel, Tool, ToolCall, ToolContext, ToolDecl, ToolEffect, ToolResult, TurnInfo, Usage, UsageTotals, UserInput, } from "../packages/kernel/src/index.js";
+export { FatalHookError, ProviderError } from "../packages/kernel/src/index.js";
 export { compatPresets, createChatClient } from "../packages/llm/src/index.js";
 export type { ChatClientOptions, ChatCompat } from "../packages/llm/src/index.js";
+export { contextPlugin } from "../packages/plugins/context/src/index.js";
+export type { ContextOptions, ContextPlugin } from "../packages/plugins/context/src/index.js";
 export { limitsPlugin } from "../packages/plugins/limits/src/index.js";
+export { resiliencePlugin } from "../packages/plugins/resilience/src/index.js";
+export type { FixOptions, ResilienceOptions } from "../packages/plugins/resilience/src/index.js";
 export { redactionPlugin } from "../packages/plugins/redaction/src/index.js";
 export { reviewPlugin } from "../packages/plugins/review/src/index.js";
+export type { McpServerConfig, McpServerStatus } from "../packages/plugins/toolset/src/index.js";
+export { toolsPlugin } from "../packages/plugins/tools/src/index.js";
+export type { ToolsPluginOptions } from "../packages/plugins/tools/src/index.js";

package/dist/sdk/index.js

@@ -1,6 +1,10 @@
 export { buildSystemPrompt, bundle, compose, CompositionError, corePlugins, createAgent } from "../packages/agent/src/index.js";
-export { createLocalEnvironment, createRemoteEnvironment } from "../packages/env/src/index.js";
+export { createLocalEnvironment, createRemoteEnvironment, createSshEnvironment, OutsideDirectoryError, RemoteConnectionError } from "../packages/env/src/index.js";
+export { FatalHookError, ProviderError } from "../packages/kernel/src/index.js";
 export { compatPresets, createChatClient } from "../packages/llm/src/index.js";
+export { contextPlugin } from "../packages/plugins/context/src/index.js";
 export { limitsPlugin } from "../packages/plugins/limits/src/index.js";
+export { resiliencePlugin } from "../packages/plugins/resilience/src/index.js";
 export { redactionPlugin } from "../packages/plugins/redaction/src/index.js";
 export { reviewPlugin } from "../packages/plugins/review/src/index.js";
+export { toolsPlugin } from "../packages/plugins/tools/src/index.js";

package/dist/sdk/testing.d.ts

@@ -0,0 +1,2 @@
+export { createFauxClient } from "../packages/testing/src/index.js";
+export type { FauxClient, FauxOptions, FauxScript, FauxTurn } from "../packages/testing/src/index.js";

package/dist/sdk/testing.js

@@ -0,0 +1,2 @@
+// A scripted model for testing an application built on the SDK: the replies are written in advance, so a test needs no provider, no key and no network.
+export { createFauxClient } from "../packages/testing/src/index.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sakura-agent",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "license": "MIT",
   "type": "module",
   "workspaces": [
@@ -23,7 +23,8 @@
     "example": "node examples/quickstart.ts",
     "build": "node scripts/build-sdk.mjs",
     "prepack": "npm run build",
-    "example:tools": "node examples/tools.ts"
+    "example:tools": "node examples/tools.ts",
+    "example:fleet": "node examples/fleet.ts"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.6.4",
@@ -55,6 +56,10 @@
     ".": {
       "types": "./dist/sdk/index.d.ts",
       "import": "./dist/sdk/index.js"
+    },
+    "./testing": {
+      "types": "./dist/sdk/testing.d.ts",
+      "import": "./dist/sdk/testing.js"
     }
   },
   "types": "./dist/sdk/index.d.ts",