@schlenkr/ragents 0.1.10 → 0.1.12

package/packages/ragents/src/access.ts

@@ -5,7 +5,7 @@ export interface AccessUser {
   readonly startEntries?: readonly string[];
 }
 
-/** Abfrageparameter, unter dem GET-Abrufe ohne Header (Ereignisstrom, iframes) einen Zugangstoken mitgeben. */
+/** Query parameter under which GET requests without headers (event stream, iframes) pass an access token. */
 export const ACCESS_TOKEN_QUERY = "access";
 
 export const isAccessRight = (value: unknown): value is string =>
@@ -21,17 +21,17 @@ export interface AccessContext extends AccessSnapshot {
 }
 
 export const builtinPermissions = [
-  { id: "runs.read", description: "Runs, Chats, Journale und Arbeitsbereiche ansehen." },
-  { id: "runs.read.all", description: "Die Runs aller Benutzer sehen und bedienen, nicht nur die eigenen; einen Run, den nur sein Eigentümer bedient, nur im Journal lesen und stoppen, ohne seinen Arbeitsbereich." },
-  { id: "runs.write", description: "Vorhandene Runs steuern, Nachrichten senden, freigegebene Setups starten und App-Aktionen ausführen." },
-  { id: "runs.create", description: "Freie Runs erstellen, Startoptionen wählen und Aufträge vorbereiten." },
-  { id: "runs.inspect", description: "Modelle, technische Laufdetails, Journale und Programmquellen ansehen." },
-  { id: "runs.trace", description: "Denk- und Werkzeugschritte im Chat mit Inhalt sehen und ihren Detailgrad wählen." },
-  { id: "runs.delete", description: "Runs und ihre gespeicherten Daten löschen." },
-  { id: "settings.read", description: "Profil, Konfiguration und Plugins ansehen." },
-  { id: "settings.write", description: "Einstellungen und externen Zugang ändern." },
-  { id: "models.use", description: "Modelle über das Modell-Relay dieses Servers aufrufen." },
-  { id: "profile.fetch", description: "Das Client-Profil dieses Servers beschreiben und herunterladen." },
+  { id: "runs.read", description: "View runs, chats, journals and workspaces." },
+  { id: "runs.read.all", description: "See and operate the runs of all users, not only your own; a run that only its owner operates can only be read in the journal and stopped, without its workspace." },
+  { id: "runs.write", description: "Control existing runs, send messages, start released setups and execute app actions." },
+  { id: "runs.create", description: "Create free runs, choose start options and prepare tasks." },
+  { id: "runs.inspect", description: "View models, technical run details, journals and program sources." },
+  { id: "runs.trace", description: "See thinking and tool steps in the chat with their content and choose their level of detail." },
+  { id: "runs.delete", description: "Delete runs and their stored data." },
+  { id: "settings.read", description: "View profile, configuration and plugins." },
+  { id: "settings.write", description: "Change settings and external access." },
+  { id: "models.use", description: "Call models through the model relay of this server." },
+  { id: "profile.fetch", description: "Describe and download the client profile of this server." },
 ] as const;
 
 export const hasRight = (access: AccessSnapshot, right: string): boolean =>

package/packages/ragents/src/agents/actor-input.ts

@@ -6,7 +6,7 @@ import type { CommandContext } from "../runtime/command.ts";
 import type { Orchestration } from "../runtime/orchestration.ts";
 
 export const actorInputSchema = Type.Object({
-    actor: Type.String({ minLength: 1, description: "Actor ID oder Handle" }),
+    actor: Type.String({ minLength: 1, description: "Actor ID or handle" }),
     content: Type.String({ minLength: 1 }),
     artifactIds: Type.Optional(Type.Array(Type.String({ minLength: 1 }), { uniqueItems: true })),
 }, { additionalProperties: false });
