@dexto/server 1.6.16 → 1.6.18

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

@@ -45,6 +45,7 @@ export declare function createSearchRouter(getAgent: GetAgentFn): OpenAPIHono<im
                             } | undefined;
                         })[] | null;
                         role: "system" | "user" | "assistant" | "tool";
+                        usageScopeId?: string | undefined;
                         id?: string | undefined;
                         name?: string | undefined;
                         timestamp?: number | undefined;
@@ -53,8 +54,12 @@ 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;
                         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?: {
@@ -127,6 +132,7 @@ export declare function createSearchRouter(getAgent: GetAgentFn): OpenAPIHono<im
                                 } | undefined;
                             })[] | null;
                             role: "system" | "user" | "assistant" | "tool";
+                            usageScopeId?: string | undefined;
                             id?: string | undefined;
                             name?: string | undefined;
                             timestamp?: number | undefined;
@@ -135,8 +141,12 @@ 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;
                             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"}

package/dist/hono/routes/sessions.cjs

@@ -22,10 +22,35 @@ __export(sessions_exports, {
 });
 module.exports = __toCommonJS(sessions_exports);
 var import_zod_openapi = require("@hono/zod-openapi");
+var import_core = require("@dexto/core");
 var import_responses = require("../schemas/responses.js");
+var import_error = require("../middleware/error.js");
 const CreateSessionSchema = import_zod_openapi.z.object({
   sessionId: import_zod_openapi.z.string().optional().describe("A custom ID for the new session")
 }).describe("Request body for creating a new session");
