@schlenkr/ragents 0.1.9 → 0.1.11

package/plugins/ragents.actor-programs/web/FullscreenHost.tsx

@@ -18,13 +18,13 @@ export function FullscreenHost({ session }: { session: SessionContext }) {
     <DialogContent className="h-[calc(100%-2*clamp(16px,2vw,24px))] w-[calc(100%-2*clamp(16px,2vw,24px))] gap-0 bg-background p-0" initialFocus={closeRef} scope="surface" showCloseButton={false} size="full">
     <header className="flex flex-none items-center gap-3 border-b border-border bg-card py-2 pr-3 pl-4">
       <DialogTitle className="min-w-0 flex-1 truncate text-[0.9rem]" render={<h2 />}>{title}</DialogTitle>
-      <Button aria-label={`${title} Vollansicht schließen`} className="rounded-full" onClick={closeFullscreen} ref={closeRef} size="icon" title={`${title} Vollansicht schließen`} variant="outline"><XIcon /></Button>
+      <Button aria-label={`Close ${title} full view`} className="rounded-full" onClick={closeFullscreen} ref={closeRef} size="icon" title={`Close ${title} full view`} variant="outline"><XIcon /></Button>
     </header>
     <div className="flex min-h-0 flex-1 flex-col overflow-hidden [&>[data-slot=host-confirmation]]:max-h-[65%] [&>[data-slot=host-confirmation]]:flex-[0_1_auto] [&>[data-slot=host-confirmation]]:overflow-auto">
       {confirmation && <HostConfirmation action={confirmation} key={confirmation.id} session={session} />}
       {app ? <ActorViewFrame api={api} app={app} invoke={invoke} pendingConfirmationInvocationId={confirmation?.parameters.invocationId}
         presentation="fullscreen" runId={runId} session={session} />
-        : <p className="flex flex-1 items-center justify-center gap-2 text-[0.7rem] text-muted-foreground" role={error ? "alert" : "status"}>{error ?? "Actor-Ansicht wird geladen"}</p>}
+        : <p className="flex flex-1 items-center justify-center gap-2 text-[0.7rem] text-muted-foreground" role={error ? "alert" : "status"}>{error ?? "Loading actor view"}</p>}
     </div>
     </DialogContent>
   </Dialog>;

package/plugins/ragents.actor-programs/web/FunctionForm.tsx

@@ -45,19 +45,19 @@ export function FunctionForm({ session, tool, detail = false }: {
     }
   };
 
