@adonis-agora/agent 0.47.0 → 0.49.0

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @adonis-agora/agent
 
+## 0.49.0
+
+### Minor Changes
+
+- [#222](https://github.com/DavideCarvalho/adonis-agora-agent/pull/222) [`241bfdc`](https://github.com/DavideCarvalho/adonis-agora-agent/commit/241bfdc298373052435890daa4513597e046377d) Thanks [@DavideCarvalho](https://github.com/DavideCarvalho)! - The chat contract `@dudousxd/nestjs-agent` settled (its `docs/stream-protocol.md`), ported:
+  
+  - **Refusals answer `{ message, code? }` (BREAKING for readers of `error`).** Every refused request on the agent routes (and the dashboard's asset route) answers its status with `{ message, code? }` instead of `{ error }` — `code` where there is a machine-readable reason (`unauthorized`, `model_not_allowed`, `thread_required`, `quota_exceeded`). `@adonis-agora/agent/client` now throws a refused send as `AgentChatHttpError` (`status`, `code`, `body`, and the server's `message` as its own message) instead of a bare `Error('Failed to start agent chat (HTTP n).')`.
+  - **A send's `model` is that turn's only** — never stored on the thread; `PATCH threads/:id { model }` is the only pin (documented and tested; the service already behaved this way).
+  - **Regenerate.** `POST chat { threadId, regenerate: true }` answers the thread's last user message again: `400 thread_required` without a thread, `message` ignored, no user message stored, the answer(s) after it dropped (a new `regenerate:truncate` durable step — normal turns journal exactly what they did), a new run. `AgentRunInput.regenerate` replaces the unused `isRegenerate`; `RegenerateNeedsThreadError` is exported.
+  - **Model lock.** `ModelCatalogView.locked: { model, reason? }` runs every turn of that agent on `locked.model` and refuses a send naming another (`400 model_not_allowed`); `GET agents` entries carry `lockedModel` (`AgentCatalogEntry`). `listAgents(actor)` is now async.
+  - **Quota soft limit and USD-only windows.** `QuotaWindow.usedTokens` is optional; `QuotaWindow.warnAt`, `QuotaReport.warning: { period, ratio, reason? }` (never while blocked), `quotaWarning(windows)`, `quotaUsedRatio(window)`; `quota: { limits, warnAt }` stamps it on the ledger windows (`LedgerQuotaProvider`'s new `options.warnAt`). `exhaustedWindow` reads a missing `usedTokens` as `0`.
+  - **Who answered a question.** `POST tool-call/answer|skip` take `via?` (1–64 characters, `'web'` by default; `400` otherwise); the settled outcome carries `answeredBy` / `answeredVia` (`ElicitationReply.answeredVia`, `ElicitationOutcome.answeredBy|answeredVia`), streamed as the call's `tool-output` and persisted with its result.
+  - **`GET tools?agent=*`** (`ALL_AGENTS`) answers the union across every agent, each tool once, under the same gates; an unknown name is still `404`.
+  - **Frame ids.** `SseEvent.id` (the client parser now keeps the `id:` line). Ids stay strictly increasing within a run; readers must tolerate gaps.
+
+## 0.48.0
+
+### Minor Changes
+
+- [#220](https://github.com/DavideCarvalho/adonis-agora-agent/pull/220) [`17ea478`](https://github.com/DavideCarvalho/adonis-agora-agent/commit/17ea478a7531d15bf42b87335036ed04e319ccab) Thanks [@DavideCarvalho](https://github.com/DavideCarvalho)! - **BREAKING — the agent stream protocol is the only wire.** `POST /agent/chat` and `GET /agent/chat/:runId/stream` always write the chat stream protocol shared with `@dudousxd/nestjs-agent`: `event: meta`, then one numbered `AgentStreamEvent` per `data:` frame (`{"kind":"text","text":…}`, `ui`, `elicitation`, `approval-requested`, reasoning, tool calls, steps, title, …), then `event: done` — or `event: error` `{ code, message }` for a failed run. `@dudousxd/nestjs-agent-react` and `@adonis-agora/agent/client` / `./react` read it unchanged.
+  
+  - **The `'legacy'` envelope is removed** — `data: {"delta":…}` text, the named `event: component` / `event: elicitation` / `event: approval` frames and the `[error]` text delta are no longer written, and `@adonis-agora/agent/client`'s `decodeFrame` no longer reads them (a `{"delta"}` payload decodes to `null`).
+  - **The `streamProtocol` option is removed** from `defineConfig`, with no shim: delete `streamProtocol: 'agent'` from `config/agent.ts`; if you relied on the old `'legacy'` default, move the browser to `@adonis-agora/agent/client` (or `./react`, or `@dudousxd/nestjs-agent-react`) or read `{"kind":"text","text":…}` where you read `{"delta":…}`.
+  - **`frameToSse` and the `StreamProtocol` type are no longer exported.** Use `AgentSseEncoder` (or the pure `frameToEvents`).
+  
+  `ChatFrame` / `ChatPart` / `foldPart` are unchanged, so code built on the package client needs no change beyond the server config.
+
 ## 0.47.0
 
 ### Minor Changes

package/dist/providers/agent_provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent_provider.d.ts","sourceRoot":"","sources":["../../providers/agent_provider.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAoJ/D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,OAAO,OAAO,aAAa;;IAMpB,SAAS,CAAC,GAAG,EAAE,kBAAkB;IAA7C,YAAsB,GAAG,EAAE,kBAAkB,EAAI;IAEjD,QAAQ,SAcP;IAEK,IAAI,kBAiJT;IAEK,QAAQ,kBASb;CAynCF"}
+{"version":3,"file":"agent_provider.d.ts","sourceRoot":"","sources":["../../providers/agent_provider.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AA4J/D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,OAAO,OAAO,aAAa;;IAMpB,SAAS,CAAC,GAAG,EAAE,kBAAkB;IAA7C,YAAsB,GAAG,EAAE,kBAAkB,EAAI;IAEjD,QAAQ,SAcP;IAEK,IAAI,kBAsJT;IAEK,QAAQ,kBASb;CAqpCF"}

package/dist/providers/agent_provider.js

@@ -1,5 +1,5 @@
 import { pathToFileURL } from 'node:url';
-import { AgentDepsFactory, AgentGenui, AgentRegistry, AgentService, AgentSseEncoder, AnonymousActorResolver, AttachmentRefusedError, DefaultToolAuthorizer, discoverTools, evaluateGovernanceGate, evaluateOwnership, frameToSse, governanceQueries as governanceQueriesFactories, HumanReplyMismatchError, InlineAgentRunner, InProcessTokenStreamSink, isQuotaProvider, LedgerQuotaProvider, lucidStoreConnection, ModelNotAllowedError, memoryForgetVerdict, offerMemories, parseStreamCursor, pricingStores, QuotaBlockedError, REQUESTER_APPROVER, registerDelegateTools, registerFunctionalTool, registerToolsFromBarrel, resolveActorResolver, ToolRegistry, toApprovalPolicy, toModelCatalog, withActorLabel, withActorLabels, } from '../src/index.js';
+import { AgentDepsFactory, AgentGenui, AgentRegistry, AgentService, AgentSseEncoder, ALL_AGENTS, AnonymousActorResolver, AttachmentRefusedError, DefaultToolAuthorizer, discoverTools, evaluateGovernanceGate, evaluateOwnership, governanceQueries as governanceQueriesFactories, HumanReplyMismatchError, InlineAgentRunner, InProcessTokenStreamSink, isQuotaProvider, LedgerQuotaProvider, lucidStoreConnection, ModelNotAllowedError, memoryForgetVerdict, offerMemories, parseStreamCursor, pricingStores, QuotaBlockedError, REQUESTER_APPROVER, RegenerateNeedsThreadError, registerDelegateTools, registerFunctionalTool, registerToolsFromBarrel, resolveActorResolver, ToolRegistry, toApprovalPolicy, toModelCatalog, withActorLabel, withActorLabels, } from '../src/index.js';
 import { McpToolImporter } from '../src/mcp-client/index.js';
 import { setTelescopeGovernanceQueries } from '../src/telescope/governance-registry.js';
 /** The catalog a model provider carries (`aiSdkModels(…).catalog`), if it carries one. */
@@ -174,7 +174,7 @@ export default class AgentProvider {
             ? undefined
             : isQuotaProvider(config.quota)
                 ? config.quota
-                : new LedgerQuotaProvider(store, undefined, config.quota.limits);
+                : new LedgerQuotaProvider(store, undefined, config.quota.limits, config.quota.warnAt !== undefined ? { warnAt: config.quota.warnAt } : {});
         const pricingStore = await this.#resolvePricing(config);
         // Governance read-model is resolved after pricing so the Lucid read-model prices its rollups
         // against the same live prices the loop's cost fold uses.
@@ -422,7 +422,6 @@ export default class AgentProvider {
             allowedContentTypes: declared.allowedContentTypes ?? DEFAULT_ALLOWED_ATTACHMENT_CONTENT_TYPES,
         };
         const defaultAgentName = config.defaultAgent?.name ?? 'default';
-        const protocol = config.streamProtocol ?? 'legacy';
         // 1. POST /agent/chat — resolve actor, start the run, SSE-pipe the token stream. When the caller
         // continues an EXISTING thread (`body.threadId`), it must own it: otherwise an authenticated caller
         // could pass another actor's threadId to load that thread's full history into the model (read it
@@ -442,15 +441,24 @@ export default class AgentProvider {
                 if (!(await this.#assertOwner(ctx, actor, owner, 'thread', governanceAuthorize)))
                     return;
             }
+            const regenerate = body.regenerate === true;
+            if (regenerate && body.threadId === undefined) {
+                return ctx.response.badRequest({
+                    message: 'regenerate requires an existing threadId',
+                    code: 'thread_required',
+                });
+            }
             const refs = attachmentRefs(body.attachments);
             if (typeof refs === 'string') {
-                return ctx.response.badRequest({ error: refs });
+                return ctx.response.badRequest({ message: refs });
             }
             let started;
             try {
                 started = await service.chat({
                     actor,
-                    message: body.message,
+                    // A regenerate answers the stored user message; whatever `message` says is ignored.
+                    message: regenerate ? '' : body.message,
+                    ...(regenerate ? { regenerate: true } : {}),
                     ...(typeof body.model === 'string' && body.model.length > 0 ? { model: body.model } : {}),
                     ...(body.threadId !== undefined ? { threadId: body.threadId } : {}),
                     ...(body.agent !== undefined ? { agentName: body.agent } : {}),
@@ -461,10 +469,13 @@ export default class AgentProvider {
             }
             catch (error) {
                 if (error instanceof AttachmentRefusedError) {
-                    return ctx.response.status(error.status).json({ error: error.message });
+                    return ctx.response.status(error.status).json({ message: error.message });
                 }
                 if (error instanceof ModelNotAllowedError) {
-                    return ctx.response.badRequest({ error: error.message });
+                    return ctx.response.badRequest({ message: error.message, code: 'model_not_allowed' });
+                }
+                if (error instanceof RegenerateNeedsThreadError) {
+                    return ctx.response.badRequest({ message: error.message, code: 'thread_required' });
                 }
                 if (error instanceof QuotaBlockedError) {
                     return ctx.response.status(429).json({
@@ -475,7 +486,7 @@ export default class AgentProvider {
                 }
                 throw error;
             }
-            await this.#pipe(ctx, service, protocol, started.runId, started.threadId);
+            await this.#pipe(ctx, service, started.runId, started.threadId);
         });
         // 2. GET /agent/chat/:runId/stream — re-attach SSE. Authenticated: the actor resolver reads the
         // request's session/cookies (an EventSource can't set headers), 401 on failure — so an anonymous
@@ -491,14 +502,14 @@ export default class AgentProvider {
             // Nothing buffered under the run — it ended while the client was away, or its buffer went with
             // a restarted process. A 404 reads as "nothing to resume"; subscribing would wait forever.
             if (!(await service.hasStream(runId))) {
-                return ctx.response.notFound({ error: 'Nothing is streaming under that run.' });
+                return ctx.response.notFound({ message: 'Nothing is streaming under that run.' });
             }
             // `?after=<seq>` (or the `Last-Event-ID` a browser EventSource sends on its own) skips the
             // events a reconnecting client already has; `after` wins when both are present.
             const after = parseStreamCursor(ctx.request.qs().after) ??
                 parseStreamCursor(ctx.request.header('last-event-id')) ??
                 0;
-            await this.#pipe(ctx, service, protocol, runId, undefined, after);
+            await this.#pipe(ctx, service, runId, undefined, after);
         });
         // 3. POST /agent/chat/:runId/cancel — authenticated + owner-scoped (a caller cancels only its own
         // runs, unless governance-privileged).
@@ -525,7 +536,7 @@ export default class AgentProvider {
             const via = decisionVia(body.via);
             if (remember === null || via === null) {
                 return ctx.response.badRequest({
-                    error: `remember must be a boolean and via a string of 1-${MAX_VIA_LENGTH} characters`,
+                    message: `remember must be a boolean and via a string of 1-${MAX_VIA_LENGTH} characters`,
                 });
             }
             const runId = await this.#runOfToolCall(ctx, service, body);
@@ -545,7 +556,7 @@ export default class AgentProvider {
             const via = decisionVia(body.via);
             if (via === null) {
                 return ctx.response.badRequest({
-                    error: `via must be a string of 1-${MAX_VIA_LENGTH} characters`,
+                    message: `via must be a string of 1-${MAX_VIA_LENGTH} characters`,
                 });
             }
             const runId = await this.#runOfToolCall(ctx, service, body);
@@ -564,6 +575,12 @@ export default class AgentProvider {
             if (actor === null)
                 return;
             const body = (ctx.request.body() ?? {});
+            const via = decisionVia(body.via);
+            if (via === null) {
+                return ctx.response.badRequest({
+                    message: `via must be a string of 1-${MAX_VIA_LENGTH} characters`,
+                });
+            }
             const runId = await this.#runOfToolCall(ctx, service, body);
             if (runId === null)
                 return;
@@ -574,7 +591,7 @@ export default class AgentProvider {
             // the person who typed it hears why — rather than signalled and quietly dropped by the loop.
             const problem = await service.answerProblem(body.toolCallId, body.answers ?? {});
             if (problem !== null) {
-                return ctx.response.badRequest({ error: problem });
+                return ctx.response.badRequest({ message: problem });
             }
             try {
                 await service.answer({
@@ -582,6 +599,7 @@ export default class AgentProvider {
                     toolCallId: body.toolCallId,
                     answers: body.answers ?? {},
                     answeredByRef: actor.id,
+                    answeredVia: via,
                 });
             }
             catch (error) {
@@ -596,6 +614,12 @@ export default class AgentProvider {
             if (actor === null)
                 return;
             const body = (ctx.request.body() ?? {});
+            const via = decisionVia(body.via);
+            if (via === null) {
+                return ctx.response.badRequest({
+                    message: `via must be a string of 1-${MAX_VIA_LENGTH} characters`,
+                });
+            }
             const runId = await this.#runOfToolCall(ctx, service, body);
             if (runId === null)
                 return;
@@ -607,6 +631,7 @@ export default class AgentProvider {
                     runId,
                     toolCallId: body.toolCallId,
                     answeredByRef: actor.id,
+                    answeredVia: via,
                 });
             }
             catch (error) {
@@ -631,11 +656,11 @@ export default class AgentProvider {
             const threadId = await service.threadOfMessage(messageId);
             if (threadId === undefined) {
                 return ctx.response.status(501).json({
-                    error: 'Message feedback requires an AgentStore that implements threadOfMessage() and setMessageFeedback().',
+                    message: 'Message feedback requires an AgentStore that implements threadOfMessage() and setMessageFeedback().',
                 });
             }
             if (threadId === null) {
-                return ctx.response.notFound({ error: 'message not found' });
+                return ctx.response.notFound({ message: 'message not found' });
             }
             const owner = await service.threadOwner(threadId);
             if (!(await this.#assertOwner(ctx, actor, owner, 'thread', undefined)))
@@ -646,7 +671,7 @@ export default class AgentProvider {
                 ...(body.comment !== undefined ? { comment: body.comment } : {}),
             });
             if (!result.ok) {
-                return ctx.response.status(result.status).json({ error: result.error });
+                return ctx.response.status(result.status).json({ message: result.error });
             }
             return ctx.response.json({ feedback: result.feedback });
         });
@@ -664,16 +689,23 @@ export default class AgentProvider {
             const actor = await this.#resolveActor(ctx, actorResolver);
             if (actor === null)
                 return;
-            return ctx.response.json(service.listAgents());
+            return ctx.response.json(await service.listAgents(actor));
         });
         // 6b. GET /agent/tools?agent= — the tools this caller can reach through an agent, with how a chat
         // surface should talk about each (`presentation`). The same list the model is offered; nothing the
         // caller passes widens it — `agent` only narrows to that agent's allow-list, and an unknown name is
-        // a 404 rather than the widest answer (no allow-list at all).
+        // a 404 rather than the widest answer (no allow-list at all). `?agent=*` is the union across every
+        // agent: each tool this caller reaches through any of them, once, under the same gates.
         router.get(p('tools'), async (ctx) => {
             const agent = ctx.request.qs().agent;
+            if (agent === ALL_AGENTS) {
+                const actor = await this.#resolveActor(ctx, actorResolver);
+                if (actor === null)
+                    return;
+                return ctx.response.json(await service.toolCatalogForAllAgents(actor));
+            }
             if (agent !== undefined && agent !== defaultAgentName && agents.get(agent) === undefined) {
-                return ctx.response.notFound({ error: `No agent named "${agent}"` });
+                return ctx.response.notFound({ message: `No agent named "${agent}"` });
             }
             const actor = await this.#resolveActor(ctx, resolveActorResolver(actorResolver, agents.get(agent ?? defaultAgentName)));
             if (actor === null)
@@ -713,20 +745,20 @@ export default class AgentProvider {
                 return;
             const body = (ctx.request.body() ?? {});
             if (body.model !== undefined && body.model !== null && typeof body.model !== 'string') {
-                return ctx.response.badRequest({ error: 'model must be a string or null' });
+                return ctx.response.badRequest({ message: 'model must be a string or null' });
             }
             if (body.model !== undefined) {
                 try {
                     const pinned = await service.setThreadModel(actor, threadId, body.model);
                     if (!pinned) {
                         return ctx.response.status(501).json({
-                            error: "Pinning a thread's model requires an AgentStore that implements updateThread().",
+                            message: "Pinning a thread's model requires an AgentStore that implements updateThread().",
                         });
                     }
                 }
                 catch (error) {
                     if (error instanceof ModelNotAllowedError) {
-                        return ctx.response.badRequest({ error: error.message });
+                        return ctx.response.badRequest({ message: error.message });
                     }
                     throw error;
                 }
@@ -734,7 +766,7 @@ export default class AgentProvider {
             if (body.title !== undefined) {
                 const title = typeof body.title === 'string' ? body.title.trim() : '';
                 if (title.length === 0 || title.length > 200) {
-                    return ctx.response.badRequest({ error: 'title must be a string of 1-200 characters' });
+                    return ctx.response.badRequest({ message: 'title must be a string of 1-200 characters' });
                 }
                 await service.renameThread(threadId, title);
             }
@@ -799,16 +831,16 @@ export default class AgentProvider {
             if (actor === null)
                 return;
             if (memory === undefined) {
-                return ctx.response.notFound({ error: 'No memory is configured in this deployment.' });
+                return ctx.response.notFound({ message: 'No memory is configured in this deployment.' });
             }
             const id = String(ctx.params.id);
             const entry = (await everyMemoryOf(actor)).entries.find((candidate) => candidate.id === id);
             if (entry === undefined) {
-                return ctx.response.notFound({ error: `No memory with id "${id}".` });
+                return ctx.response.notFound({ message: `No memory with id "${id}".` });
             }
             const verdict = memoryForgetVerdict({ record: entry, actor });
             if (!verdict.allowed) {
-                return ctx.response.forbidden({ error: verdict.reason });
+                return ctx.response.forbidden({ message: verdict.reason });
             }
             return ctx.response.json({
                 forgotten: await memory.provider.forget({ id: entry.id, ctx: { actor, threadId: '' } }),
@@ -857,19 +889,19 @@ export default class AgentProvider {
                     return;
                 const file = ctx.request.file('file');
                 if (file === null || file.tmpPath === undefined) {
-                    return ctx.response.status(400).json({ error: 'multipart field "file" is required' });
+                    return ctx.response.status(400).json({ message: 'multipart field "file" is required' });
                 }
                 const contentType = file.headers?.['content-type']?.split(';')[0]?.trim() ?? `${file.type}/${file.subtype}`;
                 if (!allowedContentTypes.includes(contentType)) {
                     return ctx.response.status(415).json({
-                        error: `content type "${contentType}" is not allowed (allowed: ${allowedContentTypes.join(', ')})`,
+                        message: `content type "${contentType}" is not allowed (allowed: ${allowedContentTypes.join(', ')})`,
                     });
                 }
                 const sizeBytes = file.size;
                 if (sizeBytes > maxBytes) {
                     return ctx.response
                         .status(413)
-                        .json({ error: `file exceeds the ${maxBytes}-byte limit` });
+                        .json({ message: `file exceeds the ${maxBytes}-byte limit` });
                 }
                 const { readFile } = await import('node:fs/promises');
                 const data = await readFile(file.tmpPath);
@@ -986,7 +1018,7 @@ export default class AgentProvider {
                 if (gov.threadDetail === undefined) {
                     return ctx.response
                         .status(501)
-                        .json({ error: 'this governance adapter does not support thread detail' });
+                        .json({ message: 'this governance adapter does not support thread detail' });
                 }
                 const detail = await withActorLabel(await gov.threadDetail(String(ctx.params.id)), actorDirectory);
                 if (detail === null)
@@ -1102,7 +1134,7 @@ export default class AgentProvider {
                         typeof body.inputPricePer1m !== 'number' ||
                         typeof body.outputPricePer1m !== 'number') {
                         return ctx.response.status(400).json({
-                            error: 'body must be {modelId: string, inputPricePer1m: number, outputPricePer1m: number, cacheWritePricePer1m?: number, cacheReadPricePer1m?: number}',
+                            message: 'body must be {modelId: string, inputPricePer1m: number, outputPricePer1m: number, cacheWritePricePer1m?: number, cacheReadPricePer1m?: number}',
                         });
                     }
                     await pricing.upsertModelPrice({
@@ -1131,7 +1163,7 @@ export default class AgentProvider {
         try {
             const actor = await actorResolver.resolve(ctx);
             if (actor === null || actor === undefined) {
-                ctx.response.status(401).json({ error: 'unauthorized' });
+                ctx.response.status(401).json({ message: 'unauthorized', code: 'unauthorized' });
                 return null;
             }
             return actor;
@@ -1141,9 +1173,10 @@ export default class AgentProvider {
             // in production, every request here is untrusted by definition, so the detail stays server-side
             // (dev/test keeps it, matching `evaluateDashboardGate`/`evaluateGovernanceGate`'s `debug` knob).
             const debug = !this.app.inProduction;
-            ctx.response
-                .status(401)
-                .json({ error: debug && error instanceof Error ? error.message : 'unauthorized' });
+            ctx.response.status(401).json({
+                message: debug && error instanceof Error ? error.message : 'unauthorized',
+                code: 'unauthorized',
+            });
             return null;
         }
     }
@@ -1159,7 +1192,7 @@ export default class AgentProvider {
             return null;
         const verdict = await evaluateGovernanceGate(actor, ctx, governanceAuthorize, !this.app.inProduction);
         if (!verdict.ok) {
-            ctx.response.status(verdict.status).json({ error: verdict.error });
+            ctx.response.status(verdict.status).json({ message: verdict.error });
             return null;
         }
         return actor;
@@ -1181,7 +1214,7 @@ export default class AgentProvider {
         const verdict = evaluateOwnership(actor.id, ownerRef, privileged);
         if (!verdict.ok) {
             const error = verdict.status === 404 ? `${kind} not found` : 'forbidden';
-            ctx.response.status(verdict.status).json({ error });
+            ctx.response.status(verdict.status).json({ message: error });
             return false;
         }
         return true;
@@ -1202,7 +1235,7 @@ export default class AgentProvider {
             return body.runId;
         const runId = typeof body.toolCallId === 'string' ? await service.toolCallRun(body.toolCallId) : null;
         if (runId === null) {
-            ctx.response.notFound({ error: 'Unknown tool call.' });
+            ctx.response.notFound({ message: 'Unknown tool call.' });
             return null;
         }
         return runId;
@@ -1226,11 +1259,11 @@ export default class AgentProvider {
         }
         else {
             if (owner === null) {
-                ctx.response.notFound({ error: 'Unknown run.' });
+                ctx.response.notFound({ message: 'Unknown run.' });
                 return false;
             }
             if (!(await service.mayDecide(actor, { toolCallId, approver, requesterRef: owner }))) {
-                ctx.response.forbidden({ error: `This approval is for ${approver}.` });
+                ctx.response.forbidden({ message: `This approval is for ${approver}.` });
                 return false;
             }
         }
@@ -1240,7 +1273,9 @@ export default class AgentProvider {
                     approval.expiresAt !== null &&
                     Date.parse(approval.expiresAt) <= Date.now()));
         if (lapsed) {
-            ctx.response.gone({ error: `The approval request for tool call ${toolCallId} has expired.` });
+            ctx.response.gone({
+                message: `The approval request for tool call ${toolCallId} has expired.`,
+            });
             return false;
         }
         return true;
@@ -1249,7 +1284,7 @@ export default class AgentProvider {
         if (!(error instanceof HumanReplyMismatchError)) {
             throw error;
         }
-        ctx.response.conflict({ error: error.message });
+        ctx.response.conflict({ message: error.message });
     }
     /**
      * Pipe the run's live token stream to the client as SSE: `event: meta` (runId/threadId), the run's
@@ -1257,12 +1292,11 @@ export default class AgentProvider {
      * raw Node response directly (Adonis has no SSE helper) and ends only on stream completion — the
      * sink closes on run finish, not on suspend.
      *
-     * The sink carries typed `StreamFrame`s; `protocol` picks the envelope they are written in. Under
-     * `'agent'` each frame becomes the `AgentStreamEvent`s it stands for (`AgentSseEncoder`) and a
-     * failure ends the stream with `event: error` instead of `done`; under `'legacy'` `frameToSse`
-     * writes the original `data: {"delta":...}` / `event: component` envelope byte-for-byte.
+     * The sink carries typed `StreamFrame`s; each becomes the `AgentStreamEvent`s it stands for
+     * (`AgentSseEncoder`, the protocol shared with `@dudousxd/nestjs-agent`), and a failure ends the
+     * stream with `event: error` instead of `done`.
      */
-    async #pipe(ctx, service, protocol, runId, threadId, after = 0) {
+    async #pipe(ctx, service, runId, threadId, after = 0) {
         const raw = ctx.response.response;
         const headers = {
             'Content-Type': 'text/event-stream',
@@ -1281,23 +1315,13 @@ export default class AgentProvider {
         }
         raw.writeHead(200, headers);
         raw.write(`event: meta\ndata: ${JSON.stringify({ runId, threadId })}\n\n`);
-        if (protocol === 'agent') {
-            const encoder = new AgentSseEncoder(after);
-            for await (const frame of service.subscribe(runId)) {
-                const text = encoder.encode(frame);
-                if (text.length > 0)
-                    raw.write(text);
-            }
-            raw.write(encoder.close());
-            raw.end();
-            return;
-        }
+        const encoder = new AgentSseEncoder(after);
         for await (const frame of service.subscribe(runId)) {
-            const text = frameToSse(frame);
+            const text = encoder.encode(frame);
             if (text.length > 0)
                 raw.write(text);
         }
-        raw.write('event: done\ndata: {}\n\n');
+        raw.write(encoder.close());
         raw.end();
     }
 }