+const MAX_SYSTEM_PROMPT_CONTRIBUTOR_CONTENT_CHARS = 12e4;
+const DEFAULT_SYSTEM_PROMPT_CONTRIBUTOR_PRIORITY = 45;
+const SessionPromptContributorInfoSchema = import_zod_openapi.z.object({
+  id: import_zod_openapi.z.string().describe("Contributor identifier"),
+  priority: import_zod_openapi.z.number().describe("Contributor priority")
+}).strict().describe("Session-scoped system prompt contributor metadata.");
+const UpsertSessionPromptContributorSchema = import_zod_openapi.z.object({
+  id: import_zod_openapi.z.string().min(1).describe("Contributor identifier"),
+  priority: import_zod_openapi.z.number().int().nonnegative().optional().default(DEFAULT_SYSTEM_PROMPT_CONTRIBUTOR_PRIORITY).describe("Optional priority override"),
+  enabled: import_zod_openapi.z.boolean().default(true).describe("Set false to remove the contributor instead of adding or updating it"),
+  content: import_zod_openapi.z.string().optional().describe("Static contributor content for this session (required when enabled)")
+}).strict().superRefine((value, ctx) => {
+  if (value.enabled !== false && (!value.content || value.content.trim().length === 0)) {
+    ctx.addIssue({
+      code: import_zod_openapi.z.ZodIssueCode.custom,
+      path: ["content"],
+      message: "Contributor content is required when enabled"
+    });
+  }
+}).describe("Session-scoped system prompt contributor update payload.");
+function sanitizeContributorId(value) {
+  return value.trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+}
 function mapSessionMetadata(sessionId, metadata, defaults) {
   return {
     id: sessionId,
@@ -33,12 +58,35 @@ function mapSessionMetadata(sessionId, metadata, defaults) {
     lastActivity: metadata?.lastActivity ?? defaults?.lastActivity ?? null,
     messageCount: metadata?.messageCount ?? defaults?.messageCount ?? 0,
     title: metadata?.title ?? defaults?.title ?? null,
+    ...metadata?.tokenUsage && { tokenUsage: metadata.tokenUsage },
+    ...metadata?.estimatedCost !== void 0 && {
+      estimatedCost: metadata.estimatedCost
+    },
+    ...metadata?.modelStats && { modelStats: metadata.modelStats },
+    ...metadata?.usageTracking && { usageTracking: metadata.usageTracking },
     workspaceId: metadata?.workspaceId ?? defaults?.workspaceId ?? null,
     parentSessionId: metadata?.parentSessionId ?? defaults?.parentSessionId ?? null
   };
 }
 function createSessionsRouter(getAgent) {
-  const app = new import_zod_openapi.OpenAPIHono();
+  const app = new import_zod_openapi.OpenAPIHono({
+    defaultHook: (result, ctx) => {
+      if (!result.success) {
+        const issues = (0, import_core.zodToIssues)(result.error);
+        return (0, import_error.handleHonoError)(
+          ctx,
+          new import_core.DextoRuntimeError(
+            "validation_failed",
+            "validation",
+            import_core.ErrorType.USER,
+            issues[0]?.message ?? "Validation failed",
+            { issues }
+          )
+        );
+      }
+    }
+  });
+  app.onError((err, ctx) => (0, import_error.handleHonoError)(ctx, err));
   const listRoute = (0, import_zod_openapi.createRoute)({
     method: "get",
     path: "/sessions",
@@ -167,6 +215,86 @@ function createSessionsRouter(getAgent) {
       }
     }
   });
+  const listSessionPromptContributorsRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/sessions/{sessionId}/system-prompt/contributors",
+    summary: "List Session System Prompt Contributors",
+    description: "Lists static system prompt contributors that apply only to the specified session.",
+    tags: ["sessions", "config"],
+    request: { params: import_zod_openapi.z.object({ sessionId: import_zod_openapi.z.string().describe("Session identifier") }) },
+    responses: {
+      200: {
+        description: "Current session contributor list",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              contributors: import_zod_openapi.z.array(SessionPromptContributorInfoSchema).describe("Registered session prompt contributors.")
+            }).strict()
+          }
+        }
+      },
+      404: {
+        description: "Session not found",
+        content: {
+          "application/json": {
+            schema: import_responses.StandardErrorEnvelopeSchema
+          }
+        }
+      }
+    }
+  });
+  const upsertSessionPromptContributorRoute = (0, import_zod_openapi.createRoute)({
+    method: "post",
+    path: "/sessions/{sessionId}/system-prompt/contributors",
+    summary: "Upsert Session System Prompt Contributor",
+    description: "Adds or updates a static system prompt contributor that applies only to the specified session. Set enabled=false to remove it.",
+    tags: ["sessions", "config"],
+    request: {
+      params: import_zod_openapi.z.object({ sessionId: import_zod_openapi.z.string().describe("Session identifier") }),
+      body: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: UpsertSessionPromptContributorSchema
+          }
+        }
+      }
+    },
+    responses: {
+      200: {
+        description: "Session contributor upsert result",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              id: import_zod_openapi.z.string().describe("Contributor identifier"),
+              enabled: import_zod_openapi.z.boolean().describe("Whether the contributor remains enabled"),
+              priority: import_zod_openapi.z.number().optional().describe("Contributor priority"),
+              replaced: import_zod_openapi.z.boolean().optional().describe("Whether an existing contributor was replaced"),
+              removed: import_zod_openapi.z.boolean().optional().describe("Whether the contributor was removed"),
+              contentLength: import_zod_openapi.z.number().optional().describe("Stored content length in characters"),
+              truncated: import_zod_openapi.z.boolean().optional().describe("Whether the submitted content was truncated")
+            }).strict()
+          }
+        }
+      },
+      400: {
+        description: "Invalid session contributor request",
+        content: {
+          "application/json": {
+            schema: import_responses.StandardErrorEnvelopeSchema
+          }
+        }
+      },
+      404: {
+        description: "Session not found",
+        content: {
+          "application/json": {
+            schema: import_responses.StandardErrorEnvelopeSchema
+          }
+        }
+      }
+    }
+  });
   const deleteRoute = (0, import_zod_openapi.createRoute)({
     method: "delete",
     path: "/sessions/{sessionId}",
@@ -245,6 +373,15 @@ function createSessionsRouter(getAgent) {
               session: import_responses.SessionMetadataSchema.extend({
                 isBusy: import_zod_openapi.z.boolean().describe(
                   "Whether the session is currently processing a message"
+                ),
+                usageSummary: import_responses.UsageSummarySchema.describe(
+                  "Exact usage summary derived from assistant message history"
+                ),
+                activeUsageScopeId: import_zod_openapi.z.string().nullable().describe(
+                  "Current runtime usage scope identifier, if configured"
+                ),
+                activeUsageScope: import_responses.ScopedUsageSummarySchema.nullable().describe(
+                  "Usage summary for the current runtime scope, if configured"
                 )
               }).describe("Session metadata with processing status")
             }).strict()
@@ -263,6 +400,29 @@ function createSessionsRouter(getAgent) {
       }
     }
   });
