@schlenkr/ragents 0.1.5 → 0.1.7

package/packages/ragents/src/agents/scheduler.ts

@@ -7,20 +7,24 @@ import {
     type DriverRegistry,
     type DriverToolEvent,
     type LiveEvent,
+    type SteeredInput,
+    type TurnAttachment,
 } from "../drivers/types.ts";
 import type { JsonValue } from "../domain/json.ts";
 import type { ModelSelection } from "../domain/driver.ts";
+import type { CommandContext } from "../runtime/command.ts";
 import type { Journal } from "../runtime/journal.ts";
 import type { Orchestration } from "../runtime/orchestration.ts";
 import type { ModelCatalog } from "./catalog.ts";
-import { actorRosterText } from "./delivery.ts";
+import { actorRosterText, deliveredInputOf, renderedPromptFor } from "./delivery.ts";
 import type { LiveBus } from "./live.ts";
-import type { ToolProvider } from "./plugins.ts";
+import { ToolRegistry, type ToolProvider } from "./plugins.ts";
 import { holdsUsable, type RunFunction } from "./tools.ts";
 import type { WorkspaceToolNaming } from "./workspace-tools.ts";
 import { TurnToolset } from "./toolset.ts";
 import { toolOrientationText } from "./tool-orientation.ts";
-import { claimTurn, promptFor, type ClaimedTurn } from "./turn.ts";
+import { claimTurn, type ClaimedTurn } from "./turn.ts";
+import { turnModelContext } from "./model-context.ts";
 import { FixedWorkspaces, type Workspaces } from "./workspaces.ts";
 
 export type TurnSchedulerOptions = {
@@ -35,8 +39,21 @@ export type TurnSchedulerOptions = {
     toolChapters?: (runId: string, actor: ExecutableActor, toolNames: readonly string[], availableTools: readonly RunFunction[]) => string | Promise<string>;
     modelSelection?: (turn: ClaimedTurn, actor: ExecutableActor) => ModelSelection;
     onError?: (error: unknown) => void;
+    /** How long an interruption waits for the aborted driver before it ends the turn in the journal alone. */
+    interruptWaitMs?: number;
 };
 
+/** Who interrupts a turn and why; the interruption is written in this command context. */
+export type TurnInterruption = {
+    context: CommandContext;
+    reason: string;
+};
+
+const DEFAULT_INTERRUPT_WAIT_MS = 15_000;
+
+/** Longer inputs do not join a running turn; they wait for their own turn. */
+export const STEERING_MAX_CHARS = 30_000;
+
 type ActiveTurn = {
     runId: string;
     actorId: string;
@@ -84,8 +101,6 @@ const keyOf = (runId: string, actorId: string) => JSON.stringify([runId, actorId
 
 const errorMessage = (error: unknown) => (error instanceof Error ? error.message : String(error));
 
-export const defaultContract = "";
-
 const systemPromptFor = (
     runId: string,
     actor: ExecutableActor,
@@ -93,9 +108,12 @@ const systemPromptFor = (
     basePrompt: (runId: string, actor: ExecutableActor, toolNames: readonly string[]) => string,
     contract: (actor: ExecutableActor) => string,
     orientation: string,
+    workspace: string,
 ) => actor.kind === "agent" && actor.toolNames?.length === 0
     ? actor.prompt.trim()
-    : [basePrompt(runId, actor, toolNames).trim(), contract(actor).trim(), orientation].filter(Boolean).join("\n\n");
+    : [basePrompt(runId, actor, toolNames).trim(), contract(actor).trim(), orientation, workspace]
+        .filter(Boolean)
+        .join("\n\n");
 
 export class TurnScheduler {
     readonly #runtime: Orchestration;
@@ -118,7 +136,10 @@ export class TurnScheduler {
     readonly #onError: (error: unknown) => void;
     readonly #modelSelection: TurnSchedulerOptions["modelSelection"];
     readonly #active = new Map<string, ActiveTurn>();
+    readonly #interruptions = new Map<string, TurnInterruption & { turnId: string }>();
+    readonly #interruptWaitMs: number;
     readonly #blocked = new Map<string, number>();
+    readonly #toolChecks = new Map<string, Promise<void>>();
     readonly #lifecycle = new Set<{ runId: string; promise: Promise<void> }>();
     readonly #pendingAgentDisposals = new Map<string, PendingAgentDisposal>();
     readonly #runs = new Map<string, RunRuntimeState>();
@@ -143,10 +164,11 @@ export class TurnScheduler {
         this.#live = options.live;
         this.#workspaceToolNaming = options.workspaceToolNaming;
         this.#basePrompt = options.basePrompt ?? ((_runId, actor) => (actor.kind === "agent" ? actor.prompt : ""));
-        this.#contract = options.contract ?? (() => defaultContract);
+        this.#contract = options.contract ?? (() => "");
         this.#toolChapters = options.toolChapters ?? (() => "");
         this.#modelSelection = options.modelSelection;
         this.#onError = options.onError ?? ((error) => console.error("Turn scheduler failed:", error));
+        this.#interruptWaitMs = options.interruptWaitMs ?? DEFAULT_INTERRUPT_WAIT_MS;
     }
 
     #workspaceToolsFor(actor: ExecutableActor): readonly string[] {
@@ -175,6 +197,12 @@ export class TurnScheduler {
                         this.#disposeAgentRuntime(event.runId, event.payload.actorId);
                     if (event.type === "actor.restarted")
                         this.#reviveAgentRuntime(event.runId, event.payload.actorId);
+                    if (event.type === "agent.spawned")
+                        this.#checkToolNames(event.runId, event.payload.agentId);
+                    if (event.type === "script.created")
+                        this.#checkToolNames(event.runId, event.payload.scriptId);
+                    if (event.type === "actor.restarted")
+                        this.#checkToolNames(event.runId, event.payload.actorId);
                 }
 
                 for (const runId of new Set(events.map((event) => event.runId)))
@@ -196,11 +224,55 @@ export class TurnScheduler {
         return this.#active.has(keyOf(runId, actorId));
     }
 
+    /** Ends only the running turn of this actor; the actor stays active, and without a running turn nothing happens. */
+    async interruptTurn(runId: string, actorId: string, interruption: TurnInterruption) {
+        const turnId = this.#runningTurnId(runId, actorId);
+
+        if (!turnId)
+            return;
+
+        const key = keyOf(runId, actorId);
+        const active = this.#active.get(key);
+
+        if (active) {
+            if (!this.#interruptions.has(key))
+                this.#interruptions.set(key, { ...interruption, turnId });
+
+            active.controller.abort();
+            await this.#settledWithin(active.promise, this.#interruptWaitMs);
+        }
+
+        if (this.#runningTurnId(runId, actorId) !== turnId)
+            return;
+
+        this.#runtime.interruptTurn(interruption.context, runId, actorId, { turnId, reason: interruption.reason });
+
+        if (active)
+            this.#live?.publish(runId, actorId, { kind: "turn-finished", turnId, outcome: "abandoned" });
+    }
+
+    #runningTurnId(runId: string, actorId: string) {
+        const actor = this.#actor(runId, actorId);
+
+        return actor?.lifecycle.kind === "running" ? actor.lifecycle.turnId : null;
+    }
+
+    async #settledWithin(promise: Promise<void>, timeoutMs: number) {
+        let timer: ReturnType<typeof setTimeout> | undefined;
+
+        try {
+            await Promise.race([promise, new Promise<void>((resolve) => { timer = setTimeout(resolve, timeoutMs); })]);
+        } finally {
+            clearTimeout(timer);
+        }
+    }
+
     async waitForIdle() {
-        while (this.#active.size > 0 || this.#lifecycle.size > 0) {
+        while (this.#active.size > 0 || this.#lifecycle.size > 0 || this.#toolChecks.size > 0) {
             await Promise.allSettled([
                 ...[...this.#active.values()].map((entry) => entry.promise),
                 ...[...this.#lifecycle].map((entry) => entry.promise),
+                ...this.#toolChecks.values(),
             ]);
         }
 
@@ -319,18 +391,18 @@ export class TurnScheduler {
         if (!this.#runState(runId).retired)
             this.#updateRunState(runId, { quarantine });
 
-        void until.then(
-            () => {
-                if (this.#runState(runId).quarantine !== quarantine)
-                    return;
+        // The quarantine lasts while cleanup runs; a failed cleanup is reported and does not block the run for good.
+        const lift = () => {
+            if (this.#runState(runId).quarantine !== quarantine)
+                return;
 
-                this.#updateRunState(runId, { quarantine: null });
-                this.#releaseRunBlock(runId);
-            },
-            (error: unknown) => {
-                this.#onError(error);
-            },
-        );
+            this.#updateRunState(runId, { quarantine: null });
+            this.#releaseRunBlock(runId);
+        };
+        void until.then(lift, (error: unknown) => {
+            this.#onError(error);
+            lift();
+        });
     }
 
     #releaseRunBlock(runId: string): void {
@@ -626,12 +698,73 @@ export class TurnScheduler {
                 actor.kind !== "human" &&
                 isAutomated(actor.execution.driver.kind) &&
                 actor.lifecycle.kind === "idle" &&
+                !this.#toolChecks.has(keyOf(runId, actor.id)) &&
                 input
             )
                 this.#launch(runId, actor.id, input.id, view.revision);
         }
     }
 
+    /** A requested tool name that no host function resolves, not even as unavailable, stops a scheduled actor before its first turn. */
+    #checkToolNames(runId: string, actorId: string) {
+        const actor = this.#actor(runId, actorId);
+
+        if (!actor || !isAutomated(actor.execution.driver.kind) || actor.toolNames === null || actor.toolNames.length === 0)
+            return;
+
+        const key = keyOf(runId, actorId);
+        const check = this.#unknownToolNames(runId, actor)
+            .then((unknown) => {
+                const current = this.#actor(runId, actorId);
+
+                if (unknown.length === 0 || !current || current.lifecycle.kind === "stopped")
+                    return;
+
+                const reason = `Keine Host-Funktion löst die Werkzeuge ${unknown.join(", ")} auf; `
+                    + `@${current.handle} wurde deshalb gestoppt. Die Namen in toolNames prüfen oder das Plugin laden, das sie bereitstellt.`;
+                const state = this.#runtime.state(runId);
+                this.#runtime.stopActor(
+                    { actorId: state.ownerId, commandId: `scheduler:unknown-tools:${actorId}:${state.revision}` },
+                    runId,
+                    actorId,
+                    reason,
+                );
+            })
+            .catch((error: unknown) => this.#onError(error))
+            .finally(() => {
+                this.#toolChecks.delete(key);
+
+                if (this.#stopped)
+                    return;
+
+                try {
+                    this.#scanRun(runId);
+                } catch (error) {
+                    this.#onError(error);
+                }
+            });
+        this.#toolChecks.set(key, check);
+    }
+
+    async #unknownToolNames(runId: string, actor: ExecutableActor): Promise<string[]> {
+        const workspace = this.#workspaceToolNaming?.agentToolNames(actor.execution.driver.kind);
+        const known = new Set<string>(workspace ? [...workspace.read, ...workspace.write, ...workspace.execute] : []);
+        const registry = this.#registry ?? new ToolRegistry();
+        const resolved = await registry.resolve({
+            runId,
+            actorId: actor.id,
+            turnId: null,
+            actor,
+            view: this.#runtime.view(runId),
+            workspace: this.#workspaces.ensure(runId, actor.execution.workspacePath),
+        }, (tool) => known.add(tool.name));
+
+        for (const tool of resolved)
+            known.add(tool.name);
+
+        return (actor.toolNames ?? []).filter((name) => !known.has(name));
+    }
+
     #launch(runId: string, actorId: string, inputId: string, revision: number) {
         const key = keyOf(runId, actorId);
 
@@ -647,6 +780,7 @@ export class TurnScheduler {
             })
             .finally(() => {
                 this.#active.delete(key);
+                this.#interruptions.delete(key);
 
                 if (this.#stopped)
                     return;
@@ -719,7 +853,6 @@ export class TurnScheduler {
                 signal: controller.signal,
                 chapters: (toolNames) => this.#toolChapters(runId, actor, toolNames, toolset.functions),
             });
-            const allowed = actor.toolNames === null ? null : new Set(actor.toolNames);
             const configuredWorkspace = this.#workspaceToolNaming?.agentToolNames(driverRef.kind);
             const configuredWorkspaceNames = configuredWorkspace
                 ? [...configuredWorkspace.read, ...configuredWorkspace.write, ...configuredWorkspace.execute]
@@ -733,10 +866,11 @@ export class TurnScheduler {
                     `Actor ${actor.id} requested workspace tools without workspace.use: ${deniedWorkspaceTools.join(", ")}.`,
                 );
 
-            const workspaceTools = this.#workspaceToolsFor(actor)
-                .filter((name) => !toolset.functions.some((tool) => tool.name === name))
-                .filter((name) => allowed === null || allowed.has(name));
-            const resolvedToolNames = new Set([...toolset.functions.map((tool) => tool.name), ...workspaceTools]);
+            const workspaceToolNames = this.#workspaceToolsFor(actor);
+            const resolvedToolNames = new Set(toolset.functions.map((tool) => tool.name));
+            const workspaceChapter = workspaceToolNames.some((name) => resolvedToolNames.has(name))
+                ? this.#workspaces.description(runId) ?? ""
+                : "";
             const unresolvedToolNames = actor.toolNames?.filter((name) => !resolvedToolNames.has(name)) ?? [];
 
             if (driverRef.kind !== "agent" && unresolvedToolNames.length > 0)
@@ -749,11 +883,8 @@ export class TurnScheduler {
                 turnId: turn.turnId,
                 startedAt: turn.startedAt,
                 input: turn.input,
-                attachments: turn.input.artifactIds.map((artifactId) => {
-                    const { artifact, content } = this.#runtime.artifactContent(runId, artifactId, actorId);
-                    return { name: artifact.title, mediaType: artifact.mediaType, content };
-                }),
-                prompt: promptFor(this.#runtime.view(runId), actorId, turn.input),
+                attachments: this.#attachmentsOf(runId, actorId, turn.input.artifactIds),
+                prompt: renderedPromptFor(this.#runtime.view(runId), actorId, turn.input),
                 systemPrompt: systemPromptFor(
                     runId,
                     actor,
@@ -766,10 +897,11 @@ export class TurnScheduler {
                             ? actorRosterText(this.#runtime.view(runId), actorId)
                             : "",
                     ].filter(Boolean).join("\n\n") : "",
+                    workspaceChapter,
                 ),
                 workspace,
+                storeAttachment: (name: string, content: Uint8Array) => this.#workspaces.storeAttachment(runId, name, content),
                 tools: driverRef.kind === "script" ? toolset.functions : toolset.tools,
-                workspaceTools,
                 allowedToolNames: actor.toolNames,
                 refreshTools: async () => {
                     await toolset.refresh();
@@ -777,7 +909,7 @@ export class TurnScheduler {
                         tools: toolset.tools,
                         systemPrompt: systemPromptFor(
                             runId, actor,
-                            [...new Set([...toolset.functions.map((tool) => tool.name), ...workspaceTools])],
+                            toolset.functions.map((tool) => tool.name),
                             this.#basePrompt, this.#contract,
                             actor.kind === "agent" ? [
                                 toolOrientationText(toolset.functions),
@@ -785,6 +917,7 @@ export class TurnScheduler {
                                     ? actorRosterText(this.#runtime.view(runId), actorId)
                                     : "",
                             ].filter(Boolean).join("\n\n") : "",
+                            workspaceChapter,
                         ),
                     };
                 },
@@ -798,8 +931,9 @@ export class TurnScheduler {
                         ...request,
                         driverKind: "agent",
                         selection: selection!,
-                        forkOf: actor.kind === "agent" ? actor.forkOf : null,
-                        invoke: (toolCallId: string, name: string, input: JsonValue) => toolset.invoke(toolCallId, name, input),
+                        invoke: (toolCallId: string, name: string, input: JsonValue, modelContext?: string) => toolset.invoke(toolCallId, name, input, modelContext),
+                        claimSteering: () => this.#claimSteering(turn, controller.signal),
+                        ...turnModelContext(this.#runtime, turn, () => emitted++),
                     },
                     controller.signal,
                 )
@@ -846,6 +980,52 @@ export class TurnScheduler {
         }
     }
 
+    #attachmentsOf(runId: string, actorId: string, artifactIds: readonly string[]): TurnAttachment[] {
+        return artifactIds.map((artifactId) => {
+            const { artifact, content } = this.#runtime.artifactContent(runId, artifactId, actorId);
+            return { name: artifact.title, mediaType: artifact.mediaType, content };
+        });
+    }
+
+    /** The oldest pending inputs join the running turn in journal order, up to the first one over the length limit. */
+    #claimSteering(turn: ClaimedTurn, signal: AbortSignal): readonly SteeredInput[] {
+        if (signal.aborted || !this.#acceptsTurns(turn.runId) || !this.#isRunning(turn))
+            return [];
+
+        const view = this.#runtime.view(turn.runId);
+        const pending = view.inputs
+            .filter((entry) => entry.actorId === turn.actorId && isPendingActorInput(entry))
+            .sort((left, right) => left.sequence - right.sequence)
+            .map((entry) => deliveredInputOf(view, entry));
+        const tooLong = pending.findIndex((entry) => entry.content.length > STEERING_MAX_CHARS);
+        const joining = tooLong === -1 ? pending : pending.slice(0, tooLong);
+
+        if (joining.length === 0)
+            return [];
+
+        const steered = this.#runtime.steerInputs(
+            {
+                actorId: turn.actorId,
+                commandId: `scheduler:${turn.turnId}:steer:${joining[0]!.id}`,
+                turnId: turn.turnId,
+                correlationId: turn.turnId,
+            },
+            turn.runId,
+            turn.actorId,
+            { turnId: turn.turnId, inputIds: joining.map((entry) => entry.id) },
+        );
+
+        return joining.map(({ id }) => {
+            const input = deliveredInputOf(steered, steered.inputs.find((entry) => entry.id === id)!);
+
+            return {
+                input,
+                prompt: renderedPromptFor(steered, turn.actorId, input),
+                attachments: this.#attachmentsOf(turn.runId, turn.actorId, input.artifactIds),
+            };
+        });
+    }
+
     #requiredDriver<Kind extends AutomatedDriverKind>(kind: Kind): AgentDriver<Kind> {
         const driver = this.#drivers[kind];
 
@@ -868,6 +1048,9 @@ export class TurnScheduler {
     }
 
     #append(turn: ClaimedTurn, index: number, driverEvent: DriverEvent) {
+        if (driverEvent.kind === "assistant-interrupted" && !this.#isRunning(turn))
+            return;
+
         const context = {
             actorId: turn.actorId,
             commandId: `scheduler:${turn.turnId}:${driverEvent.kind}:${index}`,
@@ -876,10 +1059,8 @@ export class TurnScheduler {
         };
         const payload = { turnId: turn.turnId, text: driverEvent.text };
 
-        if (driverEvent.kind === "assistant")
-            this.#runtime.appendModelOutput(context, turn.runId, turn.actorId, payload);
-        else if (driverEvent.kind === "reasoning")
-            this.#runtime.appendModelReasoning(context, turn.runId, turn.actorId, payload);
+        if (driverEvent.kind === "assistant-interrupted")
+            this.#runtime.appendInterruptedModelOutput(context, turn.runId, turn.actorId, payload);
         else
             this.#runtime.appendRuntimeOutput(context, turn.runId, turn.actorId, payload);
     }
@@ -952,7 +1133,6 @@ export class TurnScheduler {
 
         try {
             this.#append(turn, Number.MAX_SAFE_INTEGER, { kind: "runtime", text: message });
-            this.#closeOpenToolCalls(turn, message);
             this.#runtime.finishTurn(
                 {
                     actorId: turn.actorId,
@@ -979,18 +1159,25 @@ export class TurnScheduler {
         if (!this.#isRunning(turn))
             return;
 
-        try {
-            this.#closeOpenToolCalls(turn, reason);
-            this.#runtime.interruptTurn(
-                {
+        const requested = this.#interruptions.get(keyOf(turn.runId, turn.actorId));
+        const interruption: TurnInterruption = requested?.turnId === turn.turnId
+            ? requested
+            : {
+                context: {
                     actorId: turn.actorId,
                     commandId: `scheduler:${turn.turnId}:interrupt`,
                     turnId: turn.turnId,
                     correlationId: turn.turnId,
                 },
+                reason,
+            };
+
+        try {
+            this.#runtime.interruptTurn(
+                interruption.context,
                 turn.runId,
                 turn.actorId,
-                { turnId: turn.turnId, reason },
+                { turnId: turn.turnId, reason: interruption.reason },
             );
             this.#live?.publish(turn.runId, turn.actorId, {
                 kind: "turn-finished",
@@ -1004,45 +1191,8 @@ export class TurnScheduler {
     }
 
     #openToolCalls(turn: ClaimedTurn) {
-        const open = new Map<string, { id: string; name: string }>();
-
-        for (const event of this.#runtime.events(turn.runId)) {
-            if (event.actorId !== turn.actorId)
-                continue;
-
-            if (event.type === "tool.call.started" && event.payload.turnId === turn.turnId) {
-                open.set(event.payload.toolCallId, {
-                    id: event.payload.toolCallId,
-                    name: event.payload.name,
-                });
-            }
-
-            if ((event.type === "tool.call.completed" || event.type === "tool.call.failed")
-                && event.payload.turnId === turn.turnId)
-                open.delete(event.payload.toolCallId);
-        }
-
-        return [...open.values()];
-    }
-
-    #closeOpenToolCalls(turn: ClaimedTurn, reason: string) {
-        for (const call of this.#openToolCalls(turn)) {
-            this.#runtime.failToolCall(
-                {
-                    actorId: turn.actorId,
-                    commandId: `scheduler:${turn.turnId}:tool:${call.id}:abandoned`,
-                    turnId: turn.turnId,
-                    correlationId: call.id,
-                },
-                turn.runId,
-                turn.actorId,
-                {
-                    turnId: turn.turnId,
-                    toolCallId: call.id,
-                    name: call.name,
-                    error: reason,
-                },
-            );
-        }
+        return this.#runtime.view(turn.runId).turns
+            .find((entry) => entry.id === turn.turnId)?.toolCalls
+            .filter((call) => call.status === "running") ?? [];
     }
 }

package/packages/ragents/src/agents/schemas.ts

@@ -1,8 +1,7 @@
-import { Type, type Static, type TLiteral, type TSchema } from "typebox";
+import { Type, type TLiteral } from "typebox";
 
 import { agentDriverKinds } from "../domain/driver.ts";
 import { capabilityNames } from "../domain/vocabulary.ts";
-import type { VirtualTypeScriptDiagnostic } from "../typescript/compiler.ts";
 
 type Literals<Values extends readonly string[]> = { -readonly [Key in keyof Values]: TLiteral<Values[Key] & string> };
 
@@ -26,39 +25,5 @@ export const grantSchema = Type.Object({
 
 export const namedValuesSchema = Type.Array(Type.Object({ name: Type.String({ minLength: 1 }), value: Type.String() }));
 
-const positionSchema = Type.Object({
-    line: Type.Integer(),
-    column: Type.Integer(),
-}, { additionalProperties: false });
-
-export const typeScriptDiagnosticSchema = Type.Object({
-    code: Type.Integer(),
-    category: Type.Union([
-        Type.Literal("warning"),
-        Type.Literal("error"),
-        Type.Literal("suggestion"),
-        Type.Literal("message"),
-    ]),
-    message: Type.String(),
-    fileName: Type.Optional(Type.String()),
-    start: Type.Optional(positionSchema),
-    end: Type.Optional(positionSchema),
-}, { additionalProperties: false });
-
-export type JsonTypeScriptDiagnostic = Static<typeof typeScriptDiagnosticSchema>;
-
-export const jsonTypeScriptDiagnostics = (
-    diagnostics: readonly VirtualTypeScriptDiagnostic[],
-): JsonTypeScriptDiagnostic[] => diagnostics.map((entry) => ({
-    code: entry.code,
-    category: entry.category,
-    message: entry.message,
-    ...(entry.fileName ? { fileName: entry.fileName } : {}),
-    ...(entry.start ? { start: { line: entry.start.line, column: entry.start.column } } : {}),
-    ...(entry.end ? { end: { line: entry.end.line, column: entry.end.column } } : {}),
-}));
-
 export const recordOf = (entries: readonly { name: string; value: string }[] | undefined) =>
     Object.fromEntries((entries ?? []).map((entry) => [entry.name, entry.value]));
-
-export type SchemaOf<Schema extends TSchema> = Static<Schema>;

package/packages/ragents/src/agents/tool-orientation.ts

@@ -5,7 +5,7 @@ export type ToolChapters = (toolNames: readonly string[]) => string | Promise<st
 export const toolOrientationText = (functions: readonly RunFunction[]): string => functions.length === 0 ? "" : [
     "[TypeScript-Funktionen dieses Actors]",
     "Direkt bereitgestellte Werkzeuge wie read, write, edit und bash ohne zusätzliche TypeScript-Hülle aufrufen. Die übrigen Funktionen über context.functions in typescript_eval aufrufen.",
-    "typescript_api mit names liefert die genauen Eingabe- und Rückgabetypen sowie ausführliche Beschreibungen und Anleitungen.",
+    "typescript_api mit names liefert die genauen Eingabe- und Rückgabetypen sowie ausführliche Beschreibungen und Anleitungen, mit context: true einmal die Deklarationen von context selbst (state, log, std mit mediators).",
     ...functions.filter((fn) => fn.name !== "typescript_api" && fn.name !== "typescript_eval")
         .toSorted((left, right) => left.name.localeCompare(right.name, "en"))
         .map((fn) => `- ${fn.name}${fn.nativeTool ? " (direktes Werkzeug)" : ""}: ${fn.description.replace(/\s+/g, " ").trim()}`),