@schlenkr/ragents 0.1.10 → 0.1.12

package/apps/server/src/rpc/dispatcher.ts

@@ -30,11 +30,11 @@ export interface RpcConnectionOptions {
   access: AccessContext;
   local: boolean;
   peer: RpcPeer;
-  /** Ohne Ereignisstrom erreichen Benachrichtigungen den Client nicht; Abonnements sind dann abgelehnt. */
+  /** Without an event stream, notifications do not reach the client; subscriptions are then rejected. */
   streamless?: boolean;
 }
 
-/** Eine Verbindung eines Clients: hält ihre Abonnements und ist der Rückweg für Anfragen des Servers. */
+/** A client's connection: holds its subscriptions and is the way back for requests from the server. */
 export class RpcConnection implements MethodConnection {
   readonly id: string;
   readonly access: AccessContext;
@@ -63,8 +63,8 @@ export class RpcConnection implements MethodConnection {
   }
 
   call<C extends OperationContract>(contract: C, input: OperationInput<C>, options?: RpcCallOptions): Promise<OperationResult<C>> {
-    if (contract.implementedBy !== "client") return Promise.reject(new Error(`Die Operation ${contract.id} wird vom Server ausgeführt, nicht vom Client`));
-    if (this.streamless) return Promise.reject(new DomainError("stream-required", "Der Rückruf an den Client braucht einen Ereignisstrom.", 409));
+    if (contract.implementedBy !== "client") return Promise.reject(new Error(`The operation ${contract.id} is executed by the server, not by the client`));
+    if (this.streamless) return Promise.reject(new DomainError("stream-required", "The callback to the client needs an event stream.", 409));
     return this.peer.call(contract, input, options);
   }
 
@@ -87,7 +87,7 @@ export class RpcConnection implements MethodConnection {
 export interface RpcDispatcherOptions {
   methods: MethodContributionRegistry;
   channels: ChannelContributionRegistry;
-  /** Jede Methode und jeder Kanal mit runId wird zusätzlich gegen die Zugehörigkeit des Runs geprüft; eine Methode mit runs.write bedient ihn. */
+  /** Every method and every channel with runId is additionally checked against the run's ownership; a method with runs.write operates it. */
   assertRunReachable?: (access: AccessContext, runId: string, operates: boolean) => void;
 }
 
@@ -97,7 +97,7 @@ const runIdOf = (input: unknown): string | undefined => {
   return typeof value === "string" ? value : undefined;
 };
 
-/** Führt Anfragen einer Verbindung gegen die registrierten Verträge aus: Rechte, Eingabe, Ausführung, Antwort. */
+/** Executes a connection's requests against the registered contracts: rights, input, execution, response. */
 export class RpcDispatcher {
   readonly #options: RpcDispatcherOptions;
 
@@ -110,13 +110,13 @@ export class RpcDispatcher {
     if (method === RPC_METHODS.unsubscribe) return this.#unsubscribe(connection, params);
     const found = this.#options.methods.find(method);
     if (!found || found.contribution.contract.implementedBy === "client") {
-      throw new RpcError(RPC_ERROR_CODES.methodNotFound, `Unbekannte Methode: ${method}`);
+      throw new RpcError(RPC_ERROR_CODES.methodNotFound, `Unknown method: ${method}`);
     }
     const { contract, execute } = found.contribution;
     assertRights(connection.access, contract.rights);
     const input = params === undefined ? {} : params;
     if (!Value.Check(contract.input, input)) {
-      throw new RpcError(RPC_ERROR_CODES.invalidParams, `Ungültige Eingabe für ${method}: ${schemaComplaints(contract.input, input, "params")}`);
+      throw new RpcError(RPC_ERROR_CODES.invalidParams, `Invalid input for ${method}: ${schemaComplaints(contract.input, input, "params")}`);
     }
     const target = runIdOf(input);
     if (target !== undefined) this.#options.assertRunReachable?.(connection.access, target, contract.rights.includes("runs.write"));
@@ -130,27 +130,27 @@ export class RpcDispatcher {
     const plain = result === undefined ? null : JSON.parse(JSON.stringify(result)) as unknown;
     if (!Value.Check(contract.result, plain)) {
       const complaint = schemaComplaints(contract.result, plain, "result");
-      console.error(`Die Antwort von ${method} verletzt ihren Vertrag: ${complaint}`);
-      throw new RpcError(RPC_ERROR_CODES.internal, `Die Antwort von ${method} verletzt ihren Vertrag: ${complaint}`);
+      console.error(`The response of ${method} violates its contract: ${complaint}`);
+      throw new RpcError(RPC_ERROR_CODES.internal, `The response of ${method} violates its contract: ${complaint}`);
     }
     return plain;
   }
 
   async #subscribe(connection: RpcConnection, params: unknown): Promise<RpcSubscribeResult> {
     const { channel, params: channelParams } = (params ?? {}) as Partial<RpcSubscribeParams>;
-    if (typeof channel !== "string") throw new RpcError(RPC_ERROR_CODES.invalidParams, "channel fehlt");
-    if (connection.streamless) throw new DomainError("stream-required", "Abonnements brauchen einen Ereignisstrom.", 409);
+    if (typeof channel !== "string") throw new RpcError(RPC_ERROR_CODES.invalidParams, "channel is missing");
+    if (connection.streamless) throw new DomainError("stream-required", "Subscriptions need an event stream.", 409);
     const found = this.#options.channels.find(channel);
-    if (!found) throw new DomainError("unknown-channel", `Unbekannter Ereigniskanal: ${channel}`, 400);
+    if (!found) throw new DomainError("unknown-channel", `Unknown event channel: ${channel}`, 400);
     const { contract, open } = found.contribution;
     assertRights(connection.access, contract.rights);
     const input = channelParams === undefined ? {} : channelParams;
     if (!Value.Check(contract.params, input)) {
-      throw new RpcError(RPC_ERROR_CODES.invalidParams, `Ungültige Parameter für ${channel}: ${schemaComplaints(contract.params, input, "params")}`);
+      throw new RpcError(RPC_ERROR_CODES.invalidParams, `Invalid parameters for ${channel}: ${schemaComplaints(contract.params, input, "params")}`);
     }
     const target = runIdOf(input);
     if (target !== undefined) this.#options.assertRunReachable?.(connection.access, target, false);
-    if (connection.subscriptions.size >= MAX_SUBSCRIPTIONS) throw new DomainError("too-many-channels", "Zu viele Ereigniskanäle auf einer Verbindung.", 429);
+    if (connection.subscriptions.size >= MAX_SUBSCRIPTIONS) throw new DomainError("too-many-channels", "Too many event channels on one connection.", 429);
     const subscription = randomUUID();
     const buffered: unknown[] = [];
     let opening = true;
@@ -163,17 +163,17 @@ export class RpcDispatcher {
     opening = false;
     if (connection.closed) {
       stop();
-      throw new DomainError("connection-closed", "Die Ereignisverbindung wurde beendet.", 410);
+      throw new DomainError("connection-closed", "The event connection was closed.", 410);
     }
     connection.subscriptions.set(subscription, stop);
-    // Erst die Antwort auf das Abonnement, dann die beim Öffnen entstandenen Nachrichten.
+    // First the response to the subscription, then the messages created while opening.
     setTimeout(() => { if (connection.subscriptions.has(subscription)) for (const message of buffered) send(message); }, 0);
     return { subscription };
   }
 
   #unsubscribe(connection: RpcConnection, params: unknown): null {
     const { subscription } = (params ?? {}) as Partial<RpcUnsubscribeParams>;
-    if (typeof subscription !== "string") throw new RpcError(RPC_ERROR_CODES.invalidParams, "subscription fehlt");
+    if (typeof subscription !== "string") throw new RpcError(RPC_ERROR_CODES.invalidParams, "subscription is missing");
     const stop = connection.subscriptions.get(subscription);
     connection.subscriptions.delete(subscription);
     stop?.();
@@ -183,5 +183,5 @@ export class RpcDispatcher {
 
 export const assertRights = (access: AccessContext, rights: readonly string[]): void => {
   const missing = rights.find((right) => !access.can(right));
-  if (missing) throw new DomainError("access-denied", `Das Recht ${missing} fehlt.`, 403);
+  if (missing) throw new DomainError("access-denied", `The right ${missing} is missing.`, 403);
 };

package/apps/server/src/rpc/http-transport.ts

@@ -32,7 +32,7 @@ export interface RpcHttpTransportOptions {
   maxBodyBytes?: number;
 }
 
-/** JSON-RPC über HTTP: Anfragen per POST, Benachrichtigungen und Anfragen des Servers über einen SSE-Strom je Verbindung. */
+/** JSON-RPC over HTTP: requests via POST, notifications and server requests over one SSE stream per connection. */
 export class RpcHttpTransport {
   readonly #dispatcher: RpcDispatcher;
   readonly #maxBodyBytes: number;
@@ -51,7 +51,7 @@ export class RpcHttpTransport {
     if (url.pathname === RPC_STREAM_PATH) {
       if (request.method !== "GET") {
         response.setHeader("Allow", "GET");
-        writeJson(response, 405, { error: "Methode nicht erlaubt" });
+        writeJson(response, 405, { error: "Method not allowed" });
         return true;
       }
       this.#openStream(request, response, access, local);
@@ -60,7 +60,7 @@ export class RpcHttpTransport {
     if (url.pathname !== RPC_PATH) return false;
     if (request.method !== "POST") {
       response.setHeader("Allow", "POST");
-      writeJson(response, 405, { error: "Methode nicht erlaubt" });
+      writeJson(response, 405, { error: "Method not allowed" });
       return true;
     }
     await this.#post(request, response, access, local);
@@ -68,7 +68,7 @@ export class RpcHttpTransport {
   }
 
   close(): void {
-    for (const stream of [...this.#streams.values()]) this.#end(stream, "Der Server wird beendet");
+    for (const stream of [...this.#streams.values()]) this.#end(stream, "The server is shutting down");
   }
 
   #openStream(request: IncomingMessage, response: ServerResponse, access: AccessContext, local: boolean): void {
@@ -82,7 +82,7 @@ export class RpcHttpTransport {
     this.#streams.set(id, stream);
     response.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" });
     write(`event: hello\ndata: ${JSON.stringify({ connection: id })}\n\n`);
-    request.on("close", () => this.#end(stream, "Der Ereignisstrom wurde beendet"));
+    request.on("close", () => this.#end(stream, "The event stream was closed"));
   }
 
   #end(stream: StreamConnection, reason: string): void {
@@ -97,8 +97,8 @@ export class RpcHttpTransport {
     const id = Array.isArray(header) ? header[0] : header;
     if (!id) return undefined;
     const stream = this.#streams.get(id);
-    if (!stream) throw new DomainRejection(404, "unknown-connection", "Die Ereignisverbindung ist unbekannt oder beendet.");
-    if (stream.connection.userId !== (access.user?.id ?? null)) throw new DomainRejection(403, "foreign-connection", "Die Ereignisverbindung gehört einem anderen Benutzer.");
+    if (!stream) throw new DomainRejection(404, "unknown-connection", "The event connection is unknown or closed.");
+    if (stream.connection.userId !== (access.user?.id ?? null)) throw new DomainRejection(403, "foreign-connection", "The event connection belongs to another user.");
     return stream;
   }
 
@@ -111,11 +111,11 @@ export class RpcHttpTransport {
         writeJson(response, 413, rpcFailure(null, RPC_ERROR_CODES.invalidRequest, error.message));
         return;
       }
-      writeJson(response, 400, rpcFailure(null, RPC_ERROR_CODES.parse, "Der Request enthält kein gültiges JSON"));
+      writeJson(response, 400, rpcFailure(null, RPC_ERROR_CODES.parse, "The request does not contain valid JSON"));
       return;
     }
     if (!isRpcMessage(message)) {
-      writeJson(response, 400, rpcFailure(null, RPC_ERROR_CODES.invalidRequest, "Die Nachricht ist kein gültiges JSON-RPC"));
+      writeJson(response, 400, rpcFailure(null, RPC_ERROR_CODES.invalidRequest, "The message is not valid JSON-RPC"));
       return;
     }
     let stream: StreamConnection | undefined;
@@ -130,7 +130,7 @@ export class RpcHttpTransport {
     }
     if (!isRpcRequest(message)) {
       if (!stream) {
-        writeJson(response, 409, rpcFailure(null, RPC_ERROR_CODES.invalidRequest, "Benachrichtigungen und Antworten brauchen einen Ereignisstrom."));
+        writeJson(response, 409, rpcFailure(null, RPC_ERROR_CODES.invalidRequest, "Notifications and responses need an event stream."));
         return;
       }
       stream.connection.peer.receive(message);
@@ -141,7 +141,7 @@ export class RpcHttpTransport {
     await this.#answer(request, response, message, stream, access, local);
   }
 
-  /** Eine Anfrage bekommt ihren eigenen Peer, dessen Antwort die HTTP-Antwort ist; Abonnements landen auf dem Strom. */
+  /** A request gets its own peer, whose response is the HTTP response; subscriptions land on the stream. */
   #answer(request: IncomingMessage, response: ServerResponse, message: RpcMessage, stream: StreamConnection | undefined, access: AccessContext, local: boolean): Promise<void> {
     return new Promise<void>((resolve) => {
       let answered = false;

package/apps/server/src/rpc/stdio-transport.ts

@@ -16,7 +16,7 @@ export interface StdioTransport {
   close: (reason: string) => void;
 }
 
-/** JSON-RPC über stdin und stdout, eine Nachricht je Zeile; der Aufrufer gilt als vertraut. */
+/** JSON-RPC over stdin and stdout, one message per line; the caller counts as trusted. */
 export const startStdioTransport = (options: StdioTransportOptions): StdioTransport => {
   const write = (message: unknown) => new Promise<void>((resolve, reject) => {
     options.output.write(`${JSON.stringify(message)}\n`, (error) => error ? reject(error) : resolve());
@@ -36,9 +36,9 @@ export const startStdioTransport = (options: StdioTransportOptions): StdioTransp
     try {
       peer.receive(JSON.parse(line));
     } catch {
-      void write(rpcFailure(null, RPC_ERROR_CODES.parse, "Die Zeile enthält kein gültiges JSON")).catch(() => undefined);
+      void write(rpcFailure(null, RPC_ERROR_CODES.parse, "The line does not contain valid JSON")).catch(() => undefined);
     }
   });
-  lines.on("close", () => close("Die Eingabe wurde geschlossen"));
+  lines.on("close", () => close("The input was closed"));
   return { connection, closed, close };
 };

package/apps/server/src/run-preparation-input.ts

@@ -5,12 +5,12 @@ export function preparedRunInput(history: readonly RunPreparationMessage[], text
   const current = text.trim();
   const messages = [...history, ...(current || attachments?.length ? [{ role: "user" as const, text: current, attachments }] : [])];
   const files = messages.flatMap((message) => message.role === "user" ? message.attachments ?? [] : []);
-  if (!messages.length) throw new Error("Der Auftrag ist leer.");
-  const prepared = history.length === 0 ? current : "Setze den im folgenden Vorbereitungsgespräch erarbeiteten Auftrag jetzt um. "
-      + "Die letzten Angaben des Benutzers gelten. Assistentenantworten sind Vorschläge und keine bereits erledigte Arbeit.\n\n"
-      + messages.map((message) => `${message.role === "user" ? "Benutzer" : "Assistent"}:\n${message.text}`).join("\n\n");
+  if (!messages.length) throw new Error("The task is empty.");
+  const prepared = history.length === 0 ? current : "Carry out the task worked out in the following preparation conversation now. "
+      + "The user's latest statements apply. Assistant responses are suggestions, not work already done.\n\n"
+      + messages.map((message) => `${message.role === "user" ? "User" : "Assistant"}:\n${message.text}`).join("\n\n");
   return {
-    text: skillName ? `Nutze den Skill ${skillName} für diesen Auftrag.\n\n${prepared}` : prepared,
+    text: skillName ? `Use the skill ${skillName} for this task.\n\n${prepared}` : prepared,
     attachments: files.length ? files : undefined,
   };
 }

package/apps/server/src/run-preparation.ts

@@ -15,26 +15,26 @@ const PREPARATION_TIMEOUT_MS = 120_000;
 const invalid = (message: string): never => { throw new DomainError("invalid-preparation", message, 400); };
 
 export const parseRunPreparationRequest = (value: unknown): RunPreparationRequest => {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return invalid("Die Vorbereitung benötigt einen Nachrichtenverlauf.");
+  if (!value || typeof value !== "object" || Array.isArray(value)) return invalid("Preparation requires a message history.");
   const { messages: input, skillName } = value as Record<string, unknown>;
   if (skillName !== undefined && (typeof skillName !== "string" || !/^[a-z0-9][a-z0-9-]*$/.test(skillName))) {
-    return invalid("Der ausgewählte Skillname ist ungültig.");
+    return invalid("The selected skill name is invalid.");
   }
   if (!Array.isArray(input) || input.length === 0 || input.length > MAX_RUN_PREPARATION_MESSAGES || input.length % 2 === 0) {
-    return invalid(`Der Verlauf benötigt höchstens ${MAX_RUN_PREPARATION_MESSAGES} abwechselnde Nachrichten und muss mit einer Benutzernachricht beginnen und enden.`);
+    return invalid(`The history needs at most ${MAX_RUN_PREPARATION_MESSAGES} alternating messages and must start and end with a user message.`);
   }
   let totalText = 0;
   const messages = input.map((value, index): RunPreparationMessage => {
-    if (!value || typeof value !== "object" || Array.isArray(value)) return invalid(`Nachricht ${index + 1} ist ungültig.`);
+    if (!value || typeof value !== "object" || Array.isArray(value)) return invalid(`Message ${index + 1} is invalid.`);
     const { role, text, attachments: supplied } = value as Record<string, unknown>;
-    if ((role !== "user" && role !== "assistant") || role !== (index % 2 === 0 ? "user" : "assistant")) return invalid("Benutzer- und Modellnachrichten müssen sich abwechseln.");
-    if (typeof text !== "string" || text.length > MAX_RUN_PREPARATION_TEXT_CHARS) return invalid(`Eine Nachricht darf höchstens ${MAX_RUN_PREPARATION_TEXT_CHARS} Zeichen enthalten.`);
+    if ((role !== "user" && role !== "assistant") || role !== (index % 2 === 0 ? "user" : "assistant")) return invalid("User and model messages must alternate.");
+    if (typeof text !== "string" || text.length > MAX_RUN_PREPARATION_TEXT_CHARS) return invalid(`A message may contain at most ${MAX_RUN_PREPARATION_TEXT_CHARS} characters.`);
     totalText += text.length;
-    if (totalText > MAX_RUN_PREPARATION_TOTAL_TEXT_CHARS) return invalid(`Der Verlauf darf zusammen höchstens ${MAX_RUN_PREPARATION_TOTAL_TEXT_CHARS} Textzeichen enthalten.`);
-    if (role === "assistant" && supplied !== undefined) return invalid("Nur Benutzernachrichten dürfen Anhänge enthalten.");
+    if (totalText > MAX_RUN_PREPARATION_TOTAL_TEXT_CHARS) return invalid(`The history may contain at most ${MAX_RUN_PREPARATION_TOTAL_TEXT_CHARS} text characters in total.`);
+    if (role === "assistant" && supplied !== undefined) return invalid("Only user messages may contain attachments.");
     try {
       const attachments = parseChatAttachments(supplied);
-      if (!text.trim() && attachments.length === 0) return invalid("Eine Nachricht benötigt Text oder Anhänge.");
+      if (!text.trim() && attachments.length === 0) return invalid("A message requires text or attachments.");
       return { role, text, ...(attachments.length ? { attachments } : {}) };
     } catch (error) {
       if (error instanceof DomainError) throw error;
@@ -43,7 +43,7 @@ export const parseRunPreparationRequest = (value: unknown): RunPreparationReques
   });
   try { parseChatAttachments(messages.flatMap((message) => message.attachments ?? [])); }
   catch (error) { return invalid(error instanceof Error ? error.message : String(error)); }
-  if (Buffer.byteLength(JSON.stringify({ messages }), "utf8") > MAX_CHAT_REQUEST_BYTES) return invalid("Der Nachrichtenverlauf ist zu groß.");
+  if (Buffer.byteLength(JSON.stringify({ messages }), "utf8") > MAX_CHAT_REQUEST_BYTES) return invalid("The message history is too large.");
   return { messages, ...(typeof skillName === "string" ? { skillName } : {}) };
 };
 
@@ -59,7 +59,7 @@ export const prepareRunMessage = async (options: {
     signal.throwIfAborted();
     const { runtime, selection } = options;
     const model = runtime.getModel(selection.provider, selection.model);
-    if (!model) throw new DomainError("preparation-model-unavailable", `Das Modell ${selection.provider}/${selection.model} ist nicht konfiguriert.`, 400);
+    if (!model) throw new DomainError("preparation-model-unavailable", `The model ${selection.provider}/${selection.model} is not configured.`, 400);
     const messages: Message[] = [];
     for (const message of options.request.messages) {
       signal.throwIfAborted();
@@ -73,7 +73,7 @@ export const prepareRunMessage = async (options: {
       }
       try {
         const prepared = await prepareInputAttachments({ prompt: message.text, tools: [],
-          storeAttachment: () => Promise.reject(new Error("Der Vorbereitungs-Chat hat keinen Arbeitsbereich.")),
+          storeAttachment: () => Promise.reject(new Error("The preparation chat has no workspace.")),
           attachments: message.attachments?.map((attachment) => ({ name: attachment.name, mediaType: attachment.mediaType,
             content: Buffer.from(attachment.data, "base64") })),
         }, model.input);
@@ -81,20 +81,20 @@ export const prepareRunMessage = async (options: {
           ? [...(prepared.prompt ? [{ type: "text" as const, text: prepared.prompt }] : []), ...prepared.attachments]
           : prepared.prompt });
       } catch (error) {
-        throw new DomainError("preparation-attachment-unsupported", `Der Anhang kann im Vorbereitungs-Chat nicht verwendet werden: ${error instanceof Error ? error.message : String(error)}`, 400);
+        throw new DomainError("preparation-attachment-unsupported", `The attachment cannot be used in the preparation chat: ${error instanceof Error ? error.message : String(error)}`, 400);
       }
     }
     signal.throwIfAborted();
-    const systemPrompt = [options.prompt, options.request.skillName ? `Ausgewählter Skill: ${options.request.skillName}` : ""].filter(Boolean).join("\n\n");
+    const systemPrompt = [options.prompt, options.request.skillName ? `Selected skill: ${options.request.skillName}` : ""].filter(Boolean).join("\n\n");
     let startRequested = false;
     const startRun: AgentTool = {
-      name: "start_run", label: "Run starten",
-      description: "Den besprochenen Run starten, ausschließlich nach dem ausdrücklichen sinngemäßen Go des Benutzers zur Ausführung. Keine feste Formulierung nötig. Eine Detailbestätigung, ein Zitat oder eine Fähigkeitsfrage genügt nicht. Der Host übernimmt Auftrag, Skill und Anhänge aus dem Gespräch sowie die Startoptionen.",
+      name: "start_run", label: "Start run",
+      description: "Start the discussed run, exclusively after the user's explicit go-ahead to execute, in whatever words. No fixed wording is needed. A confirmation of a detail, a quotation, or a question about capabilities is not enough. The host takes the task, skill, and attachments from the conversation as well as the start options.",
       parameters: Type.Object({}),
       execute: async () => {
         signal.throwIfAborted();
         startRequested = true;
-        return { content: [{ type: "text", text: "Start zur Übergabe vorgemerkt. Nach Abschluss dieser Antwort übernimmt die Oberfläche den Auftrag." }], details: {} };
+        return { content: [{ type: "text", text: "Start marked for handover. Once this response is complete, the UI takes over the task." }], details: {} };
       },
     };
     if (!(await runtime.checkAuth(model.provider))) throw new Error(`No key is configured for the provider ${model.provider}.`);
@@ -108,7 +108,7 @@ export const prepareRunMessage = async (options: {
     try {
       signal.throwIfAborted();
       const latest = messages.at(-1)!;
-      if (latest.role !== "user") throw new Error("Die letzte Nachricht muss vom Benutzer kommen.");
+      if (latest.role !== "user") throw new Error("The last message must come from the user.");
       const content = latest.content;
       await agent.prompt({ role: "user", timestamp: Date.now(), content: typeof content === "string"
         ? [{ type: "text", text: content }]
@@ -117,20 +117,20 @@ export const prepareRunMessage = async (options: {
       const completed = agent.state.messages.at(-1);
       if (!completed || completed.role !== "assistant" || completed.stopReason !== "stop") {
         throw new DomainError("preparation-model-failed", completed?.role === "assistant"
-          ? completed.errorMessage ?? `Die Vorbereitung wurde nicht vollständig beantwortet (${completed.stopReason}).`
-          : "Die Vorbereitung wurde nicht vollständig beantwortet.", 502);
+          ? completed.errorMessage ?? `The preparation was not answered completely (${completed.stopReason}).`
+          : "The preparation was not answered completely.", 502);
       }
       if (startRequested) return { kind: "start", input: preparedRunInput(options.request.messages, "", undefined, options.request.skillName) };
       const text = completed.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("\n").trim();
-      if (text.length > MAX_RUN_PREPARATION_TEXT_CHARS) throw new DomainError("preparation-response-too-large", "Die Modellantwort ist für die Vorbereitung zu lang. Bitte grenze den Auftrag ein.", 502);
+      if (text.length > MAX_RUN_PREPARATION_TEXT_CHARS) throw new DomainError("preparation-response-too-large", "The model response is too long for the preparation. Please narrow down the task.", 502);
       return { kind: "reply", text };
     } finally {
       signal.removeEventListener("abort", abort);
     }
   } catch (error) {
-    if (options.signal.aborted) throw new DomainError("preparation-aborted", "Die Vorbereitung wurde abgebrochen.", 499);
-    if (signal.aborted) throw new DomainError("preparation-timeout", "Die Vorbereitung hat zu lange gedauert. Bitte versuche es erneut.", 504);
+    if (options.signal.aborted) throw new DomainError("preparation-aborted", "The preparation was cancelled.", 499);
+    if (signal.aborted) throw new DomainError("preparation-timeout", "The preparation took too long. Please try again.", 504);
     if (error instanceof DomainError) throw error;
-    throw new DomainError("preparation-model-failed", `Die Vorbereitung ist fehlgeschlagen: ${error instanceof Error ? error.message : String(error)}`, 502);
+    throw new DomainError("preparation-model-failed", `The preparation failed: ${error instanceof Error ? error.message : String(error)}`, 502);
   }
 };