-  const status = confirmation ? "Bestätigung erforderlich"
-    : invocation?.status === "queued" ? "Wartet auf Ausführung"
-      : invocation?.status === "running" ? "Funktion läuft"
-        : invocation?.status === "succeeded" ? "Ausgeführt"
-          : invocation?.status === "cancelled" ? "Abgebrochen"
-            : invocation?.status === "failed" ? "Fehlgeschlagen"
-              : busy ? "Aufruf wird gesendet" : undefined;
+  const status = confirmation ? "Confirmation required"
+    : invocation?.status === "queued" ? "Waiting for execution"
+      : invocation?.status === "running" ? "Function running"
+        : invocation?.status === "succeeded" ? "Executed"
+          : invocation?.status === "cancelled" ? "Cancelled"
+            : invocation?.status === "failed" ? "Failed"
+              : busy ? "Sending call" : undefined;
   const failure = error ?? (invocation?.status === "failed" || invocation?.status === "cancelled" ? invocation.error : undefined);
 
   return (
     <div className="grid min-w-0 gap-2.5">
-      <form aria-label={`${tool.name} aufrufen`} className={cn("grid", detail ? "gap-3.5" : "gap-2")} onSubmit={(event) => void submit(event)}>
-        {tool.parameters.length === 0 && detail && <p>Diese Funktion benötigt keine Parameter.</p>}
+      <form aria-label={`Call ${tool.name}`} className={cn("grid", detail ? "gap-3.5" : "gap-2")} onSubmit={(event) => void submit(event)}>
+        {tool.parameters.length === 0 && detail && <p>This function needs no parameters.</p>}
         {tool.parameters.map((parameter) => (
           <label className={cn("grid gap-[3px] font-[650] text-foreground [&_small]:text-[0.61rem] [&_small]:font-normal [&_small]:text-muted-foreground",
             detail ? "text-[0.8rem]" : "text-[0.68rem]",
@@ -65,7 +65,7 @@ export function FunctionForm({ session, tool, detail = false }: {
             {parameter.type === "boolean" && parameter.required && <input aria-description={parameter.description} className="m-0 accent-primary" disabled={!writable || busy} name={parameter.name} type="checkbox" />}
             <span>{parameter.name}{parameter.required ? " *" : ""}{detail && <small className="ml-2">{parameter.type}{parameter.required ? "" : " (optional)"}</small>}</span>
             {parameter.type === "boolean"
-              ? !parameter.required && <select className={selectClass} disabled={!writable || busy} name={parameter.name} defaultValue=""><option value="">Nicht übergeben</option><option value="true">Ja</option><option value="false">Nein</option></select>
+              ? !parameter.required && <select className={selectClass} disabled={!writable || busy} name={parameter.name} defaultValue=""><option value="">Not passed</option><option value="true">Yes</option><option value="false">No</option></select>
               : parameter.type === "json" || parameter.type === "string[]" || parameter.type === "number[]" || detail && parameter.type === "string"
                 ? <Textarea aria-description={parameter.description} className="min-h-8 resize-y font-normal" disabled={!writable || busy} name={parameter.name} placeholder={parameter.description} required={parameter.required} rows={2} />
                 : <Input
@@ -79,21 +79,21 @@ export function FunctionForm({ session, tool, detail = false }: {
                     type={parameter.type === "integer" || parameter.type === "number" ? "number" : "text"}
                   />}
             {(detail || parameter.type === "boolean") && <small>{parameter.description}</small>}
-            {parameter.type === "json" && <small>Als JSON eingeben.</small>}
-            {parameter.type === "number[]" && <small>Als JSON-Liste eingeben, z. B. [1, 2, 3].</small>}
-            {parameter.type === "string[]" && <small>Ein Eintrag pro Zeile oder als JSON-Liste.</small>}
+            {parameter.type === "json" && <small>Enter as JSON.</small>}
+            {parameter.type === "number[]" && <small>Enter as a JSON list, e.g. [1, 2, 3].</small>}
+            {parameter.type === "string[]" && <small>One entry per line or as a JSON list.</small>}
           </label>
         ))}
         <div className="flex flex-wrap items-center gap-2">
-          <Button disabled={!writable || busy} type="submit">{busy ? "Wird ausgeführt ..." : "Ausführen"}</Button>
+          <Button disabled={!writable || busy} type="submit">{busy ? "Running ..." : "Run"}</Button>
           {status && <span className="text-[0.63rem] text-muted-foreground" role="status">{status}</span>}
         </div>
       </form>
       {confirmation && <HostConfirmation action={confirmation} key={confirmation.id} session={session} />}
       {failure && <p className="text-destructive [overflow-wrap:anywhere]" role="alert">{failure}</p>}
       {invocation?.status === "succeeded" && !error && (
-        <section aria-label="Ergebnis" className="grid min-w-0 gap-2">
-          <h3>Ergebnis</h3>
+        <section aria-label="Result" className="grid min-w-0 gap-2">
+          <h3>Result</h3>
           <pre className="max-h-[320px] overflow-auto rounded-md border border-border-soft bg-card p-2.5 text-[0.75rem] whitespace-pre-wrap text-foreground [overflow-wrap:anywhere]">{typeof invocation.result === "string" ? invocation.result : JSON.stringify(invocation.result, null, 2)}</pre>
         </section>
       )}

package/plugins/ragents.actor-programs/web/ProgramSource.tsx

@@ -45,17 +45,17 @@ export function ProgramSource({ api, moduleId, runId, revision, expandedByDefaul
 
   return (
     <section className="grid w-full min-w-0 grid-cols-[minmax(0,1fr)] justify-items-start gap-2">
-      <h3 className="text-xs font-semibold text-muted-foreground">Quellcode</h3>
+      <h3 className="text-xs font-semibold text-muted-foreground">Source code</h3>
       {!expanded && (
-        <Button onClick={() => setExpanded(true)} size="sm" variant="outline">Quellcode anzeigen</Button>
+        <Button onClick={() => setExpanded(true)} size="sm" variant="outline">Show source code</Button>
       )}
       {expanded && (
         <>
-          <p className="text-[0.67rem] text-muted-foreground">Quelle des installierten Builds</p>
+          <p className="text-[0.67rem] text-muted-foreground">Source of the installed build</p>
           {state.kind === "loading" && (
             <p className="flex items-center gap-2 text-[0.72rem] text-muted-foreground">
               <Spinner aria-hidden aria-label={undefined} role={undefined} />
-              <span>Quellcode wird geladen</span>
+              <span>Loading source code</span>
             </p>
           )}
           {state.kind === "error" && <Alert className="w-full" variant="destructive">{state.message}</Alert>}
@@ -75,7 +75,7 @@ export function ProgramSource({ api, moduleId, runId, revision, expandedByDefaul
             </div>
           )}
           {active && <SourceCode className="h-full max-h-[340px] w-full min-h-0 min-w-0 overflow-auto rounded-lg border border-border-soft bg-background/70" content={active.content} path={active.path} />}
-          {!expandedByDefault && <Button onClick={() => setExpanded(false)} size="sm" variant="outline">Quellcode ausblenden</Button>}
+          {!expandedByDefault && <Button onClick={() => setExpanded(false)} size="sm" variant="outline">Hide source code</Button>}
         </>
       )}
     </section>

package/plugins/ragents.actor-programs/web/api.ts

@@ -111,35 +111,35 @@ const HASH_PATTERN = /^[a-f0-9]{64}$/;
 const PARAMETER_TYPES = new Set<RunToolParameter["type"]>(actorFunctionParameterTypes);
 
 const requiredString = (value: unknown, field: string): string => {
-  if (typeof value !== "string" || !value.trim()) throw new Error(`${field} fehlt oder ist leer`);
+  if (typeof value !== "string" || !value.trim()) throw new Error(`${field} is missing or empty`);
   return value;
 };
 
 const optionalString = (value: unknown, field: string): string | undefined => {
   if (value === undefined) return undefined;
-  if (typeof value !== "string") throw new Error(`${field} ist kein Text`);
+  if (typeof value !== "string") throw new Error(`${field} is not text`);
   return value;
 };
 
 const idFrom = (value: unknown, field: string): string => {
   const id = requiredString(value, field);
-  if (!ID_PATTERN.test(id)) throw new Error(`${field} ist keine gültige Kennung`);
+  if (!ID_PATTERN.test(id)) throw new Error(`${field} is not a valid identifier`);
   return id;
 };
 
 const unique = <T,>(values: T[], keyOf: (value: T) => string, label: string): T[] => {
   const ids = values.map(keyOf);
-  if (new Set(ids).size !== ids.length) throw new Error(`${label} enthält doppelte Kennungen`);
+  if (new Set(ids).size !== ids.length) throw new Error(`${label} contains duplicate identifiers`);
   return values;
 };
 
 export const runAppActionFrom = (value: unknown): RunAppAction => {
-  if (!isRecord(value)) throw new Error("Eine App-Aktion ist kein Objekt");
+  if (!isRecord(value)) throw new Error("An app action is not an object");
   if (value.confirmation !== null && typeof value.confirmation !== "string") {
-    throw new Error("confirmation einer App-Aktion muss Text oder null sein");
+    throw new Error("confirmation of an app action must be text or null");
   }
   if (typeof value.confirmation === "string" && !value.confirmation.trim()) {
-    throw new Error("confirmation einer App-Aktion darf nicht leer sein");
+    throw new Error("confirmation of an app action must not be empty");
   }
   return {
     id: idFrom(value.id, "action.id"),
@@ -152,9 +152,9 @@ export const runAppActionFrom = (value: unknown): RunAppAction => {
 };
 
 export const runAppInvocationFrom = (value: unknown): RunAppInvocation => {
-  if (!isRecord(value)) throw new Error("Eine App-Ausführung ist kein Objekt");
+  if (!isRecord(value)) throw new Error("An app execution is not an object");
   if (!Array.isArray(value.output) || value.output.some((line) => typeof line !== "string")) {
-    throw new Error("output einer App-Ausführung ist keine Textliste");
+    throw new Error("output of an app execution is not a text list");
   }
   const base = {
     id: idFrom(value.id, "invocation.id"),
@@ -173,7 +173,7 @@ export const runAppInvocationFrom = (value: unknown): RunAppInvocation => {
     case "running":
       return { ...base, status: "running", startedAt: requiredString(value.startedAt, "invocation.startedAt") };
     case "succeeded": {
-      if (!isJsonValue(value.result)) throw new Error("result einer App-Ausführung ist kein JSON-Wert");
+      if (!isJsonValue(value.result)) throw new Error("result of an app execution is not a JSON value");
       return {
         ...base,
         status: "succeeded",
@@ -194,28 +194,28 @@ export const runAppInvocationFrom = (value: unknown): RunAppInvocation => {
         error: requiredString(value.error, "invocation.error"),
       };
     default:
-      throw new Error("status einer App-Ausführung ist ungültig");
+      throw new Error("status of an app execution is invalid");
   }
 };
 
 const runAppPlacementFrom = (value: unknown): RunAppPlacement => {
-  if (!isRecord(value)) throw new Error("Eine App-Platzierung ist kein Objekt");
+  if (!isRecord(value)) throw new Error("An app placement is not an object");
   if (value.kind === "canvas") {
     return {
       kind: "canvas",
       anchorActorId: requiredString(value.anchorActorId, "placement.anchorActorId"),
     };
   }
-  throw new Error("kind einer App-Platzierung muss canvas sein");
+  throw new Error("kind of an app placement must be canvas");
 };
 
 export const runAppFrom = (value: unknown): RunApp => {
-  if (!isRecord(value)) throw new Error("Eine App ist kein Objekt");
-  if (!Array.isArray(value.actions)) throw new Error("actions einer App ist keine Liste");
-  if (!Array.isArray(value.invocations)) throw new Error("invocations einer App ist keine Liste");
+  if (!isRecord(value)) throw new Error("An app is not an object");
+  if (!Array.isArray(value.actions)) throw new Error("actions of an app is not a list");
+  if (!Array.isArray(value.invocations)) throw new Error("invocations of an app is not a list");
   const rawPlacements = value.placements ?? [];
-  if (!Array.isArray(rawPlacements)) throw new Error("placements einer App ist keine Liste");
-  if (!isRecord(value.state) || value.state.version !== 1 || !Number.isSafeInteger(value.state.revision) || !isJsonValue(value.state.values)) throw new Error("state einer Ansicht entspricht nicht dem Zustandvertrag");
+  if (!Array.isArray(rawPlacements)) throw new Error("placements of an app is not a list");
+  if (!isRecord(value.state) || value.state.version !== 1 || !Number.isSafeInteger(value.state.revision) || !isJsonValue(value.state.values)) throw new Error("state of a view does not match the state contract");
   const actions = unique(value.actions.map(runAppActionFrom), (action) => action.id, "actions");
   const invocations = unique(
     value.invocations.map(runAppInvocationFrom),
@@ -224,15 +224,15 @@ export const runAppFrom = (value: unknown): RunApp => {
   );
   const actionIds = new Set(actions.map((action) => action.id));
   if (invocations.some((invocation) => !actionIds.has(invocation.actionId))) {
-    throw new Error("Eine App-Ausführung verweist auf eine unbekannte Aktion");
+    throw new Error("An app execution refers to an unknown action");
   }
-  if (value.visible !== undefined && typeof value.visible !== "boolean") throw new Error("visible einer App ist kein Wahrheitswert");
-  if (rawPlacements.length > 1) throw new Error("placements einer App enthält mehr als eine Platzierung");
+  if (value.visible !== undefined && typeof value.visible !== "boolean") throw new Error("visible of an app is not a boolean");
+  if (rawPlacements.length > 1) throw new Error("placements of an app contains more than one placement");
   const placements = rawPlacements.map(runAppPlacementFrom);
   const id = requiredString(value.id, "view.id");
-  if (!VIEW_ID_PATTERN.test(id)) throw new Error("view.id ist keine gültige Kennung");
+  if (!VIEW_ID_PATTERN.test(id)) throw new Error("view.id is not a valid identifier");
   const actorId = requiredString(value.actorId, "view.actorId");
-  if (placements.some((placement) => placement.anchorActorId !== actorId)) throw new Error("Die Ansicht muss bei ihrem eigenen Actor platziert sein");
+  if (placements.some((placement) => placement.anchorActorId !== actorId)) throw new Error("The view must be placed at its own actor");
   return {
     id,
     actorId,
@@ -251,11 +251,11 @@ export const runAppFrom = (value: unknown): RunApp => {
 };
 
 const runToolParameterFrom = (value: unknown): RunToolParameter => {
-  if (!isRecord(value)) throw new Error("Ein Werkzeugparameter ist kein Objekt");
+  if (!isRecord(value)) throw new Error("A tool parameter is not an object");
   if (typeof value.type !== "string" || !PARAMETER_TYPES.has(value.type as RunToolParameter["type"])) {
-    throw new Error("type eines Werkzeugparameters ist ungültig");
+    throw new Error("type of a tool parameter is invalid");
   }
-  if (typeof value.required !== "boolean") throw new Error("required eines Werkzeugparameters ist kein Wahrheitswert");
+  if (typeof value.required !== "boolean") throw new Error("required of a tool parameter is not a boolean");
   return {
     name: idFrom(value.name, "parameter.name"),
     description: requiredString(value.description, "parameter.description"),
@@ -265,9 +265,9 @@ const runToolParameterFrom = (value: unknown): RunToolParameter => {
 };
 
 const runToolTargetFrom = (value: unknown): RunToolTarget => {
-  if (!isRecord(value)) throw new Error("Ein Werkzeugziel ist kein Objekt");
+  if (!isRecord(value)) throw new Error("A tool target is not an object");
   if (value.handle !== null && typeof value.handle !== "string") {
-    throw new Error("handle eines Werkzeugziels muss Text oder null sein");
+    throw new Error("handle of a tool target must be text or null");
   }
   return {
     actorId: requiredString(value.actorId, "target.actorId"),
@@ -276,11 +276,11 @@ const runToolTargetFrom = (value: unknown): RunToolTarget => {
 };
 
 export const runScriptToolFrom = (value: unknown): RunScriptTool => {
-  if (!isRecord(value)) throw new Error("Ein Script-Werkzeug ist kein Objekt");
-  if (!Array.isArray(value.parameters)) throw new Error("parameters eines Script-Werkzeugs ist keine Liste");
-  if (!Array.isArray(value.targets)) throw new Error("targets eines Script-Werkzeugs ist keine Liste");
+  if (!isRecord(value)) throw new Error("A script tool is not an object");
+  if (!Array.isArray(value.parameters)) throw new Error("parameters of a script tool is not a list");
+  if (!Array.isArray(value.targets)) throw new Error("targets of a script tool is not a list");
   const sourceHash = requiredString(value.sourceHash, "tool.sourceHash");
-  if (!HASH_PATTERN.test(sourceHash)) throw new Error("sourceHash eines Script-Werkzeugs ist ungültig");
+  if (!HASH_PATTERN.test(sourceHash)) throw new Error("sourceHash of a script tool is invalid");
   return {
     actorId: requiredString(value.actorId, "tool.actorId"),
     actorHandle: requiredString(value.actorHandle, "tool.actorHandle"),
@@ -298,8 +298,8 @@ export const runScriptToolFrom = (value: unknown): RunScriptTool => {
 };
 
 const actorProgramSourceFileFrom = (value: unknown): ActorProgramSourceFile => {
-  if (!isRecord(value)) throw new Error("Eine Quelldatei ist kein Objekt");
-  if (typeof value.content !== "string") throw new Error("content einer Quelldatei ist kein Text");
+  if (!isRecord(value)) throw new Error("A source file is not an object");
+  if (typeof value.content !== "string") throw new Error("content of a source file is not text");
   return {
     path: requiredString(value.path, "source.path"),
     content: value.content,
@@ -307,13 +307,13 @@ const actorProgramSourceFileFrom = (value: unknown): ActorProgramSourceFile => {
 };
 
 export const actorProgramSourceFrom = (value: unknown): ActorProgramSourceFile[] => {
-  if (!isRecord(value) || !Array.isArray(value.files)) throw new Error("Die Quellenliste entspricht nicht dem Vertrag");
+  if (!isRecord(value) || !Array.isArray(value.files)) throw new Error("The source list does not match the contract");
   return unique(value.files.map(actorProgramSourceFileFrom), (file) => file.path, "files");
 };
 
 export const actorProgramsListingFrom = (value: unknown): ActorProgramsListing => {
   if (!isRecord(value) || !Array.isArray(value.apps) || !Array.isArray(value.tools)) {
-    throw new Error("Die Liste der Actor-Programme entspricht nicht dem Vertrag");
+    throw new Error("The list of actor programs does not match the contract");
   }
   return {
     apps: unique(value.apps.map(runAppFrom), (app) => app.id, "apps"),

package/plugins/ragents.actor-programs/web/bridge.ts

@@ -75,18 +75,18 @@ const inputWithinLimit = (value: JsonValue): boolean => {
 };
 
 export const validateRunAppBridgeRequest = (value: unknown): RunAppBridgeValidation => {
-  if (!isRecord(value)) return { ok: false, error: "Die App-Nachricht ist kein Objekt" };
+  if (!isRecord(value)) return { ok: false, error: "The app message is not an object" };
   const requestId = requestIdFrom(value.requestId);
-  if (!requestId) return { ok: false, error: "Die App-Nachricht enthält keine gültige requestId" };
+  if (!requestId) return { ok: false, error: "The app message contains no valid requestId" };
   if (value.version !== RUN_APP_BRIDGE_VERSION) {
-    return { ok: false, requestId, error: "Die App verwendet eine nicht unterstützte Bridge-Version" };
+    return { ok: false, requestId, error: "The app uses an unsupported bridge version" };
   }
   if (value.type === RUN_APP_GET_STATE) {
     return { ok: true, request: { type: RUN_APP_GET_STATE, version: RUN_APP_BRIDGE_VERSION, requestId } };
   }
   if (value.type === RUN_APP_CHAT_WATCH || value.type === RUN_APP_CHAT_UNWATCH || value.type === RUN_APP_CHAT_SEND) {
     if (typeof value.actor !== "string" || !/^@?[\p{L}\p{N}_-]{1,64}$/u.test(value.actor)) {
-      return { ok: false, requestId, error: "Das Chat-Ziel muss primary oder ein Actor-Handle wie @reviewer sein" };
+      return { ok: false, requestId, error: "The chat target must be primary or an actor handle such as @reviewer" };
     }
     const common = { version: RUN_APP_BRIDGE_VERSION, requestId, actor: value.actor } as const;
     if (value.type !== RUN_APP_CHAT_SEND) return { ok: true, request: { ...common, type: value.type } };
@@ -95,18 +95,18 @@ export const validateRunAppBridgeRequest = (value: unknown): RunAppBridgeValidat
       return { ok: false, requestId, error: cause instanceof Error ? cause.message : String(cause) };
     }
     if (typeof value.text !== "string" || (!value.text.trim() && !attachments.length) || !inputWithinLimit(value.text)) {
-      return { ok: false, requestId, error: "Die Chat-Nachricht ist leer oder zu groß" };
+      return { ok: false, requestId, error: "The chat message is empty or too large" };
     }
     return { ok: true, request: { ...common, type: RUN_APP_CHAT_SEND, text: value.text.trim(), ...(attachments.length ? { attachments } : {}) } };
   }
   if (value.type !== RUN_APP_INVOKE) {
-    return { ok: false, requestId, error: "Die App-Nachricht hat einen unbekannten Typ" };
+    return { ok: false, requestId, error: "The app message has an unknown type" };
   }
   if (typeof value.actionId !== "string" || !ID_PATTERN.test(value.actionId)) {
-    return { ok: false, requestId, error: "Die App-Nachricht enthält keine gültige actionId" };
+    return { ok: false, requestId, error: "The app message contains no valid actionId" };
   }
   if (!isJsonValue(value.input) || !inputWithinLimit(value.input)) {
-    return { ok: false, requestId, error: "Die Eingabe der App-Aktion ist kein gültiger JSON-Wert oder zu groß" };
+    return { ok: false, requestId, error: "The input of the app action is not a valid JSON value or too large" };
   }
   return {
     ok: true,

package/plugins/ragents.actor-programs/web/chat-state.ts

@@ -7,13 +7,13 @@ import { programChatNotice } from "@ragents/web/chat/chat-target";
 
 export const resolveChatActor = (session: SessionContext, target: string) => {
   const view = runViewFrom(session.runView);
-  if (!view || view.id !== session.session.id) throw new Error("Die Run-Ansicht für diesen Chat ist noch nicht verfügbar");
+  if (!view || view.id !== session.session.id) throw new Error("The run view for this chat is not available yet");
   const actor = target === "primary"
     ? view.actors.find((entry) => entry.id === view.primaryActorId)
     : actorByHandle(view.actors, target);
   if (!actor || actor.kind === "human") {
     const names = view.actors.filter((entry) => entry.kind !== "human").map((entry) => `@${entry.handle}`).join(", ");
-    throw new Error(`Das Chat-Ziel ist nicht verfügbar. Erlaubt sind primary und: ${names || "noch keine Actors"}`);
+    throw new Error(`The chat target is not available. Allowed are primary and: ${names || "no actors yet"}`);
   }
   return { view, actor };
 };
@@ -23,8 +23,8 @@ export const chatSnapshotOf = (session: SessionContext, target: string): ChatSna
     const { view, actor } = resolveChatActor(session, target);
     const primary = actor.id === view.primaryActorId;
     const error = actor.kind === "script" ? programChatNotice : session.conversationError ?? (!session.connected
-      ? "Die Verbindung zum Run ist unterbrochen"
-      : actor.lifecycle?.kind === "stopped" ? `@${actor.handle} gestoppt: ${actor.lifecycle.reason}. Er nimmt keine Eingaben an, bis er neu gestartet wird` : undefined);
+      ? "The connection to the run is interrupted"
+      : actor.lifecycle?.kind === "stopped" ? `@${actor.handle} stopped: ${actor.lifecycle.reason}. It accepts no input until it is restarted` : undefined);
     return {
       owner: actor.id,
       messages: actorChatMessages(view, actor, session.messages, session.actorConversations?.[actor.id]),

package/plugins/ragents.actor-programs/web/context.ts

@@ -25,6 +25,6 @@ export const useOptionalActorPrograms = () => useContext(ActorProgramsContext);
 
 export const useActorPrograms = (): ActorProgramsContextValue => {
   const value = useOptionalActorPrograms();
-  if (!value) throw new Error("Der Actor-Programm-Provider ist nicht aktiv");
+  if (!value) throw new Error("The actor program provider is not active");
   return value;
 };

package/plugins/ragents.actor-programs/web/function-input.ts

@@ -9,11 +9,11 @@ const parseParameter = (parameter: RunToolParameter, form: FormData): JsonValue
   }
   if (raw === "" && !parameter.required) return undefined;
   if (parameter.type === "string") return raw;
-  if (!raw.trim()) throw new Error(`${parameter.name}: Bitte einen Wert eingeben.`);
+  if (!raw.trim()) throw new Error(`${parameter.name}: Please enter a value.`);
   if (parameter.type === "number" || parameter.type === "integer") {
     const value = Number(raw);
     if (!Number.isFinite(value) || parameter.type === "integer" && !Number.isInteger(value)) {
-      throw new Error(`${parameter.name} ist keine gültige ${parameter.type === "integer" ? "Ganzzahl" : "Zahl"}.`);
+      throw new Error(`${parameter.name} is not a valid ${parameter.type === "integer" ? "integer" : "number"}.`);
     }
     return value;
   }
@@ -22,13 +22,13 @@ const parseParameter = (parameter: RunToolParameter, form: FormData): JsonValue
   }
   let value: unknown;
   try { value = JSON.parse(raw); }
-  catch { throw new Error(`${parameter.name}: Bitte gültiges JSON eingeben.`); }
-  if (!isJsonValue(value)) throw new Error(`${parameter.name}: Kein gültiger JSON-Wert.`);
+  catch { throw new Error(`${parameter.name}: Please enter valid JSON.`); }
+  if (!isJsonValue(value)) throw new Error(`${parameter.name}: Not a valid JSON value.`);
   if (parameter.type === "string[]" && (!Array.isArray(value) || !value.every((entry) => typeof entry === "string"))) {
-    throw new Error(`${parameter.name}: Bitte eine Liste aus Texten eingeben.`);
+    throw new Error(`${parameter.name}: Please enter a list of texts.`);
   }
   if (parameter.type === "number[]" && (!Array.isArray(value) || !value.every((entry) => typeof entry === "number"))) {
-    throw new Error(`${parameter.name}: Bitte eine JSON-Liste aus Zahlen eingeben.`);
+    throw new Error(`${parameter.name}: Please enter a JSON list of numbers.`);
   }
   return value;
 };

package/plugins/ragents.actor-programs/web/index.tsx

@@ -68,7 +68,7 @@ const configuredPlugin = (descriptor: WebPluginDescriptor, routePrefix: string):
       {
         readRight: "runs.inspect",
         id: RUN_TOOLS_TAB_ID,
-        label: "Funktionen",
+        label: "Functions",
         order: 251,
         Icon: IconTools,
         Panel: ToolsPanel,

package/plugins/ragents.actor-programs/web/program-state.ts

@@ -20,7 +20,7 @@ export const actorProgramSourceReference = (runView: unknown, actorId: string):
   if (!entry || !isRecord(entry.state) || entry.state.program === null) return undefined;
   const program = entry.state.program;
   if (!isRecord(program) || program.actorId !== actorId || typeof program.name !== "string" || typeof program.revision !== "string") {
-    throw new Error("Die Quellcode-Zuordnung des Actor-Programms ist ungültig.");
+    throw new Error("The source code mapping of the actor program is invalid.");
   }
   return { name: program.name, revision: program.revision };
 };
@@ -36,10 +36,10 @@ export const actorProgramViews = (runView: unknown): ActorProgramView[] => {
     if (!isRecord(entry.state) || !isRecord(entry.state.program)) return [];
     const program = entry.state.program;
     if (program.actorId !== actor.id || program.actorHandle !== actor.handle || typeof program.revision !== "string" || !Array.isArray(program.views)) {
-      throw new Error(`Das Ansichtsprogramm von @${actor.handle} ist ungültig.`);
+      throw new Error(`The view program of @${actor.handle} is invalid.`);
     }
     return program.views.map((app) => {
-      if (!isRecord(app) || typeof app.id !== "string" || typeof app.title !== "string") throw new Error(`Eine Ansicht von @${actor.handle} ist ungültig.`);
+      if (!isRecord(app) || typeof app.id !== "string" || typeof app.title !== "string") throw new Error(`A view of @${actor.handle} is invalid.`);
       return { id: app.id, title: app.title, actorId: actor.id, actorHandle: actor.handle, revision: program.revision as string, app };
     });
   });
@@ -57,7 +57,7 @@ export const currentActorListing = (listing: ActorProgramsListing | undefined, r
       if (!current || current.actorId !== app.actorId || current.revision !== app.revision) return [];
       const state = view.pluginStates.find((entry) => entry.pluginId === ACTOR_STATE_ID && entry.scope.kind === "actor" && entry.scope.actorId === app.actorId);
       const values = state ? state.state : app.state.values;
-      if (!isJsonValue(values)) throw new Error(`Der Zustand von @${app.actorHandle} ist kein JSON-Wert.`);
+      if (!isJsonValue(values)) throw new Error(`The state of @${app.actorHandle} is not a JSON value.`);
       return [{ ...app, visible: current.app.visible !== false,
         state: { ...app.state, values } }];
     }),

package/plugins/ragents.ask/ask-payload.ts

@@ -7,7 +7,7 @@ export interface AskPayload {
   question: string;
   options: string[];
   multi: boolean;
-  /** Der Actor, für den die Frage steht, wenn der Eigentümer des Runs sie außerhalb eines Turns stellt. */
+  /** The actor the question stands for when the run owner asks it outside a turn. */
   recipient?: string;
 }
 

package/plugins/ragents.ask/contract.ts

@@ -4,13 +4,13 @@ import { defineOperation } from "@ragents/engine/src/rpc/contract";
 export const askContracts = {
   answer: defineOperation({
     id: "ragents.ask.answer",
-    description: "Eine Rückfrage des Runs beantworten oder verwerfen. Rechte: runs.read und runs.write.",
+    description: "Answer or dismiss a question of the run. Rights: runs.read and runs.write.",
     rights: ["runs.read", "runs.write"],
     input: Type.Object({
-      runId: Type.String({ minLength: 1, maxLength: 64, description: "Kennung des Runs" }),
-      actionId: Type.String({ minLength: 1, maxLength: 80, description: "Kennung der Frage" }),
-      answer: Type.Optional(Type.String({ description: "Die Antwort des Benutzers" })),
-      dismiss: Type.Optional(Type.Boolean({ description: "true verwirft die Frage ohne Antwort" })),
+      runId: Type.String({ minLength: 1, maxLength: 64, description: "Run id" }),
+      actionId: Type.String({ minLength: 1, maxLength: 80, description: "Question id" }),
+      answer: Type.Optional(Type.String({ description: "The user's answer" })),
+      dismiss: Type.Optional(Type.Boolean({ description: "true dismisses the question without an answer" })),
     }, { additionalProperties: false }),
     result: Type.Null(),
   }),

package/plugins/ragents.ask/server/answer-method.ts

@@ -7,7 +7,7 @@ export const createAnswerMethod = (
   ensureSession: (runId: string) => void,
 ): MethodContribution => implement(askContracts.answer, ({ runId, actionId, answer, dismiss }) => {
   if (dismiss !== true && (typeof answer !== "string" || answer.trim() === "")) {
-    throw new DomainError("answer-missing", "answer ist erforderlich, wenn nicht verworfen wird", 400);
+    throw new DomainError("answer-missing", "answer is required unless the question is dismissed", 400);
   }
   ensureSession(runId);
   service.answer(runId, actionId, { ...(answer !== undefined ? { answer } : {}), ...(dismiss !== undefined ? { dismiss } : {}) });

package/plugins/ragents.ask/server/ask-service.ts

@@ -35,7 +35,7 @@ export class RuntimeAskService implements AskService {
   readonly #aborting = new Set<string>();
 
   bind(runtime: Orchestration): void {
-    if (this.#runtime) throw new Error("Der Ask-Service wurde bereits an eine Runtime gebunden");
+    if (this.#runtime) throw new Error("The ask service is already bound to a runtime");
     this.#runtime = runtime;
     runtime.subscribe((events) => this.#onJournal(events));
   }
@@ -53,7 +53,7 @@ export class RuntimeAskService implements AskService {
       title: request.question,
       description: request.description,
       parameters: request.parameters,
-      input: { label: "Antwort", placeholder: null, required: true },
+      input: { label: "Answer", placeholder: null, required: true },
       payload: {
         question: request.question,
         options: [...request.options],
@@ -64,7 +64,7 @@ export class RuntimeAskService implements AskService {
     const proposed = runtime.events(call.runId).find((event) =>
       event.type === "action.proposed" && event.commandId === call.commandId);
     if (proposed?.type !== "action.proposed") {
-      throw new Error(`Die Frage von ${call.agentId} wurde nicht im Journal von ${call.runId} angelegt`);
+      throw new Error(`The question from ${call.agentId} was not created in the journal of ${call.runId}`);
     }
     return this.#awaitAnswer(call.runId, proposed.payload.actionId, call.turnId ? call.agentId : null, signal);
   }
@@ -74,7 +74,7 @@ export class RuntimeAskService implements AskService {
     const state = runtime.state(runId);
     const action = state.actions.get(actionId);
     if (!action || action.owner !== ASK_PLUGIN_ID) {
-      throw new DomainError("question-not-found", `Frage ${actionId} existiert nicht in Run ${runId}.`, 404);
+      throw new DomainError("question-not-found", `Question ${actionId} does not exist in run ${runId}.`, 404);
     }
     runtime.resolveAction(
       { actorId: state.ownerId, commandId: `ask-answer:${actionId}:${randomUUID()}` },
@@ -120,7 +120,7 @@ export class RuntimeAskService implements AskService {
   #awaitAnswer(runId: string, actionId: string, blockedActorId: string | null, signal: AbortSignal | undefined): Promise<string> {
     const runtime = this.#requireRuntime();
     const action = runtime.state(runId).actions.get(actionId);
-    if (!action) throw new Error(`Frage ${actionId} existiert nicht in Run ${runId}`);
+    if (!action) throw new Error(`Question ${actionId} does not exist in run ${runId}`);
     const settled = resolvedAnswerOf(action);
     if (settled !== null) return Promise.resolve(settled);
     return new Promise<string>((resolve, reject) => {
@@ -138,7 +138,7 @@ export class RuntimeAskService implements AskService {
               { decision: "dismissed", result: null },
             );
           }
-          reject(new Error("Das Warten auf die Antwort wurde abgebrochen."));
+          reject(new Error("Waiting for the answer was cancelled."));
         } catch (error) {
           reject(error);
         } finally {
@@ -201,16 +201,16 @@ export class RuntimeAskService implements AskService {
         runId,
         {
           actorId: recipientId,
-          content: `Antwort auf ${recipientId === action.askedBy ? "deine Frage" : "die Frage"}: ${action.title}\nAntwort: ${answer}`,
+          content: `Answer to ${recipientId === action.askedBy ? "your question" : "the question"}: ${action.title}\nAnswer: ${answer}`,
         },
       );
     } catch (error) {
-      console.error(`Antwort auf Frage ${actionId} konnte nicht als Input eingereiht werden: ${error instanceof Error ? error.message : String(error)}`);
+      console.error(`Answer to question ${actionId} could not be enqueued as input: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
 
   #requireRuntime(): Orchestration {
-    if (!this.#runtime) throw new Error("Der Ask-Service ist noch nicht an die Runtime gebunden");
+    if (!this.#runtime) throw new Error("The ask service is not bound to the runtime yet");
     return this.#runtime;
   }
 }