@@ -22,44 +22,44 @@ const eventPayloads = {
         title: Type.String(),
     }),
     "run.forked": payloadOf<"run.forked">({
-        sourceRunId: Type.String({ description: "ID des Quell-Runs" }),
+        sourceRunId: Type.String({ description: "ID of the source run" }),
         sourceSequence: Type.Integer(),
     }),
     "run.primary-actor-selected": payloadOf<"run.primary-actor-selected">({
-        actorId: Type.String({ description: "ID des primären Actors" }),
+        actorId: Type.String({ description: "ID of the primary actor" }),
     }),
     "run.title-changed": payloadOf<"run.title-changed">({
-        title: Type.String({ description: "Neuer Titel des Runs" }),
+        title: Type.String({ description: "New title of the run" }),
     }),
     "agent.spawned": payloadOf<"agent.spawned">({
-        agentId: Type.String({ description: "ID des neuen Agenten; actor_input und actor_stop nehmen sie oder @handle" }),
+        agentId: Type.String({ description: "ID of the new agent; actor_input and actor_stop take it or @handle" }),
         handle: Type.String(),
         displayName: Type.String(),
     }),
     "script.created": payloadOf<"script.created">({
-        scriptId: Type.String({ description: "ID des neuen TypeScript-Actors" }),
+        scriptId: Type.String({ description: "ID of the new TypeScript actor" }),
         handle: Type.String(),
         displayName: Type.String(),
     }),
     "actor.input.enqueued": payloadOf<"actor.input.enqueued">({
-        inputId: Type.String({ description: "ID des eingereihten Inputs" }),
-        actorId: Type.String({ description: "ID des empfangenden Actors" }),
+        inputId: Type.String({ description: "ID of the enqueued input" }),
+        actorId: Type.String({ description: "ID of the receiving actor" }),
     }),
     "turn.started": payloadOf<"turn.started">({
-        turnId: Type.String({ description: "ID des gestarteten Turns" }),
+        turnId: Type.String({ description: "ID of the started turn" }),
         inputId: Type.String(),
     }),
     "turn.input-steered": payloadOf<"turn.input-steered">({
-        turnId: Type.String({ description: "Laufender Turn, in den der Input eingespeist wurde" }),
+        turnId: Type.String({ description: "Running turn into which the input was fed" }),
         inputId: Type.String(),
     }),
     "turn.finished": payloadOf<"turn.finished">({
-        turnId: Type.String({ description: "ID des beendeten Turns" }),
+        turnId: Type.String({ description: "ID of the finished turn" }),
         outcome: Type.String(),
         reason: Type.Optional(Type.String()),
     }),
     "turn.interrupted": payloadOf<"turn.interrupted">({
-        turnId: Type.String({ description: "ID des unterbrochenen Turns" }),
+        turnId: Type.String({ description: "ID of the interrupted turn" }),
     }),
     "model.input.presented": payloadOf<"model.input.presented">({
         turnId: Type.String({ description: "Turn in which the model was given the input" }),
@@ -77,85 +77,85 @@ const eventPayloads = {
         tokensBefore: Type.Integer(),
     }),
     "model.output.completed": payloadOf<"model.output.completed">({
-        turnId: Type.String({ description: "Turn, zu dem die Ausgabe gehört" }),
+        turnId: Type.String({ description: "Turn the output belongs to" }),
     }),
     "model.output.interrupted": payloadOf<"model.output.interrupted">({
-        turnId: Type.String({ description: "Turn, zu dem die Ausgabe gehört" }),
+        turnId: Type.String({ description: "Turn the output belongs to" }),
     }),
     "model.reasoning.completed": payloadOf<"model.reasoning.completed">({
-        turnId: Type.String({ description: "Turn, zu dem die Ausgabe gehört" }),
+        turnId: Type.String({ description: "Turn the output belongs to" }),
     }),
     "runtime.output.recorded": payloadOf<"runtime.output.recorded">({
-        turnId: Type.String({ description: "Turn, zu dem die Ausgabe gehört" }),
+        turnId: Type.String({ description: "Turn the output belongs to" }),
     }),
     "tool.call.started": payloadOf<"tool.call.started">({
         turnId: Type.String(),
-        toolCallId: Type.String({ description: "ID des Werkzeugaufrufs" }),
+        toolCallId: Type.String({ description: "ID of the tool call" }),
         name: Type.String(),
     }),
     "tool.call.source": payloadOf<"tool.call.source">({
         turnId: Type.String(),
-        toolCallId: Type.String({ description: "ID des Werkzeugaufrufs" }),
+        toolCallId: Type.String({ description: "ID of the tool call" }),
         path: Type.Union([Type.String(), Type.Null()]),
     }),
     "tool.call.completed": payloadOf<"tool.call.completed">({
         turnId: Type.String(),
-        toolCallId: Type.String({ description: "ID des Werkzeugaufrufs" }),
+        toolCallId: Type.String({ description: "ID of the tool call" }),
         name: Type.String(),
     }),
     "tool.call.failed": payloadOf<"tool.call.failed">({
         turnId: Type.String(),
-        toolCallId: Type.String({ description: "ID des Werkzeugaufrufs" }),
+        toolCallId: Type.String({ description: "ID of the tool call" }),
         name: Type.String(),
         error: Type.String(),
     }),
     "actor.tools.opened": payloadOf<"actor.tools.opened">({
-        actorId: Type.String({ description: "Actor, dessen Werkzeuge geöffnet wurden" }),
+        actorId: Type.String({ description: "Actor whose tools were opened" }),
         toolNames: Type.Array(Type.String()),
     }),
     "actor.stopped": payloadOf<"actor.stopped">({
-        actorId: Type.String({ description: "ID des gestoppten Actors" }),
+        actorId: Type.String({ description: "ID of the stopped actor" }),
     }),
     "actor.restarted": payloadOf<"actor.restarted">({
-        actorId: Type.String({ description: "ID des neu gestarteten Actors" }),
+        actorId: Type.String({ description: "ID of the restarted actor" }),
     }),
     "subscription.created": payloadOf<"subscription.created">({
-        subscriptionId: Type.String({ description: "ID der neuen Subscription" }),
+        subscriptionId: Type.String({ description: "ID of the new subscription" }),
         subscriberId: Type.String(),
     }),
     "subscription.removed": payloadOf<"subscription.removed">({
-        subscriptionId: Type.String({ description: "ID der entfernten Subscription" }),
+        subscriptionId: Type.String({ description: "ID of the removed subscription" }),
     }),
     "subscription.failed": payloadOf<"subscription.failed">({
-        subscriptionId: Type.String({ description: "ID der gescheiterten Subscription" }),
+        subscriptionId: Type.String({ description: "ID of the failed subscription" }),
         sourceEventId: Type.String(),
         reason: Type.String(),
     }),
     "action.proposed": payloadOf<"action.proposed">({
-        actionId: Type.String({ description: "ID der vorgeschlagenen Aktion" }),
+        actionId: Type.String({ description: "ID of the proposed action" }),
     }),
     "action.resolved": payloadOf<"action.resolved">({
-        actionId: Type.String({ description: "ID der aufgelösten Aktion" }),
+        actionId: Type.String({ description: "ID of the resolved action" }),
         decision: Type.String(),
     }),
     "artifact.published": payloadOf<"artifact.published">({
         artifact: Type.Object({
-            id: Type.String({ description: "ID des Artefakts; artifact_read liest es damit" }),
+            id: Type.String({ description: "ID of the artifact; artifact_read reads it with this" }),
         }, { additionalProperties: false }),
     }),
     "plugin.state-replaced": payloadOf<"plugin.state-replaced">({
-        pluginId: Type.String({ description: "Plugin, dessen Zustand ersetzt wurde" }),
+        pluginId: Type.String({ description: "Plugin whose state was replaced" }),
     }),
     "plugin.state-patched": payloadOf<"plugin.state-patched">({
-        pluginId: Type.String({ description: "Plugin, dessen Zustand geändert wurde" }),
+        pluginId: Type.String({ description: "Plugin whose state was changed" }),
     }),
 } satisfies Record<EventType, TSchema>;
 
