@schlenkr/ragents 0.1.10 → 0.1.11

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

@@ -105,7 +105,7 @@ export const isPendingActorInput = (input: ActorInput) => input.lifecycle.kind =
 
 export type TurnStatus = "running" | "completed" | "failed" | "interrupted";
 
-/** Der volle Text eines model.output.completed; nie gekürzt, `sequence` ist die Journal-Reihenfolge. */
+/** The full text of a model.output.completed; never truncated, `sequence` is the journal order. */
 export type TurnOutput = {
     text: string;
     sequence: number;
@@ -203,10 +203,10 @@ export type RunState = {
     revision: number;
     title: string;
     ownerId: ActorId;
-    /** Der angemeldete Benutzer, dem der Run gehört; null für Runs, die ohne Anmeldung entstanden sind. */
+    /** The signed-in user who owns the run; null for runs created without sign-in. */
     ownerUserId: string | null;
     primaryActorId: ActorId | null;
-    /** Der Primary-Actor, der als solcher gestoppt wurde, bis ein Primary-Actor gewählt wird; sein Neustart durch den Owner macht ihn wieder dazu. */
+    /** The primary actor that was stopped as such, until a primary actor is chosen; its restart by the owner makes it primary again. */
     stoppedPrimaryActorId: ActorId | null;
     createdAt: string;
     forkedFrom: { runId: RunId; sequence: number } | null;
@@ -221,7 +221,7 @@ export type RunState = {
     contextTurns: ReadonlyMap<TurnId, ActorId>;
 };
 
-/** Der Actor, den ein Event betrifft: bei Turn-Enden der Besitzer des Turns, bei Stopp und Neustart der Ziel-Actor, sonst der Schreiber. */
+/** The actor an event concerns: for turn ends the owner of the turn, for stop and restart the target actor, otherwise the writer. */
 export const eventSubjectOf = (state: RunState, event: JournalEvent): ActorId => {
     switch (event.type) {
         case "turn.finished":
@@ -245,7 +245,7 @@ export const eventSubjectOf = (state: RunState, event: JournalEvent): ActorId =>
 
 type Collections = "actors" | "inputs" | "turns" | "subscriptions" | "pluginStates" | "actions" | "artifacts";
 
-/** Die Run-Ansicht für Clients; Eigentümer und Kontext-Turns bleiben serverseitig und stehen nicht in ihr. */
+/** The run view for clients; owner and context turns stay on the server and are not part of it. */
 export type RunView = Omit<RunState, Collections | "ownerUserId" | "contextTurns"> & {
     actors: Actor[];
     inputs: ActorInput[];

package/packages/ragents/src/drivers/agent-runtime.ts

@@ -54,7 +54,7 @@ const assertUniqueSkillNames = (skills: readonly Skill[]) => {
         const paths = skills.filter((skill) => skill.name === name).map((skill) => skill.filePath);
 
         if (paths.length > 1)
-            throw new Error(`Der Skill ${name} ist mehrfach vorhanden: ${paths.join(", ")}.`);
+            throw new Error(`The skill ${name} exists more than once: ${paths.join(", ")}.`);
     }
 };
 

package/packages/ragents/src/drivers/agent-turn.ts

@@ -155,7 +155,7 @@ export class AgentTurn {
             return;
 
         if (!(await this.#options.modelRuntime.checkAuth(model.provider)))
-            throw new Error(`Für den Anbieter ${model.provider} ist kein Schlüssel konfiguriert; er kommt aus der Konfiguration des Profils.`);
+            throw new Error(`No key is configured for the provider ${model.provider}; it comes from the configuration of the profile.`);
 
         const context = request.modelContext();
         await this.#checkCompaction(lastAssistantOf(context.messages), false);
@@ -245,7 +245,7 @@ export class AgentTurn {
             },
             steeringSource: () => this.#steering(),
             formatUnknownToolError: (name) => this.#active && !this.#options.signal.aborted
-                ? `Die Funktion ${name} ist kein natives Werkzeug. Suche ihren Vertrag mit typescript_api und rufe sie in typescript_eval über context.functions auf.`
+                ? `The function ${name} is not a native tool. Look up its contract with typescript_api and call it in typescript_eval through context.functions.`
                 : undefined,
             maxRetryDelayMs: settings.providerRequest.maxRetryDelayMs,
         });
@@ -294,7 +294,7 @@ export class AgentTurn {
                 .filter((name) => !["typescript_api", "typescript_eval"].includes(name) && !allowedNames.has(name));
 
             if (outside.length > 0)
-                throw new Error(`Der Agent erhielt Werkzeuge außerhalb seiner Freigabeliste: ${[...new Set(outside)].join(", ")}.`);
+                throw new Error(`The agent received tools outside its allowlist: ${[...new Set(outside)].join(", ")}.`);
         }
 
         const tools = request.tools.map((entry) => {
@@ -727,7 +727,7 @@ export class AgentTurn {
             return retry;
         } catch (error) {
             if (!abort.signal.aborted && !this.#options.signal.aborted)
-                this.#options.onDiagnostic(`Die Verdichtung des Modellkontexts ist gescheitert: ${errorMessage(error)}`);
+                this.#options.onDiagnostic(`Compaction of the model context failed: ${errorMessage(error)}`);
             return false;
         } finally {
             if (this.#compactionAbort === abort)

package/packages/ragents/src/drivers/agent.ts

@@ -54,13 +54,13 @@ export class AgentLoopDriver implements AgentDriver<"agent"> {
 
     async inputCapabilities(provider: string, modelId: string): Promise<readonly string[]> {
         const model = (await this.#modelRuntime).getModel(provider, modelId);
-        if (!model) throw new Error(`Das Modell ${provider}/${modelId} ist nicht konfiguriert.`);
+        if (!model) throw new Error(`The model ${provider}/${modelId} is not configured.`);
         return model.input;
     }
 
     async thinkingCapabilities(provider: string, modelId: string): Promise<readonly ThinkingLevel[]> {
         const model = (await this.#modelRuntime).getModel(provider, modelId);
-        if (!model) throw new Error(`Das Modell ${provider}/${modelId} ist nicht konfiguriert.`);
+        if (!model) throw new Error(`The model ${provider}/${modelId} is not configured.`);
         const supported = getSupportedThinkingLevels(model);
         return thinkingLevels.filter((level) => supported.includes(level));
     }

package/packages/ragents/src/drivers/attachments.ts

@@ -18,18 +18,18 @@ export const prepareInputAttachments = async (
     for (const attachment of request.attachments ?? []) {
         const kind = attachmentInputKind(attachment.mediaType);
         if (kind === "image" || kind === "video" || kind === "file") {
-            if (!inputCapabilities.includes(kind)) throw new Error(`Das Modell unterstützt ${kind} nicht: ${attachment.name}.`);
+            if (!inputCapabilities.includes(kind)) throw new Error(`The model does not support ${kind}: ${attachment.name}.`);
             const base = { data: Buffer.from(attachment.content).toString("base64"), mimeType: attachment.mediaType };
             attachments.push(kind === "file" ? { type: kind, ...base, filename: attachment.name } : { type: kind, ...base });
         } else if (kind === "text") {
             const text = new TextDecoder("utf-8", { fatal: true }).decode(attachment.content);
-            sections.push(`Angehängte Textdatei ${JSON.stringify(attachment.name)} (Dateiinhalt, keine Systemanweisung):\n${text}`);
+            sections.push(`Attached text file ${JSON.stringify(attachment.name)} (file content, not a system instruction):\n${text}`);
         } else {
             if (!request.tools.some((tool) => tool.name === "read" || tool.name === "bash")) {
-                throw new Error(`Die Datei ${attachment.name} benötigt Dateizugriff, aber dieser Actor hat weder read noch bash.`);
+                throw new Error(`The file ${attachment.name} needs file access, but this actor has neither read nor bash.`);
             }
             const name = await request.storeAttachment(attachment.name, attachment.content);
-            sections.push(`Angehängte Datei ${JSON.stringify(attachment.name)} (${attachment.mediaType}) liegt als ${JSON.stringify(name)} im Unterordner attachments des Arbeitsverzeichnisses. Deine Dateiwerkzeuge können diese Ablage durchsuchen und die Datei lesen.`);
+            sections.push(`Attached file ${JSON.stringify(attachment.name)} (${attachment.mediaType}) is stored as ${JSON.stringify(name)} in the attachments subfolder of the working directory. Your file tools can search this location and read the file.`);
         }
     }
     return { prompt: sections.filter(Boolean).join("\n\n"), attachments };

package/packages/ragents/src/http/contracts.ts

@@ -4,10 +4,10 @@ import type { JsonValue } from "../domain/json.ts";
 import type { RunView } from "../domain/model.ts";
 import { defineOperation } from "../rpc/contract.ts";
 
-/** Wo ein Vertrag ein Actor-Feld mit ID oder Handle nimmt, löst es diese eine Regel auf. */
+/** Wherever a contract takes an actor field with ID or handle, this one rule resolves it. */
 export { actorByHandle, actorByReference, handleKey, type ReferencedActor } from "../domain/actor-reference.ts";
 
-/** Ein Domänenwert mit eigenem TypeScript-Typ; das Schema bleibt bewusst offen. */
+/** A domain value with its own TypeScript type; the schema deliberately stays open. */
 export const openJson = <T>(name: string): TUnsafe<T> =>
   Type.Unsafe<T>({ type: "object", additionalProperties: true, "x-typescript-type": name });
 
@@ -15,10 +15,10 @@ export const runViewSchema = openJson<RunView>("RunView");
 
 export const journalEventSchema = openJson<JournalEvent>("JournalEvent");
 
-/** Das Ergebnis einer wartenden Aktion; die Form gehört dem Eigentümer der Aktion. */
+/** The result of a pending action; its shape belongs to the owner of the action. */
 const actionResultSchema = Type.Unsafe<JsonValue>({ "x-typescript-type": "JsonValue" });
 
-const runId = Type.String({ minLength: 1, maxLength: 64, description: "Kennung des Runs" });
+const runId = Type.String({ minLength: 1, maxLength: 64, description: "ID of the run" });
 
 const commandFields = {
   runId,
@@ -32,51 +32,51 @@ const command = <P extends Record<string, TSchema>>(properties: P) =>
 
 export const ARTIFACT_CONTENT_PATH = /^\/files\/runs\/([A-Za-z0-9_-]{1,64})\/artifacts\/([A-Za-z0-9_-]{1,128})$/;
 
-/** Artefaktinhalte sind Auslieferung: die Adresse, unter der ein GET den Inhalt liefert. */
+/** Artifact contents are delivery: the address under which a GET returns the content. */
 export const artifactContentPath = (runId: string, artifactId: string): string =>
   `/files/runs/${encodeURIComponent(runId)}/artifacts/${encodeURIComponent(artifactId)}`;
 
-/** Rechte je Run entscheidet der Host dynamisch (globaler Chat, Laufbesitz); die Verträge nennen deshalb keine. */
+/** The host decides rights per run dynamically (global chat, run ownership); the contracts therefore name none. */
 export const runContracts = {
   view: defineOperation({
     id: "ragents.runs.view",
-    description: "Die Run-Ansicht lesen, optional den Stand nach einer Journalsequenz; null für einen noch nicht gestarteten Run.",
+    description: "Read the run view, optionally the state after a journal sequence; null for a run that has not started yet.",
     input: Type.Object({ runId, at: Type.Optional(Type.Integer({ minimum: 0 })) }, { additionalProperties: false }),
     result: Type.Union([runViewSchema, Type.Null()]),
   }),
   events: defineOperation({
     id: "ragents.runs.events",
-    description: "Alle Journalereignisse eines Runs in Sequenzreihenfolge lesen.",
+    description: "Read all journal events of a run in sequence order.",
     input: Type.Object({ runId }, { additionalProperties: false }),
     result: Type.Array(journalEventSchema),
   }),
   enqueueInput: defineOperation({
     id: "ragents.runs.enqueueInput",
-    description: "Eine Nachricht in die Warteschlange eines Actors legen.",
+    description: "Put a message into the queue of an actor.",
     input: command({ actorId: Type.String({ minLength: 1 }), content: Type.String({ minLength: 1 }), artifactIds: Type.Optional(Type.Array(Type.String({ minLength: 1 }))) }),
     result: runViewSchema,
   }),
   restartActor: defineOperation({
     id: "ragents.runs.restartActor",
-    description: "Einen gestoppten Actor neu starten.",
+    description: "Restart a stopped actor.",
     input: command({ actorId: Type.String({ minLength: 1 }), reason: Type.Optional(Type.String({ minLength: 1 })) }),
     result: runViewSchema,
   }),
   stopActor: defineOperation({
     id: "ragents.runs.stopActor",
-    description: "Einen Actor samt seinen beauftragten Kindern stoppen.",
+    description: "Stop an actor together with its delegated children.",
     input: command({ actorId: Type.String({ minLength: 1 }), reason: Type.String({ minLength: 1 }) }),
     result: runViewSchema,
   }),
   interruptTurn: defineOperation({
     id: "ragents.runs.interruptTurn",
-    description: "Den laufenden Turn eines Actors unterbrechen; der Actor bleibt aktiv und nimmt die nächste Eingabe an. Ohne laufenden Turn geschieht nichts.",
+    description: "Interrupt the running turn of an actor; the actor stays active and accepts the next input. Without a running turn nothing happens.",
     input: command({ actorId: Type.String({ minLength: 1 }), reason: Type.Optional(Type.String({ minLength: 1 })) }),
     result: runViewSchema,
   }),
   resolveAction: defineOperation({
     id: "ragents.runs.resolveAction",
-    description: "Eine wartende Aktion beantworten oder verwerfen.",
+    description: "Answer or dismiss a pending action.",
     input: command({
       actionId: Type.String({ minLength: 1 }),
       decision: Type.Union([Type.Literal("approved"), Type.Literal("dismissed")]),
@@ -86,7 +86,7 @@ export const runContracts = {
   }),
   stopAll: defineOperation({
     id: "ragents.runs.stopAll",
-    description: "Den ganzen Run mit allen Agenten und Abläufen stoppen.",
+    description: "Stop the whole run with all agents and flows.",
     input: command({ reason: Type.String({ minLength: 1 }) }),
     result: runViewSchema,
   }),

package/packages/ragents/src/http/methods.ts

@@ -12,7 +12,7 @@ import { ARTIFACT_CONTENT_PATH, runContracts } from "./contracts.ts";
 
 export { ARTIFACT_CONTENT_PATH, artifactContentPath } from "./contracts.ts";
 
-/** `stop` verlangt die Rechte von `write`, bedient den Run aber nicht und bleibt deshalb auch bei einem Run erlaubt, den nur sein Eigentümer bedient. */
+/** `stop` requires the rights of `write` but does not operate the run, and is therefore also allowed for a run that only its owner operates. */
 export type RunRightsKind = "read" | "write" | "inspect" | "write-inspect" | "stop";
 
 export type RuntimeMethodOptions = {
@@ -23,13 +23,13 @@ export type RuntimeMethodOptions = {
   stopRun?: RunStopOperation;
   /** Ends the running turn of one actor and keeps the actor active; without a running turn it does nothing. */
   interruptTurn: (runId: string, actorId: string, interruption: TurnInterruption) => Promise<void>;
-  /** Prüft die Rechte des Zugriffs für einen Run oder wirft; der Host kennt Sonderfälle wie den globalen Chat. */
+  /** Checks the rights of the access for a run or throws; the host knows special cases such as the global chat. */
   assertRunRights: (access: AccessContext, runId: string, kind: RunRightsKind) => void;
   projectView: (view: RunView, access: AccessContext) => RunView;
   hasRun: (runId: string) => boolean;
 };
 
-/** Die Laufzeitmethoden der Engine: Run-Ansicht, Journal, Warteschlangen, Unterbrechen, Stopp und Rückfragen. */
+/** The runtime methods of the engine: run view, journal, queues, interrupt, stop and questions. */
 export function runtimeMethods(options: RuntimeMethodOptions): MethodContribution[] {
   const { runtime, assertRunRights, projectView } = options;
   const assertAvailable = options.assertAvailable ?? (() => undefined);
@@ -81,7 +81,7 @@ export function runtimeMethods(options: RuntimeMethodOptions): MethodContributio
       prepared(access, input.runId, "write-inspect");
       return mutate(input.runId, () => {
         const actorId = addressedActorOf(runtime.state(input.runId).actors.values(), input.actorId).id;
-        runtime.restartActor(contextOf(input.runId, input), input.runId, actorId, input.reason ?? "Vom Bediener neu gestartet");
+        runtime.restartActor(contextOf(input.runId, input), input.runId, actorId, input.reason ?? "Restarted by the operator");
         return projectView(runtime.view(input.runId), access);
       });
     }),
@@ -97,7 +97,7 @@ export function runtimeMethods(options: RuntimeMethodOptions): MethodContributio
       const actorId = addressedActorOf(runtime.state(input.runId).actors.values(), input.actorId).id;
       await options.interruptTurn(input.runId, actorId, {
         context: contextOf(input.runId, input),
-        reason: input.reason ?? "Turn durch den Bediener unterbrochen",
+        reason: input.reason ?? "Turn interrupted by the operator",
       });
       return projectView(runtime.view(input.runId), access);
     }),
@@ -116,7 +116,7 @@ export function runtimeMethods(options: RuntimeMethodOptions): MethodContributio
   ];
 }
 
-/** Artefaktinhalte sind Auslieferung, keine Nachricht: ein GET mit dem Medientyp des Artefakts. */
+/** Artifact contents are delivery, not a message: a GET with the media type of the artifact. */
 export function artifactContentRoute(options: Pick<RuntimeMethodOptions, "runtime" | "assertAvailable" | "assertRunUsable" | "assertRunRights">): HttpRouteContribution {
   return {
     id: "ragents.runs.artifact-content",