@schlenkr/ragents 0.1.4 → 0.1.6

package/packages/ragents/src/drivers/agent-runtime.ts

@@ -10,17 +10,18 @@ import {
     defineTool,
     CURRENT_SESSION_VERSION,
     SessionManager,
-    SettingsManager,
     type AgentSession,
     type SessionEntry,
     type AgentSessionRuntime,
-    type AgentSessionRuntimeDiagnostic,
     type CreateAgentSessionRuntimeFactory,
     type ExtensionAPI,
+    type ExtensionContext,
     type ExtensionError,
     type InlineExtension,
     type ModelRuntime,
-} from "@aicontainer/agent";
+    type Skill,
+} from "@ragents/agent";
+import type { UserMessage } from "@ragents/ai";
 
 import { ignoredFieldsNotice } from "../agents/toolset.ts";
 import { assertJsonValue, type JsonValue } from "../domain/json.ts";
@@ -31,44 +32,43 @@ import {
     type SkillPreloadConfiguration,
 } from "./skill-preload.ts";
 import { prepareInputAttachments } from "./attachments.ts";
-
-export type AgentThinkingLevel = import("../domain/driver.ts").ThinkingLevel;
+import type { ThinkingLevel } from "../domain/driver.ts";
 
 export type AgentRuntimeContext = {
     runId: string;
     agentId: string;
+    /** The working directory of the workspace tools; a runtime stays bound to it, and it is never a local path of this runtime. */
     workspace: string;
     allowedToolNames: readonly string[] | null;
     forkOf: string | null;
 };
 