-/** Die Journal-Events eines Aufrufs, eingegrenzt auf die Typen, die er tatsächlich erzeugt. */
+/** The journal events of a call, narrowed to the types it actually produces. */
 export const eventResultSchemaOf = (...types: readonly EventType[]): TSchema => {
     const variants = types.map((type) => Type.Object({ type: Type.Literal(type), payload: eventPayloads[type] }, { additionalProperties: false }));
     return Type.Array(variants.length === 1 ? variants[0]! : Type.Union(variants), {
-        description: "Die Journal-Events dieses Aufrufs. Die payload nennt die Kennungen des Ergebnisses; Eingaben und Hashes wiederholt sie nicht.",
+        description: "The journal events of this call. The payload names the ids of the result; it does not repeat inputs and hashes.",
     });
 };
 

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

@@ -42,7 +42,7 @@ export interface ModelCatalog {
 const defaultProfiles: AgentProfile[] = [
     {
         name: "manual",
-        description: "Kein automatischer Treiber. Ein Mensch führt die Turns.",
+        description: "No automatic driver. A human drives the turns.",
         driver: "manual",
         turnTimeoutMs: null,
         isolateWorkspace: false,

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

@@ -32,7 +32,7 @@ const carriesTextEvent = (event: DeliveredEvent): event is Extract<DeliveredEven
 
 const recordOf = (value: unknown, what: string): Readonly<Record<string, unknown>> => {
     if (typeof value !== "object" || value === null || Array.isArray(value))
-        throw new Error(`${what} ist kein Objekt.`);
+        throw new Error(`${what} is not an object.`);
 
     return value as Record<string, unknown>;
 };
@@ -41,7 +41,7 @@ const stringOf = (source: Readonly<Record<string, unknown>>, field: string, what
     const value = source[field];
 
     if (typeof value !== "string")
-        throw new Error(`${what} hat kein Textfeld ${field}.`);
+        throw new Error(`${what} has no text field ${field}.`);
 
     return value;
 };
@@ -50,7 +50,7 @@ const numberOf = (source: Readonly<Record<string, unknown>>, field: string, what
     const value = source[field];
 
     if (typeof value !== "number" || !Number.isFinite(value))
-        throw new Error(`${what} hat kein Zahlenfeld ${field}.`);
+        throw new Error(`${what} has no number field ${field}.`);
 
     return value;
 };
@@ -70,7 +70,7 @@ export const deliveredEventOf = (
     sourceActorHandle: string,
 ): DeliveredEvent => {
     if (!isObservableEventType(source.type))
-        throw new Error(`Der Eventtyp ${source.type} ist nicht beobachtbar und wird nicht zugestellt.`);
+        throw new Error(`The event type ${source.type} is not observable and is not delivered.`);
 
     return {
         type: source.type,
@@ -85,23 +85,23 @@ export const deliveredEventOf = (
 
 const sourceEventOf = (inputId: string, content: string): Readonly<Record<string, unknown>> => {
     try {
-        return recordOf(JSON.parse(content), `Der zugestellte Inhalt von Input ${inputId}`);
+        return recordOf(JSON.parse(content), `The delivered content of input ${inputId}`);
     } catch (error) {
         throw new Error(
-            `Der Subscription-Input ${inputId} trägt kein Event-JSON: `
+            `The subscription input ${inputId} carries no event JSON: `
             + (error instanceof Error ? error.message : String(error)),
         );
     }
 };
 
 export const deliveredEventFromJson = (view: RunView, inputId: string, content: string): DeliveredEvent => {
-    const what = `Das zugestellte Event von Input ${inputId}`;
+    const what = `The delivered event of input ${inputId}`;
     const source = sourceEventOf(inputId, content);
     const actorId = stringOf(source, "actorId", what);
     const author = view.actors.find((entry) => entry.id === actorId);
 
     if (!author)
-        throw new Error(`${what} stammt von Actor ${actorId}, den dieser Run nicht kennt.`);
+        throw new Error(`${what} comes from actor ${actorId}, which this run does not know.`);
 
     return deliveredEventOf({
         eventId: stringOf(source, "eventId", what),
@@ -153,20 +153,20 @@ export const subscriptionSummaryFor = (view: RunView, actorId: string): readonly
             const sources = subscription.sourceActorIds
                 ? subscription.sourceActorIds.map(handleOf).join(", ")
                 : subscription.sourceActorKinds
-                    ? `alle Actors der Art ${subscription.sourceActorKinds.join(", ")}`
-                    : "alle Actors";
+                    ? `all actors of kind ${subscription.sourceActorKinds.join(", ")}`
+                    : "all actors";
 
-            return `${subscription.id}: Quellen ${sources}; Events ${subscription.eventTypes.join(", ")}`;
+            return `${subscription.id}: sources ${sources}; events ${subscription.eventTypes.join(", ")}`;
         });
 };
 
 export const actorRosterText = (view: RunView, actorId: string): string => [
-    "[Actors im Run, Stand bei Turn-Beginn]",
-    "Diese Actors sind bereits angelegt. Verwende passende Beteiligte weiter; actor_list aktualisiert den Bestand.",
-    "agent: Gespräch mit einem Modell. script: Programm mit festem Eingabeprotokoll, kein Chatpartner; dokumentierte Funktionen oder Programmeingaben verwenden. primär bezeichnet das Standardziel, keine Dialogfähigkeit.",
+    "[Actors in the run, as of turn start]",
+    "These actors already exist. Keep using suitable participants; actor_list refreshes the roster.",
+    "agent: conversation with a model. script: program with a fixed input protocol, not a chat partner; use documented functions or program inputs. primary denotes the default target, not a dialog capability.",
     ...view.actors.map((actor) => {
         const status = actor.kind === "human" ? "human" : actor.lifecycle.kind;
-        const markers = [actor.id === actorId ? "du" : "", actor.id === view.primaryActorId ? "primär" : ""]
+        const markers = [actor.id === actorId ? "you" : "", actor.id === view.primaryActorId ? "primary" : ""]
             .filter(Boolean);
 
         return `- @${actor.handle}: ${JSON.stringify(actor.displayName)}, ${actor.kind}, ${status}`
@@ -178,9 +178,9 @@ export const renderedPromptFor = (view: RunView, actorId: string, input: Deliver
     const subscriptions = subscriptionSummaryFor(view, actorId);
     const header = [
         ...(input.event
-            ? [`[Event ${input.event.type} von @${input.event.sourceActorHandle}, Sequenz ${input.event.sequence}]`]
+            ? [`[Event ${input.event.type} from @${input.event.sourceActorHandle}, sequence ${input.event.sequence}]`]
             : []),
-        ...(subscriptions.length > 0 ? [`[Aktive Subscriptions] ${subscriptions.join(" | ")}`] : []),
+        ...(subscriptions.length > 0 ? [`[Active subscriptions] ${subscriptions.join(" | ")}`] : []),
     ];
 
     return header.length > 0 ? `${header.join("\n")}\n\n${input.content}` : input.content;

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

@@ -19,7 +19,7 @@ export type ToolContributor = {
     name: string;
     descriptors: readonly ToolDescriptor[];
     dynamic?: boolean;
-    /** Ob die Werkzeuge in einem Run gelten; ohne Angabe in jedem, sonst fehlen sie dort ganz. */
+    /** Whether the tools apply in a run; without it in every run, otherwise they are missing there entirely. */
     runCondition?: (runId: string) => boolean;
     tools: (context: PluginContext) => readonly RunFunction[] | Promise<readonly RunFunction[]>;
 };

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

@@ -371,7 +371,7 @@ export class TurnScheduler {
                 throw failures[0];
 
             if (failures.length > 1)
-                throw new AggregateError(failures, `Run ${runId} konnte nicht vollständig angehalten werden.`);
+                throw new AggregateError(failures, `Run ${runId} could not be halted completely.`);
         } finally {
             const state = this.#runState(runId);
 
@@ -385,7 +385,7 @@ export class TurnScheduler {
 
     quarantineRun(runId: string, until: Promise<void>): void {
         if (this.#runState(runId).haltBoundaries === 0)
-            throw new Error(`Run ${runId} kann nur innerhalb einer aktiven Stopp-Grenze quarantiniert werden.`);
+            throw new Error(`Run ${runId} can only be quarantined within an active stop boundary.`);
 
         const quarantine = { promise: until };
         if (!this.#runState(runId).retired)
@@ -720,8 +720,8 @@ export class TurnScheduler {
                 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 reason = `No host function resolves the tools ${unknown.join(", ")}; `
+                    + `@${current.handle} was therefore stopped. Check the names in toolNames or load the plugin that provides them.`;
                 const state = this.#runtime.state(runId);
                 this.#runtime.stopActor(
                     { actorId: state.ownerId, commandId: `scheduler:unknown-tools:${actorId}:${state.revision}` },
@@ -950,7 +950,7 @@ export class TurnScheduler {
                 return;
 
             if (controller.signal.aborted || !this.#acceptsTurns(runId)) {
-                this.#interrupt(turn, "Der Turn wurde abgebrochen.");
+                this.#interrupt(turn, "The turn was cancelled.");
 
                 return;
             }
@@ -965,8 +965,8 @@ export class TurnScheduler {
         } catch (error) {
             const usage = (error as { usage?: TurnUsage }).usage;
             const message = controller.signal.aborted
-                ? "Der Turn wurde abgebrochen."
-                : `Der Turn ist gescheitert: ${errorMessage(error)}`;
+                ? "The turn was cancelled."
+                : `The turn failed: ${errorMessage(error)}`;
 
             if (this.#isRunning(turn)) {
                 if (controller.signal.aborted || !this.#acceptsTurns(runId))

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

@@ -20,7 +20,7 @@ export const grantSchema = Type.Object({
     capability: capabilitySchema,
     scope: scopeSchema,
     delegable: Type.Boolean(),
-    usable: Type.Optional(Type.Boolean({ description: "false = darf nur weitergegeben, nicht selbst benutzt werden" })),
+    usable: Type.Optional(Type.Boolean({ description: "false = may only be passed on, not used directly" })),
 });
 
 export const namedValuesSchema = Type.Array(Type.Object({ name: Type.String({ minLength: 1 }), value: Type.String() }));

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

@@ -3,10 +3,10 @@ import type { RunFunction } from "./tools.ts";
 export type ToolChapters = (toolNames: readonly string[]) => string | Promise<string>;
 
 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, mit context: true einmal die Deklarationen von context selbst (state, log, std mit mediators).",
+    "[TypeScript functions of this actor]",
+    "Call directly provided tools such as read, write, edit and bash without an extra TypeScript wrapper. Call the remaining functions through context.functions in typescript_eval.",
+    "typescript_api with names returns the exact input and return types as well as detailed descriptions and instructions, with context: true once the declarations of context itself (state, log, std with 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()}`),
+        .map((fn) => `- ${fn.name}${fn.nativeTool ? " (direct tool)" : ""}: ${fn.description.replace(/\s+/g, " ").trim()}`),
 ].join("\n");

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

@@ -73,7 +73,7 @@ export const defineToolAvailability = (
 export const describeToolAvailability = (available: ToolAvailability): ToolAvailabilitySummary =>
     (available as CataloguedToolAvailability).summary ?? {
         availability: "conditional",
-        availabilityDetail: "Die Verfügbarkeit wird für jeden Actor und Run aus dem aktuellen Kontext ermittelt.",
+        availabilityDetail: "Availability is determined for each actor and run from the current context.",
     };
 
 export type ToolExecutionMode = "sequential" | "parallel";
@@ -114,7 +114,7 @@ const tool = defineRunFunction;
 
 const always = defineToolAvailability({
     availability: "always",
-    availabilityDetail: "In jedem Turn verfügbar.",
+    availabilityDetail: "Available in every turn.",
 }, () => true);
 
 export const holdsUsable = (actor: Actor, capability: CapabilityName) =>
@@ -124,7 +124,7 @@ const needs =
     (capability: CapabilityName): ToolAvailability =>
         defineToolAvailability({
             availability: "conditional",
-            availabilityDetail: `Nur mit der Capability ${capability}.`,
+            availabilityDetail: `Only with the capability ${capability}.`,
             requiredCapabilities: [capability],
         }, (actor) => holdsUsable(actor, capability));
 
@@ -156,13 +156,13 @@ const actorReferenceSchema = Type.Object({
 }, { additionalProperties: false });
 
 const subscriptionBaseSchema = {
-    subscriptionId: Type.String({ description: "ID der Subscription; event_unsubscribe nimmt sie als subscriptionId" }),
+    subscriptionId: Type.String({ description: "ID of the subscription; event_unsubscribe takes it as subscriptionId" }),
     subscriberId: Type.String(),
     sourceActorIds: Type.Union([Type.Array(Type.String()), Type.Null()], {
-        description: "Quell-Actors als ID; null = alle. ID und @handle sind als Eingabe gleichwertig.",
+        description: "Source actors as ID; null = all. ID and @handle are equivalent as input.",
     }),
     sources: Type.Union([Type.Array(Type.String()), Type.Null()], {
-        description: "Dieselben Quellen als @handle, soweit auflösbar; sonst die ID.",
+        description: "The same sources as @handle where resolvable; otherwise the ID.",
     }),
     sourceActorKinds: Type.Union([Type.Array(actorKindSchema), Type.Null()]),
     eventTypes: Type.Array(Type.String()),
@@ -249,7 +249,7 @@ const modelListResultSchema = Type.Object({
         model: Type.String(),
         label: Type.String(),
         thinking: Type.Array(Type.String(), {
-            description: "Denkstufen, die agent_spawn für dieses Modell annimmt.",
+            description: "Thinking levels that agent_spawn accepts for this model.",
         }),
     }, { additionalProperties: false })),
 }, { additionalProperties: false });
@@ -295,13 +295,13 @@ const subscriptionView = (view: RunView, subscription: EventSubscription) => {
 };
 
 const subscriptionCreatedSchema = Type.Object({
-    subscriptionId: Type.String({ description: "ID der Subscription; event_unsubscribe nimmt sie als subscriptionId" }),
+    subscriptionId: Type.String({ description: "ID of the subscription; event_unsubscribe takes it as subscriptionId" }),
     sources: Type.Union([Type.Array(Type.String()), Type.Null()], {
-        description: "Die aufgelösten Quell-Actors als @handle, soweit auflösbar, sonst als ID; null = alle.",
+        description: "The resolved source actors as @handle where resolvable, otherwise as ID; null = all.",
     }),
 }, { additionalProperties: false });
 
-const acknowledgementSchema = Type.Null({ description: "Erledigt; ein Fehler wirft." });
+const acknowledgementSchema = Type.Null({ description: "Done; an error throws." });
 
 const subscriptionResult = (runtime: Orchestration, runId: string, commandId: string) => {
     const created = runtime.events(runId).findLast(
@@ -393,7 +393,7 @@ export const agentTools: RunFunction[] = [
         label: "Remove Event Subscription",
         description: "Remove one event subscription owned by this actor.",
         schema: Type.Object({
-            subscriptionId: Type.String({ minLength: 1, description: "subscriptionId aus event_subscribe oder event_subscription_list" }),
+            subscriptionId: Type.String({ minLength: 1, description: "subscriptionId from event_subscribe or event_subscription_list" }),
             reason: Type.String({ minLength: 1 }),
         }, { additionalProperties: false }),
         resultSchema: acknowledgementSchema,
@@ -429,8 +429,8 @@ export const agentTools: RunFunction[] = [
             eventTypes: Type.Optional(Type.Array(Type.String({ minLength: 1 }), {
                 uniqueItems: true,
                 description:
-                    "Jeder Journal-Eventtyp ist abfragbar. Abonnierbar sind nur die observable Typen; "
-                    + "event_subscribe zeigt sie.",
+                    "Every journal event type can be queried. Only the observable types can be subscribed to; "
+                    + "event_subscribe shows them.",
             })),
             limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 500 })),
         }, { additionalProperties: false }),
@@ -547,8 +547,8 @@ export const agentTools: RunFunction[] = [
             + "forkOf gives the new agent an unchanged copy of the model context of an existing LLM agent of this run, up to the end of that agent's last finished turn; nothing of its running turn is copied, and a source without a finished turn is rejected. The new agent still gets its own prompt, tools and model, and its first input follows the copy.",
         schema: Type.Object({
             handle: Type.String({ minLength: 1 }),
-            displayName: Type.Optional(Type.String({ minLength: 1, description: "Anzeigename; ohne Angabe der Handle" })),
-            description: Type.Optional(Type.String({ minLength: 1, maxLength: actorDescriptionMaxLength, description: "Sehr kurze Beschreibung der Aufgabe für die Übersicht der Beteiligten, wenige Wörter wie \"prüft die Regel zu Kommentaren\"" })),
+            displayName: Type.Optional(Type.String({ minLength: 1, description: "Display name; defaults to the handle" })),
+            description: Type.Optional(Type.String({ minLength: 1, maxLength: actorDescriptionMaxLength, description: "Very short description of the task for the participants overview, a few words like \"checks the rule on comments\"" })),
             prompt: Type.String(),
             forkOf: Type.Optional(Type.String({ minLength: 1, description: "Handle or ID of an LLM agent of this run whose model context up to the end of its last finished turn is copied into the new agent" })),
             tools: Type.Union([Type.Array(Type.String({ minLength: 1 }), { uniqueItems: true }), Type.Null()], { description: "Required explicit selection: [] for plain text-only work including app-mediated conversations; an array for exact existing tool names; null only when the task needs an open, dynamically resolved toolset. Never inherits the caller's tools. Names of future, not yet activated actor functions are invalid; choose null when those must become available later." }),
@@ -605,17 +605,17 @@ export const agentTools: RunFunction[] = [
             "Set the run title and/or choose the primary actor the chat talks to. Give title, primaryActor or both; "
             + "the primary actor must be an active agent or TypeScript actor of this run.",
         schema: Type.Object({
-            title: Type.Optional(Type.String({ minLength: 1, maxLength: 200, description: "Neuer Titel des Runs" })),
+            title: Type.Optional(Type.String({ minLength: 1, maxLength: 200, description: "New title of the run" })),
             primaryActor: Type.Optional(Type.String({
                 minLength: 1,
-                description: "Handle oder ID des Actors, mit dem der Chat des Benutzers spricht",
+                description: "Handle or ID of the actor the user's chat talks to",
             })),
         }, { additionalProperties: false }),
         resultSchema: acknowledgementSchema,
         available: needs("run.configure"),
         run: ({ runtime, caller, context }, toolCallId, input) => {
             if (input.title === undefined && input.primaryActor === undefined)
-                throw new Error("run_configure braucht title oder primaryActor; gültig sind { title }, { primaryActor } und beides zusammen.");
+                throw new Error("run_configure needs title or primaryActor; valid are { title }, { primaryActor } and both together.");
 
             if (input.title !== undefined)
                 runtime.retitleRun(context(toolCallId, "title"), caller.runId, input.title);
@@ -637,7 +637,7 @@ export const agentTools: RunFunction[] = [
         label: "Restart Actor",
         description: "Restart a stopped actor in this actor's branch. It resumes with its full history; the LLM is stateless.",
         schema: Type.Object({
-            actorId: Type.String({ minLength: 1, description: "Handle oder ID" }),
+            actorId: Type.String({ minLength: 1, description: "Handle or ID" }),
             reason: Type.String({ minLength: 1 }),
         }, { additionalProperties: false }),
         resultSchema: eventResultSchemaOf("actor.restarted", "run.primary-actor-selected"),
@@ -658,7 +658,7 @@ export const agentTools: RunFunction[] = [
         label: "Stop Actor",
         description: "Stop an actor in this actor's branch together with its active descendants.",
         schema: Type.Object({
-            actorId: Type.String({ minLength: 1, description: "Handle oder ID" }),
+            actorId: Type.String({ minLength: 1, description: "Handle or ID" }),
             reason: Type.String({ minLength: 1 }),
         }, { additionalProperties: false }),
         resultSchema: eventResultSchemaOf("turn.interrupted", "actor.stopped", "subscription.removed"),

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

@@ -30,7 +30,7 @@ const messageText = (value: unknown) =>
     value === undefined || value === null ? "" : (value instanceof Error ? value.message : String(value)).trim();
 
 const errorText = (error: unknown) =>
-    messageText(error) || (error instanceof Error ? messageText(error.cause) : "") || "Fehler ohne Ursache";
+    messageText(error) || (error instanceof Error ? messageText(error.cause) : "") || "Error without a cause";
 
 export { schemaComplaints } from "../domain/schema-errors.ts";
 
@@ -75,12 +75,12 @@ const inputComplaint = (tool: RunFunction, input: JsonValue, ignoredFields: read
 };
 
 export const ignoredFieldsNotice = (tool: Pick<RunFunction, "name" | "schema">, ignoredFields: readonly string[]) => {
-    const fields = ignoredFields.length === 1 ? `das Feld ${ignoredFields[0]}` : `die Felder ${ignoredFields.join(", ")}`;
-    const ignored = ignoredFields.length === 1 ? "wurde ignoriert" : "wurden ignoriert";
+    const fields = ignoredFields.length === 1 ? `the field ${ignoredFields[0]}` : `the fields ${ignoredFields.join(", ")}`;
+    const ignored = ignoredFields.length === 1 ? "was ignored" : "were ignored";
 
     return takesNoInput(tool.schema)
-        ? `Hinweis: ${tool.name} nimmt keine Eingabe; ${fields} ${ignoredFields.length === 1 ? "ist" : "sind"} unbekannt und ${ignored}.`
-        : `Hinweis: ${fields} kennt ${tool.name} nicht und ${ignored}.`;
+        ? `Note: ${tool.name} takes no input; ${fields} ${ignoredFields.length === 1 ? "is" : "are"} unknown and ${ignored}.`
+        : `Note: ${tool.name} does not know ${fields}, which ${ignored}.`;
 };
 
 export class TurnToolset {

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

@@ -22,6 +22,6 @@ export class FixedWorkspaces implements Workspaces {
     }
 
     storeAttachment(): Promise<string> {
-        return Promise.reject(new Error("Ein fester Arbeitsbereich ohne Executor nimmt keine Dateianhänge an."));
+        return Promise.reject(new Error("A fixed workspace without an executor does not accept file attachments."));
     }
 }

package/packages/ragents/src/domain/events.ts

@@ -54,7 +54,7 @@ export type EventPayloads = {
             handle: string;
             displayName: string;
             grants: CapabilityGrant[];
-            /** Der angemeldete Benutzer, dem der Run gehört; ohne Anmeldung nicht gesetzt. */
+            /** The signed-in user who owns the run; not set without sign-in. */
             userId?: string;
         };
     };