@dexto/server 1.6.16 → 1.6.17

package/dist/hono/routes/a2a-tasks.d.ts

@@ -38,6 +38,7 @@ export declare function createA2ATasksRouter(getAgent: GetAgentFn, sseSubscriber
                 json: {
                     message: {
                         role: "user" | "agent";
+                        messageId: string;
                         kind: "message";
                         parts: ({
                             text: string;
@@ -60,7 +61,6 @@ export declare function createA2ATasksRouter(getAgent: GetAgentFn, sseSubscriber
                             kind: "data";
                             metadata?: Record<string, any> | undefined;
                         })[];
-                        messageId: string;
                         metadata?: Record<string, any> | undefined;
                         taskId?: string | undefined;
                         contextId?: string | undefined;
@@ -84,6 +84,7 @@ export declare function createA2ATasksRouter(getAgent: GetAgentFn, sseSubscriber
                     state: "unknown" | "failed" | "auth-required" | "submitted" | "working" | "input-required" | "completed" | "canceled" | "rejected";
                     message?: {
                         role: "user" | "agent";
+                        messageId: string;
                         kind: "message";
                         parts: ({
                             text: string;
@@ -114,7 +115,6 @@ export declare function createA2ATasksRouter(getAgent: GetAgentFn, sseSubscriber
                                 [x: string]: any;
                             } | undefined;
                         })[];
-                        messageId: string;
                         metadata?: {
                             [x: string]: any;
                         } | undefined;
@@ -133,6 +133,7 @@ export declare function createA2ATasksRouter(getAgent: GetAgentFn, sseSubscriber
                 } | undefined;
                 history?: {
                     role: "user" | "agent";
+                    messageId: string;
                     kind: "message";
                     parts: ({
                         text: string;
@@ -163,7 +164,6 @@ export declare function createA2ATasksRouter(getAgent: GetAgentFn, sseSubscriber
                             [x: string]: any;
                         } | undefined;
                     })[];
-                    messageId: string;
                     metadata?: {
                         [x: string]: any;
                     } | undefined;
@@ -198,6 +198,7 @@ export declare function createA2ATasksRouter(getAgent: GetAgentFn, sseSubscriber
                         state: "unknown" | "failed" | "auth-required" | "submitted" | "working" | "input-required" | "completed" | "canceled" | "rejected";
                         message?: {
                             role: "user" | "agent";
+                            messageId: string;
                             kind: "message";
                             parts: ({
                                 text: string;
@@ -228,7 +229,6 @@ export declare function createA2ATasksRouter(getAgent: GetAgentFn, sseSubscriber
                                     [x: string]: any;
                                 } | undefined;
                             })[];
-                            messageId: string;
                             metadata?: {
                                 [x: string]: any;
                             } | undefined;
@@ -247,6 +247,7 @@ export declare function createA2ATasksRouter(getAgent: GetAgentFn, sseSubscriber
                     } | undefined;
                     history?: {
                         role: "user" | "agent";
+                        messageId: string;
                         kind: "message";
                         parts: ({
                             text: string;
@@ -277,7 +278,6 @@ export declare function createA2ATasksRouter(getAgent: GetAgentFn, sseSubscriber
                                 [x: string]: any;
                             } | undefined;
                         })[];
-                        messageId: string;
                         metadata?: {
                             [x: string]: any;
                         } | undefined;
@@ -318,6 +318,7 @@ export declare function createA2ATasksRouter(getAgent: GetAgentFn, sseSubscriber
                     state: "unknown" | "failed" | "auth-required" | "submitted" | "working" | "input-required" | "completed" | "canceled" | "rejected";
                     message?: {
                         role: "user" | "agent";
+                        messageId: string;
                         kind: "message";
                         parts: ({
                             text: string;
@@ -348,7 +349,6 @@ export declare function createA2ATasksRouter(getAgent: GetAgentFn, sseSubscriber
                                 [x: string]: any;
                             } | undefined;
                         })[];
-                        messageId: string;
                         metadata?: {
                             [x: string]: any;
                         } | undefined;
@@ -367,6 +367,7 @@ export declare function createA2ATasksRouter(getAgent: GetAgentFn, sseSubscriber
                 } | undefined;
                 history?: {
                     role: "user" | "agent";
+                    messageId: string;
                     kind: "message";
                     parts: ({
                         text: string;
@@ -397,7 +398,6 @@ export declare function createA2ATasksRouter(getAgent: GetAgentFn, sseSubscriber
                             [x: string]: any;
                         } | undefined;
                     })[];
-                    messageId: string;
                     metadata?: {
                         [x: string]: any;
                     } | undefined;
@@ -434,6 +434,7 @@ export declare function createA2ATasksRouter(getAgent: GetAgentFn, sseSubscriber
                     state: "unknown" | "failed" | "auth-required" | "submitted" | "working" | "input-required" | "completed" | "canceled" | "rejected";
                     message?: {
                         role: "user" | "agent";
+                        messageId: string;
                         kind: "message";
                         parts: ({
                             text: string;
@@ -464,7 +465,6 @@ export declare function createA2ATasksRouter(getAgent: GetAgentFn, sseSubscriber
                                 [x: string]: any;
                             } | undefined;
                         })[];
-                        messageId: string;
                         metadata?: {
                             [x: string]: any;
                         } | undefined;
@@ -483,6 +483,7 @@ export declare function createA2ATasksRouter(getAgent: GetAgentFn, sseSubscriber
                 } | undefined;
                 history?: {
                     role: "user" | "agent";
+                    messageId: string;
                     kind: "message";
                     parts: ({
                         text: string;
@@ -513,7 +514,6 @@ export declare function createA2ATasksRouter(getAgent: GetAgentFn, sseSubscriber
                             [x: string]: any;
                         } | undefined;
                     })[];
-                    messageId: string;
                     metadata?: {
                         [x: string]: any;
                     } | undefined;

package/dist/hono/routes/approvals.cjs

@@ -24,14 +24,85 @@ module.exports = __toCommonJS(approvals_exports);
 var import_zod_openapi = require("@hono/zod-openapi");
 var import_core = require("@dexto/core");
 const ApprovalBodySchema = import_zod_openapi.z.object({
-  status: import_zod_openapi.z.enum([import_core.ApprovalStatus.APPROVED, import_core.ApprovalStatus.DENIED]).describe("The user decision"),
+  status: import_zod_openapi.z.enum([import_core.ApprovalStatus.APPROVED, import_core.ApprovalStatus.DENIED, import_core.ApprovalStatus.CANCELLED]).describe("The user decision"),
   formData: import_zod_openapi.z.record(import_zod_openapi.z.unknown()).optional().describe("Optional form data provided by the user (for elicitation)"),
-  rememberChoice: import_zod_openapi.z.boolean().optional().describe("Whether to remember this choice for future requests")
+  rememberChoice: import_zod_openapi.z.boolean().optional().describe("Whether to remember this choice for future requests"),
+  rememberPattern: import_zod_openapi.z.string().optional().describe("Optional approval pattern to remember for future requests"),
+  rememberDirectory: import_zod_openapi.z.boolean().optional().describe("Whether to remember the approved directory for future requests"),
+  reason: import_zod_openapi.z.nativeEnum(import_core.DenialReason).optional().describe("Optional structured denial or cancellation reason"),
+  message: import_zod_openapi.z.string().optional().describe("Optional freeform denial or cancellation message")
+}).strict().superRefine((value, refinementCtx) => {
+  const addFieldIssue = (path, message) => {
+    refinementCtx.addIssue({
+      code: import_zod_openapi.z.ZodIssueCode.custom,
+      path: [path],
+      message
+    });
+  };
+  if (value.status === import_core.ApprovalStatus.APPROVED) {
+    if (value.reason !== void 0) {
+      addFieldIssue(
+        "reason",
+        "reason is only allowed when status is denied or cancelled"
+      );
+    }
+    if (value.message !== void 0) {
+      addFieldIssue(
+        "message",
+        "message is only allowed when status is denied or cancelled"
+      );
+    }
+    return;
+  }
+  if (value.formData !== void 0) {
+    addFieldIssue("formData", "formData is only allowed when status is approved");
+  }
+  if (value.rememberChoice !== void 0) {
+    addFieldIssue(
+      "rememberChoice",
+      "rememberChoice is only allowed when status is approved"
+    );
+  }
+  if (value.rememberPattern !== void 0) {
+    addFieldIssue(
+      "rememberPattern",
+      "rememberPattern is only allowed when status is approved"
+    );
+  }
+  if (value.rememberDirectory !== void 0) {
+    addFieldIssue(
+      "rememberDirectory",
+      "rememberDirectory is only allowed when status is approved"
+    );
+  }
+  if (value.reason === void 0) {
+    return;
+  }
+  if (value.status === import_core.ApprovalStatus.DENIED) {
+    const invalidReasons2 = /* @__PURE__ */ new Set([
+      import_core.DenialReason.USER_CANCELLED,
+      import_core.DenialReason.SYSTEM_CANCELLED,
+      import_core.DenialReason.TIMEOUT
+    ]);
+    if (invalidReasons2.has(value.reason)) {
+      addFieldIssue("reason", "reason must describe a denial when status is denied");
+    }
+    return;
+  }
+  const invalidReasons = /* @__PURE__ */ new Set([
+    import_core.DenialReason.USER_DENIED,
+    import_core.DenialReason.SYSTEM_DENIED,
+    import_core.DenialReason.VALIDATION_FAILED,
+    import_core.DenialReason.ELICITATION_DISABLED
+  ]);
+  if (invalidReasons.has(value.reason)) {
+    addFieldIssue("reason", "reason must describe a cancellation when status is cancelled");
+  }
 }).describe("Request body for submitting an approval decision");
 const ApprovalResponseSchema = import_zod_openapi.z.object({
   ok: import_zod_openapi.z.boolean().describe("Whether the approval was successfully processed"),
   approvalId: import_zod_openapi.z.string().describe("The ID of the processed approval"),
-  status: import_zod_openapi.z.enum([import_core.ApprovalStatus.APPROVED, import_core.ApprovalStatus.DENIED]).describe("The final status")
+  status: import_zod_openapi.z.enum([import_core.ApprovalStatus.APPROVED, import_core.ApprovalStatus.DENIED, import_core.ApprovalStatus.CANCELLED]).describe("The final status")
 }).describe("Response after processing approval");
 const PendingApprovalSchema = import_zod_openapi.z.object({
   approvalId: import_zod_openapi.z.string().describe("The unique ID of the approval request"),
@@ -126,7 +197,15 @@ function createApprovalsRouter(getAgent, approvalCoordinator) {
   }).openapi(submitApprovalRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { approvalId } = ctx.req.valid("param");
-    const { status, formData, rememberChoice } = ctx.req.valid("json");
+    const {
+      status,
+      formData,
+      rememberChoice,
+      rememberPattern,
+      rememberDirectory,
+      reason,
+      message
+    } = ctx.req.valid("json");
     agent.logger.info(`Received approval decision for ${approvalId}: ${status}`);
     if (!approvalCoordinator) {
       agent.logger.error("ApprovalCoordinator not available");
@@ -145,6 +224,12 @@ function createApprovalsRouter(getAgent, approvalCoordinator) {
         if (rememberChoice !== void 0) {
           data.rememberChoice = rememberChoice;
         }
+        if (rememberPattern !== void 0) {
+          data.rememberPattern = rememberPattern;
+        }
+        if (rememberDirectory !== void 0) {
+          data.rememberDirectory = rememberDirectory;
+        }
       }
       const sessionId = approvalCoordinator.getSessionId(approvalId);
       const responsePayload = {
@@ -153,8 +238,11 @@ function createApprovalsRouter(getAgent, approvalCoordinator) {
         sessionId,
         // Attach sessionId for SSE routing to correct client streams
         ...status === import_core.ApprovalStatus.DENIED ? {
-          reason: import_core.DenialReason.USER_DENIED,
-          message: "User denied the request via API"
+          reason: reason ?? import_core.DenialReason.USER_DENIED,
+          message: message ?? "User denied the request via API"
+        } : status === import_core.ApprovalStatus.CANCELLED ? {
+          reason: reason ?? import_core.DenialReason.USER_CANCELLED,
+          message: message ?? "User cancelled the request via API"
         } : {},
         ...Object.keys(data).length > 0 ? { data } : {}
       };

package/dist/hono/routes/approvals.d.ts

@@ -1,5 +1,5 @@
 import { OpenAPIHono } from '@hono/zod-openapi';
-import { type DextoAgent, ApprovalStatus } from '@dexto/core';
+import { type DextoAgent, DenialReason, ApprovalStatus } from '@dexto/core';
 import type { ApprovalCoordinator } from '../../approval/approval-coordinator.js';
 import type { Context } from 'hono';
 type GetAgentFn = (ctx: Context) => DextoAgent | Promise<DextoAgent>;
@@ -41,9 +41,13 @@ export declare function createApprovalsRouter(getAgent: GetAgentFn, approvalCoor
                 };
             } & {
                 json: {
-                    status: ApprovalStatus.APPROVED | ApprovalStatus.DENIED;
+                    status: ApprovalStatus;
+                    message?: string | undefined;
                     formData?: Record<string, unknown> | undefined;
                     rememberChoice?: boolean | undefined;
+                    rememberPattern?: string | undefined;
+                    rememberDirectory?: boolean | undefined;
+                    reason?: DenialReason | undefined;
                 };
             };
             output: {};
@@ -60,9 +64,13 @@ export declare function createApprovalsRouter(getAgent: GetAgentFn, approvalCoor
                 };
             } & {
                 json: {
-                    status: ApprovalStatus.APPROVED | ApprovalStatus.DENIED;
+                    status: ApprovalStatus;
+                    message?: string | undefined;
                     formData?: Record<string, unknown> | undefined;
                     rememberChoice?: boolean | undefined;
+                    rememberPattern?: string | undefined;
+                    rememberDirectory?: boolean | undefined;
+                    reason?: DenialReason | undefined;
                 };
             };
             output: {};
@@ -79,9 +87,13 @@ export declare function createApprovalsRouter(getAgent: GetAgentFn, approvalCoor
                 };
             } & {
                 json: {
-                    status: ApprovalStatus.APPROVED | ApprovalStatus.DENIED;
+                    status: ApprovalStatus;
+                    message?: string | undefined;
                     formData?: Record<string, unknown> | undefined;
                     rememberChoice?: boolean | undefined;
+                    rememberPattern?: string | undefined;
+                    rememberDirectory?: boolean | undefined;
+                    reason?: DenialReason | undefined;
                 };
             };
             output: {};
@@ -98,13 +110,17 @@ export declare function createApprovalsRouter(getAgent: GetAgentFn, approvalCoor
                 };
             } & {
                 json: {
-                    status: ApprovalStatus.APPROVED | ApprovalStatus.DENIED;
+                    status: ApprovalStatus;
+                    message?: string | undefined;
                     formData?: Record<string, unknown> | undefined;
                     rememberChoice?: boolean | undefined;
+                    rememberPattern?: string | undefined;
+                    rememberDirectory?: boolean | undefined;
+                    reason?: DenialReason | undefined;
                 };
             };
             output: {
-                status: ApprovalStatus.APPROVED | ApprovalStatus.DENIED;
+                status: ApprovalStatus;
                 ok: boolean;
                 approvalId: string;
             };

package/dist/hono/routes/approvals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"approvals.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/approvals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,EAAE,KAAK,UAAU,EAAgB,cAAc,EAAiB,MAAM,aAAa,CAAC;AAC3F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAClF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AA8CrE,wBAAgB,qBAAqB,CACjC,QAAQ,EAAE,UAAU,EACpB,mBAAmB,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAgK5C"}
+{"version":3,"file":"approvals.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/approvals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,EAAE,KAAK,UAAU,EAAE,YAAY,EAAE,cAAc,EAAiB,MAAM,aAAa,CAAC;AAC3F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAClF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAqIrE,wBAAgB,qBAAqB,CACjC,QAAQ,EAAE,UAAU,EACpB,mBAAmB,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAmL5C"}

package/dist/hono/routes/approvals.js

@@ -1,14 +1,85 @@
 import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
 import { DenialReason, ApprovalStatus, ApprovalError } from "@dexto/core";
 const ApprovalBodySchema = z.object({
-  status: z.enum([ApprovalStatus.APPROVED, ApprovalStatus.DENIED]).describe("The user decision"),
+  status: z.enum([ApprovalStatus.APPROVED, ApprovalStatus.DENIED, ApprovalStatus.CANCELLED]).describe("The user decision"),
   formData: z.record(z.unknown()).optional().describe("Optional form data provided by the user (for elicitation)"),
-  rememberChoice: z.boolean().optional().describe("Whether to remember this choice for future requests")
+  rememberChoice: z.boolean().optional().describe("Whether to remember this choice for future requests"),
+  rememberPattern: z.string().optional().describe("Optional approval pattern to remember for future requests"),
+  rememberDirectory: z.boolean().optional().describe("Whether to remember the approved directory for future requests"),
+  reason: z.nativeEnum(DenialReason).optional().describe("Optional structured denial or cancellation reason"),
+  message: z.string().optional().describe("Optional freeform denial or cancellation message")
+}).strict().superRefine((value, refinementCtx) => {
+  const addFieldIssue = (path, message) => {
+    refinementCtx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: [path],
+      message
+    });
+  };
+  if (value.status === ApprovalStatus.APPROVED) {
+    if (value.reason !== void 0) {
+      addFieldIssue(
+        "reason",
+        "reason is only allowed when status is denied or cancelled"
+      );
+    }
+    if (value.message !== void 0) {
+      addFieldIssue(
+        "message",
+        "message is only allowed when status is denied or cancelled"
+      );
+    }
+    return;
+  }
+  if (value.formData !== void 0) {
+    addFieldIssue("formData", "formData is only allowed when status is approved");
+  }
+  if (value.rememberChoice !== void 0) {
+    addFieldIssue(
+      "rememberChoice",
+      "rememberChoice is only allowed when status is approved"
+    );
+  }
+  if (value.rememberPattern !== void 0) {
+    addFieldIssue(
+      "rememberPattern",
+      "rememberPattern is only allowed when status is approved"
+    );
+  }
+  if (value.rememberDirectory !== void 0) {
+    addFieldIssue(
+      "rememberDirectory",
+      "rememberDirectory is only allowed when status is approved"
+    );
+  }
+  if (value.reason === void 0) {
+    return;
+  }
+  if (value.status === ApprovalStatus.DENIED) {
+    const invalidReasons2 = /* @__PURE__ */ new Set([
+      DenialReason.USER_CANCELLED,
+      DenialReason.SYSTEM_CANCELLED,
+      DenialReason.TIMEOUT
+    ]);
+    if (invalidReasons2.has(value.reason)) {
+      addFieldIssue("reason", "reason must describe a denial when status is denied");
+    }
+    return;
+  }
+  const invalidReasons = /* @__PURE__ */ new Set([
+    DenialReason.USER_DENIED,
+    DenialReason.SYSTEM_DENIED,
+    DenialReason.VALIDATION_FAILED,
+    DenialReason.ELICITATION_DISABLED
+  ]);
+  if (invalidReasons.has(value.reason)) {
+    addFieldIssue("reason", "reason must describe a cancellation when status is cancelled");
+  }
 }).describe("Request body for submitting an approval decision");
 const ApprovalResponseSchema = z.object({
   ok: z.boolean().describe("Whether the approval was successfully processed"),
   approvalId: z.string().describe("The ID of the processed approval"),
-  status: z.enum([ApprovalStatus.APPROVED, ApprovalStatus.DENIED]).describe("The final status")
+  status: z.enum([ApprovalStatus.APPROVED, ApprovalStatus.DENIED, ApprovalStatus.CANCELLED]).describe("The final status")
 }).describe("Response after processing approval");
 const PendingApprovalSchema = z.object({
   approvalId: z.string().describe("The unique ID of the approval request"),
@@ -103,7 +174,15 @@ function createApprovalsRouter(getAgent, approvalCoordinator) {
   }).openapi(submitApprovalRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { approvalId } = ctx.req.valid("param");
-    const { status, formData, rememberChoice } = ctx.req.valid("json");
+    const {
+      status,
+      formData,
+      rememberChoice,
+      rememberPattern,
+      rememberDirectory,
+      reason,
+      message
+    } = ctx.req.valid("json");
     agent.logger.info(`Received approval decision for ${approvalId}: ${status}`);
     if (!approvalCoordinator) {
       agent.logger.error("ApprovalCoordinator not available");
@@ -122,6 +201,12 @@ function createApprovalsRouter(getAgent, approvalCoordinator) {
         if (rememberChoice !== void 0) {
           data.rememberChoice = rememberChoice;
         }
+        if (rememberPattern !== void 0) {
+          data.rememberPattern = rememberPattern;
+        }
+        if (rememberDirectory !== void 0) {
+          data.rememberDirectory = rememberDirectory;
+        }
       }
       const sessionId = approvalCoordinator.getSessionId(approvalId);
       const responsePayload = {
@@ -130,8 +215,11 @@ function createApprovalsRouter(getAgent, approvalCoordinator) {
         sessionId,
         // Attach sessionId for SSE routing to correct client streams
         ...status === ApprovalStatus.DENIED ? {
-          reason: DenialReason.USER_DENIED,
-          message: "User denied the request via API"
+          reason: reason ?? DenialReason.USER_DENIED,
+          message: message ?? "User denied the request via API"
+        } : status === ApprovalStatus.CANCELLED ? {
+          reason: reason ?? DenialReason.USER_CANCELLED,
+          message: message ?? "User cancelled the request via API"
         } : {},
         ...Object.keys(data).length > 0 ? { data } : {}
       };

package/dist/hono/routes/messages.cjs

@@ -94,6 +94,14 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
               response: import_zod_openapi.z.string().describe("Agent response text"),
               sessionId: import_zod_openapi.z.string().describe("Session ID used for this message"),
               tokenUsage: import_responses.TokenUsageSchema.optional().describe("Token usage statistics"),
+              messageId: import_zod_openapi.z.string().uuid().optional().describe("Assistant message ID for this response"),
+              usageScopeId: import_zod_openapi.z.string().optional().describe(
+                "Optional usage scope identifier for runtime-scoped metering"
+              ),
+              estimatedCost: import_zod_openapi.z.number().nonnegative().optional().describe("Estimated cost in USD for this response"),
+              pricingStatus: import_responses.PricingStatusSchema.optional().describe(
+                "Whether pricing was resolved for this response"
+              ),
               reasoning: import_zod_openapi.z.string().optional().describe("Extended thinking content from reasoning models"),
               model: import_zod_openapi.z.string().optional().describe("Model used for this response"),
               provider: import_zod_openapi.z.enum(import_core.LLM_PROVIDERS).optional().describe("LLM provider")
@@ -131,7 +139,7 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
     method: "post",
     path: "/message-stream",
     summary: "Stream message response",
-    description: "Sends a message and streams the response via Server-Sent Events (SSE). Returns SSE stream directly in response. Events include llm:thinking, llm:chunk, llm:tool-call, llm:tool-result, llm:response, and llm:error. If the session is busy processing another message, returns 202 with queue information.",
+    description: "Sends a message and streams the response via Server-Sent Events (SSE). Returns SSE stream directly in response. Events include llm:thinking, llm:chunk, llm:tool-call, llm:tool-result, llm:response, and llm:error. Final llm:response events include token usage, assistant message ID, and pricing metadata when available. If the session is busy processing another message, returns 202 with queue information.",
     tags: ["messages"],
     request: {
       body: {
@@ -162,7 +170,7 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
         content: {
           "text/event-stream": {
             schema: import_zod_openapi.z.string().describe(
-              "Server-Sent Events stream. Events: llm:thinking (start), llm:chunk (text fragments), llm:tool-call (tool execution), llm:tool-result (tool output), llm:response (final), llm:error (errors)"
+              "Server-Sent Events stream. Events: llm:thinking (start), llm:chunk (text fragments), llm:tool-call (tool execution), llm:tool-result (tool output), llm:response (final), llm:error (errors). Final llm:response payloads include token usage, assistant message ID, and pricing metadata when available."
             )
           }
         }
@@ -200,14 +208,17 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
     const { content, sessionId } = ctx.req.valid("json");
     agent.logger.info(`Message for session: ${sessionId}`);
     const result = await agent.generate(content, sessionId);
-    const llmConfig = agent.stateManager.getLLMConfig(sessionId);
     return ctx.json({
       response: result.content,
       sessionId: result.sessionId,
       tokenUsage: result.usage,
+      messageId: result.messageId,
+      usageScopeId: result.usageScopeId,
+      estimatedCost: result.estimatedCost,
+      pricingStatus: result.pricingStatus,
       reasoning: result.reasoning,
-      model: llmConfig.model,
-      provider: llmConfig.provider
+      model: result.model,
+      provider: result.provider
     });
   }).openapi(resetRoute, async (ctx) => {
     const agent = await getAgent(ctx);

package/dist/hono/routes/messages.d.ts

@@ -103,10 +103,16 @@ export declare function createMessagesRouter(getAgent: GetAgentFn, approvalCoord
                     inputTokens?: number | undefined;
                     outputTokens?: number | undefined;
                     reasoningTokens?: number | undefined;
+                    cacheReadTokens?: number | undefined;
+                    cacheWriteTokens?: number | undefined;
                     totalTokens?: number | undefined;
                 } | undefined;
+                estimatedCost?: number | undefined;
+                pricingStatus?: "estimated" | "unpriced" | undefined;
+                usageScopeId?: string | undefined;
                 model?: string | undefined;
                 provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova" | undefined;
+                messageId?: string | undefined;
             };
             outputFormat: "json";
             status: 200;

package/dist/hono/routes/messages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/messages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAIhE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAElF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA0D9C,wBAAgB,oBAAoB,CAChC,QAAQ,EAAE,UAAU,EACpB,mBAAmB,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA0U5C"}
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/messages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAIhE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAElF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA0D9C,wBAAgB,oBAAoB,CAChC,QAAQ,EAAE,UAAU,EACpB,mBAAmB,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA+V5C"}

package/dist/hono/routes/messages.js

@@ -1,7 +1,7 @@
 import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
 import { streamSSE } from "hono/streaming";
 import { LLM_PROVIDERS } from "@dexto/core";
-import { TokenUsageSchema } from "../schemas/responses.js";
+import { PricingStatusSchema, TokenUsageSchema } from "../schemas/responses.js";
 const TextPartSchema = z.object({
   type: z.literal("text").describe("Content type identifier"),
   text: z.string().describe("Text content")
@@ -71,6 +71,14 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
               response: z.string().describe("Agent response text"),
               sessionId: z.string().describe("Session ID used for this message"),
               tokenUsage: TokenUsageSchema.optional().describe("Token usage statistics"),
+              messageId: z.string().uuid().optional().describe("Assistant message ID for this response"),
+              usageScopeId: z.string().optional().describe(
+                "Optional usage scope identifier for runtime-scoped metering"
+              ),
+              estimatedCost: z.number().nonnegative().optional().describe("Estimated cost in USD for this response"),
+              pricingStatus: PricingStatusSchema.optional().describe(
+                "Whether pricing was resolved for this response"
+              ),
               reasoning: z.string().optional().describe("Extended thinking content from reasoning models"),
               model: z.string().optional().describe("Model used for this response"),
               provider: z.enum(LLM_PROVIDERS).optional().describe("LLM provider")
@@ -108,7 +116,7 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
     method: "post",
     path: "/message-stream",
     summary: "Stream message response",
-    description: "Sends a message and streams the response via Server-Sent Events (SSE). Returns SSE stream directly in response. Events include llm:thinking, llm:chunk, llm:tool-call, llm:tool-result, llm:response, and llm:error. If the session is busy processing another message, returns 202 with queue information.",
+    description: "Sends a message and streams the response via Server-Sent Events (SSE). Returns SSE stream directly in response. Events include llm:thinking, llm:chunk, llm:tool-call, llm:tool-result, llm:response, and llm:error. Final llm:response events include token usage, assistant message ID, and pricing metadata when available. If the session is busy processing another message, returns 202 with queue information.",
     tags: ["messages"],
     request: {
       body: {
@@ -139,7 +147,7 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
         content: {
           "text/event-stream": {
             schema: z.string().describe(
-              "Server-Sent Events stream. Events: llm:thinking (start), llm:chunk (text fragments), llm:tool-call (tool execution), llm:tool-result (tool output), llm:response (final), llm:error (errors)"
+              "Server-Sent Events stream. Events: llm:thinking (start), llm:chunk (text fragments), llm:tool-call (tool execution), llm:tool-result (tool output), llm:response (final), llm:error (errors). Final llm:response payloads include token usage, assistant message ID, and pricing metadata when available."
             )
           }
         }
@@ -177,14 +185,17 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
     const { content, sessionId } = ctx.req.valid("json");
     agent.logger.info(`Message for session: ${sessionId}`);
     const result = await agent.generate(content, sessionId);
-    const llmConfig = agent.stateManager.getLLMConfig(sessionId);
     return ctx.json({
       response: result.content,
       sessionId: result.sessionId,
       tokenUsage: result.usage,
+      messageId: result.messageId,
+      usageScopeId: result.usageScopeId,
+      estimatedCost: result.estimatedCost,
+      pricingStatus: result.pricingStatus,
       reasoning: result.reasoning,
-      model: llmConfig.model,
-      provider: llmConfig.provider
+      model: result.model,
+      provider: result.provider
     });
   }).openapi(resetRoute, async (ctx) => {
     const agent = await getAgent(ctx);

package/dist/hono/routes/search.d.ts

@@ -53,8 +53,13 @@ export declare function createSearchRouter(getAgent: GetAgentFn): OpenAPIHono<im
                             inputTokens?: number | undefined;
                             outputTokens?: number | undefined;
                             reasoningTokens?: number | undefined;
+                            cacheReadTokens?: number | undefined;
+                            cacheWriteTokens?: number | undefined;
                             totalTokens?: number | undefined;
                         } | undefined;
+                        estimatedCost?: number | undefined;
+                        pricingStatus?: "estimated" | "unpriced" | undefined;
+                        usageScopeId?: string | undefined;
                         model?: string | undefined;
                         provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova" | undefined;
                         toolCalls?: {
@@ -135,8 +140,13 @@ export declare function createSearchRouter(getAgent: GetAgentFn): OpenAPIHono<im
                                 inputTokens?: number | undefined;
                                 outputTokens?: number | undefined;
                                 reasoningTokens?: number | undefined;
+                                cacheReadTokens?: number | undefined;
+                                cacheWriteTokens?: number | undefined;
                                 totalTokens?: number | undefined;
                             } | undefined;
+                            estimatedCost?: number | undefined;
+                            pricingStatus?: "estimated" | "unpriced" | undefined;
+                            usageScopeId?: string | undefined;
                             model?: string | undefined;
                             provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova" | undefined;
                             toolCalls?: {

package/dist/hono/routes/search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AA0BrE,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAwDtD"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AA0BrE,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAwDtD"}