@schlenkr/ragents 0.1.5 → 0.1.6

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

@@ -79,6 +79,15 @@ const turn = (state: RunDraft, id: string): Draft<Turn> => {
     return found;
 };
 
+/** A turn end closes the calls still open: they are interrupted, whatever ended the turn. */
+const interruptOpenToolCalls = (current: Draft<Turn>, at: string) => {
+    for (const call of current.toolCalls) {
+        if (call.status !== "running") continue;
+        call.status = "interrupted";
+        call.finishedAt = at;
+    }
+};
+
 const subscriptionBaseOf = (subscription: Draft<EventSubscription>) => ({
     id: subscription.id,
     subscriberId: subscription.subscriberId,
@@ -96,7 +105,9 @@ const created = (event: Extract<JournalEvent, { type: "run.created" }>): RunDraf
     revision: event.sequence,
     title: event.payload.title,
     ownerId: event.payload.owner.id,
+    ownerUserId: event.payload.owner.userId ?? null,
     primaryActorId: null,
+    stoppedPrimaryActorId: null,
     createdAt: event.occurredAt,
     forkedFrom: null,
     actors: new Map([
@@ -104,7 +115,10 @@ const created = (event: Extract<JournalEvent, { type: "run.created" }>): RunDraf
             event.payload.owner.id,
             {
                 kind: "human" as const,
-                ...event.payload.owner,
+                id: event.payload.owner.id,
+                handle: event.payload.owner.handle,
+                displayName: event.payload.owner.displayName,
+                grants: event.payload.owner.grants,
                 createdAt: event.occurredAt,
             },
         ],
@@ -148,6 +162,7 @@ export function applyEvent(
         case "run.primary-actor-selected":
             executable(state, event.payload.actorId);
             state.primaryActorId = event.payload.actorId;
+            state.stoppedPrimaryActorId = null;
             break;
 
         case "run.title-changed":
@@ -161,6 +176,7 @@ export function applyEvent(
                 handle: event.payload.handle,
                 displayName: event.payload.displayName,
                 createdBy: event.actorId,
+                description: event.payload.description ?? null,
                 prompt: event.payload.prompt,
                 forkOf: event.payload.forkOf ?? null,
                 execution: event.payload.execution,
@@ -180,6 +196,7 @@ export function applyEvent(
                 handle: event.payload.handle,
                 displayName: event.payload.displayName,
                 createdBy: event.actorId,
+                description: event.payload.description ?? null,
                 execution: event.payload.execution,
                 grants: event.payload.grants,
                 toolNames: event.payload.toolNames,
@@ -229,7 +246,7 @@ export function applyEvent(
             if (input.lifecycle.kind === "claimed")
                 throw new Error(`Input ${input.id} already belongs to turn ${input.lifecycle.turnId}.`);
 
-            input.lifecycle = { kind: "claimed", turnId: event.payload.turnId };
+            input.lifecycle = { kind: "claimed", turnId: event.payload.turnId, steered: false };
             target.lifecycle = {
                 kind: "running",
                 turnId: event.payload.turnId,
@@ -251,6 +268,17 @@ export function applyEvent(
             break;
         }
 
+        case "turn.input-steered": {
+            const current = turn(state, event.payload.turnId);
+            const input = state.inputs.get(event.payload.inputId);
+
+            if (!input)
+                throw new Error(`Input ${event.payload.inputId} does not exist.`);
+
+            input.lifecycle = { kind: "claimed", turnId: current.id, steered: true };
+            break;
+        }
+
         case "turn.finished": {
             const current = turn(state, event.payload.turnId);
             const target = executable(state, current.actorId);
@@ -260,6 +288,7 @@ export function applyEvent(
             current.status = event.payload.outcome;
             current.finishedAt = event.occurredAt;
             current.reason = event.payload.outcome === "failed" ? event.payload.reason : null;
+            interruptOpenToolCalls(current, event.occurredAt);
 
             if (event.payload.usage && cumulativeUsage) {
                 current.usage = event.payload.usage;
@@ -278,11 +307,7 @@ export function applyEvent(
             current.status = "interrupted";
             current.finishedAt = event.occurredAt;
             current.reason = event.payload.reason;
-            for (const call of current.toolCalls) {
-                if (call.status !== "running") continue;
-                call.status = "interrupted";
-                call.finishedAt = event.occurredAt;
-            }
+            interruptOpenToolCalls(current, event.occurredAt);
 
             if (target.lifecycle.kind === "running" && target.lifecycle.turnId === current.id)
                 target.lifecycle = { kind: "idle", since: event.occurredAt };
@@ -321,6 +346,7 @@ export function applyEvent(
         }
 
         case "model.reasoning.completed":
+        case "model.output.interrupted":
         case "runtime.output.recorded":
         case "tool.call.source":
             break;
@@ -338,8 +364,10 @@ export function applyEvent(
                 reason: event.payload.reason,
             };
 
-            if (state.primaryActorId === event.payload.actorId)
+            if (state.primaryActorId === event.payload.actorId) {
                 state.primaryActorId = null;
+                state.stoppedPrimaryActorId = event.payload.actorId;
+            }
             break;
 
         case "actor.restarted":
@@ -426,22 +454,21 @@ export function applyEvent(
         }
 
         case "action.proposed": {
-            const base = {
+            const action: Draft<Action> = {
                 id: event.payload.actionId,
                 askedBy: event.actorId,
+                owner: event.payload.owner,
                 title: event.payload.title,
                 description: event.payload.description,
                 parameters: event.payload.parameters,
                 input: event.payload.input,
-                status: "pending" as const,
+                payload: event.payload.payload,
+                status: "pending",
                 proposedAt: event.occurredAt,
                 resolvedAt: null,
                 resolvedBy: null,
-                response: null,
+                result: null,
             };
-            const action: Draft<Action> = event.payload.kind === "question"
-                ? { ...base, kind: "question", question: event.payload.question }
-                : { ...base, kind: "action" };
             state.actions.set(action.id, action);
             break;
         }
@@ -455,7 +482,7 @@ export function applyEvent(
             found.status = event.payload.decision;
             found.resolvedAt = event.occurredAt;
             found.resolvedBy = event.actorId;
-            found.response = event.payload.response;
+            found.result = event.payload.result;
             break;
         }
 
@@ -491,6 +518,7 @@ export function viewOf(state: RunState): RunView {
         title: state.title,
         ownerId: state.ownerId,
         primaryActorId: state.primaryActorId,
+        stoppedPrimaryActorId: state.stoppedPrimaryActorId,
         createdAt: state.createdAt,
         forkedFrom: state.forkedFrom,
         actors: [...state.actors.values()],

package/packages/ragents/src/domain/schema-errors.ts

@@ -24,7 +24,7 @@ const stringsOf = (params: unknown, key: string): string[] => {
     return Array.isArray(value) ? value.map(String) : [];
 };
 
-export const schemaComplaints = (schema: unknown, input: unknown): string => {
+export const schemaComplaints = (schema: unknown, input: unknown, root = "input"): string => {
     const errors = [...Value.Errors(schema as Parameters<typeof Value.Errors>[0], input)];
     const byPath = new Map<string, typeof errors>();
 
@@ -34,7 +34,7 @@ export const schemaComplaints = (schema: unknown, input: unknown): string => {
     const lines: string[] = [];
 
     for (const [pointer, group] of byPath) {
-        const path = pointer.split("/").slice(1).join(".") || "input";
+        const path = pointer.split("/").slice(1).join(".") || root;
         const allowed = group.flatMap((entry) =>
             entry.keyword === "const" ? [String((entry.params as Record<string, unknown>).allowedValue)] : []);
         const missing = group.flatMap((entry) => (entry.keyword === "required" ? stringsOf(entry.params, "requiredProperties") : []));
@@ -51,6 +51,6 @@ export const schemaComplaints = (schema: unknown, input: unknown): string => {
             lines.push(`${path} ${group[0].message}, got ${shortJson(valueAt(input, pointer))}`);
     }
 
-    return lines.slice(0, 8).join("; ");
+    return lines.length > 0 ? lines.slice(0, 8).join("; ") : `${root} does not match its schema`;
 };
 

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

@@ -0,0 +1,40 @@
+import type { InlineExtension } from "@ragents/agent";
+import type { JsonValue } from "../domain/json.ts";
+import type { AgentContribution, AgentContributionContext, AgentHookContext } from "../plugin-types.ts";
+
+const hookContextOf = (context: { signal: AbortSignal | undefined; model: { input: readonly string[] } | undefined }): AgentHookContext => ({
+  signal: context.signal,
+  modelReadsImages: context.model?.input.includes("image") === true,
+});
+
+/** The one place that turns the hooks of a plugin into an extension of the agent runtime; plugins never see the runtime. */
+export const agentHookExtension = (contribution: AgentContribution, agent: AgentContributionContext): InlineExtension => ({
+  name: contribution.id,
+  factory: (api) => {
+    const { beforeModelCall, afterToolCall } = contribution;
+    if (beforeModelCall) {
+      api.on("context", async (event, context) => {
+        const stored = context.sessionManager.getBranch()
+          .filter((entry) => entry.type === "custom" && entry.customType === contribution.id)
+          .at(-1);
+        const note = await beforeModelCall(agent, {
+          ...hookContextOf(context),
+          kept: stored?.type === "custom" ? stored.data as JsonValue : undefined,
+          keep: (value) => api.appendEntry(contribution.id, value),
+        });
+        if (note === undefined) return undefined;
+        return { messages: [...event.messages, { role: "custom" as const, customType: contribution.id, content: note, display: false, timestamp: Date.now() }] };
+      });
+    }
+    if (afterToolCall) {
+      api.on("tool_result", async (event, context) => {
+        const replacement = await afterToolCall(agent, { toolName: event.toolName, isError: event.isError }, hookContextOf(context));
+        if (replacement === undefined) return undefined;
+        return {
+          content: replacement.content.map((part) => ({ ...part })),
+          ...(replacement.isError === undefined ? {} : { isError: replacement.isError }),
+        };
+      });
+    }
+  },
+});