@schlenkr/ragents 0.1.10 → 0.1.11

package/bundles/ragents.reference/run-scripts/learning-afternoon/src/server.ts

@@ -26,7 +26,7 @@ const contract = {
   }, { additionalProperties: false }),
   functions: {
     start: {
-      label: "Ideen sammeln",
+      label: "Collect ideas",
       input: Type.Object({}, { additionalProperties: false }),
       output: Type.Object({}, { additionalProperties: false }),
       capabilities: ["actor_input"],
@@ -61,12 +61,12 @@ export default defineActor(contract, {
   onInput: async (input, context) => {
     const state = context.state.read();
     if (state.board && !input.event && input.content !== startMarker) {
-      throw new Error("Der Lernnachmittag versteht keine freien Chatnachrichten. Verwende den Startknopf der Mini-App; für neue Ideen ist ein neuer Run nötig.");
+      throw new Error("The learning afternoon does not understand free chat messages. Use the start button of the mini-app; new ideas need a new run.");
     }
     if (!state.board) {
       const catalog = await context.functions.model_list({});
       const profile = catalog.profiles.find((entry) => entry.driver === "agent" && entry.name === "standard");
-      if (!profile) throw new Error("Die Rolle standard fehlt.");
+      if (!profile) throw new Error("The role standard is missing.");
       const prompt = await workflowInstructions(learningWorkflow, "helper", readPrompt);
       const helpers = await Promise.all(initialState.helpers.map(async (helper) => {
         const actor = await context.functions.agent_spawn({ handle: `learning-${helper.id}`, displayName: helper.label, profile: profile.name, prompt, tools: [] });
@@ -92,11 +92,11 @@ export default defineActor(contract, {
       });
       const results = await Promise.allSettled(state.board.helpers.map(async (helper): Promise<HelperState> => {
         const step = helperSteps.find((entry) => entry.id === helper.id);
-        if (!step) throw new Error(`Unbekannter Helfer: ${helper.id}`);
+        if (!step) throw new Error(`Unknown helper: ${helper.id}`);
         const content = step.goal;
         const events = await context.functions.actor_input({ actor: `@learning-${helper.id}`, content });
         const queued = events.find((event) => event.type === "actor.input.enqueued");
-        if (!queued || queued.type !== "actor.input.enqueued") throw new Error("Der Auftrag wurde nicht bestätigt.");
+        if (!queued || queued.type !== "actor.input.enqueued") throw new Error("The task was not confirmed.");
         return { ...helper, inputId: queued.payload.inputId, status: "working" };
       }));
       const helpers = state.board.helpers.map((helper, index): HelperState => {
@@ -104,7 +104,7 @@ export default defineActor(contract, {
         return result.status === "fulfilled" ? result.value : { ...helper, status: "error", error: result.reason instanceof Error ? result.reason.message : String(result.reason) };
       });
       const board = boardWith(helpers);
-      if (board.phase !== "working") await context.functions.event_unsubscribe({ subscriptionId: subscription.subscriptionId, reason: "Beide Aufträge sind beendet." });
+      if (board.phase !== "working") await context.functions.event_unsubscribe({ subscriptionId: subscription.subscriptionId, reason: "Both tasks have ended." });
       context.state.replace({ board, subscriptionId: subscription.subscriptionId });
       return;
     }
@@ -114,7 +114,7 @@ export default defineActor(contract, {
     const helper = state.board.helpers.find((entry) => entry.actorId === event.sourceActorId && entry.status === "working");
     if (!helper) return;
     const next = await (async (): Promise<HelperState | undefined> => {
-      if (event.type === "actor.stopped") return { ...helper, status: "error", error: "Der Helfer wurde gestoppt." };
+      if (event.type === "actor.stopped") return { ...helper, status: "error", error: "The helper was stopped." };
       if (event.type !== "turn.finished" && event.type !== "turn.interrupted") return;
       const payload = event.payload;
       const turnId = payload.turnId;
@@ -126,12 +126,12 @@ export default defineActor(contract, {
       const text = events.filter((entry) => entry.type === "model.output.completed" && entry.payload.turnId === turnId)
         .map((entry) => typeof entry.payload.text === "string" ? entry.payload.text.trim() : "").filter(Boolean).join("\n\n");
       if (event.type === "turn.finished" && payload.outcome === "completed" && text) return { ...helper, text, status: "complete" };
-      const error = typeof payload.reason === "string" && payload.reason.trim() ? payload.reason : "Der Helfer hat keine Idee geliefert.";
+      const error = typeof payload.reason === "string" && payload.reason.trim() ? payload.reason : "The helper delivered no idea.";
       return { ...helper, status: "error", error };
     })();
     if (!next) return;
     const board = boardWith(state.board.helpers.map((entry) => entry.id === next.id ? next : entry));
-    if (board.phase !== "working") await context.functions.event_unsubscribe({ subscriptionId: state.subscriptionId!, reason: "Beide Aufträge sind beendet." });
+    if (board.phase !== "working") await context.functions.event_unsubscribe({ subscriptionId: state.subscriptionId!, reason: "Both tasks have ended." });
     context.state.replace({ ...state, board });
   },
 });

package/bundles/ragents.reference/run-scripts/learning-afternoon/tests/program.test.ts

@@ -22,7 +22,7 @@ function setup(options: { missingProfile?: boolean; failDispatch?: string; befor
     "model_list", "agent_spawn", "canvas_layout_replace", "run_configure", "actor_input", "event_subscribe", "event_unsubscribe", "event_query",
   ].map((name) => [name, async (input: unknown) => {
     calls.push({ name, input });
-    if (name === "model_list") return { profiles: options.missingProfile ? [] : [{ name: "standard", driver: "agent", description: "Testprofil", turnTimeoutMs: null, isolateWorkspace: false, provider: "test", model: "test" }], models: [] };
+    if (name === "model_list") return { profiles: options.missingProfile ? [] : [{ name: "standard", driver: "agent", description: "Test profile", turnTimeoutMs: null, isolateWorkspace: false, provider: "test", model: "test" }], models: [] };
     if (name === "agent_spawn") {
       const handle = (input as { handle: string }).handle;
       return { id: `actor-${handle}`, handle };
@@ -32,7 +32,7 @@ function setup(options: { missingProfile?: boolean; failDispatch?: string; befor
     if (name === "actor_input") {
       const actor = (input as { actor: string }).actor;
       await options.beforeDispatch?.(actor);
-      if (actor === options.failDispatch) throw new Error("Auftrag konnte nicht gesendet werden.");
+      if (actor === options.failDispatch) throw new Error("Task could not be sent.");
       return [{ type: "actor.input.enqueued", payload: { actorId: `actor-${actor.slice(1)}`, inputId: `input-${actor.slice(1)}` } }];
     }
     return null;
@@ -56,7 +56,7 @@ async function complete(context: ReturnType<typeof setup>["context"], helper: st
   await program.onInput(eventOf(helper, "turn.finished", { outcome: "completed" }), context);
 }
 
-test("Start richtet nur zwei reine Helfer und die eigene App ein; erst der Button stellt einen Auftrag an den Besitzer", async () => {
+test("start sets up only two plain helpers and its own app; only the button sends a task to the owner", async () => {
   const { context, calls } = setup();
   await program.onInput(setupInput, context);
   assert.equal(context.state.read().board?.phase, "ready");
@@ -68,7 +68,7 @@ test("Start richtet nur zwei reine Helfer und die eigene App ein; erst der Butto
   assert.equal(calls.some((call) => call.name === "actor_input" || call.name === "event_subscribe"), false);
   const before = structuredClone(context.state.read());
   const callCount = calls.length;
-  await assert.rejects(async () => program.onInput(setupInput, context), /keine freien Chatnachrichten/);
+  await assert.rejects(async () => program.onInput(setupInput, context), /does not understand free chat messages/);
   assert.deepEqual(context.state.read(), before);
   assert.equal(calls.length, callCount);
   await program.functions.start({}, context);
@@ -76,13 +76,13 @@ test("Start richtet nur zwei reine Helfer und die eigene App ein; erst der Butto
   assert.equal(context.state.read().board?.phase, "ready");
 });
 
-test("der Input-Handler abonniert zuerst und sendet beide unabhängigen Aufträge parallel genau einmal", async () => {
+test("the input handler subscribes first and sends both independent tasks in parallel exactly once", async () => {
   const pending: (() => void)[] = [];
   const { context, calls } = setup({ beforeDispatch: () => new Promise<void>((resolve) => pending.push(resolve)) });
   await program.onInput(setupInput, context);
   const starting = program.onInput(startInput, context);
   for (let attempt = 0; attempt < 20 && pending.length < 2; attempt++) await Promise.resolve();
-  assert.equal(pending.length, 2, "Beide Inputs beginnen, bevor einer fertig ist.");
+  assert.equal(pending.length, 2, "Both inputs begin before one finishes.");
   assert.equal(calls.filter((call) => call.name === "event_subscribe").length, 1);
   for (const resolve of pending) resolve();
   await starting;
@@ -93,104 +93,104 @@ test("der Input-Handler abonniert zuerst und sendet beide unabhängigen Aufträg
 });
 
 for (const phase of ["ready", "working", "complete"]) {
-  test(`freie Chatnachrichten werden bei ${phase} abgelehnt und erhalten die Ideen`, async () => {
+  test(`free chat messages are rejected when ${phase} and keep the ideas`, async () => {
     const { context, calls } = setup();
     if (phase === "ready") {
       await program.onInput(setupInput, context);
     } else {
       await begin(context);
-      await complete(context, "experiment", "Die Experimentidee ist fertig.");
-      if (phase === "complete") await complete(context, "quiz", "Die Quizidee ist fertig.");
+      await complete(context, "experiment", "The experiment idea is ready.");
+      if (phase === "complete") await complete(context, "quiz", "The quiz idea is ready.");
     }
     assert.equal(context.state.read().board?.phase, phase);
     const before = structuredClone(context.state.read());
     const callCount = calls.length;
-    const content = "Sammle bitte noch einmal neue Ideen für den Lernnachmittag.";
-    await assert.rejects(async () => program.onInput(inputOf(content), context), /keine freien Chatnachrichten.*Startknopf.*neuer Run/);
+    const content = "Please collect new ideas for the learning afternoon again.";
+    await assert.rejects(async () => program.onInput(inputOf(content), context), /does not understand free chat messages.*start button.*new run/);
     assert.deepEqual(context.state.read(), before);
     assert.equal(calls.length, callCount);
     if (phase === "ready") {
       await program.onInput(startInput, context);
       assert.equal(context.state.read().board?.phase, "working");
     } else if (phase === "working") {
-      await complete(context, "quiz", "Die Quizidee ist fertig.");
+      await complete(context, "quiz", "The quiz idea is ready.");
       assert.equal(context.state.read().board?.phase, "complete");
-      assert.equal(context.state.read().board?.helpers[0]?.text, "Die Experimentidee ist fertig.");
+      assert.equal(context.state.read().board?.helpers[0]?.text, "The experiment idea is ready.");
     }
   });
 }
 
 for (const order of [["experiment", "quiz"], ["quiz", "experiment"]]) {
-  test(`sammelt Antworten in beliebiger Reihenfolge: ${order.join(", ")}`, async () => {
+  test(`collects answers in any order: ${order.join(", ")}`, async () => {
     const { context, calls } = setup();
     await begin(context);
-    await complete(context, order[0]!, "Erste echte Antwort");
+    await complete(context, order[0]!, "First real answer");
     assert.equal(context.state.read().board?.phase, "working");
-    await complete(context, order[1]!, "Zweite echte Antwort");
+    await complete(context, order[1]!, "Second real answer");
     const board = context.state.read().board!;
     assert.equal(board.phase, "complete");
-    assert.equal(board.helpers.find((helper) => helper.id === order[0])?.text, "Erste echte Antwort");
-    assert.equal(board.helpers.find((helper) => helper.id === order[1])?.text, "Zweite echte Antwort");
+    assert.equal(board.helpers.find((helper) => helper.id === order[0])?.text, "First real answer");
+    assert.equal(board.helpers.find((helper) => helper.id === order[1])?.text, "Second real answer");
     assert.equal(calls.filter((call) => call.name === "event_unsubscribe").length, 1);
-    for (let count = 0; count < 10; count++) await complete(context, order[0]!, "Späte Antwort");
+    for (let count = 0; count < 10; count++) await complete(context, order[0]!, "Late answer");
     assert.deepEqual(context.state.read().board, board);
     assert.equal(calls.filter((call) => call.name === "actor_input").length, 2);
   });
 }
 
-test("ignoriert falsche Actors, Inputs, Turns, Abos und doppelte Antworten", async () => {
+test("ignores wrong actors, inputs, turns, subscriptions, and duplicate answers", async () => {
   const { context } = setup();
   await program.onInput(setupInput, context);
   await program.onInput(startInput, context);
-  record(context, "experiment", "turn.started", { inputId: "fremd", turnId: "fremd" });
-  record(context, "experiment", "model.output.completed", { text: "Fremd", turnId: "fremd" });
+  record(context, "experiment", "turn.started", { inputId: "foreign", turnId: "foreign" });
+  record(context, "experiment", "model.output.completed", { text: "Foreign", turnId: "foreign" });
   record(context, "experiment", "turn.started", { inputId: "input-learning-experiment" });
-  record(context, "experiment", "model.output.completed", { text: "Meine Idee" });
+  record(context, "experiment", "model.output.completed", { text: "My idea" });
   const before = context.state.read();
   await program.onInput(eventOf("foreign", "turn.finished", { outcome: "completed" }), context);
-  await program.onInput(eventOf("experiment", "turn.finished", { outcome: "completed", turnId: "fremd" }), context);
-  await program.onInput({ ...eventOf("experiment", "turn.finished", { outcome: "completed" }), subscriptionId: "fremd" }, context);
+  await program.onInput(eventOf("experiment", "turn.finished", { outcome: "completed", turnId: "foreign" }), context);
+  await program.onInput({ ...eventOf("experiment", "turn.finished", { outcome: "completed" }), subscriptionId: "foreign" }, context);
   assert.deepEqual(context.state.read(), before);
   const answer = eventOf("experiment", "turn.finished", { outcome: "completed" });
   await program.onInput(answer, context);
   await program.onInput(answer, context);
-  assert.equal(context.state.read().board?.helpers[0]?.text, "Meine Idee");
+  assert.equal(context.state.read().board?.helpers[0]?.text, "My idea");
   assert.equal(context.state.read().board?.helpers[0]?.status, "complete");
 });
 
 for (const ending of ["failed", "interrupted", "empty", "stopped"]) {
-  test(`ein ${ending}-Ergebnis erhält die erfolgreiche Idee des anderen Helfers`, async () => {
+  test(`a ${ending} result keeps the successful idea of the other helper`, async () => {
     const { context, calls } = setup();
     await begin(context);
-    await complete(context, "quiz", "Das Quiz ist fertig.");
-    await program.onInput(eventOf("experiment", ending === "stopped" ? "actor.stopped" : ending === "interrupted" ? "turn.interrupted" : "turn.finished", { outcome: ending === "empty" ? "completed" : "failed", ...(ending === "empty" ? {} : { reason: "Modellfehler" }) }), context);
+    await complete(context, "quiz", "The quiz is ready.");
+    await program.onInput(eventOf("experiment", ending === "stopped" ? "actor.stopped" : ending === "interrupted" ? "turn.interrupted" : "turn.finished", { outcome: ending === "empty" ? "completed" : "failed", ...(ending === "empty" ? {} : { reason: "Model error" }) }), context);
     assert.equal(context.state.read().board?.phase, "error");
     assert.equal(context.state.read().board?.helpers[0]?.status, "error");
     assert.ok(context.state.read().board?.helpers[0]?.error);
-    assert.equal(context.state.read().board?.helpers[1]?.text, "Das Quiz ist fertig.");
+    assert.equal(context.state.read().board?.helpers[1]?.text, "The quiz is ready.");
     assert.equal(calls.filter((call) => call.name === "actor_input").length, 2);
     assert.equal(calls.filter((call) => call.name === "event_unsubscribe").length, 1);
   });
 }
 
-test("ein gescheiterter Input verhindert den Auftrag des anderen Helfers nicht", async () => {
+test("a failed input does not prevent the other helper's task", async () => {
   const { context } = setup({ failDispatch: "@learning-experiment" });
   await begin(context);
   assert.equal(context.state.read().board?.helpers[0]?.status, "error");
   assert.equal(context.state.read().board?.phase, "working");
-  await complete(context, "quiz", "Eine Quizidee.");
+  await complete(context, "quiz", "A quiz idea.");
   assert.equal(context.state.read().board?.phase, "error");
   assert.equal(context.state.read().board?.helpers[1]?.status, "complete");
 });
 
-test("ohne Standardprofil wird kein Helfer angelegt", async () => {
+test("without a standard profile no helper is created", async () => {
   const { context, calls } = setup({ missingProfile: true });
-  await assert.rejects(async () => program.onInput(setupInput, context), /Rolle standard fehlt/);
+  await assert.rejects(async () => program.onInput(setupInput, context), /role standard is missing/);
   assert.deepEqual(calls.map((call) => call.name), ["model_list"]);
   assert.deepEqual(context.state.read(), {});
 });
 
-test("der gemeinsame Ablauf liefert Helferaufträge, Prompt und parallele Graphzweige", async () => {
+test("the shared flow provides helper tasks, prompt, and parallel graph branches", async () => {
   const { learningWorkflow, helperSteps } = await import("../src/workflow.ts");
   const { learningWorkflowState, initialState } = await import("../src/state.ts");
   const { workflowGraph } = await import("@ragents/workflow");
@@ -200,15 +200,15 @@ test("der gemeinsame Ablauf liefert Helferaufträge, Prompt und parallele Graphz
   assert.equal(spawns.length, helperSteps.length);
   for (const spawn of spawns) {
     const prompt = (spawn.input as { prompt: string }).prompt;
-    assert.match(prompt, /Bearbeite ausschließlich diese Aufgabe/);
-    assert.match(prompt, /Beispielfrage/);
-    assert.match(prompt, /gefährliche Stoffe/);
+    assert.match(prompt, /Work only on this task/);
+    assert.match(prompt, /sample question/);
+    assert.match(prompt, /dangerous substances/);
   }
   assert.deepEqual(calls.filter((call) => call.name === "actor_input").map((call) => (call.input as { content: string }).content), helperSteps.map((step) => step.goal));
   const initial = workflowGraph(learningWorkflow, learningWorkflowState(initialState));
   assert.ok(initial.nodes.every((node) => node.status === "pending"));
   assert.deepEqual(initial.edges.map((edge) => [edge.source, edge.target]), [["experiment", "collect"], ["quiz", "collect"]]);
-  await complete(context, "quiz", "Eine Quizidee.");
+  await complete(context, "quiz", "A quiz idea.");
   const partial = workflowGraph(learningWorkflow, learningWorkflowState(context.state.read().board!));
   assert.deepEqual(partial.nodes.map((node) => [node.id, node.status]), [["experiment", "active"], ["quiz", "done"], ["collect", "active"]]);
   await program.onInput(eventOf("experiment", "actor.stopped", {}), context);

package/bundles/ragents.reference/run-scripts/moderated-round/RUN.md

@@ -1,12 +1,12 @@
 ---
-title: Moderierte Runde ohne Koordinator
-description: "Ein vorbereiteter Aufbau zeigt einen Run, der von Anfang an ohne Koordinator arbeitet. Der Moderator wird Primary-Actor und direkter Ansprechpartner im Chat."
+title: Moderated round without coordinator
+description: "A prepared setup shows a run that works without a coordinator from the start. The moderator becomes the primary actor and your direct contact in the chat."
 order: 130
 coordinator: false
-tags: Run-Scripts, Anwendungsfall, Konzeptdemo, Primary-Actor, Agententeams
+tags: Run scripts, Use case, Concept demo, Primary actor, Agent teams
 ---
 
-Referenzfall für `coordinator: false`: der Host spawnt keinen Koordinator, das Script wählt mit
-`run_configure` den Moderator als Primary-Actor und setzt den Run-Titel. Der Chat bindet sich, sobald
-der Primary-Actor feststeht. Der Moderator behält seinen eigenen Actor-Prompt auch als Primary-Actor; den konkreten Auftrag
-erhält er über den ersten ActorInput. Ein Startwert `{ "topic": "..." }` setzt das Thema.
+Reference case for `coordinator: false`: the host spawns no coordinator, the script uses
+`run_configure` to choose the moderator as primary actor and sets the run title. The chat binds as soon as
+the primary actor is determined. The moderator keeps its own actor prompt even as primary actor; it receives the concrete task
+through the first ActorInput. A start value `{ "topic": "..." }` sets the topic.

package/bundles/ragents.reference/run-scripts/moderated-round/package.json

@@ -3,7 +3,7 @@
   "private": true,
   "type": "module",
   "ragents": {
-    "title": "Moderierte Runde ohne Koordinator",
+    "title": "Moderated round without coordinator",
     "backend": "src/server.ts"
   }
 }

package/bundles/ragents.reference/run-scripts/moderated-round/src/server.ts

@@ -10,7 +10,7 @@ const contract = {
 type Start = { input: { topic?: string } | null };
 
 const guestOf = (name: string): string =>
-  name === "kai" ? "Du bist Kai, pragmatisch und knapp." : "Du bist Lena, gründlich und abwägend.";
+  name === "kai" ? "You are Kai, pragmatic and brief." : "You are Lena, thorough and deliberate.";
 
 export default defineActor(contract, {
   functions: {},
@@ -18,17 +18,17 @@ export default defineActor(contract, {
     const state = context.state.read();
     if (state && state.built) return;
     const start = JSON.parse(input.content) as Start;
-    const topic = start.input && start.input.topic ? start.input.topic : "Was macht ein gutes Team aus?";
+    const topic = start.input && start.input.topic ? start.input.topic : "What makes a good team?";
 
     const catalog = await context.functions.model_list({});
     const profiles = catalog.profiles.filter((profile) => profile.driver === "agent" && profile.name !== "coordinator");
     const first = profiles[0];
-    if (!first) throw new Error("Keine Rolle außer coordinator; agent_spawn braucht eine.");
+    if (!first) throw new Error("No role other than coordinator; agent_spawn needs one.");
 
     const moderator = await context.functions.agent_spawn({
       handle: "moderator",
       displayName: "Moderator",
-      prompt: "Du moderierst eine Gesprächsrunde zwischen dem Benutzer und zwei Gästen.",
+      prompt: "You moderate a conversation circle between the user and two guests.",
       profile: first.name,
       tools: ["actor_input", "event_subscribe", "event_unsubscribe", "event_subscription_list"],
     });
@@ -36,7 +36,7 @@ export default defineActor(contract, {
     for (const name of ["kai", "lena"]) {
       const guest = await context.functions.agent_spawn({
         handle: name,
-        prompt: `${guestOf(name)} Antworte mit höchstens zwei Sätzen.`,
+        prompt: `${guestOf(name)} Reply with at most two sentences.`,
         profile: first.name,
         tools: [],
       });
@@ -44,15 +44,15 @@ export default defineActor(contract, {
     }
 
     await context.functions.run_configure({
-      title: `Moderierte Runde: ${topic}`,
+      title: `Moderated round: ${topic}`,
       primaryActor: `@${moderator.handle}`,
     });
 
     await context.functions.actor_input({
       actor: `@${moderator.handle}`,
-      content: "Du bist der Moderator dieses Runs und sprichst direkt mit dem Benutzer im Chat; einen Koordinator gibt es nicht. "
-        + `Deine Gäste sind ${guests.join(" und ")}. Hole ihre Beiträge ein und beziehe sie in die Gesprächsrunde ein. `
-        + `Thema: "${topic}". Begrüße den Benutzer mit zwei Sätzen, nenne das Thema und frage, ob er die erste Frage stellt oder du beginnen sollst.`,
+      content: "You are the moderator of this run and talk directly with the user in the chat; there is no coordinator. "
+        + `Your guests are ${guests.join(" and ")}. Gather their contributions and include them in the conversation circle. `
+        + `Topic: "${topic}". Greet the user with two sentences, name the topic, and ask whether they want to ask the first question or whether you should begin.`,
     });
 
     context.state.replace({ built: true });

package/bundles/ragents.reference/run-scripts/moderated-round/tests/helpers.ts

@@ -13,7 +13,7 @@ export const setupContext = (profiles = [{ name: "coordinator", driver: "agent"
       return { name: value.name, actor: value.actor, views: 1, active: true };
     }
     return name === "model_list" ? {
-      profiles: profiles.map((profile) => ({ ...profile, description: "Testprofil", turnTimeoutMs: null,
+      profiles: profiles.map((profile) => ({ ...profile, description: "Test profile", turnTimeoutMs: null,
         isolateWorkspace: false, provider: "test", model: "test" })), models: [],
     } : name === "actor_input" ? [] : null;
   }]));

package/bundles/ragents.reference/run-scripts/moderated-round/tests/program.test.ts

@@ -3,22 +3,22 @@ import test from "node:test";
 import program from "../src/server.ts";
 import { setupContext, startInput } from "./helpers.ts";
 
-test("stellt Moderator und Gäste auf und übergibt ihm den Chat", async () => {
+test("sets up the moderator and guests and hands the chat to the moderator", async () => {
   const { calls, context } = setupContext();
-  await program.onInput!(startInput({ topic: "Gute Zusammenarbeit" }), context);
+  await program.onInput!(startInput({ topic: "Good collaboration" }), context);
   assert.deepEqual(calls.filter((call) => call.name === "agent_spawn").map((call) => (call.input as { handle: string }).handle), ["moderator", "kai", "lena"]);
   assert.deepEqual(calls.filter((call) => call.name === "agent_spawn").map((call) => (call.input as { tools: string[] }).tools), [["actor_input", "event_subscribe", "event_unsubscribe", "event_subscription_list"], [], []]);
-  assert.deepEqual(calls.find((call) => call.name === "run_configure")?.input, { title: "Moderierte Runde: Gute Zusammenarbeit", primaryActor: "@moderator" });
-  assert.match(JSON.stringify(calls.at(-1)), /Gute Zusammenarbeit/);
+  assert.deepEqual(calls.find((call) => call.name === "run_configure")?.input, { title: "Moderated round: Good collaboration", primaryActor: "@moderator" });
+  assert.match(JSON.stringify(calls.at(-1)), /Good collaboration/);
   assert.deepEqual(context.state.read(), { built: true });
   const completedCalls = calls.length;
   await program.onInput!(startInput(null), context);
   assert.equal(calls.length, completedCalls);
 });
 
-test("ohne eine nutzbare Rolle bleibt der Aufbau unverändert", async () => {
+test("without a usable role the setup stays unchanged", async () => {
   const { calls, context } = setupContext([{ name: "coordinator", driver: "agent" }]);
-  await assert.rejects(async () => program.onInput!(startInput(null), context), /Keine Rolle/);
+  await assert.rejects(async () => program.onInput!(startInput(null), context), /No role/);
   assert.deepEqual(calls.map((call) => call.name), ["model_list"]);
   assert.deepEqual(context.state.read(), {});
 });

package/bundles/ragents.reference/run-scripts/shared-actor-list/RUN.md

@@ -1,18 +1,18 @@
 ---
-title: Sammelboard einrichten
-description: "Ein vorbereitetes Setup zeigt einen LLM-Listenhelfer mit eigener Funktion, Mini-App und gemeinsamem Zustand. Ein Startleitfaden legt Titel und ersten Eintrag fest."
+title: Set up collection board
+description: "A prepared setup shows an LLM list helper with its own function, mini-app, and shared state. A start guide sets the title and the first entry."
 order: 100
 guide: ragents.reference.shared-actor-list
-tags: Run-Scripts, Anwendungsfall, Konzeptdemo, Startleitfaden, Actor-Funktionen, Actor-Zustand, Mini-Apps, LLM-Actor mit View
+tags: Run scripts, Use case, Concept demo, Start guide, Actor functions, Actor state, Mini-apps, LLM actor with view
 ---
 
-Das Setup legt einen echten LLM-Listenhelfer an und bindet das mitgelieferte Programm
-`actors/shared-list/` an ihn. Seine Funktion `append_to_list` und die React-View teilen den
-intrinsischen Zustand dieses Actors. `actor_program_activate` prüft und aktiviert das bereits
-vom Host kopierte Paket. Ein eigener App-Actor oder eine zweite Listenimplementierung entsteht nicht.
+The setup creates a real LLM list helper and binds the bundled program
+`actors/shared-list/` to it. Its function `append_to_list` and the React view share the
+intrinsic state of this actor. `actor_program_activate` checks and activates the package
+the host has already copied. No separate app actor or second list implementation is created.
 
-Der Leitfaden übergibt `{ "title": "...", "firstEntry": "..." }`. Der Titel hat 1 bis 160 Zeichen,
-der erste Eintrag 1 bis 2000 Zeichen. `null` startet mit "Gemeinsame Liste" und
-"Hallo aus dem Run-Script". Ungültige Werte werden vor dem Aufbau abgelehnt. Nach dem Aufbau
-bekommt der Listenhelfer den ausdrücklichen Auftrag, den ersten Eintrag über seine Funktion
-anzulegen. Die Pakettests prüfen Konfiguration, Zustand und die tatsächliche Aufrufreihenfolge.
+The guide passes `{ "title": "...", "firstEntry": "..." }`. The title has 1 to 160 characters,
+the first entry 1 to 2000 characters. `null` starts with "Shared list" and
+"Hello from the run script". Invalid values are rejected before the setup. After the setup,
+the list helper receives the explicit task to create the first entry through its function.
+The package tests check configuration, state, and the actual call order.

package/bundles/ragents.reference/run-scripts/shared-actor-list/actors/shared-list/package.json

@@ -3,8 +3,8 @@
   "private": true,
   "type": "module",
   "ragents": {
-    "title": "Gemeinsame Liste",
-    "description": "Sammelt Texte aus der App und aus einem Agenten-Werkzeug in einer gemeinsamen Liste.",
+    "title": "Shared list",
+    "description": "Collects texts from the app and from an agent tool in a shared list.",
     "backend": "src/server.ts",
     "views": [
       {

package/bundles/ragents.reference/run-scripts/shared-actor-list/actors/shared-list/src/contract.ts

@@ -4,9 +4,9 @@ export const contract = {
   state: Type.Object({ entries: Type.Optional(Type.Array(Type.String())) }, {"additionalProperties": false}),
   functions: {
     append: {
-      label: "Eintrag hinzufügen",
-      description: "Hängt den eingegebenen Text an die gemeinsame Liste an.",
-      input: Type.Object({ text: Type.String({"description": "Der Text für den neuen Listeneintrag."}) }, {"additionalProperties": false}),
+      label: "Add entry",
+      description: "Appends the entered text to the shared list.",
+      input: Type.Object({ text: Type.String({"description": "The text for the new list entry."}) }, {"additionalProperties": false}),
       output: Type.Object({ text: Type.String(), entries: Type.Array(Type.String()) }, {"additionalProperties": false}),
       capabilities: [],
       tool: {"name": "append_to_list", "targets": ["self"], "card": true},

package/bundles/ragents.reference/run-scripts/shared-actor-list/actors/shared-list/tests/program.test.ts

@@ -5,9 +5,9 @@ import { createTestContext } from "@ragents/server/testing";
 import { contract } from "../src/contract.ts";
 import program from "../src/server.ts";
 
-test("ergänzt Einträge ohne vorhandene Einträge zu verlieren", async () => {
+test("adds entries without losing existing entries", async () => {
   const context = createTestContext<Static<typeof contract.state>>({ state: {} });
-  assert.deepEqual(await program.functions.append({"text": "  Erster Eintrag  "}, context), {"text": "Erster Eintrag", "entries": ["Erster Eintrag"]});
-  assert.deepEqual(await program.functions.append({"text": "Zweiter Eintrag"}, context), {"text": "Zweiter Eintrag", "entries": ["Erster Eintrag", "Zweiter Eintrag"]});
-  assert.deepEqual(context.state.read(), {"entries": ["Erster Eintrag", "Zweiter Eintrag"]});
+  assert.deepEqual(await program.functions.append({"text": "  First entry  "}, context), {"text": "First entry", "entries": ["First entry"]});
+  assert.deepEqual(await program.functions.append({"text": "Second entry"}, context), {"text": "Second entry", "entries": ["First entry", "Second entry"]});
+  assert.deepEqual(context.state.read(), {"entries": ["First entry", "Second entry"]});
 });

package/bundles/ragents.reference/run-scripts/shared-actor-list/package.json

@@ -3,7 +3,7 @@
   "private": true,
   "type": "module",
   "ragents": {
-    "title": "Sammelboard einrichten",
+    "title": "Set up collection board",
     "backend": "src/server.ts"
   }
 }

package/bundles/ragents.reference/run-scripts/shared-actor-list/src/server.ts

@@ -10,15 +10,15 @@ const contract = {
 type Start = { input: unknown };
 
 const settingsFrom = (value: unknown): { title: string; firstEntry: string } => {
-  if (value === null) return { title: "Gemeinsame Liste", firstEntry: "Hallo aus dem Run-Script" };
+  if (value === null) return { title: "Shared list", firstEntry: "Hello from the run script" };
   if (typeof value !== "object" || Array.isArray(value)) {
-    throw new Error("Startwert braucht title (1 bis 160 Zeichen) und firstEntry (1 bis 2000 Zeichen).");
+    throw new Error("The start value needs title (1 to 160 characters) and firstEntry (1 to 2000 characters).");
   }
   const settings = value as Record<string, unknown>;
   if (Object.keys(settings).some((key) => key !== "title" && key !== "firstEntry")
     || typeof settings.title !== "string" || !settings.title.trim() || settings.title.trim().length > 160
     || typeof settings.firstEntry !== "string" || !settings.firstEntry.trim() || settings.firstEntry.trim().length > 2000) {
-    throw new Error("Startwert braucht title (1 bis 160 Zeichen) und firstEntry (1 bis 2000 Zeichen).");
+    throw new Error("The start value needs title (1 to 160 characters) and firstEntry (1 to 2000 characters).");
   }
   return { title: settings.title.trim(), firstEntry: settings.firstEntry.trim() };
 };
@@ -36,13 +36,13 @@ export default defineActor(contract, {
     const catalog = await context.functions.model_list({});
     const profiles = catalog.profiles.filter((profile) => profile.driver === "agent" && profile.name !== "coordinator");
     const first = profiles[0];
-    if (!first) throw new Error("Keine Rolle außer coordinator; agent_spawn braucht eine.");
+    if (!first) throw new Error("No role other than coordinator; agent_spawn needs one.");
 
-    await context.functions.run_configure({ title: `Sammelboard: ${title}` });
+    await context.functions.run_configure({ title: `Collection board: ${title}` });
 
     const helper = await context.functions.agent_spawn({
-      handle: "listenhelfer",
-      prompt: `Du führst die gemeinsame Sammlung "${title}". Jeden Eintrag, den man dir gibt, hängst du mit deiner Funktion append_to_list an und meldest den neuen Stand.`,
+      handle: "list-helper",
+      prompt: `You keep the shared collection "${title}". You append every entry you are given with your function append_to_list and report the new state.`,
       profile: first.name,
       tools: null,
     });
@@ -51,13 +51,13 @@ export default defineActor(contract, {
 
     await context.functions.actor_input({
       actor: `@${helper.handle}`,
-      content: `Trage mit deiner Funktion append_to_list den Eintrag ${JSON.stringify(firstEntry)} in die gemeinsame Sammlung ${JSON.stringify(title)} ein und melde den Stand der Liste.`,
+      content: `Use your function append_to_list to add the entry ${JSON.stringify(firstEntry)} to the shared collection ${JSON.stringify(title)} and report the state of the list.`,
     });
     await context.functions.actor_input({
       actor: "@coordinator",
-      content: `Die gemeinsame Sammlung heißt ${JSON.stringify(title)}. Das Run-Script hat das Programm shared-list an @${helper.handle} gebunden. Seine View ist auf der Fläche sichtbar; der Helfer ergänzt gerade den ersten Eintrag mit append_to_list. `
-        + "Unten unter Actors öffnet sein Name den Inspector mit Chat und Details. Seine Kachel ist standardmäßig ausgeblendet und lässt sich in der Actors-Liste bei Bedarf einschalten. "
-        + "Erkläre dem Benutzer in drei Sätzen, wie er die sichtbare Liste bedient, den Helfer öffnet und dass View und Funktion denselben Listenstand teilen.",
+      content: `The shared collection is called ${JSON.stringify(title)}. The run script has bound the program shared-list to @${helper.handle}. Its view is visible on the surface; the helper is currently adding the first entry with append_to_list. `
+        + "Below under Actors, its name opens the inspector with chat and details. Its tile is hidden by default and can be turned on in the Actors list when needed. "
+        + "Explain to the user in three sentences how to use the visible list, how to open the helper, and that the view and the function share the same list state.",
     });
 
     context.state.replace({ built: true });

package/bundles/ragents.reference/run-scripts/shared-actor-list/tests/helpers.ts

@@ -13,7 +13,7 @@ export const setupContext = (profiles = [{ name: "coordinator", driver: "agent"
       return { name: value.name, actor: value.actor, views: 1, active: true };
     }
     return name === "model_list" ? {
-      profiles: profiles.map((profile) => ({ ...profile, description: "Testprofil", turnTimeoutMs: null,
+      profiles: profiles.map((profile) => ({ ...profile, description: "Test profile", turnTimeoutMs: null,
         isolateWorkspace: false, provider: "test", model: "test" })), models: [],
     } : name === "actor_input" ? [] : null;
   }]));