@schlenkr/ragents 0.1.6 → 0.1.8

package/packages/ragents/src/runtime/orchestration.ts

@@ -1,4 +1,8 @@
-import type { JournalEvent, UncommittedEvent } from "../domain/events.ts";
+import type { ImageContent, TextContent, UserContent } from "@ragents/ai";
+
+import type { EventPayloads, JournalEvent, ModelInputContent, ModelToolResultPart, UncommittedEvent } from "../domain/events.ts";
+import { derivedToolResultText } from "../domain/tool-result-text.ts";
+import { ModelContexts } from "../agents/model-context.ts";
 import { assertJsonValue, type JsonObject, type JsonValue } from "../domain/json.ts";
 import type {
     ActionInput,
@@ -41,17 +45,32 @@ export type { CommandContext } from "./command.ts";
 
 const errorMessage = (error: unknown) => error instanceof Error ? error.message : String(error);
 
+const firstOf = <Value, Found extends Value>(values: Iterable<Value>, matches: (value: Value) => value is Found): Found | undefined => {
+    for (const value of values)
+        if (matches(value))
+            return value;
+
+    return undefined;
+};
+
 export class Orchestration {
     readonly #journal: Journal;
     readonly #services: RuntimeServices;
     readonly #artifactContents: ArtifactContents;
     readonly #suppressedSubscriptionRuns = new Set<string>();
+    readonly #modelContexts: ModelContexts;
 
     constructor(journal: Journal, services: RuntimeServices, artifactContents: ArtifactContents = new MemoryArtifactContents()) {
         this.#journal = journal;
         this.#services = services;
         this.#artifactContents = artifactContents;
+        this.#modelContexts = new ModelContexts({
+            eventsSince: (runId, sequence) => this.#journal.eventsSince(runId, sequence),
+            firstEventId: (runId) => this.#journal.firstEventId(runId),
+            media: (hash) => this.mediaContent(hash),
+        });
         this.#journal.subscribe((events) => {
+            this.#releaseModelContexts(events);
             this.#dispatchSubscriptions(events);
             this.#dispatchCreatorAlerts(events);
         });
@@ -107,6 +126,21 @@ export class Orchestration {
         return state;
     }
 
+    /** A value of the current state without cloning all of it; `read` must neither keep nor change the state. */
+    select<Value>(runId: string, read: (state: RunState) => Value): Value {
+        const found = this.#journal.select(runId, (state) => ({ value: read(state) }));
+
+        if (!found)
+            throw new DomainError("run-not-found", `Run ${runId} does not exist.`, 404);
+
+        return found.value;
+    }
+
+    /** The events of a run from the newest back, without copying the journal. */
+    recentEvents(runId: string) {
+        return this.#journal.recentEvents(runId);
+    }
+
     view(runId: string) {
         return viewOf(this.state(runId));
     }
@@ -275,6 +309,14 @@ export class Orchestration {
                 };
             }
 
