@dexto/server 1.6.7 → 1.6.9

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

@@ -37,6 +37,7 @@ export declare function createSessionsRouter(getAgent: GetAgentFn): OpenAPIHono<
                         lastUsedAt: number;
                     }[] | undefined;
                     workspaceId?: string | null | undefined;
+                    parentSessionId?: string | null | undefined;
                 }[];
             };
             outputFormat: "json";
@@ -84,12 +85,79 @@ export declare function createSessionsRouter(getAgent: GetAgentFn): OpenAPIHono<
                         lastUsedAt: number;
                     }[] | undefined;
                     workspaceId?: string | null | undefined;
+                    parentSessionId?: string | null | undefined;
                 };
             };
             outputFormat: "json";
             status: 201;
         };
     };
+} & {
+    "/sessions/:sessionId/fork": {
+        $post: {
+            input: {
+                param: {
+                    sessionId: string;
+                };
+            };
+            output: {
+                session: {
+                    id: string;
+                    messageCount: number;
+                    createdAt: number | null;
+                    lastActivity: number | null;
+                    title?: string | null | undefined;
+                    tokenUsage?: {
+                        inputTokens: number;
+                        outputTokens: number;
+                        reasoningTokens: number;
+                        totalTokens: number;
+                        cacheReadTokens: number;
+                        cacheWriteTokens: number;
+                    } | undefined;
+                    estimatedCost?: number | undefined;
+                    modelStats?: {
+                        tokenUsage: {
+                            inputTokens: number;
+                            outputTokens: number;
+                            reasoningTokens: number;
+                            totalTokens: number;
+                            cacheReadTokens: number;
+                            cacheWriteTokens: number;
+                        };
+                        model: string;
+                        provider: string;
+                        messageCount: number;
+                        estimatedCost: number;
+                        firstUsedAt: number;
+                        lastUsedAt: number;
+                    }[] | undefined;
+                    workspaceId?: string | null | undefined;
+                    parentSessionId?: string | null | undefined;
+                };
+            };
+            outputFormat: "json";
+            status: 201;
+        } | {
+            input: {
+                param: {
+                    sessionId: string;
+                };
+            };
+            output: never;
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    sessionId: string;
+                };
+            };
+            output: never;
+            outputFormat: "json";
+            status: 404;
+        };
+    };
 } & {
     "/sessions/:sessionId": {
         $get: {
@@ -132,6 +200,7 @@ export declare function createSessionsRouter(getAgent: GetAgentFn): OpenAPIHono<
                         lastUsedAt: number;
                     }[] | undefined;
                     workspaceId?: string | null | undefined;
+                    parentSessionId?: string | null | undefined;
                 };
             };
             outputFormat: "json";
@@ -284,6 +353,7 @@ export declare function createSessionsRouter(getAgent: GetAgentFn): OpenAPIHono<
                         lastUsedAt: number;
                     }[] | undefined;
                     workspaceId?: string | null | undefined;
+                    parentSessionId?: string | null | undefined;
                 };
             };
             outputFormat: "json";
@@ -346,6 +416,7 @@ export declare function createSessionsRouter(getAgent: GetAgentFn): OpenAPIHono<
                         lastUsedAt: number;
                     }[] | undefined;
                     workspaceId?: string | null | undefined;
+                    parentSessionId?: string | null | undefined;
                 };
             };
             outputFormat: "json";

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

@@ -1 +1 @@
-{"version":3,"file":"sessions.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/sessions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAEhE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAQ9C,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAuexD"}
+{"version":3,"file":"sessions.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/sessions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAOhE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA+B9C,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA8fxD"}

package/dist/hono/routes/sessions.js

@@ -1,8 +1,23 @@
 import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
-import { SessionMetadataSchema, InternalMessageSchema } from "../schemas/responses.js";
+import {
+  SessionMetadataSchema,
+  InternalMessageSchema,
+  StandardErrorEnvelopeSchema
+} from "../schemas/responses.js";
 const CreateSessionSchema = z.object({
   sessionId: z.string().optional().describe("A custom ID for the new session")
 }).describe("Request body for creating a new session");