+  const clearContextRoute = (0, import_zod_openapi.createRoute)({
+    method: "post",
+    path: "/sessions/{sessionId}/clear-context",
+    summary: "Clear Session Context",
+    description: "Clears the model context window for a session while preserving conversation history for review.",
+    tags: ["sessions"],
+    request: {
+      params: import_zod_openapi.z.object({ sessionId: import_zod_openapi.z.string().describe("Session identifier") })
+    },
+    responses: {
+      200: {
+        description: "Session context cleared successfully",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              status: import_zod_openapi.z.literal("context cleared").describe("Context clear status"),
+              sessionId: import_zod_openapi.z.string().describe("Session ID")
+            }).strict()
+          }
+        }
+      }
+    }
+  });
   const patchRoute = (0, import_zod_openapi.createRoute)({
     method: "patch",
     path: "/sessions/{sessionId}",
@@ -381,6 +541,81 @@ function createSessionsRouter(getAgent) {
       history,
       isBusy
     });
+  }).openapi(listSessionPromptContributorsRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const { sessionId } = ctx.req.valid("param");
+    const contributors = await agent.getSessionSystemPromptContributors(sessionId);
+    return ctx.json(
+      {
+        contributors: contributors.map((contributor) => ({
+          id: contributor.id,
+          priority: contributor.priority
+        }))
+      },
+      200
+    );
+  }).openapi(upsertSessionPromptContributorRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const { sessionId } = ctx.req.valid("param");
+    const payload = ctx.req.valid("json");
+    const contributorId = sanitizeContributorId(payload.id);
+    if (contributorId.length === 0) {
+      throw new import_core.DextoRuntimeError(
+        "session_systemprompt_contributor_config_invalid",
+        import_core.ErrorScope.SYSTEM_PROMPT,
+        import_core.ErrorType.USER,
+        "A valid contributor id is required",
+        {
+          id: payload.id,
+          sessionId
+        }
+      );
+    }
+    const rawContent = payload.content ?? "";
+    const content = rawContent.slice(0, MAX_SYSTEM_PROMPT_CONTRIBUTOR_CONTENT_CHARS);
+    if (!payload.enabled) {
+      const removed = await agent.removeSessionSystemPromptContributor(
+        sessionId,
+        contributorId
+      );
+      return ctx.json(
+        {
+          id: contributorId,
+          enabled: false,
+          removed
+        },
+        200
+      );
+    }
+    if (content.trim().length === 0) {
+      throw new import_core.DextoRuntimeError(
+        "session_systemprompt_contributor_config_invalid",
+        import_core.ErrorScope.SYSTEM_PROMPT,
+        import_core.ErrorType.USER,
+        "Contributor content is required when enabled",
+        {
+          id: payload.id,
+          sessionId
+        }
+      );
+    }
+    const priority = payload.priority;
+    const result = await agent.upsertSessionSystemPromptContributor(sessionId, {
+      id: contributorId,
+      priority,
+      content
+    });
+    return ctx.json(
+      {
+        id: contributorId,
+        enabled: true,
+        priority,
+        replaced: result.replaced,
+        contentLength: content.length,
+        truncated: rawContent.length > content.length
+      },
+      200
+    );
   }).openapi(deleteRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.param();
@@ -424,15 +659,29 @@ function createSessionsRouter(getAgent) {
     }
     const metadata = await agent.getSessionMetadata(sessionId);
     const isBusy = await agent.isSessionBusy(sessionId);
+    const usageSummary = await agent.getSessionUsageSummary(sessionId);
+    const activeUsageScopeId = agent.getEffectiveConfig().usageScopeId ?? null;
+    const activeUsageScope = activeUsageScopeId ? {
+      scopeId: activeUsageScopeId,
+      ...await agent.getSessionUsageSummary(sessionId, activeUsageScopeId)
+    } : null;
     return ctx.json(
       {
         session: {
           ...mapSessionMetadata(sessionId, metadata),
-          isBusy
+          isBusy,
+          usageSummary,
+          activeUsageScopeId,
+          activeUsageScope
         }
       },
       200
     );
+  }).openapi(clearContextRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const { sessionId } = ctx.req.valid("param");
+    await agent.clearContext(sessionId);
+    return ctx.json({ status: "context cleared", sessionId });
   }).openapi(patchRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("param");