@vincemakes/kiso-server 0.53.0 → 0.54.1

package/dist/http.d.ts

@@ -18,6 +18,7 @@ import { type ProjectionOptions } from "./wire.js";
  *   POST {prefix}/:id/run        202 { runId } — or the run's own stream with ?stream=1
  *   POST {prefix}/:id/resume     202 { runId } — or the stream with ?stream=1
  *   POST {prefix}/:id/steer      202 { runId } — 409 idle | closed (ADR-0057)
+ *   POST {prefix}/:id/retract    200 { runId, count } — the person's steers not admitted yet, taken back (ADR-0057)
  *   POST {prefix}/:id/abort      200 idle | stopped — 409 parked (who is waited for)
  *   POST {prefix}/:id/approve    200 { needsResume }
  *   POST {prefix}/:id/uncertain  200 { remaining }

package/dist/http.js

@@ -6,7 +6,7 @@ import { toWireEvent } from "./wire.js";
  *  store never did — a nanoid can start with `_` or `-` (about 1 in 32 do)
  *  and every such session answered 404. */
 const SESSION_ID = /^[A-Za-z0-9._-]{1,128}$/;
-const ACTIONS = new Set(["", "state", "events", "replay", "run", "resume", "steer", "abort", "approve", "uncertain"]);
+const ACTIONS = new Set(["", "state", "events", "replay", "run", "resume", "steer", "retract", "abort", "approve", "uncertain"]);
 export function createHttpHandler(service, options) {
     const prefix = (options.prefix ?? "/v1/sessions").replace(/\/+$/, "");
     const keepaliveMs = options.keepaliveMs ?? 15_000;
@@ -238,6 +238,10 @@ export function createHttpHandler(service, options) {
                 json(res, 202, service.steer(sessionId, input));
                 return true;
             }
+            if (action === "retract") {
+                json(res, 200, service.retract(sessionId));
+                return true;
+            }
             if (action === "abort") {
                 const outcome = await service.abort(sessionId, body["force"] === true ? { force: true } : {});
                 const reply = outcome.kind === "stopped" ? { kind: "stopped", runId: outcome.runId } : outcome;

package/dist/service.d.ts

@@ -1,4 +1,4 @@
-import type { ContentBlock, Event, MessageSource } from "@vincemakes/kiso-core";
+import type { ContentBlock, Event, MessageSource, UserInputVia } from "@vincemakes/kiso-core";
 import type { Agent, ApprovalRequest, Session, SessionStore } from "@vincemakes/kiso-runtime";
 import { type Listener } from "./tail.js";
 /**
@@ -81,6 +81,8 @@ export interface RunHandle {
 }
 export interface RunOptions {
     readonly source?: MessageSource;
+    /** ADR-0058 §8: the receipt a task wake carries (the host's onWake hands it over), recorded on the run's user_input. */
+    readonly via?: UserInputVia;
     /** The log holds an open run from a previous process: resume it to its
      *  terminal first, then start this turn. Without this the call refuses
      *  with `OpenRunError` — the service never resumes silently. */
@@ -127,6 +129,13 @@ export declare class SessionService {
     steer(sessionId: string, input: string | readonly ContentBlock[]): {
         readonly runId: string;
     };
+    /** ADR-0057 — take back the person's input the live run has not admitted yet (a task notice stays). The host
+     *  steers again what it still wants, in order: a page cancelling one waiting line takes them all back and
+     *  re-steers the rest. Nothing to take back when no run is live. */
+    retract(sessionId: string): {
+        readonly runId: string | null;
+        readonly count: number;
+    };
     /** ADR-0057 — what the run that ended at `terminalSeq` accepted and never
      *  admitted; null when nothing, or when that is not the latest terminal. */
     unadmittedAt(sessionId: string, terminalSeq: number): {

package/dist/service.js

@@ -24,7 +24,7 @@ export class SessionService {
         const opening = (async () => {
             const agent = await this.#open(sessionId);
             const session = await agent.session({ id: sessionId });
-            const held = { id: sessionId, agent, session, listeners: new Set(), live: null, pumping: null, executing: 0, highWater: -1, mismatch: null, unadmitted: null };
+            const held = { id: sessionId, agent, session, listeners: new Set(), live: null, pumping: null, executing: 0, highWater: -1, published: session.log.lastSeq, mismatch: null, unadmitted: null };
             this.#held.set(sessionId, held);
             return held;
         })();
@@ -48,6 +48,28 @@ export class SessionService {
         held.agent = agent;
         held.session = await agent.session({ id: sessionId });
     }
+    /** Fan out every event on the open log after `published`, in seq order.
+     *  A run's events arrive through `#pump`, but a verdict given while no
+     *  run is live (`resolveUncertain`, an offline `approve`) is appended
+     *  straight to the log; reading the log here — not the one event in
+     *  hand — is what keeps an event appended outside a run from being
+     *  skipped when a run's next event reaches a subscriber first. */
+    #publish(held) {
+        const log = held.session.log.all;
+        // the log's seq is its index (EventLog refuses a discontinuity)
+        for (let i = held.published + 1; i < log.length; i++) {
+            const event = log[i];
+            held.published = event.seq;
+            for (const listener of [...held.listeners]) {
+                try {
+                    listener(event);
+                }
+                catch {
+                    held.listeners.delete(listener); // a throwing observer leaves; the run does not
+                }
+            }
+        }
+    }
     // ---- runs -----------------------------------------------------------------
     #pump(held, run) {
         held.live = run;
@@ -60,14 +82,7 @@ export class SessionService {
                         held.unadmitted = { runId: run.runId, terminalSeq: event.seq, items: run.unadmitted() };
                     held.executing = Math.max(0, held.executing + executionDelta(event));
                     held.highWater = Math.max(held.highWater, event.seq);
-                    for (const listener of [...held.listeners]) {
-                        try {
-                            listener(event);
-                        }
-                        catch {
-                            held.listeners.delete(listener); // a throwing observer leaves; the run does not
-                        }
-                    }
+                    this.#publish(held);
                 }
             }
             finally {
@@ -113,6 +128,15 @@ export class SessionService {
         live.steer(input);
         return { runId: live.runId };
     }
+    /** ADR-0057 — take back the person's input the live run has not admitted yet (a task notice stays). The host
+     *  steers again what it still wants, in order: a page cancelling one waiting line takes them all back and
+     *  re-steers the rest. Nothing to take back when no run is live. */
+    retract(sessionId) {
+        const live = this.#held.get(sessionId)?.live ?? null;
+        if (live === null)
+            return { runId: null, count: 0 };
+        return { runId: live.runId, count: live.retract().length };
+    }
     /** ADR-0057 — what the run that ended at `terminalSeq` accepted and never
      *  admitted; null when nothing, or when that is not the latest terminal. */
     unadmittedAt(sessionId, terminalSeq) {
@@ -136,7 +160,7 @@ export class SessionService {
                 throw new OpenRunError(sessionId, open);
             await this.#pump(held, held.session.resume()).done;
         }
-        const run = held.session.run(input, options.source !== undefined ? { source: options.source } : {});
+        const run = held.session.run(input, { ...(options.source !== undefined ? { source: options.source } : {}), ...(options.via !== undefined ? { via: options.via } : {}) });
         return this.#pump(held, run);
     }
     /** Drive the open run (one a previous process left, or one parked at an
@@ -182,6 +206,10 @@ export class SessionService {
         const held = await this.#hold(sessionId);
         const wasLive = held.live !== null;
         await held.session.approve(decisionId, allow, reason);
+        // a live run appends the verdict itself and `#pump` fans it out once it
+        // is on disk; only a verdict appended with no run live is published here
+        if (held.live === null)
+            this.#publish(held);
         return { needsResume: !wasLive };
     }
     async pendingApprovals(sessionId) {
@@ -196,6 +224,8 @@ export class SessionService {
     async resolveUncertain(sessionId, executionId, resolution) {
         const held = await this.#hold(sessionId);
         await held.session.resolveUncertain(executionId, resolution);
+        if (held.live === null)
+            this.#publish(held);
         return { remaining: held.session.uncertainExecutions().length };
     }
     // ---- observation ----------------------------------------------------------
@@ -212,7 +242,9 @@ export class SessionService {
     events(sessionId, after = -1) {
         const held = this.#held.get(sessionId);
         const events = held !== undefined ? held.session.log.all : this.#store.load(sessionId).map((r) => r.event);
-        return events.filter((e) => e.seq > after);
+        // the log's seq is its index (EventLog refuses a discontinuity): no scan, and with no `after` no copy either — a
+        // host that read every event's frames through a filtered copy spent seconds per replay on a long Work. Read-only.
+        return (after < 0 ? events : events.slice(after + 1));
     }
     isRunning(sessionId) {
         return this.#held.get(sessionId)?.live !== null && this.#held.get(sessionId)?.live !== undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-server",
-	"version": "0.53.0",
+	"version": "0.54.1",
 	"description": "kiso server — the hosted-session service: many durable sessions in one process, observers with exact replay from a sequence number, approve / abort / resume routed to the right run, drain and close. No transport; a product supplies the agent factory.",
 	"type": "module",
 	"license": "MIT",
@@ -25,12 +25,12 @@
 		"test": "vitest run"
 	},
 	"dependencies": {
-		"@vincemakes/kiso-core": "0.53.0",
-		"@vincemakes/kiso-protocol": "0.53.0",
-		"@vincemakes/kiso-runtime": "0.53.0"
+		"@vincemakes/kiso-core": "0.54.1",
+		"@vincemakes/kiso-protocol": "0.54.1",
+		"@vincemakes/kiso-runtime": "0.54.1"
 	},
 	"devDependencies": {
-		"@vincemakes/kiso-evals": "0.53.0",
+		"@vincemakes/kiso-evals": "0.54.1",
 		"@types/node": "^26.1.2",
 		"typescript": "^5.7.2",
 		"vitest": "^3.0.0"