+function mapSessionMetadata(sessionId, metadata, defaults) {
+  return {
+    id: sessionId,
+    createdAt: metadata?.createdAt ?? defaults?.createdAt ?? null,
+    lastActivity: metadata?.lastActivity ?? defaults?.lastActivity ?? null,
+    messageCount: metadata?.messageCount ?? defaults?.messageCount ?? 0,
+    title: metadata?.title ?? defaults?.title ?? null,
+    workspaceId: metadata?.workspaceId ?? defaults?.workspaceId ?? null,
+    parentSessionId: metadata?.parentSessionId ?? defaults?.parentSessionId ?? null
+  };
+}
 function createSessionsRouter(getAgent) {
   const app = new OpenAPIHono();
   const listRoute = createRoute({
@@ -68,6 +83,48 @@ function createSessionsRouter(getAgent) {
       }
     }
   });
+  const forkRoute = createRoute({
+    method: "post",
+    path: "/sessions/{sessionId}/fork",
+    summary: "Fork Session",
+    description: "Creates a new child session by cloning the specified parent session history and metadata lineage.",
+    tags: ["sessions"],
+    request: {
+      params: z.object({
+        sessionId: z.string().describe("Parent session identifier")
+      })
+    },
+    responses: {
+      201: {
+        description: "Forked session created successfully",
+        content: {
+          "application/json": {
+            schema: z.object({
+              session: SessionMetadataSchema.describe(
+                "Newly created child session metadata"
+              )
+            }).strict()
+          }
+        }
+      },
+      400: {
+        description: "Invalid fork request (for example, max session limit reached)",
+        content: {
+          "application/json": {
+            schema: StandardErrorEnvelopeSchema
+          }
+        }
+      },
+      404: {
+        description: "Parent session not found",
+        content: {
+          "application/json": {
+            schema: StandardErrorEnvelopeSchema
+          }
+        }
+      }
+    }
+  });
   const historyRoute = createRoute({
     method: "get",
     path: "/sessions/{sessionId}/history",
@@ -251,23 +308,9 @@ function createSessionsRouter(getAgent) {
       sessionIds.map(async (id) => {
         try {
           const metadata = await agent.getSessionMetadata(id);
-          return {
-            id,
-            createdAt: metadata?.createdAt || null,
-            lastActivity: metadata?.lastActivity || null,
-            messageCount: metadata?.messageCount || 0,
-            title: metadata?.title || null,
-            workspaceId: metadata?.workspaceId || null
-          };
+          return mapSessionMetadata(id, metadata);
         } catch {
-          return {
-            id,
-            createdAt: null,
-            lastActivity: null,
-            messageCount: 0,
-            title: null,
-            workspaceId: null
-          };
+          return mapSessionMetadata(id, void 0);
         }
       })
     );
@@ -279,14 +322,21 @@ function createSessionsRouter(getAgent) {
     const metadata = await agent.getSessionMetadata(session.id);
     return ctx.json(
       {
-        session: {
-          id: session.id,
-          createdAt: metadata?.createdAt || Date.now(),
-          lastActivity: metadata?.lastActivity || Date.now(),
-          messageCount: metadata?.messageCount || 0,
-          title: metadata?.title || null,
-          workspaceId: metadata?.workspaceId || null
-        }
+        session: mapSessionMetadata(session.id, metadata, {
+          createdAt: Date.now(),
+          lastActivity: Date.now()
+        })
+      },
+      201
+    );
+  }).openapi(forkRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const { sessionId: parentSessionId } = ctx.req.valid("param");
+    const session = await agent.forkSession(parentSessionId);
+    const metadata = await agent.getSessionMetadata(session.id);
+    return ctx.json(
+      {
+        session: mapSessionMetadata(session.id, metadata)
       },
       201
     );
@@ -297,12 +347,7 @@ function createSessionsRouter(getAgent) {
     const history = await agent.getSessionHistory(sessionId);
     return ctx.json({
       session: {
-        id: sessionId,
-        createdAt: metadata?.createdAt || null,
-        lastActivity: metadata?.lastActivity || null,
-        messageCount: metadata?.messageCount || 0,
-        title: metadata?.title || null,
-        workspaceId: metadata?.workspaceId || null,
+        ...mapSessionMetadata(sessionId, metadata),
         history: history.length
       }
     });
@@ -363,12 +408,7 @@ function createSessionsRouter(getAgent) {
     return ctx.json(
       {
         session: {
-          id: sessionId,
-          createdAt: metadata?.createdAt || null,
-          lastActivity: metadata?.lastActivity || null,
-          messageCount: metadata?.messageCount || 0,
-          title: metadata?.title || null,
-          workspaceId: metadata?.workspaceId || null,
+          ...mapSessionMetadata(sessionId, metadata),
           isBusy
         }
       },
@@ -381,14 +421,7 @@ function createSessionsRouter(getAgent) {
     await agent.setSessionTitle(sessionId, title);
     const metadata = await agent.getSessionMetadata(sessionId);
     return ctx.json({
-      session: {
-        id: sessionId,
-        createdAt: metadata?.createdAt || null,
-        lastActivity: metadata?.lastActivity || null,
-        messageCount: metadata?.messageCount || 0,
-        title: metadata?.title || title,
-        workspaceId: metadata?.workspaceId || null
-      }
+      session: mapSessionMetadata(sessionId, metadata, { title })
     });
   }).openapi(generateTitleRoute, async (ctx) => {
     const agent = await getAgent(ctx);

package/dist/hono/routes/system-prompt.cjs

@@ -0,0 +1,185 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var system_prompt_exports = {};
+__export(system_prompt_exports, {
+  createSystemPromptRouter: () => createSystemPromptRouter
+});
+module.exports = __toCommonJS(system_prompt_exports);
+var import_zod_openapi = require("@hono/zod-openapi");
+var import_core = require("@dexto/core");
+var import_responses = require("../schemas/responses.js");
+const MAX_SYSTEM_PROMPT_CONTRIBUTOR_CONTENT_CHARS = 12e4;
+const DEFAULT_SYSTEM_PROMPT_CONTRIBUTOR_PRIORITY = 45;
+const ContributorInfoSchema = 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("System prompt contributor metadata.");
+const UpsertSystemPromptContributorSchema = import_zod_openapi.z.object({
+  id: import_zod_openapi.z.string().min(1).describe("Contributor identifier"),
+  priority: import_zod_openapi.z.number().optional().describe("Optional priority override"),
+  enabled: import_zod_openapi.z.boolean().optional().describe("Set false to remove the contributor instead of adding/updating it"),
+  content: import_zod_openapi.z.string().optional().describe("Static contributor content (required when enabled).")
+}).strict().describe("System prompt contributor update payload.");
+const SystemPromptContributorErrorSchema = import_responses.StandardErrorEnvelopeSchema.describe(
+  "System prompt contributor error response."
+);
+function sanitizeContributorId(value) {
+  return value.trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+}
+function resolveContributorPriority(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return Math.trunc(value);
+  }
+  return DEFAULT_SYSTEM_PROMPT_CONTRIBUTOR_PRIORITY;
+}
+function createSystemPromptRouter(getAgent) {
+  const app = new import_zod_openapi.OpenAPIHono();
+  const listContributorsRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/system-prompt/contributors",
+    summary: "List System Prompt Contributors",
+    description: "Lists currently registered system prompt contributors.",
+    tags: ["config"],
+    responses: {
+      200: {
+        description: "Current contributor list",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              contributors: import_zod_openapi.z.array(ContributorInfoSchema).describe("Registered system prompt contributors.")
+            }).strict().describe("System prompt contributors list response.")
+          }
+        }
+      }
+    }
+  });
+  const upsertContributorRoute = (0, import_zod_openapi.createRoute)({
+    method: "post",
+    path: "/system-prompt/contributors",
+    summary: "Upsert System Prompt Contributor",
+    description: "Adds or updates a static system prompt contributor. Set enabled=false (or empty content) to remove.",
+    tags: ["config"],
+    request: {
+      body: {
+        content: {
+          "application/json": {
+            schema: UpsertSystemPromptContributorSchema
+          }
+        }
+      }
+    },
+    responses: {
+      200: {
+        description: "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().describe("System prompt contributor upsert response.")
+          }
+        }
+      },
+      400: {
+        description: "Invalid contributor update request",
+        content: {
+          "application/json": {
+            schema: SystemPromptContributorErrorSchema
+          }
+        }
+      }
+    }
+  });
+  return app.openapi(listContributorsRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const contributors = agent.systemPromptManager.getContributors().map((contributor) => ({
+      id: contributor.id,
+      priority: contributor.priority
+    }));
+    return ctx.json({ contributors });
+  }).openapi(upsertContributorRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const payload = ctx.req.valid("json");
+    const contributorId = sanitizeContributorId(payload.id);
+    if (contributorId.length === 0) {
+      throw new import_core.DextoRuntimeError(
+        "systemprompt_contributor_config_invalid",
+        import_core.ErrorScope.SYSTEM_PROMPT,
+        import_core.ErrorType.USER,
+        "A valid contributor id is required",
+        {
+          id: payload.id
+        }
+      );
+    }
+    const enabled = payload.enabled !== false;
+    const hasContent = payload.content !== void 0;
+    const rawContent = payload.content ?? "";
+    const content = rawContent.slice(0, MAX_SYSTEM_PROMPT_CONTRIBUTOR_CONTENT_CHARS);
+    const priority = resolveContributorPriority(payload.priority);
+    if (!enabled || hasContent && content.trim().length === 0) {
+      const removed = agent.systemPromptManager.removeContributor(contributorId);
+      return ctx.json(
+        {
+          id: contributorId,
+          enabled: false,
+          removed
+        },
+        200
+      );
+    }
+    if (!hasContent || content.trim().length === 0) {
+      throw new import_core.DextoRuntimeError(
+        "systemprompt_contributor_config_invalid",
+        import_core.ErrorScope.SYSTEM_PROMPT,
+        import_core.ErrorType.USER,
+        "Contributor content is required when enabled",
+        {
+          id: payload.id
+        }
+      );
+    }
+    const replaced = agent.systemPromptManager.removeContributor(contributorId);
+    agent.systemPromptManager.addContributor({
+      id: contributorId,
+      priority,
+      getContent: async () => content
+    });
+    return ctx.json(
+      {
+        id: contributorId,
+        enabled: true,
+        priority,
+        replaced,
+        contentLength: hasContent ? content.length : void 0,
+        truncated: hasContent ? rawContent.length > content.length : void 0
+      },
+      200
+    );
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSystemPromptRouter
+});

