@plurnk/plurnk-agui 1.14.1 → 1.15.0

package/dist/Module.js

@@ -14,90 +14,32 @@
 var _a;
 import { createServer } from "node:http";
 import Portal from "./Portal.js";
-import { derivationActivity, stateDelta, stateSnapshot, statusState, parseAction, actionResult } from "./AguiPlus.js";
+import { derivationActivity, statusState, actionResult } from "./AguiPlus.js";
 import { EventType } from "./types.js";
 import { aguiRouteTemplate, observed } from "./observe.js";
-import { RunAgentInputSchema } from "@ag-ui/core";
-import { Problems, PlurnkParser, UNKNOWN_POSITION, Validator, } from "@plurnk/plurnk-contracts";
-import { AGUI_BUILTIN_ACTIONS, AGUI_NOTIFICATIONS, } from "./AguiSurface.js";
+import { Validator } from "@plurnk/plurnk-contracts";
+import { AGUI_BUILTIN_ACTIONS, AGUI_NOTIFICATIONS } from "./AguiSurface.js";
 import { resolveModuleOptions } from "./config.js";
-const actionFailure = (code, detail, status = 400, extensions = {}) => ({
-    ok: false,
-    problem: Problems.create("agui:action", code, status, detail, {
-        stage: status < 500 ? "action-validation" : "action-execution",
-        retryable: false,
-        ...extensions,
-    }),
-});
-const httpProblem = (code, status, detail, extensions = {}) => Problems.create("agui:http", code, status, detail, extensions);
-class HttpProblemError extends Error {
-    problem;
-    constructor(problem) {
-        super(problem.detail);
-        this.name = "HttpProblemError";
-        this.problem = problem;
-    }
-}
-const problemFromError = (error) => {
-    if (error instanceof HttpProblemError)
-        return error.problem;
-    if (typeof error !== "object" || error === null)
-        return null;
-    const result = error.result;
-    if (result !== undefined) {
-        try {
-            return Validator.assertOperationResult(result).problem ?? null;
-        }
-        catch {
-            return null;
-        }
-    }
-    const problem = error.problem;
-    if (problem !== undefined) {
-        try {
-            return Validator.assertProblemDetails(problem);
-        }
-        catch {
-            return null;
-        }
-    }
-    return null;
-};
-const operationOutcome = (result) => {
-    const exact = Validator.assertOperationResult(result);
-    return exact.problem === undefined
-        ? { ok: true, result: exact }
-        : { ok: false, problem: exact.problem };
-};
-const parseFailureResult = ({ detail, line, column, source, severity, }) => ({
-    status: 400,
-    problem: Problems.create("agui:action", "parse-failed", 400, detail, {
-        line,
-        column,
-        source,
-        severity,
-        stage: "parsing",
-        retryable: false,
-    }),
-});
+import { HttpProblemError, actionFailure, problemFromError } from "./action-results.js";
+import BuiltinActions from "./BuiltinActions.js";
+import { httpProblem, runErrorEvents } from "./run-events.js";
+import RunHandler from "./RunHandler.js";
 const writeHttpProblem = (res, problem) => {
     res.writeHead(problem.status, { "content-type": "application/problem+json" });
     res.end(JSON.stringify(problem));
 };