-export type AgentRuntimeDiagnostic = AgentSessionRuntimeDiagnostic & {
+export type AgentRuntimeDiagnostic = {
+    type: "warning" | "error";
+    message: string;
     context: AgentRuntimeContext;
 };
 
 export type AgentSessionStore = {
     directory: (runId: string, agentId: string) => string | undefined;
     directoryMode: number;
-    persisted?: (runId: string, agentId: string, file: string, sessionId: string) => void | Promise<void>;
 };
 
 export type AgentRuntimeManagerOptions = {
-    agentDir: string;
     modelRuntime: ModelRuntime | Promise<ModelRuntime>;
-    skillPaths?: readonly string[];
-    resolveSkillPaths?: (
+    /** The skills of an agent, read and checked by the host. */
+    resolveSkills?: (
         context: AgentRuntimeContext,
         signal: AbortSignal,
-    ) => readonly string[] | Promise<readonly string[]>;
+    ) => readonly Skill[] | Promise<readonly Skill[]>;
     skillPreload?: false | SkillPreloadConfiguration;
-    thinkingLevel?: AgentThinkingLevel;
+    thinkingLevel?: ThinkingLevel;
     sessions?: AgentSessionStore;
     extensionFactories?: readonly InlineExtension[];
     resolveExtensionFactories?: (
         context: AgentRuntimeContext,
         signal: AbortSignal,
     ) => readonly InlineExtension[] | Promise<readonly InlineExtension[]>;
-    sessionShutdownTimeoutMs?: number;
     turnAbortTimeoutMs?: number;
     onDiagnostic?: (diagnostic: AgentRuntimeDiagnostic) => void;
 };
@@ -93,6 +93,15 @@ const sameToolNames = (left: readonly string[] | null, right: readonly string[]
         ? left === right
         : left.length === right.length && left.every((name, index) => name === right[index]);
 
+const assertUniqueSkillNames = (skills: readonly Skill[]) => {
+    for (const name of new Set(skills.map((skill) => skill.name))) {
+        const paths = skills.filter((skill) => skill.name === name).map((skill) => skill.filePath);
+
+        if (paths.length > 1)
+            throw new Error(`Der Skill ${name} ist mehrfach vorhanden: ${paths.join(", ")}.`);
+    }
+};
+
 const DEFAULT_TURN_ABORT_TIMEOUT_MS = 5_000;
 
 const turnAbortTimeout = (value: number | undefined) => {
@@ -189,11 +198,6 @@ class TurnAbortDeadline {
     }
 }
 
-const setReplacementSignal = (runtime: AgentSessionRuntime, signal: AbortSignal | undefined): void =>
-    (runtime as AgentSessionRuntime & {
-        setReplacementSignal(value: AbortSignal | undefined): void;
-    }).setReplacementSignal(signal);
-
 const syncFile = (file: string) => {
     const descriptor = openSync(file, "r+");
 
@@ -243,6 +247,10 @@ const asJson = (value: unknown) => {
 
 const asJsonValue = (value: unknown): JsonValue => JSON.parse(asJson(value)) as JsonValue;
 
+/** The conversation and its latest compaction; a new session or a compaction yields another model context. */
+const modelContextOf = (branch: readonly SessionEntry[]): string =>
+    `${branch[0]?.id ?? ""}:${branch.findLast((entry) => entry.type === "compaction")?.id ?? ""}`;
+
 const asText = (value: unknown): string => {
     if (typeof value === "string")
         return value;
@@ -307,7 +315,6 @@ class TurnDispatcher {
     readonly #context: AgentRuntimeContext;
     readonly #onDiagnostic: ((diagnostic: AgentRuntimeDiagnostic) => void) | undefined;
     #api: ExtensionAPI | null = null;
-    #baseActiveTools: string[] = [];
     #registeredNames = new Set<string>();
     #activeManagedNames = new Set<string>();
     readonly #directToolCalls = new Map<string, { name: string; input: unknown }>();
@@ -317,6 +324,8 @@ class TurnDispatcher {
         signal: AbortSignal;
         usage: TurnUsage;
         failure: string | null;
+        modelFailure: string | null;
+        pendingText: string;
     } | null = null;
 
     constructor(context: AgentRuntimeContext, onDiagnostic: ((diagnostic: AgentRuntimeDiagnostic) => void) | undefined) {
@@ -336,19 +345,12 @@ class TurnDispatcher {
     initialize() {
         const api = this.#requiredApi();
         this.#registeredNames = new Set();
-        this.#refreshBaseTools();
-        api.setActiveTools(this.#context.allowedToolNames === null ? this.#baseActiveTools : []);
+        api.setActiveTools([]);
 
         if (this.#turn)
             this.#configureTools(this.#turn.request);
     }
 
-    needsReload(request: TurnRequest<"agent">) {
-        const current = new Set(request.tools.map((tool) => tool.name));
-
-        return request.workspaceTools.some((name) => this.#registeredNames.has(name) && !current.has(name));
-    }
-
     unknownToolError(name: string): string | undefined {
         const turn = this.#turn;
         if (!turn || turn.signal.aborted)
@@ -357,12 +359,19 @@ class TurnDispatcher {
         return `Die Funktion ${name} ist kein natives Werkzeug. Suche ihren Vertrag mit typescript_api und rufe sie in typescript_eval über context.functions auf.`;
     }
 
+    /** The running turn that may still take steering; null between turns and after an abort. */
+    steerableTurn(): TurnRequest<"agent"> | null {
+        const turn = this.#turn;
+
+        return turn && !turn.signal.aborted ? turn.request : null;
+    }
+
     activate(request: TurnRequest<"agent">, signal: AbortSignal) {
         if (this.#turn)
             throw new Error(`agent ${request.agentId} already has an active turn.`);
 
         this.#configureTools(request);
-        this.#turn = { request, signal, usage: emptyUsage(), failure: null };
+        this.#turn = { request, signal, usage: emptyUsage(), failure: null, modelFailure: null, pendingText: "" };
     }
 
     async refreshTools(): Promise<string | undefined> {
@@ -386,20 +395,21 @@ class TurnDispatcher {
         )
             return;
 
+        const turn = this.#turn;
         this.#turn = null;
         this.#activeManagedNames.clear();
         this.#directToolCalls.clear();
         this.#unexecutedManagedCalls.clear();
 
-        if (this.#api) {
-            this.#refreshBaseTools();
-            this.#api.setActiveTools(this.#context.allowedToolNames === null ? this.#baseActiveTools : []);
-        }
+        this.#api?.setActiveTools([]);
+
+        if (turn?.signal.aborted)
+            this.#recordInterruptedOutput(turn);
     }
 
     result(): { failure: string | null; usage: TurnUsage } {
         return this.#turn
-            ? { failure: this.#turn.failure, usage: this.#turn.usage }
+            ? { failure: this.#turn.failure ?? this.#turn.modelFailure, usage: this.#turn.usage }
             : { failure: null, usage: emptyUsage() };
     }
 
@@ -408,6 +418,14 @@ class TurnDispatcher {
             this.#turn.usage = addUsage(this.#turn.usage, usage);
     }
 
+    #recordInterruptedOutput(turn = this.#turn) {
+        if (!turn?.pendingText.trim())
+            return;
+
+        turn.request.emit({ kind: "assistant-interrupted", text: turn.pendingText });
+        turn.pendingText = "";
+    }
+
     handleExtensionError(error: ExtensionError) {
         const message = `agent extension ${error.extensionPath} failed during ${error.event}: ${error.error}`;
 
@@ -426,11 +444,15 @@ class TurnDispatcher {
         const event = raw as Record<string, unknown>;
 
         if (event.type === "message_update") {
+            if (turn.signal.aborted)
+                return;
+
             const delta = event.assistantMessageEvent as { type?: string; delta?: string } | undefined;
 
-            if (delta?.type === "text_delta" && delta.delta)
+            if (delta?.type === "text_delta" && delta.delta) {
+                turn.pendingText += delta.delta;
                 turn.request.publish({ kind: "text", delta: delta.delta });
-            else if (delta?.type === "thinking_delta" && delta.delta)
+            } else if (delta?.type === "thinking_delta" && delta.delta)
                 turn.request.publish({ kind: "thinking", delta: delta.delta });
 
             return;
@@ -516,6 +538,13 @@ class TurnDispatcher {
 
         turn.usage = addUsage(turn.usage, usageOf(message.usage));
 
+        if (turn.signal.aborted || message.stopReason === "aborted") {
+            this.#recordInterruptedOutput(turn);
+            turn.failure ??= "The agent turn was aborted.";
+            return;
+        }
+
+        turn.pendingText = "";
         for (const entry of message.content ?? []) {
             if (entry.type === "text" && entry.text?.trim())
                 turn.request.emit({ kind: "assistant", text: entry.text.trim() });
@@ -523,15 +552,14 @@ class TurnDispatcher {
                 turn.request.emit({ kind: "reasoning", text: entry.thinking.trim() });
         }
 
-        if (message.stopReason === "error")
-            turn.failure ??= message.errorMessage ?? "The model provider returned an error.";
-        else if (message.stopReason === "aborted")
-            turn.failure ??= "The agent turn was aborted.";
+        // The session retries or compacts after a provider error, so only the last answer decides.
+        turn.modelFailure = message.stopReason === "error"
+            ? message.errorMessage ?? "The model provider returned an error."
+            : null;
     }
 
     #configureTools(request: TurnRequest<"agent">) {
         const api = this.#requiredApi();
-        this.#refreshBaseTools();
         const requestedNames = new Set<string>();
         const allowedNames = request.allowedToolNames === null ? null : new Set(request.allowedToolNames);
 
@@ -539,10 +567,9 @@ class TurnDispatcher {
             throw new Error(`agent ${request.agentId} received duplicate allowed tool names.`);
 
         if (allowedNames) {
-            const outside = [
-                ...request.tools.map((tool) => tool.name),
-                ...request.workspaceTools,
-            ].filter((name) => !["typescript_api", "typescript_eval"].includes(name) && !allowedNames.has(name));
+            const outside = request.tools
+                .map((tool) => tool.name)
+                .filter((name) => !["typescript_api", "typescript_eval"].includes(name) && !allowedNames.has(name));
 
             if (outside.length > 0)
                 throw new Error(`Der Agent erhielt Werkzeuge außerhalb seiner Freigabeliste: ${[...new Set(outside)].join(", ")}.`);
@@ -555,7 +582,7 @@ class TurnDispatcher {
             requestedNames.add(entry.name);
             const existing = api.getAllTools().find((tool) => tool.name === entry.name);
 
-            if (existing && existing.sourceInfo.source !== "builtin" && !this.#registeredNames.has(entry.name))
+            if (existing && !this.#registeredNames.has(entry.name))
                 throw new Error(`RAgents tool ${entry.name} conflicts with agent extension tool ${existing.sourceInfo.path}.`);
 
             api.registerTool(
@@ -567,7 +594,7 @@ class TurnDispatcher {
                     executionMode:
                         entry.executionMode ??
                         (entry.name.startsWith("agent_") ? "sequential" : "parallel"),
-                    execute: async (toolCallId: string, params: unknown, toolSignal: AbortSignal | undefined) => {
+                    execute: async (toolCallId: string, params: unknown, toolSignal: AbortSignal | undefined, _onUpdate: unknown, context: ExtensionContext) => {
                         const current = this.#turn;
 
                         if (!current)
@@ -578,7 +605,7 @@ class TurnDispatcher {
 
                         assertJsonValue(params, `agent tool ${entry.name} input`);
                         this.#unexecutedManagedCalls.delete(toolCallId);
-                        const call = await current.request.invoke(toolCallId, entry.name, params);
+                        const call = await current.request.invoke(toolCallId, entry.name, params, modelContextOf(context.sessionManager.getBranch()));
                         const text = typeof call.output === "string" ? call.output : asJson(call.output);
 
                         return {
@@ -595,39 +622,7 @@ class TurnDispatcher {
         }
 
         this.#activeManagedNames = requestedNames;
-        this.#applyActiveTools(request);
-    }
-
-    #applyActiveTools(request: TurnRequest<"agent">) {
-        const api = this.#requiredApi();
-        const allowedNames = request.allowedToolNames === null ? null : new Set(request.allowedToolNames);
-        const managed = [...this.#activeManagedNames];
-        const active = allowedNames === null
-            ? [
-                ...this.#baseActiveTools.filter((name) => !this.#registeredNames.has(name)),
-                ...request.workspaceTools.filter((name) => !this.#activeManagedNames.has(name)),
-                ...managed,
-            ]
-            : [
-                ...request.workspaceTools.filter((name) => !this.#registeredNames.has(name)),
-                ...this.#baseActiveTools.filter((name) => allowedNames.has(name) && !this.#registeredNames.has(name)),
-                ...managed,
-            ];
-        const available = new Set(api.getAllTools().map((tool) => tool.name));
-        const missing = active.filter((name) => !available.has(name));
-
-        if (missing.length > 0)
-            throw new Error(`agent tools are not registered: ${missing.join(", ")}.`);
-
-        api.setActiveTools([...new Set(active)]);
-    }
-
-    #refreshBaseTools() {
-        const api = this.#requiredApi();
-        this.#baseActiveTools = api
-            .getAllTools()
-            .filter((tool) => tool.sourceInfo.source !== "builtin" && !this.#registeredNames.has(tool.name))
-            .map((tool) => tool.name);
+        api.setActiveTools([...requestedNames]);
     }
 
     #requiredApi() {
@@ -664,22 +659,24 @@ export const forkableBranch = (branch: readonly SessionEntry[]): SessionEntry[]
 class PersistedAgentSession {
     readonly #context: AgentRuntimeContext;
     readonly #store: AgentSessionStore | undefined;
+    readonly #runtimeDirectory: string;
     #directory: string | null = null;
     #signature: string | null = null;
 
-    constructor(context: AgentRuntimeContext, store: AgentSessionStore | undefined) {
+    constructor(context: AgentRuntimeContext, store: AgentSessionStore | undefined, runtimeDirectory: string) {
         this.#context = context;
         this.#store = store;
+        this.#runtimeDirectory = runtimeDirectory;
     }
 
     async open(): Promise<SessionManager> {
         if (!this.#store)
-            return SessionManager.inMemory(this.#context.workspace);
+            return SessionManager.inMemory(this.#runtimeDirectory);
 
         const configuredDirectory = this.#store.directory(this.#context.runId, this.#context.agentId);
 
         if (!configuredDirectory)
-            return SessionManager.inMemory(this.#context.workspace);
+            return SessionManager.inMemory(this.#runtimeDirectory);
 
         this.#directory = resolve(configuredDirectory);
         await mkdir(this.#directory, { recursive: true, mode: this.#store.directoryMode });
@@ -694,7 +691,6 @@ class PersistedAgentSession {
         }
 
         const manager = this.#context.forkOf ? await this.#forkedManager(this.#context.forkOf) : await this.#newManager();
-        this.#assertWorkspace(manager);
         await this.persist(manager.getSessionFile(), manager.getSessionId());
 
         return manager;
@@ -730,17 +726,16 @@ class PersistedAgentSession {
         }
 
         this.#signature = signature;
-        await this.#store.persisted?.(this.#context.runId, this.#context.agentId, resolvedFile, sessionId);
     }
 
     async #newManager() {
         if (!this.#directory)
-            return SessionManager.inMemory(this.#context.workspace);
+            return SessionManager.inMemory(this.#runtimeDirectory);
 
         const file = join(this.#directory, `ragents-${randomUUID()}.jsonl`);
         await writeDurably(file, "");
         await syncDirectory(this.#directory);
-        const manager = SessionManager.open(file, this.#directory, this.#context.workspace);
+        const manager = SessionManager.open(file, this.#directory, this.#runtimeDirectory);
         syncFile(file);
 
         return manager;
@@ -761,20 +756,20 @@ class PersistedAgentSession {
             throw new Error(`Fork source ${sourceAgentId} has no model context yet.`);
 
         const sourceFile = resolve(sourceDirectory, record.file);
-        const source = SessionManager.open(sourceFile, resolve(sourceDirectory), this.#context.workspace);
+        const source = SessionManager.open(sourceFile, resolve(sourceDirectory), this.#runtimeDirectory);
         const header = {
             type: "session",
             version: CURRENT_SESSION_VERSION,
             id: randomUUID(),
             timestamp: new Date().toISOString(),
-            cwd: this.#context.workspace,
+            cwd: this.#runtimeDirectory,
             parentSession: sourceFile,
         };
         const lines = [header, ...forkableBranch(source.getBranch())].map((entry) => JSON.stringify(entry)).join("\n");
         const file = join(this.#directory, `ragents-${randomUUID()}.jsonl`);
         await writeDurably(file, `${lines}\n`);
         await syncDirectory(this.#directory);
-        const manager = SessionManager.open(file, this.#directory, this.#context.workspace);
+        const manager = SessionManager.open(file, this.#directory, this.#runtimeDirectory);
         syncFile(file);
 
         return manager;
@@ -825,8 +820,7 @@ class PersistedAgentSession {
 
         const file = resolve(directory, record.file);
         await access(file);
-        const manager = SessionManager.open(file, directory, this.#context.workspace);
-        this.#assertWorkspace(manager);
+        const manager = SessionManager.open(file, directory, this.#runtimeDirectory);
 
         if (manager.getSessionId() !== record.sessionId)
             throw new Error(`agent session identity ${record.sessionId} does not match ${manager.getSessionId()} in ${file}.`);
@@ -834,11 +828,6 @@ class PersistedAgentSession {
         return manager;
     }
 
-    #assertWorkspace(manager: SessionManager) {
-        if (resolve(manager.getCwd()) !== resolve(this.#context.workspace))
-            throw new Error(`agent session workspace ${manager.getCwd()} does not match ${this.#context.workspace}.`);
-    }
-
     #markerPath() {
         if (!this.#directory)
             throw new Error("A agent session marker requires a session directory.");
@@ -854,8 +843,7 @@ class ManagedAgentRuntime {
     readonly #identity: PersistedAgentSession;
     readonly #configuration: RuntimeConfiguration;
     readonly #modelRuntime: ModelRuntime;
-    readonly #defaultThinking: AgentThinkingLevel | undefined;
-    readonly #sessionShutdownTimeoutMs: number | undefined;
+    readonly #defaultThinking: ThinkingLevel | undefined;
     readonly #turnAbortTimeoutMs: number;
     readonly #onDiagnostic: ((diagnostic: AgentRuntimeDiagnostic) => void) | undefined;
     #unsubscribe: (() => void) | null = null;
@@ -874,8 +862,7 @@ class ManagedAgentRuntime {
         identity: PersistedAgentSession;
         configuration: RuntimeConfiguration;
         modelRuntime: ModelRuntime;
-        defaultThinking: AgentThinkingLevel | undefined;
-        sessionShutdownTimeoutMs: number | undefined;
+        defaultThinking: ThinkingLevel | undefined;
         turnAbortTimeoutMs: number;
         onDiagnostic: ((diagnostic: AgentRuntimeDiagnostic) => void) | undefined;
     }) {
@@ -886,13 +873,11 @@ class ManagedAgentRuntime {
         this.#configuration = options.configuration;
         this.#modelRuntime = options.modelRuntime;
         this.#defaultThinking = options.defaultThinking;
-        this.#sessionShutdownTimeoutMs = options.sessionShutdownTimeoutMs;
         this.#turnAbortTimeoutMs = options.turnAbortTimeoutMs;
         this.#onDiagnostic = options.onDiagnostic;
     }
 
     async start() {
-        this.#runtime.setRebindSession((session) => this.#bind(session));
         await this.#bind(this.#runtime.session);
     }
 
@@ -907,7 +892,6 @@ class ManagedAgentRuntime {
         const stopController = new AbortController();
         const turnSignal = AbortSignal.any([signal, stopController.signal]);
         this.#running = true;
-        setReplacementSignal(this.#runtime, turnSignal);
         this.#idle = new Promise<void>((resolveIdle) => {
             this.#resolveIdle = resolveIdle;
         });
@@ -936,22 +920,6 @@ class ManagedAgentRuntime {
                 this.#runtime.session.setSystemPrompt(request.systemPrompt);
             }
 
-            if (this.#dispatcher.needsReload(request)) {
-                const reload = this.#track(this.#runtime.session.reload({
-                    signal: turnSignal,
-                    ...(this.#sessionShutdownTimeoutMs !== undefined
-                        ? { sessionShutdownTimeoutMs: this.#sessionShutdownTimeoutMs }
-                        : {}),
-                }));
-                await awaitWithSignal(reload, turnSignal);
-                this.#assertResourceDiagnostics();
-                this.#dispatcher.initialize();
-            }
-
-            if (turnSignal.aborted) {
-                return this.#abortedResult();
-            }
-
             await abortDeadline.wait(this.#track(this.#selectModel(request)));
 
             if (turnSignal.aborted) {
@@ -968,8 +936,6 @@ class ManagedAgentRuntime {
             } else {
                 await abortDeadline.wait(this.#track(this.#runtime.session.prompt(prepared.prompt, {
                     attachments: prepared.attachments,
-                    expandPromptTemplates: false,
-                    source: "rpc",
                     preflightResult: (accepted) => {
                         if (!accepted)
                             return;
@@ -997,7 +963,6 @@ class ManagedAgentRuntime {
         } finally {
             try {
                 turnSignal.removeEventListener("abort", abort);
-                setReplacementSignal(this.#runtime, undefined);
                 this.#dispatcher.deactivate();
                 if (this.#abortActiveTurn === abortTurn)
                     this.#abortActiveTurn = null;
@@ -1080,12 +1045,9 @@ class ManagedAgentRuntime {
     }
 
     async #bind(session: AgentSession) {
-        this.#unsubscribe?.();
-        this.#unsubscribe = null;
         const bindingErrors: ExtensionError[] = [];
         let initializing = true;
         await session.bindExtensions({
-            mode: "print",
             onError: (error) => {
                 if (initializing)
                     bindingErrors.push(error);
@@ -1098,7 +1060,6 @@ class ManagedAgentRuntime {
         if (bindingErrors.length > 0)
             throw new Error(bindingErrors.map((entry) => `${entry.extensionPath}: ${entry.error}`).join("; "));
 
-        this.#assertResourceDiagnostics();
         this.#dispatcher.initialize();
         const prepareNextTurn = session.agent.prepareNextTurnWithContext;
         session.agent.prepareNextTurnWithContext = async (turn, signal) => {
@@ -1106,10 +1067,30 @@ class ManagedAgentRuntime {
             return prepareNextTurn?.(turn, signal);
         };
         session.agent.formatUnknownToolError = (name) => this.#dispatcher.unknownToolError(name);
+        session.agent.steeringSource = () => this.#steering();
         this.#unsubscribe = session.subscribe((event) => this.#dispatcher.handleEvent(event));
         await this.#identity.persist(session.sessionFile, session.sessionId);
     }
 
+    async #steering(): Promise<UserMessage[]> {
+        const request = this.#dispatcher.steerableTurn();
+
+        if (!request)
+            return [];
+
+        const messages: UserMessage[] = [];
+
+        for (const steered of request.claimSteering()) {
+            const prepared = await prepareInputAttachments(
+                { ...request, attachments: steered.attachments, prompt: steered.prompt },
+                this.#runtime.session.model?.input ?? [],
+            );
+            messages.push({ role: "user", content: [{ type: "text", text: prepared.prompt }, ...prepared.attachments], timestamp: Date.now() });
+        }
+
+        return messages;
+    }
+
     async #refreshTools(): Promise<void> {
         const systemPrompt = await this.#dispatcher.refreshTools();
         if (systemPrompt !== undefined && systemPrompt !== this.#configuration.systemPrompt) {
@@ -1139,17 +1120,6 @@ class ManagedAgentRuntime {
 
         this.#runtime.session.setThinkingLevel(level);
     }
-
-    #assertResourceDiagnostics() {
-        const loader = this.#runtime.services.resourceLoader;
-        const diagnostics = [
-            ...loader.getSkills().diagnostics.map((entry) => `skill ${entry.path ?? "?"}: ${entry.message}`),
-            ...loader.getPrompts().diagnostics.map((entry) => `prompt ${entry.path ?? "?"}: ${entry.message}`),
-        ];
-
-        if (diagnostics.length > 0)
-            throw new Error(`Das Laden der Ressourcen ist unvollständig: ${diagnostics.join("; ")}`);
-    }
 }
 
 type RuntimeRecord = {
@@ -1187,7 +1157,7 @@ export class AgentRuntimeManager {
         const context: AgentRuntimeContext = {
             runId: request.runId,
             agentId: request.agentId,
-            workspace: resolve(request.workspace),
+            workspace: request.workspace,
             allowedToolNames: request.allowedToolNames === null ? null : [...request.allowedToolNames],
             forkOf: request.forkOf,
         };
@@ -1323,7 +1293,8 @@ export class AgentRuntimeManager {
 
     async #create(context: AgentRuntimeContext, request: TurnRequest<"agent">, signal: AbortSignal) {
         const modelRuntime = await awaitWithSignal(this.#modelRuntime, signal);
-        const identity = new PersistedAgentSession(context, this.#options.sessions);
+        const runtimeDirectory = resolve(await awaitWithSignal(request.runtimeDirectory(), signal));
+        const identity = new PersistedAgentSession(context, this.#options.sessions, runtimeDirectory);
         const sessionManager = await awaitWithSignal(identity.open(), signal);
         const dispatcher = new TurnDispatcher(context, this.#options.onDiagnostic);
         const managedEnvironment = request.allowedToolNames === null;
@@ -1331,13 +1302,11 @@ export class AgentRuntimeManager {
         const resolvedFactories = loadHostFactories && this.#options.resolveExtensionFactories
             ? await awaitWithSignal(this.#options.resolveExtensionFactories(context, signal), signal)
             : undefined;
-        const resolvedSkillPaths = managedEnvironment && this.#options.resolveSkillPaths
-            ? await awaitWithSignal(this.#options.resolveSkillPaths(context, signal), signal)
-            : undefined;
-        const skillPaths = managedEnvironment
-            ? [...new Set([...(this.#options.skillPaths ?? []), ...(resolvedSkillPaths ?? [])])]
+        const skills = managedEnvironment && this.#options.resolveSkills
+            ? await awaitWithSignal(this.#options.resolveSkills(context, signal), signal)
             : [];
-        const skillPreload = managedEnvironment && skillPaths.length > 0 && this.#options.skillPreload !== false
+        assertUniqueSkillNames(skills);
+        const skillPreload = skills.length > 0 && this.#options.skillPreload !== false
             ? createSkillPreloadExtension({
                 modelRuntime,
                 ...this.#options.skillPreload,
@@ -1356,39 +1325,19 @@ export class AgentRuntimeManager {
             systemPrompt: request.systemPrompt,
         };
         const factory: CreateAgentSessionRuntimeFactory = async (runtimeOptions) => {
-            if (resolve(runtimeOptions.cwd) !== context.workspace)
-                throw new Error(`agent extension attempted to switch ${context.agentId} to workspace ${runtimeOptions.cwd}.`);
-
-            const settingsManager = SettingsManager.create(runtimeOptions.cwd, runtimeOptions.agentDir, {
-                projectTrusted: false,
-            });
             const services = await createAgentSessionServices({
                 cwd: runtimeOptions.cwd,
-                agentDir: runtimeOptions.agentDir,
                 signal: runtimeOptions.signal,
                 ...(runtimeOptions.onExtensionFactorySettlement
                     ? { onExtensionFactorySettlement: runtimeOptions.onExtensionFactorySettlement }
                     : {}),
                 modelRuntime,
-                settingsManager,
                 resourceLoaderOptions: {
-                    noExtensions: true,
-                    noSkills: true,
-                    noPromptTemplates: true,
-                    noContextFiles: true,
-                    additionalSkillPaths: skillPaths,
+                    skills,
                     extensionFactories,
                     systemPrompt: configuration.systemPrompt,
-                    systemPromptOverride: () => configuration.systemPrompt,
-                    appendSystemPrompt: [],
                 },
             });
-            this.#assertCreationDiagnostics(context, services.diagnostics);
-            const settingsErrors = settingsManager.drainErrors();
-
-            if (settingsErrors.length > 0)
-                throw new Error(settingsErrors.map((entry) => `${entry.scope}: ${entry.error.message}`).join("; "));
-
             const extensionErrors = services.resourceLoader.getExtensions().errors;
 
             if (extensionErrors.length > 0)
@@ -1405,26 +1354,20 @@ export class AgentRuntimeManager {
             const created = await createAgentSessionFromServices({
                 services,
                 sessionManager: runtimeOptions.sessionManager,
-                ...(runtimeOptions.sessionStartEvent ? { sessionStartEvent: runtimeOptions.sessionStartEvent } : {}),
                 model,
                 ...(thinking ?? this.#options.thinkingLevel
                     ? { thinkingLevel: thinking ?? this.#options.thinkingLevel }
                     : {}),
-                noTools: "builtin",
             });
 
-            return { ...created, services, diagnostics: services.diagnostics };
+            return { ...created, services };
         };
         const runtime = await createAgentSessionRuntime(factory, {
-            cwd: context.workspace,
-            agentDir: this.#options.agentDir,
+            cwd: runtimeDirectory,
             sessionManager,
             signal,
             onExtensionFactorySettlement: (settlement) =>
                 this.#rememberRunSettlement(context.runId, settlement),
-            ...(this.#options.sessionShutdownTimeoutMs !== undefined
-                ? { sessionShutdownTimeoutMs: this.#options.sessionShutdownTimeoutMs }
-                : {}),
         });
         const managed = new ManagedAgentRuntime({
             context,
@@ -1434,7 +1377,6 @@ export class AgentRuntimeManager {
             configuration,
             modelRuntime,
             defaultThinking: this.#options.thinkingLevel,
-            sessionShutdownTimeoutMs: this.#options.sessionShutdownTimeoutMs,
             turnAbortTimeoutMs: this.#turnAbortTimeoutMs,
             onDiagnostic: this.#options.onDiagnostic,
         });
@@ -1448,16 +1390,6 @@ export class AgentRuntimeManager {
         }
     }
 
-    #assertCreationDiagnostics(context: AgentRuntimeContext, diagnostics: AgentSessionRuntimeDiagnostic[]) {
-        for (const diagnostic of diagnostics)
-            this.#options.onDiagnostic?.({ ...diagnostic, context });
-
-        const errors = diagnostics.filter((entry) => entry.type === "error");
-
-        if (errors.length > 0)
-            throw new Error(errors.map((entry) => entry.message).join("; "));
-    }
-
     async #disposeRecord(key: string, record: RuntimeRecord) {
         record.creationAbort.abort(new Error(`agent runtime ${record.context.runId}/${record.context.agentId} is stopping.`));
         let created = false;