package/dist/hono/routes/system-prompt.d.ts

@@ -0,0 +1,57 @@
+import { OpenAPIHono } from '@hono/zod-openapi';
+import type { DextoAgent } from '@dexto/core';
+import type { Context } from 'hono';
+type GetAgentFn = (ctx: Context) => DextoAgent | Promise<DextoAgent>;
+export declare function createSystemPromptRouter(getAgent: GetAgentFn): OpenAPIHono<import("hono").Env, {
+    "/system-prompt/contributors": {
+        $get: {
+            input: {};
+            output: {
+                contributors: {
+                    id: string;
+                    priority: number;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/system-prompt/contributors": {
+        $post: {
+            input: {
+                json: {
+                    id: string;
+                    content?: string | undefined;
+                    enabled?: boolean | undefined;
+                    priority?: number | undefined;
+                };
+            };
+            output: never;
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {
+                json: {
+                    id: string;
+                    content?: string | undefined;
+                    enabled?: boolean | undefined;
+                    priority?: number | undefined;
+                };
+            };
+            output: {
+                id: string;
+                enabled: boolean;
+                removed?: boolean | undefined;
+                priority?: number | undefined;
+                replaced?: boolean | undefined;
+                contentLength?: number | undefined;
+                truncated?: boolean | undefined;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">;
+export {};
+//# sourceMappingURL=system-prompt.d.ts.map

package/dist/hono/routes/system-prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-prompt.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/system-prompt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAG9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAEpC,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAgDrE,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAoK5D"}