+            if (entry.type === "context.compacted") {
+                return {
+                    ...entry,
+                    ...identities,
+                    payload: { ...entry.payload, firstKeptEventId: rewriteEventId(entry.payload.firstKeptEventId) },
+                };
+            }
+
             if (entry.type === "subscription.failed") {
                 return {
                     ...entry,
@@ -385,22 +427,111 @@ export class Orchestration {
         return this.#run(context, runId, "turn.steer", { actorId, ...input }, turns.steerInputs(actorId, input));
     }
 
-    appendModelOutput(context: CommandContext, runId: string, actorId: string, input: { turnId: string; text: string }) {
-        return this.#run(context, runId, "model.output.complete", { actorId, ...input }, turns.appendModelOutput(actorId, input));
-    }
-
     appendInterruptedModelOutput(context: CommandContext, runId: string, actorId: string, input: { turnId: string; text: string }) {
         return this.#run(context, runId, "model.output.interrupt", { actorId, ...input }, turns.appendInterruptedModelOutput(actorId, input));
     }
 
-    appendModelReasoning(context: CommandContext, runId: string, actorId: string, input: { turnId: string; text: string }) {
-        return this.#run(context, runId, "model.reasoning.complete", { actorId, ...input }, turns.appendModelReasoning(actorId, input));
-    }
-
     appendRuntimeOutput(context: CommandContext, runId: string, actorId: string, input: { turnId: string; text: string }) {
         return this.#run(context, runId, "runtime.output.record", { actorId, ...input }, turns.appendRuntimeOutput(actorId, input));
     }
 
+    /** The model context of an actor, extended by the events since the last call. */
+    modelContext(runId: string, actorId: string) {
+        return this.#modelContexts.contextOf(runId, actorId);
+    }
+
+    /** How many actor contexts are held in memory. */
+    heldModelContexts() {
+        return this.#modelContexts.size;
+    }
+
+    #releaseModelContexts(events: readonly JournalEvent[]) {
+        for (const event of events) {
+            if ((event.type !== "turn.finished" && event.type !== "turn.interrupted") || this.#journal.failureOf(event.runId))
+                continue;
+
+            const actorId = this.#journal.select(event.runId, (state) => state.turns.get(event.payload.turnId)?.actorId);
+
+            if (actorId)
+                this.#modelContexts.forgetActor(event.runId, actorId);
+        }
+    }
+
+    /** Removes a run from the journal and everything held for it in memory; its files stay. */
+    forgetRun(runId: string) {
+        this.#modelContexts.forget(runId);
+        return this.#journal.forget(runId);
+    }
+
+    /** The Base64 of stored media bytes, for the model context. */
+    mediaContent(hash: string): string {
+        return Buffer.from(this.#artifactContents.read(hash)).toString("base64");
+    }
+
+    #storedMedia(data: string): string {
+        return this.#artifactContents.put(Buffer.from(data, "base64")).hash;
+    }
+
+    presentModelInput(
+        context: CommandContext,
+        runId: string,
+        actorId: string,
+        input: { turnId: string; inputId: string | null; content: string | readonly UserContent[] },
+    ) {
+        const content: ModelInputContent = typeof input.content === "string"
+            ? input.content
+            : input.content.map((part) => {
+                if (part.type === "text") return { type: "text" as const, text: part.text };
+                const hash = this.#storedMedia(part.data);
+                return part.type === "file"
+                    ? { type: "file" as const, mimeType: part.mimeType, filename: part.filename, hash }
+                    : { type: part.type, mimeType: part.mimeType, hash };
+            });
+        const payload = { turnId: input.turnId, inputId: input.inputId, content };
+
+        return this.#run(context, runId, "model.input.present", { actorId, ...payload }, turns.presentModelInput(actorId, payload));
+    }
+
+    completeModelStep(context: CommandContext, runId: string, actorId: string, input: { turnId: string; step: turns.CompletedModelStep }) {
+        const step = JSON.parse(JSON.stringify(input.step)) as turns.CompletedModelStep;
+
+        return this.#run(context, runId, "model.step.complete", { actorId, turnId: input.turnId, step }, turns.completeModelStep(actorId, { turnId: input.turnId, step }));
+    }
+
+    /** Stores what the model saw of a tool result; the content is left out when it is exactly the text of the recorded result. */
+    presentToolResult(
+        context: CommandContext,
+        runId: string,
+        actorId: string,
+        input: { turnId: string; toolCallId: string; toolName: string; isError: boolean; content: readonly (TextContent | ImageContent)[] },
+    ) {
+        const content: ModelToolResultPart[] = input.content.map((part) => part.type === "text"
+            ? { type: "text", text: part.text }
+            : { type: "image", mimeType: part.mimeType, hash: this.#storedMedia(part.data) });
+        const recorded = firstOf(this.recentEvents(runId), (event): event is Extract<JournalEvent, { type: "tool.call.completed" | "tool.call.failed" }> =>
+            (event.type === "tool.call.completed" || event.type === "tool.call.failed")
+            && event.actorId === actorId
+            && event.payload.turnId === input.turnId
+            && event.payload.toolCallId === input.toolCallId);
+        const derived = recorded !== undefined
+            && content.length === 1
+            && content[0]!.type === "text"
+            && content[0]!.text === derivedToolResultText(recorded);
+        const payload = {
+            turnId: input.turnId,
+            toolCallId: input.toolCallId,
+            toolName: input.toolName,
+            isError: input.isError,
+            ...(derived ? {} : { content }),
+        };
+
+        return this.#run(context, runId, "model.tool-result.present", { actorId, ...payload }, turns.presentToolResult(actorId, payload));
+    }
+
+    compactContext(context: CommandContext, runId: string, actorId: string, input: EventPayloads["context.compacted"]) {
+        return this.#run(context, runId, "context.compact", { actorId, ...input }, turns.compactContext(actorId, input));
+    }
+
     startToolCall(
         context: CommandContext,
         runId: string,

package/packages/workspace-executor/src/sandbox-tools.ts

@@ -27,7 +27,6 @@ type ToolExecute = (
   input: unknown,
   signal: AbortSignal | undefined,
   onUpdate: ((update: ToolUpdate) => void) | undefined,
-  context: unknown,
 ) => Promise<unknown>;
 
 export interface SandboxToolCall {
@@ -177,17 +176,17 @@ export const createSandboxTools = async (
     await allowedWorkspacePath(path.resolve(cwd, String(raw)), roots);
   };
 
-  const concurrent = (execute: ToolExecute): ToolExecute => (toolCallId, input, signal, onUpdate, context) => {
+  const concurrent = (execute: ToolExecute): ToolExecute => (toolCallId, input, signal, onUpdate) => {
     if (shuttingDown) throw new Error("Die Werkzeuge werden killed");
     if (signal?.aborted) throw new Error("Abgebrochen");
-    const run = () => execute(toolCallId, input, signal, onUpdate, context);
+    const run = () => execute(toolCallId, input, signal, onUpdate);
     return initial.runOperation ? initial.runOperation(run) : run();
   };
 
   const serial = (execute: ToolExecute): ToolExecute => {
     const inner = concurrent(execute);
-    return (toolCallId, input, signal, onUpdate, context) => {
-      const call = () => inner(toolCallId, input, signal, onUpdate, context);
+    return (toolCallId, input, signal, onUpdate) => {
+      const call = () => inner(toolCallId, input, signal, onUpdate);
       const result = toolOperation.then(call, call);
       toolOperation = result.then(() => undefined, () => undefined);
       return result;
@@ -222,7 +221,7 @@ export const createSandboxTools = async (
 
   const guarded = (name: FileToolName, execute: ToolExecute): ToolExecute => {
     const writing = name !== "read";
-    const checked: ToolExecute = async (toolCallId, input, signal, onUpdate, ctx) => {
+    const checked: ToolExecute = async (toolCallId, input, signal, onUpdate) => {
       const { seen, ...params } = (input ?? {}) as FileToolInput;
       const context = await contextFor();
       const shown = typeof params.path === "string" ? params.path : undefined;
@@ -236,7 +235,7 @@ export const createSandboxTools = async (
         const tracked = seen !== undefined && file !== undefined && shown !== undefined;
         const early = tracked ? await checkedAgainstSeen(name, file, shown, params, seen) : undefined;
         if (early) return early;
-        const result = await execute(toolCallId, requested === undefined ? params : { ...params, path: requested }, signal, onUpdate, ctx);
+        const result = await execute(toolCallId, requested === undefined ? params : { ...params, path: requested }, signal, onUpdate);
         const recorded = tracked ? { ...result as ToolResult, details: { ...(result as ToolResult).details as object, seen: seenAfter(name, file, params, result) } } : result;
         const annotated = writing && annotate && file !== undefined ? withAnnotation(recorded, await annotate(file)) : recorded;
         return requested === undefined || shown === undefined ? annotated : withShownPath(annotated, requested, shown);
@@ -248,9 +247,9 @@ export const createSandboxTools = async (
   };
 
   /** Der Ordner eines Bash-Aufrufs: relativ zum Arbeitsverzeichnis oder mit Alias, auf jedem Rechner gleich, darum nie absolut, und immer in einer Wurzel des Runs. */
-  const inFolder = (execute: ToolExecute): ToolExecute => async (toolCallId, input, signal, onUpdate, ctx) => {
+  const inFolder = (execute: ToolExecute): ToolExecute => async (toolCallId, input, signal, onUpdate) => {
     const params = input as { cwd?: unknown } | undefined;
-    if (params?.cwd === undefined) return execute(toolCallId, input, signal, onUpdate, ctx);
+    if (params?.cwd === undefined) return execute(toolCallId, input, signal, onUpdate);
     const requested = params.cwd;
     if (typeof requested !== "string" || requested === "" || path.isAbsolute(requested)) {
       throw new WorkspaceOperationError("workspace-path-invalid",
@@ -262,7 +261,7 @@ export const createSandboxTools = async (
     if (!(await stat(directory).catch(() => undefined))?.isDirectory()) {
       throw new WorkspaceOperationError("workspace-path-not-found", `Den Ordner ${requested} gibt es nicht`, 404);
     }
-    return execute(toolCallId, { ...params, cwd: directory }, signal, onUpdate, ctx);
+    return execute(toolCallId, { ...params, cwd: directory }, signal, onUpdate);
   };
 
   const startBash: BashOperations["exec"] = async (command, commandCwd, options) => {
@@ -355,7 +354,7 @@ export const createSandboxTools = async (
   ];
   return {
     tools: new Map(wrapped.map(([name, execute]) =>
-      [name, (input: unknown, call: SandboxToolCall) => execute(call.toolCallId, input, call.signal, call.onUpdate, undefined)])),
+      [name, (input: unknown, call: SandboxToolCall) => execute(call.toolCallId, input, call.signal, call.onUpdate)])),
     shutdown,
   };
 };

package/plugins/ragents.reference/run-scripts/learning-afternoon/tests/program.test.ts

@@ -214,5 +214,5 @@ test("der gemeinsame Ablauf liefert Helferaufträge, Prompt und parallele Graphz
   await program.onInput(eventOf("experiment", "actor.stopped", {}), context);
   const failed = workflowGraph(learningWorkflow, learningWorkflowState(context.state.read().board!));
   assert.deepEqual(failed.nodes.map((node) => [node.id, node.status]), [["experiment", "blocked"], ["quiz", "done"], ["collect", "blocked"]]);
-  assert.match(failed.nodes.find((node) => node.id === "collect")!.detail!, /1 von 2/);
+  assert.match(failed.nodes.find((node) => node.id === "collect")!.detail!, /1 of 2/);
 });

package/plugins/ragents.reference/run-scripts/word-game/tests/program.test.ts

@@ -96,7 +96,7 @@ test("wartet auf spätere Ereignisse, zählt zwölf Beiträge und beendet die We
   assert.deepEqual(inputs.map((call) => (call.input as { actor: string }).actor), words.map((_word, index) => `actor-${participants[index % 4]!.handle}`));
   assert.equal(context.state.read().status, "completed");
   assert.equal(context.state.read().entries?.length, 12);
-  assert.match(context.state.read().document!, /12\. Grün: Blume/);
+  assert.match(context.state.read().document!, /12\. Green: Blume/);
   assert.equal(context.state.read().pendingInputId, undefined);
   assert.deepEqual(await program.functions.start({}, context), { accepted: false });
 });
@@ -122,7 +122,7 @@ for (const scenario of [
   { name: "Modellfehler", word: "Strand", options: { outcome: "failed" } },
   { name: "Unterbrechung", word: "Strand", options: { type: "turn.interrupted" } },
   { name: "Mehrwortantwort", word: "Schöner Strand", options: {} },
-  { name: "wiederholtes Ausgangswort", word: "sonne", options: {} },
+  { name: "wiederholtes Ausgangswort", word: "sun", options: {} },
 ]) {
   test(`${scenario.name} bleibt als Fehler sichtbar und startet nicht erneut`, async () => {
     const { context, calls, response, start } = fixture();
@@ -247,6 +247,6 @@ test("ein gestoppter aktueller Teilnehmer hält das Spiel an", async () => {
   await start();
   await program.onInput(response("Strand", { type: "actor.stopped" }), context);
   assert.equal(context.state.read().status, "error");
-  assert.match(context.state.read().error!, /Rot wurde gestoppt/);
+  assert.match(context.state.read().error!, /Red wurde gestoppt/);
   assert.equal(context.state.read().entries?.length, 0);
 });

package/scripts/agent/journal.ts

@@ -84,7 +84,7 @@ export const usageByActor = (events: readonly JournalEvent[]): Map<string, Actor
   const result = new Map<string, ActorUsage>();
   for (const event of events) {
     const model = event.payload.usage as Record<string, unknown> | undefined;
-    if (!model) continue;
+    if (!model || event.type === "model.step.completed") continue;
     const entry = result.get(event.actorId) ?? { calls: 0, inputTokens: 0, cacheReadTokens: 0, outputTokens: 0, costUsd: 0 };
     entry.calls += 1;
     for (const key of ["inputTokens", "cacheReadTokens", "outputTokens", "costUsd"] as const) {
@@ -111,8 +111,10 @@ export const journalLines = (events: readonly JournalEvent[], mode: JournalMode,
       const output = text(payload.text);
       if (output.trim()) lines.push(`[${event.sequence}] ${actor}: ${output.slice(0, 800)}`);
     } else if (type === "actor.input.enqueued" && mode !== "tools") {
-      const input = payload.input as Record<string, unknown> | undefined;
-      lines.push(`[${event.sequence}] INPUT -> ${String(payload.actorId ?? "").slice(0, 14)}: ${text(payload.text ?? input?.text).slice(0, 300)}`);
+      const content = payload.subscriptionId ? `[event ${String((payload.sourceEventIds as string[] | undefined)?.[0] ?? "")}]` : text(payload.content);
+      lines.push(`[${event.sequence}] INPUT -> ${String(payload.actorId ?? "").slice(0, 14)}: ${content.slice(0, 300)}`);
+    } else if (type === "context.compacted" && mode !== "tools") {
+      lines.push(`[${event.sequence}] CONTEXT COMPACTED ${actor}: about ${String(payload.tokensBefore)} tokens summarized`);
     } else if (type === "turn.input-steered" && mode !== "tools") {
       lines.push(`[${event.sequence}] STEERING -> ${actor}: ${String(payload.inputId ?? "")} in ${String(payload.turnId ?? "")}`);
     } else if (type.startsWith("tool.call.") && mode !== "chat") {

package/scripts/package/publish-package.ts

@@ -1,7 +1,7 @@
 import { spawnSync } from "node:child_process";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { compareVersions, nextVersion, readVersion, versionLine, writeHostPackageVersion, writeVersion } from "../publish-version.ts";
+import { compareVersions, readVersion, releaseVersion, versionLine, writeHostPackageVersion, writeVersion } from "../publish-version.ts";
 import { buildPackage, PACKAGE_FOLDER, PACKAGE_NAME } from "./build-package.ts";
 
 const repositoryRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
@@ -121,11 +121,12 @@ const main = async (): Promise<void> => {
   if (!token) throw new Error(`npm_key fehlt: der npm-Token mit Schreibrecht auf ${PACKAGE_NAME}.\n${usage}`);
   const manifestFile = path.join(repositoryRoot, "package.json");
   const published = publishedVersions(PACKAGE_NAME, runNpm);
-  const next = nextVersion(readVersion(manifestFile), published);
-  console.log(versionLine(next));
   const extensionManifestFile = path.join(repositoryRoot, "apps", "vscode", "package.json");
+  const next = releaseVersion([readVersion(manifestFile), readVersion(extensionManifestFile)], published);
+  console.log(versionLine(next));
   if (!dryRun) {
     writeVersion(manifestFile, next.version);
+    writeVersion(extensionManifestFile, next.version);
     writeHostPackageVersion(extensionManifestFile, next.version);
   }
   const built = await buildPackage(path.join(repositoryRoot, "dist", PACKAGE_FOLDER));

package/packages/agent/dist/core/agent-session-runtime.d.ts

@@ -1,33 +0,0 @@
-import type { AgentSession } from "./agent-session.ts";
-import type { AgentSessionServices } from "./agent-session-services.ts";
-import type { ExtensionFactorySettlementObserver } from "./extensions/index.ts";
-import type { CreateAgentSessionResult } from "./sdk.ts";
-import type { SessionManager } from "./session-manager.ts";
-/** Result returned by runtime creation: the created session and its cwd-bound services. */
-export interface CreateAgentSessionRuntimeResult extends CreateAgentSessionResult {
-    services: AgentSessionServices;
-}
-/** Creates the services and the AgentSession for a target cwd and session manager. */
-export type CreateAgentSessionRuntimeFactory = (options: {
-    cwd: string;
-    sessionManager: SessionManager;
-    signal: AbortSignal;
-    onExtensionFactorySettlement?: ExtensionFactorySettlementObserver;
-}) => Promise<CreateAgentSessionRuntimeResult>;
-/** Owns one AgentSession plus its cwd-bound services. */
-export declare class AgentSessionRuntime {
-    readonly session: AgentSession;
-    readonly services: AgentSessionServices;
-    constructor(session: AgentSession, services: AgentSessionServices);
-    waitForSettlement(): Promise<void>;
-    dispose(): Promise<void>;
-}
-/** Create the runtime from a runtime factory; an abort during creation disposes the late session. */
-export declare function createAgentSessionRuntime(createRuntime: CreateAgentSessionRuntimeFactory, options: {
-    cwd: string;
-    sessionManager: SessionManager;
-    signal?: AbortSignal;
-    onExtensionFactorySettlement?: ExtensionFactorySettlementObserver;
-}): Promise<AgentSessionRuntime>;
-export { type AgentSessionServices, type CreateAgentSessionFromServicesOptions, type CreateAgentSessionServicesOptions, createAgentSessionFromServices, createAgentSessionServices, } from "./agent-session-services.ts";
-//# sourceMappingURL=agent-session-runtime.d.ts.map

package/packages/agent/dist/core/agent-session-services.d.ts

@@ -1,35 +0,0 @@
-import type { ThinkingLevel } from "../loop/index.ts";
-import type { Model } from "@ragents/ai";
-import type { ExtensionFactorySettlementObserver, ToolDefinition } from "./extensions/index.ts";
-import type { ModelRuntime } from "./model-runtime.ts";
-import { type DefaultResourceLoaderOptions, type ResourceLoader } from "./resource-loader.ts";
-import { type CreateAgentSessionResult } from "./sdk.ts";
-import type { SessionManager } from "./session-manager.ts";
-/** Inputs for creating the services of one session: its cwd, model runtime and loaded resources. */
-export interface CreateAgentSessionServicesOptions {
-    cwd: string;
-    signal?: AbortSignal;
-    modelRuntime: ModelRuntime;
-    onExtensionFactorySettlement?: ExtensionFactorySettlementObserver;
-    resourceLoaderOptions?: Omit<DefaultResourceLoaderOptions, "onExtensionFactorySettlement">;
-}
-/** Inputs for creating an AgentSession from already-created services. */
-export interface CreateAgentSessionFromServicesOptions {
-    services: AgentSessionServices;
-    sessionManager: SessionManager;
-    model: Model<any>;
-    thinkingLevel?: ThinkingLevel;
-    tools?: string[];
-    customTools?: ToolDefinition[];
-}
-/** The services of one session; the AgentSession itself is created separately. */
-export interface AgentSessionServices {
-    cwd: string;
-    modelRuntime: ModelRuntime;
-    resourceLoader: ResourceLoader;
-}
-/** Create the services of one session and load its extensions; it does not create an AgentSession. */
-export declare function createAgentSessionServices(options: CreateAgentSessionServicesOptions): Promise<AgentSessionServices>;
-/** Create an AgentSession from previously created services. */
-export declare function createAgentSessionFromServices(options: CreateAgentSessionFromServicesOptions): Promise<CreateAgentSessionResult>;
-//# sourceMappingURL=agent-session-services.d.ts.map

package/packages/agent/dist/core/agent-session.d.ts

@@ -1,234 +0,0 @@
-/** One agent: model and thinking level, prompts, persistence, auto-compaction and retry, extension hooks and tools. */
-import type { Agent, AgentEvent, AgentMessage, ThinkingLevel } from "../loop/index.ts";
-import type { Model, UserAttachment } from "@ragents/ai";
-import { type CompactionResult } from "./compaction/index.ts";
-import { type ExtensionErrorListener, ExtensionRunner, type ToolDefinition, type ToolInfo } from "./extensions/index.ts";
-import type { ModelRuntime } from "./model-runtime.ts";
-import type { ResourceLoader } from "./resource-loader.ts";
-import type { SessionManager } from "./session-manager.ts";
-import type { AgentSettings } from "./agent-settings.ts";
-/** Session-specific events that extend the core AgentEvent */
-export type AgentSessionEvent = Exclude<AgentEvent, {
-    type: "agent_end";
-}> | {
-    type: "agent_end";
-    messages: AgentMessage[];
-    willRetry: boolean;
-} | {
-    type: "agent_settled";
-} | {
-    type: "compaction_start";
-    reason: "threshold" | "overflow";
-} | {
-    type: "thinking_level_changed";
-    level: ThinkingLevel;
-} | {
-    type: "compaction_end";
-    reason: "threshold" | "overflow";
-    result: CompactionResult | undefined;
-    aborted: boolean;
-    willRetry: boolean;
-    errorMessage?: string;
-} | {
-    type: "auto_retry_start";
-    attempt: number;
-    maxAttempts: number;
-    delayMs: number;
-    errorMessage: string;
-} | {
-    type: "auto_retry_end";
-    success: boolean;
-    attempt: number;
-    finalError?: string;
-};
-/** Listener function for agent session events */
-export type AgentSessionEventListener = (event: AgentSessionEvent) => void;
-export interface AgentSessionConfig {
-    agent: Agent;
-    sessionManager: SessionManager;
-    settings: AgentSettings;
-    cwd: string;
-    /** Resource loader for extensions, skills and the system prompt */
-    resourceLoader: ResourceLoader;
-    /** SDK custom tools registered outside extensions */
-    customTools?: ToolDefinition[];
-    /** Canonical model/auth runtime. */
-    modelRuntime: ModelRuntime;
-    /** Optional allowlist of tool names. When provided, only these tool names are exposed. */
-    allowedToolNames?: string[];
-    /** Mutable ref used by Agent to access the current ExtensionRunner */
-    extensionRunnerRef?: {
-        current?: ExtensionRunner;
-    };
-}
-export interface ExtensionBindings {
-    onError?: ExtensionErrorListener;
-}
-/** Options for AgentSession.prompt() */
-export interface PromptOptions {
-    attachments?: UserAttachment[];
-    /** Observes whether the prompt was accepted or rejected before the agent run starts. */
-    preflightResult?: (success: boolean) => void;
-}
-export declare class AgentSession {
-    readonly agent: Agent;
-    readonly sessionManager: SessionManager;
-    readonly settings: AgentSettings;
-    private _unsubscribeAgent?;
-    private _eventListeners;
-    private _isAgentRunActive;
-    private _disposed;
-    private _idleWaitPromise;
-    private _resolveIdleWait;
-    private _autoCompactionAbortController;
-    private _overflowRecoveryAttempted;
-    private _retryAbortController;
-    private _retryAttempt;
-    private _extensionRunner;
-    private _resourceLoader;
-    private _customTools;
-    private _cwd;
-    private _extensionRunnerRef?;
-    private _allowedToolNames?;
-    private _extensionErrorUnsubscriber?;
-    private _modelRuntime;
-    private _toolRegistry;
-    private _toolDefinitions;
-    private _toolPromptSnippets;
-    private _toolPromptGuidelines;
-    private _baseSystemPrompt;
-    private _baseSystemPromptOptions;
-    private _systemPromptOverride?;
-    constructor(config: AgentSessionConfig);
-    private _getRequiredRequestAuth;
-    private _getSummarizationRequestAuth;
-    /** The tool result hook reads `this._extensionRunner` at execution time. */
-    private _installAgentToolHooks;
-    private _installAgentNextTurnRefresh;
-    /** Emit an event to all listeners */
-    private _emit;
-    private _getIdleWaitPromise;
-    private _resolveIdleWaitIfIdle;
-    private _emitAgentSettled;
-    private _lastAssistantMessage;
-    /** Internal handler for agent events - shared by subscribe and reconnect */
-    private _handleAgentEvent;
-    private _willRetryAfterAgentEnd;
-    /** Find the last assistant message in agent state (including aborted ones) */
-    private _findLastAssistantMessage;
-    /**
-     * Subscribe to agent events.
-     * Session persistence is handled internally (saves messages on message_end).
-     * Multiple listeners can be added. Returns unsubscribe function for this listener.
-     */
-    subscribe(listener: AgentSessionEventListener): () => void;
-    /**
-     * Remove all listeners and disconnect from agent.
-     * Call this when completely done with the session.
-     */
-    dispose(): void;
-    waitForSettlement(): Promise<void>;
-    /** Current model (may be undefined if not yet selected) */
-    get model(): Model<any> | undefined;
-    /** Current thinking level */
-    get thinkingLevel(): ThinkingLevel;
-    /** Whether the session is currently processing an agent run or post-run continuation. */
-    get isStreaming(): boolean;
-    /** Whether the session has no active agent run, retry, auto-compaction, or queued continuation. */
-    get isIdle(): boolean;
-    /** Replace the custom system prompt and rebuild the effective prompt for the next model call. */
-    setSystemPrompt(prompt: string): void;
-    /**
-     * Get the names of currently active tools.
-     * Returns the names of tools currently set on the agent.
-     */
-    getActiveToolNames(): string[];
-    /**
-     * Get all configured tools with name, description, parameter schema, prompt guidelines, and source metadata.
-     */
-    getAllTools(): ToolInfo[];
-    /**
-     * Set active tools by name.
-     * Only tools in the registry can be enabled. Unknown tool names are ignored.
-     * Also rebuilds the system prompt to reflect the new tool set.
-     * Changes take effect on the next agent turn.
-     */
-    setActiveToolsByName(toolNames: string[]): void;
-    /** All messages including custom types */
-    get messages(): AgentMessage[];
-    /** Current session file path, or undefined if sessions are disabled */
-    get sessionFile(): string | undefined;
-    /** Current session ID */
-    get sessionId(): string;
-    private _normalizePromptSnippet;
-    private _normalizePromptGuidelines;
-    private _rebuildSystemPrompt;
-    private _runAgentPrompt;
-    private _handlePostAgentRun;
-    /** Run a prompt; while the agent runs, or without model or key, it throws. */
-    prompt(text: string, options?: PromptOptions): Promise<void>;
-    private _assertNotDisposed;
-    /**
-     * Abort current operation and wait for agent to become idle.
-     */
-    abort(): Promise<void>;
-    waitForIdle(): Promise<void>;
-    /**
-     * Set model directly.
-     * Validates that auth is configured, saves to session and settings.
-     * @throws Error if no auth is configured for the model
-     */
-    setModel(model: Model<any>): Promise<void>;
-    /**
-     * Set thinking level.
-     * Clamps to model capabilities based on available thinking levels.
-     * Saves to session and settings only if the level actually changes.
-     */
-    setThinkingLevel(level: ThinkingLevel): void;
-    /**
-     * Get available thinking levels for current model.
-     * The provider will clamp to what the specific model supports internally.
-     */
-    getAvailableThinkingLevels(): ThinkingLevel[];
-    /**
-     * Check if current model supports thinking/reasoning.
-     */
-    private supportsThinking;
-    private _getThinkingLevelForModelSwitch;
-    private _clampThinkingLevel;
-    /**
-     * Check if compaction is needed and run it.
-     * Called after agent_end and before prompt submission.
-     *
-     * Two cases:
-     * 1. Overflow: LLM returned context overflow error, remove error message from agent state, compact, auto-retry
-     * 2. Threshold: Context over threshold, compact, NO auto-retry (user continues manually)
-     *
-     * @param assistantMessage The assistant message to check
-     * @param skipAbortedCheck If false, include aborted messages (for pre-prompt check). Default: true
-     */
-    private _checkCompaction;
-    /**
-     * Internal: Run auto-compaction with events.
-     */
-    private _runAutoCompaction;
-    bindExtensions(bindings: ExtensionBindings): Promise<void>;
-    private _bindExtensionCore;
-    private _refreshToolRegistry;
-    private _buildRuntime;
-    /**
-     * Check if an error is retryable (overloaded, rate limit, server errors).
-     * Context overflow errors are NOT retryable (handled by compaction instead).
-     */
-    private _isRetryableError;
-    /**
-     * Prepare a retryable error for continuation with exponential backoff.
-     * @returns true if the caller should continue the agent, false otherwise
-     */
-    private _prepareRetry;
-    /**
-     * Cancel in-progress retry.
-     */
-    abortRetry(): void;
-}
-//# sourceMappingURL=agent-session.d.ts.map

package/packages/agent/dist/core/auth-guidance.d.ts

@@ -1,4 +0,0 @@
-export declare function getProviderLoginHelp(): string;
-export declare function formatNoModelSelectedMessage(): string;
-export declare function formatNoApiKeyFoundMessage(provider: string): string;
-//# sourceMappingURL=auth-guidance.d.ts.map