-const runErrorEvents = (problem) => [
-    { type: EventType.CUSTOM, name: "plurnk.problem", value: problem },
-    { type: EventType.RUN_ERROR, message: problem.detail, code: problem.type },
-];
 class Module {
     #seam;
     #opts;
     #portal;
     #http;
-    #threads = new Map(); // threadId → envelope
-    #threadWorkers = new Map(); // threadId → conversation workerId
+    #threadEnvelopes = new Map(); // [workspace, threadId] → envelope
+    #threadWorkers = new Map(); // [workspace, threadId] → conversation workerId
     #actions = new Map();
     #listening = false;
     #activated = false;
+    #builtins = new BuiltinActions({ seam: () => this.#seam, capabilities: this.#capabilities.bind(this), envelope: this.#envelope.bind(this), requireWorkspace: _a.#requireWorkspace });
+    #runs = new RunHandler({ seam: () => this.#seam, opts: () => this.#opts, portal: () => this.#portal, requiresWorkspace: this.#requiresWorkspace.bind(this), controlRun: this.#controlRun.bind(this), envelope: this.#envelope.bind(this), conversationWorker: this.#conversationWorker.bind(this), workerStatus: this.#workerStatus.bind(this), action: this.#action.bind(this) });
     #closing = null;
     constructor(opts) {
         this.#opts = resolveModuleOptions(opts);
@@ -107,7 +49,7 @@ class Module {
         for (const [name, contract] of Object.entries(AGUI_BUILTIN_ACTIONS)) {
             this.#actions.set(name, {
                 ...contract,
-                execute: (params, env, conversationWorkerId) => this.#executeBuiltin(name, params, env, conversationWorkerId),
+                execute: (params, env, conversationWorkerId) => this.#builtins.executeBuiltin(name, params, env, conversationWorkerId),
             });
         }
         for (const descriptor of this.#seam.listModuleActions()) {
@@ -152,6 +94,9 @@ class Module {
             throw new Error(`action '${kind}' operates within a workspace, but none is bound`);
         return env;
     }
+    static #threadKey(workspace, threadId) {
+        return JSON.stringify([workspace, threadId]);
+    }
     static init(opts) {
         return {
             start: async (seam) => {
@@ -252,7 +197,7 @@ class Module {
                 return;
             }
             if (req.method === "POST" && (req.url === "/" || req.url === "/agui"))
-                return await this.#run(req, res);
+                return await this.#runs.run(req, res);
             writeHttpProblem(res, httpProblem("route-not-found", 404, "The requested HTTP route does not exist.", {
                 method: req.method ?? null,
                 path: req.url ?? null,
@@ -300,7 +245,8 @@ class Module {
                 retryable: false,
             }));
         }
-        const cached = this.#threads.get(threadId);
+        const key = _a.#threadKey(workspace, threadId);
+        const cached = this.#threadEnvelopes.get(key);
         if (cached !== undefined)
             return { env: cached, reattached: true };
         const known = (await this.#seam.listWorkspaces()).find((s) => s.name === workspace);
@@ -325,22 +271,23 @@ class Module {
                     : {}),
             });
         }
-        this.#threads.set(threadId, env);
+        this.#threadEnvelopes.set(key, env);
         return { env, reattached };
     }
     // Resolve the thread's conversation worker within its world. Cached per
-    // threadId; worker names are immutable so the binding cannot rot. Durable
+    // workspace + threadId; worker names are immutable so the binding cannot rot. Durable
     // capability changes use worker.capabilities.set; per-run attenuation belongs
     // to the loop policy forwarded below.
     async #conversationWorker(threadId, env) {
-        const cached = this.#threadWorkers.get(threadId);
+        const key = _a.#threadKey(env.workspaceName, threadId);
+        const cached = this.#threadWorkers.get(key);
         if (cached !== undefined)
             return cached;
         const workerId = threadId === env.workspaceName
             ? await this.#seam.ensureModelWorker(env.workspaceId)
             : (await this.#seam.listWorkers(env.workspaceId)).find((r) => r.name === threadId)?.id
                 ?? (await this.#seam.createConversationWorker({ workspaceId: env.workspaceId, name: threadId })).workerId;
-        this.#threadWorkers.set(threadId, workerId);
+        this.#threadWorkers.set(key, workerId);
         return workerId;
     }
     async #workerStatus(workspaceId, workerId) {
@@ -350,222 +297,6 @@ class Module {
         ]);
         return statusState(model, loops.at(-1) ?? null, derivationActivity(this.#seam.workspaceDerivationStatus(workspaceId)));
     }
-    async #run(req, res) {
-        let decoded;
-        try {
-            decoded = JSON.parse(await _a.#body(req));
-        }
-        catch {
-            throw new HttpProblemError(httpProblem("invalid-json", 400, "The request body is not valid JSON.", { stage: "request-validation", retryable: false }));
-        }
-        const parsed = RunAgentInputSchema.safeParse(decoded);
-        if (!parsed.success) {
-            throw new HttpProblemError(httpProblem("invalid-run-input", 400, "The request body does not satisfy the AG-UI RunAgentInput contract.", {
-                stage: "request-validation",
-                issues: parsed.error.issues,
-                retryable: false,
-            }));
-        }
-        const input = parsed.data;
-        const forwarded = input.forwardedProps?.plurnk;
-        // Control plane FIRST: a management action that doesn't live in a world (and an
-        // unknown kind, which is no worker at all) answers without binding — or forging — a
-        // workspace. Only world-scoped actions and conversations reach #envelope below.
-        const action = parseAction(input.forwardedProps);
-        if (action !== null && !this.#requiresWorkspace(action.kind)) {
-            return await this.#controlRun(action, input, res);
-        }
-        let prompt = null;
-        if (action === null && input.resume === undefined) {
-            const lastUser = [...input.messages].reverse().find((message) => message.role === "user");
-            if (lastUser === undefined || typeof lastUser.content !== "string" || lastUser.content.length === 0) {
-                throw new HttpProblemError(httpProblem("user-message-required", 400, "A new AG-UI Run requires a non-empty textual user message.", {
-                    stage: "request-validation",
-                    recovery: "Provide a non-empty user message.",
-                    retryable: false,
-                }));
-            }
-            prompt = lastUser.content;
-        }
-        const { env, reattached } = await this.#envelope(input.threadId, forwarded);
-        const workspaceId = env.workspaceId;
-        // {§agui-thread-binding} The threadId is the conversation over the
-        // world. threadId == workspace name binds the model worker (the default conversation);
-        // a distinct threadId names its own worker: found by name, else minted via
-        // createConversationWorker. The name is the identity at BOTH levels.
-        const workerId = await this.#conversationWorker(input.threadId, env);
-        res.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache", "connection": "keep-alive" });
-        let finished = false;
-        const interrupts = [];
-        // {§agui-configuration}: long generations can emit no events; SSE comments keep
-        // consumers fed without adding protocol events.
-        const cadence = this.#opts.heartbeatMs;
-        const heartbeat = cadence > 0 ? setInterval(() => { res.write(": hb\n\n"); }, cadence) : null;
-        const finish = () => {
-            if (finished)
-                return;
-            finished = true;
-            if (heartbeat !== null)
-                clearInterval(heartbeat);
-            this.#portal.closeRun(workspaceId, boundRun);
-            res.end();
-        };
-        const emit = (events) => {
-            for (const e of events) {
-                res.write(`data: ${JSON.stringify(e)}\n\n`);
-                // Terminate-resume, the terminate half: a stopped-world tool call
-                // ends this AG-UI Run while its core owner remains paused.
-                if (e.type === "TOOL_CALL_END") {
-                    const interrupt = this.#portal.interruptForToolCall(e.toolCallId);
-                    if (interrupt !== null)
-                        interrupts.push(interrupt);
-                }
-                if (e.type === "RUN_FINISHED" || e.type === "RUN_ERROR")
-                    finish();
-            }
-            if (interrupts.length > 0 && !finished) {
-                res.write(`data: ${JSON.stringify({
-                    type: EventType.RUN_FINISHED,
-                    threadId: input.threadId,
-                    runId: input.runId,
-                    outcome: { type: "interrupt", interrupts: interrupts.splice(0) },
-                })}\n\n`);
-                finish();
-            }
-        };
-        const lifecycleWorkerId = action?.kind === "op.exec" || action?.kind === "op.parse" ? env.workerId : workerId;
-        const notificationScope = action === null
-            ? "conversation"
-            : action.kind === "op.exec" || action.kind === "op.parse"
-                ? "operation"
-                : "result";
-        const boundRun = this.#portal.openThread({
-            workspaceId,
-            workerId: lifecycleWorkerId,
-            threadId: input.threadId,
-            notificationScope,
-            emit,
-            modelWorkerId: workerId,
-            inputRunId: input.runId,
-            ...(input.resume === undefined ? {} : { resume: input.resume }),
-        });
-        const status = await this.#workerStatus(workspaceId, workerId);
-        emit([
-            { type: EventType.RUN_STARTED, threadId: input.threadId, runId: input.runId },
-            stateSnapshot({ providers: this.#seam.listProviders().aliases, workspace: { id: workspaceId, name: env.workspaceName, projectRoot: env.projectRoot }, status }),
-        ]);
-        if (finished)
-            return;
-        try {
-            // §3 — a management-action AG-UI Run (forwardedProps.plurnk.action): execute via the
-            // seam; the outcome rides the workspace's CURRENT thread binding (Portal.finishRun),
-            // never this closure — a proposal-gated action (op.exec → 202) terminates THIS
-            // AG-UI Run and completes after the resume AG-UI Run rebinds the stream.
-            if (action !== null) {
-                const finishAction = (outcome) => {
-                    const events = [actionResult(action.kind, outcome)];
-                    // Plain action (stream still open): answer on OUR OWN stream — concurrent
-                    // actions share a workspace, and the workspace binding is whoever bound last
-                    // (results would cross streams). Only a proposal-pause (this stream already
-                    // terminated) hands off to the workspace binding, which the resume AG-UI Run rebinds.
-                    if (!finished) {
-                        this.#portal.finishThread(boundRun, events);
-                        return;
-                    }
-                    this.#portal.finishRun(workspaceId, lifecycleWorkerId, input.threadId, events);
-                };
-                void this.#action(action, env, workerId)
-                    // One queue barrier: a dispatch's channel notifies are enqueued but not yet
-                    // delivered when its promise resolves — drain them so Portal's stream
-                    // bookkeeping arms BEFORE the finish decision (then stream/concluded,
-                    // not a timer, releases any deferral).
-                    .then(async (outcome) => { await new Promise((r) => setImmediate(r)); finishAction(outcome); })
-                    .catch((err) => {
-                    console.error(`AG-UI action '${action.kind}' failed:`, err);
-                    const problem = problemFromError(err);
-                    finishAction(problem === null
-                        ? actionFailure("action-failed", "The action failed unexpectedly.", 500)
-                        : { ok: false, problem });
-                });
-                res.on("close", () => {
-                    if (finished)
-                        return;
-                    this.#seam.cancelDrain(lifecycleWorkerId, "client_disconnected");
-                    finish();
-                });
-                return;
-            }
-            // AG-UI interrupt resume: this is a new AG-UI Run on the same thread. Bind it
-            // to the durable continuation before releasing the proposal.
-            if (input.resume !== undefined) {
-                await this.#portal.resolve(workspaceId, boundRun, input.resume);
-                res.on("close", finish); // client hangup on a resume just detaches; the loop is already active
-                return;
-            }
-            if (prompt === null)
-                throw new Error("conversation AG-UI Run reached dispatch without a validated prompt");
-            if (reattached) {
-                const history = await this.#seam.readLog({ workspaceId, workerId, limit: 1000 }).catch(() => null);
-                if (history !== null)
-                    emit(this.#portal.replay(boundRun, history));
-            }
-            const started = await this.#portal.run(boundRun, {
-                workspaceId, workerId, prompt,
-                ...(forwarded !== undefined && Object.hasOwn(forwarded, "maxTurns")
-                    ? { maxTurns: forwarded.maxTurns }
-                    : this.#opts.maxTurns !== undefined ? { maxTurns: this.#opts.maxTurns } : {}),
-                ...(forwarded !== undefined && Object.hasOwn(forwarded, "policy")
-                    ? { policy: forwarded.policy }
-                    : {}),
-                ...(forwarded !== undefined && Object.hasOwn(forwarded, "openPaths")
-                    ? { openPaths: forwarded.openPaths }
-                    : {}),
-                // {§methods-loop-run-model} The client may still forward one explicit
-                // alias-or-provider/model selector. The daemon
-                // persists an explicit selection onto the worker and snapshots it on the
-                // loop; an omitted selector continues the worker's durable model.
-                ...(forwarded !== undefined && Object.hasOwn(forwarded, "selector")
-                    ? { selector: forwarded.selector }
-                    : {}),
-                ...(forwarded !== undefined && Object.hasOwn(forwarded, "childSelector")
-                    ? { childSelector: forwarded.childSelector }
-                    : {}),
-            });
-            if (started !== null && !finished) {
-                const currentStatus = await this.#workerStatus(workspaceId, workerId);
-                if (!finished) {
-                    emit([stateDelta([{
-                                op: "replace",
-                                path: "/plurnk/status",
-                                value: currentStatus,
-                            }])]);
-                }
-            }
-            // A dropped SSE on a live AG-UI Run cancels the loop (hangup is the abort). A stream we
-            // finished ourselves — terminal event or proposal-terminate — leaves the engine
-            // alone (the paused loop is exactly what the resume AG-UI Run needs).
-            res.on("close", () => {
-                if (finished)
-                    return;
-                this.#seam.cancelDrain(workerId, "client_disconnected");
-                finish();
-            });
-        }
-        catch (err) {
-            // {§agui-http-failure} After headers, the frame alone is
-            // not enough — the heartbeat interval and the Portal binding are live, and a
-            // throw that escapes past finish() leaks them forever (the drill-hang). emit()
-            // writes the terminal frame AND finish()es on RUN_ERROR — one door out.
-            const exactProblem = problemFromError(err);
-            if (exactProblem === null)
-                console.error("AG-UI Run failed:", err);
-            const problem = exactProblem ?? httpProblem("run-failed", 500, "The AG-UI Run failed unexpectedly.", {
-                stage: "run",
-                retryable: false,
-            });
-            emit(runErrorEvents(problem));
-        }
-    }
     // A control-plane AG-UI Run: no world bound. Open the SSE, execute the worldless verb, answer on
     // our own stream. No Portal thread, no model worker, and no ephemeral workspace.
     async #controlRun(action, input, res) {
@@ -637,321 +368,6 @@ class Module {
             return actionFailure("action-failed", "The action failed unexpectedly.", 500);
         }
     }
-    // The built-in implementation half of the declarative registry. The registry
-    // owns membership, scope, admission, projection, and discovery; this dispatch
-    // owns only the corresponding daemon operation.
-    async #executeBuiltin(kind, p, env, conversationWorkerId) {
-        try {
-            // Worldless actions never bind or forge a workspace.
-            switch (kind) {
-                case "ping": return { ok: true, result: {} };
-                case "discover": return { ok: true, result: await this.#capabilities() };
-                case "providers.list": return { ok: true, result: this.#seam.listProviders() };
-                case "models.list": {
-                    return { ok: true, result: this.#seam.listModels(Validator.assertModelCatalogQuery(p)) };
-                }
-                case "workspace.list": return { ok: true, result: { workspaces: await this.#seam.listWorkspaces() } };
-                case "workspace.create": {
-                    // The name IS the identity: an explicit name creates/attaches EXACTLY
-                    // that workspace; no name = the daemon names it and the real name binds.
-                    if (Object.hasOwn(p, "name") && (typeof p.name !== "string" || p.name.length === 0)) {
-                        return actionFailure("invalid-action-parameters", "workspace.create name is not a non-empty string.", 400, { field: "name", recovery: "Provide a non-empty workspace name or omit it." });
-                    }
-                    if (typeof p.name === "string") {
-                        // The name IS the world here — feed it as the workspace so #envelope
-                        // creates/attaches exactly it (p carries no `workspace` of its own).
-                        const { env: created } = await this.#envelope(p.name, { ...p, workspace: p.name });
-                        return { ok: true, result: { id: created.workspaceId, name: created.workspaceName, workerId: created.workerId } };
-                    }
-                    const created = await this.#seam.createWorkspace({
-                        ...(Object.hasOwn(p, "projectRoot")
-                            ? { projectRoot: p.projectRoot }
-                            : {}),
-                        ...(Object.hasOwn(p, "constraints")
-                            ? { constraints: p.constraints }
-                            : {}),
-                        ...(Object.hasOwn(p, "settings")
-                            ? { settings: p.settings }
-                            : {}),
-                    });
-                    this.#threads.set(created.workspaceName, created);
-                    return { ok: true, result: { id: created.workspaceId, name: created.workspaceName, workerId: created.workerId } };
-                }
-                case "workspace.attach": {
-                    // A REAL attach: rebind the thread map to the chosen workspace and hand
-                    // back its envelope — the picker does what it says (the unwired kind +
-                    // a nil-masking fallback produced the 2026-07-10 front-door disaster).
-                    if (typeof p.id !== "number") {
-                        return actionFailure("invalid-action-parameters", "workspace.attach requires a numeric workspace id.", 400, {
-                            field: "id",
-                            recovery: "Provide a workspace id returned by workspace.list.",
-                        });
-                    }
-                    const att = await this.#seam.attachWorkspace({ workspaceId: p.id, ...(typeof p.workerId === "number" ? { workerId: p.workerId } : {}) });
-                    this.#threads.set(att.workspaceName, att);
-                    return { ok: true, result: { id: att.workspaceId, name: att.workspaceName, workerId: att.workerId } };
-                }
-            }
-            const world = _a.#requireWorkspace(kind, env);
-            switch (kind) {
-                case "workspace.workers": return { ok: true, result: { workers: await this.#seam.listWorkers(typeof p.id === "number" ? p.id : world.workspaceId) } };
-                case "log.read": {
-                    // Default worker: the conversation; p.workerId pins another.
-                    const readWorkerId = typeof p.workerId === "number" ? p.workerId : conversationWorkerId ?? await this.#seam.ensureModelWorker(world.workspaceId);
-                    const entries = await this.#seam.readLog({
-                        workspaceId: world.workspaceId,
-                        workerId: readWorkerId,
-                        ...(Object.hasOwn(p, "limit") ? { limit: p.limit } : {}),
-                        ...(Object.hasOwn(p, "sinceId") ? { sinceId: p.sinceId } : {}),
-                        ...(Object.hasOwn(p, "loopId") ? { loopId: p.loopId } : {}),
-                        ...(Object.hasOwn(p, "turnId") ? { turnId: p.turnId } : {}),
-                        ...(Object.hasOwn(p, "loopSeq") ? { loopSeq: p.loopSeq } : {}),
-                        ...(Object.hasOwn(p, "turnSeq") ? { turnSeq: p.turnSeq } : {}),
-                        ...(Object.hasOwn(p, "sequence") ? { sequence: p.sequence } : {}),
-                    });
-                    return { ok: true, result: { entries } };
-                }
-                case "loop.inject": {
-                    if (typeof p.prompt !== "string" || p.prompt.length === 0) {
-                        return actionFailure("invalid-action-parameters", "loop.inject requires a non-empty prompt.", 400, { field: "prompt", recovery: "Provide the prompt to inject." });
-                    }
-                    const ack = await this.#seam.runLoop({ workspaceId: world.workspaceId, workerId: conversationWorkerId ?? await this.#seam.ensureModelWorker(world.workspaceId), prompt: p.prompt });
-                    return operationOutcome(ack);
-                }
-                // The stop button (TUI /stop + Ctrl-C, nvim :PlurnkStop): abort the model
-                // worker's active drain. Mirrors the SSE-hangup abort, addressable as a verb.
-                case "loop.cancel": return { ok: true, result: { cancelled: this.#seam.cancelDrain(conversationWorkerId ?? await this.#seam.ensureModelWorker(world.workspaceId), typeof p.reason === "string" ? p.reason : undefined) } };
-                case "workspace.prompts": return {
-                    ok: true,
-                    result: {
-                        prompts: await this.#seam.listPrompts(world.workspaceId, Object.hasOwn(p, "limit") ? p.limit : undefined),
-                    },
-                };
-                case "workspace.rename": {
-                    if (typeof p.name !== "string" || p.name.length === 0) {
-                        return actionFailure("invalid-action-parameters", "workspace.rename requires a non-empty name.", 400, { field: "name", recovery: "Provide the new workspace name." });
-                    }
-                    return { ok: true, result: await this.#seam.renameWorkspace(world.workspaceId, p.name) };
-                }
-                case "workspace.derivation": return { ok: true, result: { status: this.#seam.workspaceDerivationStatus(world.workspaceId) } };
-                case "entry.read": {
-                    if (typeof p.target !== "string") {
-                        return actionFailure("invalid-action-parameters", "entry.read requires a string target.", 400, { field: "target", recovery: "Provide an entry URI." });
-                    }
-                    if (Object.hasOwn(p, "workerId")
-                        && (typeof p.workerId !== "number" || !Number.isSafeInteger(p.workerId) || p.workerId <= 0)) {
-                        return actionFailure("invalid-action-parameters", "entry.read workerId must be a positive integer.", 400, { field: "workerId", recovery: "Use the workerId supplied with the entry notification." });
-                    }
-                    const result = Validator.assertEntryReadResult(await this.#seam.readEntry({
-                        workspaceId: world.workspaceId,
-                        workerId: typeof p.workerId === "number"
-                            ? p.workerId
-                            : conversationWorkerId ?? await this.#seam.ensureModelWorker(world.workspaceId),
-                        target: p.target,
-                        ...(Object.hasOwn(p, "channel") ? { channel: p.channel } : {}),
-                        ...(Object.hasOwn(p, "offset") ? { offset: p.offset } : {}),
-                    }));
-                    return operationOutcome(result);
-                }
-                case "op.exec": {
-                    // EXEC constructed structurally (no DSL text): the model-facing shape,
-                    // proposal-gated by the engine like any client op.
-                    if (typeof p.command !== "string" || p.command.length === 0) {
-                        return actionFailure("invalid-action-parameters", "op.exec requires a non-empty command.", 400, { field: "command", recovery: "Provide the command to execute." });
-                    }
-                    const statement = {
-                        op: "EXEC", delimiter: "", annotation: null, signal: null, target: null,
-                        metadata: null, lineMarker: null, body: p.command, position: UNKNOWN_POSITION,
-                    };
-                    // Client ops journal as client-origin turns in the client worker (worker split:
-                    // only LOOPS live in the model worker) and execute in the attached Worker's
-                    // Functionality ({§actor-boundary-attached-functionality}).
-                    const [result] = await this.#seam.dispatchClientAction({
-                        workspaceId: world.workspaceId,
-                        workerId: world.workerId,
-                        functionalityWorkerId: conversationWorkerId ?? await this.#seam.ensureModelWorker(world.workspaceId),
-                        statements: [statement],
-                    });
-                    if (result === undefined)
-                        throw new Error("op.exec dispatch returned no operation result");
-                    return operationOutcome(result);
-                }
-                case "op.parse": {
-                    // Raw DSL is parsed at the module's edge; statements and parser facts project
-                    // through one ordered result contract. {§agui-op-parse}
-                    if (typeof p.text !== "string" || p.text.length === 0) {
-                        return actionFailure("invalid-action-parameters", "op.parse requires non-empty PLURNK text.", 400, { field: "text", recovery: "Provide PLURNK statements to parse." });
-                    }
-                    const parsed = PlurnkParser.parseClient(p.text);
-                    const results = [];
-                    const statements = [];
-                    for (const item of parsed.items) {
-                        if (item.kind === "error") {
-                            results.push(parseFailureResult({
-                                detail: item.error.message,
-                                line: item.error.line,
-                                column: item.error.column,
-                                source: item.error.source,
-                                severity: item.error.severity,
-                            }));
-                            continue;
-                        }
-                        if (item.kind !== "statement")
-                            continue; // interstitial text isn't dispatchable
-                        statements.push(item.statement);
-                        results.push(null);
-                    }
-                    if (parsed.unparsedTail !== undefined) {
-                        results.push(parseFailureResult({
-                            detail: parsed.unparsedTail.reason,
-                            line: parsed.unparsedTail.from.line,
-                            column: parsed.unparsedTail.from.column,
-                            source: "grammar",
-                            severity: "error",
-                        }));
-                    }
-                    const dispatched = statements.length === 0
-                        ? []
-                        : await this.#seam.dispatchClientAction({
-                            workspaceId: world.workspaceId,
-                            workerId: world.workerId,
-                            functionalityWorkerId: conversationWorkerId ?? await this.#seam.ensureModelWorker(world.workspaceId),
-                            statements,
-                        });
-                    let index = 0;
-                    for (let i = 0; i < results.length; i++) {
-                        if (results[i] === null)
-                            results[i] = dispatched[index++];
-                    }
-                    return { ok: true, result: { results } };
-                }
-                case "op.look": {
-                    // {§agui-op-look}
-                    if (typeof p.text !== "string" || p.text.length === 0) {
-                        return actionFailure("invalid-action-parameters", "op.look requires non-empty PLURNK text.", 400, { field: "text", recovery: "Provide one PLURNK statement to observe." });
-                    }
-                    const parsed = PlurnkParser.parseClient(p.text);
-                    const diagnostic = parsed.items.find((item) => item.kind === "error");
-                    if (diagnostic !== undefined && diagnostic.kind === "error") {
-                        return operationOutcome(parseFailureResult({
-                            detail: diagnostic.error.message,
-                            line: diagnostic.error.line,
-                            column: diagnostic.error.column,
-                            source: diagnostic.error.source,
-                            severity: diagnostic.error.severity,
-                        }));
-                    }
-                    if (parsed.unparsedTail !== undefined) {
-                        return operationOutcome(parseFailureResult({
-                            detail: parsed.unparsedTail.reason,
-                            line: parsed.unparsedTail.from.line,
-                            column: parsed.unparsedTail.from.column,
-                            source: "grammar",
-                            severity: "error",
-                        }));
-                    }
-                    const textItem = parsed.items.find((item) => item.kind === "text");
-                    if (textItem !== undefined && textItem.kind === "text") {
-                        return actionFailure("invalid-action-parameters", "op.look parsed text outside the statement; only surrounding whitespace is allowed.", 400, {
-                            field: "text",
-                            line: textItem.position.line,
-                            column: textItem.position.column,
-                            recovery: "Remove text outside the LOOK statement.",
-                        });
-                    }
-                    const statements = parsed.items.filter((item) => item.kind === "statement");
-                    if (statements.length !== 1) {
-                        return actionFailure("invalid-action-parameters", `op.look parsed ${statements.length} statements; exactly one LOOK statement is required.`, 400, { field: "text", recovery: "Provide exactly one valid LOOK statement." });
-                    }
-                    const [item] = statements;
-                    if (item.statement.op !== "LOOK") {
-                        return actionFailure("invalid-action-parameters", `op.look parsed ${item.statement.op}; the single statement must be LOOK.`, 400, { field: "text", recovery: "Use LOOK as the observation operation." });
-                    }
-                    const statement = { ...item.statement, op: "READ" };
-                    return operationOutcome(await this.#seam.look({
-                        workspaceId: world.workspaceId,
-                        workerId: world.workerId,
-                        functionalityWorkerId: conversationWorkerId ?? await this.#seam.ensureModelWorker(world.workspaceId),
-                        statement,
-                    }));
-                }
-                case "run.fork": return { ok: true, result: await this.#seam.forkWorker({ workspaceId: world.workspaceId, workerId: conversationWorkerId ?? await this.#seam.ensureModelWorker(world.workspaceId), ...(typeof p.name === "string" ? { name: p.name } : {}) }) };
-                case "worker.model.get": {
-                    const { model, spawnModel } = await this.#seam.readWorkerModel({
-                        workspaceId: world.workspaceId,
-                        workerId: conversationWorkerId ?? await this.#seam.ensureModelWorker(world.workspaceId),
-                    });
-                    return { ok: true, result: { model, spawnModel } };
-                }
-                case "worker.model.set": {
-                    if (typeof p.selector !== "string" || p.selector.length === 0) {
-                        return actionFailure("invalid-action-parameters", "worker.model.set requires a selector.", 400, { recovery: "Provide a declared alias or provider/model route." });
-                    }
-                    return { ok: true, result: await this.#seam.setWorkerModel({
-                            workspaceId: world.workspaceId,
-                            workerId: conversationWorkerId ?? await this.#seam.ensureModelWorker(world.workspaceId),
-                            selector: p.selector,
-                        }) };
-                }
-                case "worker.child.set": {
-                    if (!Object.hasOwn(p, "selector")
-                        || (p.selector !== null && (typeof p.selector !== "string" || p.selector.length === 0))) {
-                        return actionFailure("invalid-action-parameters", "worker.child.set requires a selector.", 400, { recovery: "Provide a declared alias or provider/model route; null means inherit." });
-                    }
-                    return { ok: true, result: await this.#seam.setWorkerSpawnModel({
-                            workspaceId: world.workspaceId,
-                            workerId: conversationWorkerId ?? await this.#seam.ensureModelWorker(world.workspaceId),
-                            selector: p.selector,
-                        }) };
-                }
-                case "worker.reasoning.get": {
-                    return { ok: true, result: await this.#seam.readWorkerReasoning({
-                            workspaceId: world.workspaceId,
-                            workerId: conversationWorkerId ?? await this.#seam.ensureModelWorker(world.workspaceId),
-                        }) };
-                }
-                case "worker.reasoning.set": {
-                    if (!Object.hasOwn(p, "policy")) {
-                        return actionFailure("invalid-action-parameters", "worker.reasoning.set requires a policy.", 400, { recovery: "Provide a reasoning policy." });
-                    }
-                    return { ok: true, result: await this.#seam.setWorkerReasoning({
-                            workspaceId: world.workspaceId,
-                            workerId: conversationWorkerId ?? await this.#seam.ensureModelWorker(world.workspaceId),
-                            policy: p.policy,
-                        }) };
-                }
-                case "worker.capabilities.get": {
-                    return { ok: true, result: await this.#seam.readWorkerCapabilities({
-                            workspaceId: world.workspaceId,
-                            workerId: conversationWorkerId ?? await this.#seam.ensureModelWorker(world.workspaceId),
-                        }) };
-                }
-                case "worker.capabilities.set": {
-                    return { ok: true, result: await this.#seam.setWorkerCapabilities({
-                            workspaceId: world.workspaceId,
-                            workerId: conversationWorkerId ?? await this.#seam.ensureModelWorker(world.workspaceId),
-                            policy: p.policy,
-                        }) };
-                }
-                default: throw new Error(`AG-UI built-in '${kind}' has no executor`);
-            }
-        }
-        catch (err) {
-            const problem = problemFromError(err);
-            if (problem !== null)
-                return { ok: false, problem };
-            console.error(`AG-UI action '${kind}' failed:`, err);
-            return actionFailure("action-failed", "The action failed unexpectedly.", 500);
-        }
-    }
-    static #body(req) {
-        return new Promise((resolve, reject) => {
-            let data = "";
-            req.on("data", (c) => { data += c.toString(); });
-            req.on("end", () => resolve(data));
-            req.on("error", reject);
-        });
-    }
 }
 _a = Module;
 export default Module;