@dexto/server 1.6.8 → 1.6.9

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

@@ -584,6 +584,96 @@ export declare function createLlmRouter(getAgent: GetAgentFn): OpenAPIHono<impor
             status: 404;
         };
     };
+} & {
+    "/llm/model-picker-state": {
+        $get: {
+            input: {};
+            output: {
+                custom: {
+                    model: string;
+                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova";
+                    supportedFileTypes: ("image" | "audio" | "pdf")[];
+                    source: "custom" | "catalog" | "local-installed";
+                    displayName?: string | undefined;
+                }[];
+                featured: {
+                    model: string;
+                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova";
+                    supportedFileTypes: ("image" | "audio" | "pdf")[];
+                    source: "custom" | "catalog" | "local-installed";
+                    displayName?: string | undefined;
+                }[];
+                recents: {
+                    model: string;
+                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova";
+                    supportedFileTypes: ("image" | "audio" | "pdf")[];
+                    source: "custom" | "catalog" | "local-installed";
+                    displayName?: string | undefined;
+                }[];
+                favorites: {
+                    model: string;
+                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova";
+                    supportedFileTypes: ("image" | "audio" | "pdf")[];
+                    source: "custom" | "catalog" | "local-installed";
+                    displayName?: string | undefined;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/llm/model-picker-state/recents": {
+        $post: {
+            input: {
+                json: {
+                    model: string;
+                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova";
+                };
+            };
+            output: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/llm/model-picker-state/favorites/toggle": {
+        $post: {
+            input: {
+                json: {
+                    model: string;
+                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova";
+                };
+            };
+            output: {
+                ok: true;
+                isFavorite: boolean;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/llm/model-picker-state/favorites": {
+        $put: {
+            input: {
+                json: {
+                    favorites: {
+                        model: string;
+                        provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova";
+                    }[];
+                };
+            };
+            output: {
+                ok: true;
+                count: number;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
 } & {
     "/llm/capabilities": {
         $get: {

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

@@ -1 +1 @@
-{"version":3,"file":"llm.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/llm.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAwB9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAOpC,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAmFrE,wBAAgB,eAAe,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA0J5C,CAAP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA5JA,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAohBD"}
+{"version":3,"file":"llm.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/llm.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAkC9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAQpC,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AA0IrE,wBAAgB,eAAe,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAkGhC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAnKS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA24B9B"}

package/dist/hono/routes/llm.js

@@ -1,5 +1,5 @@
 import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
-import { DextoRuntimeError, ErrorScope, ErrorType } from "@dexto/core";
+import { DextoRuntimeError, ErrorScope, ErrorType, logger } from "@dexto/core";
 import {
   LLM_REGISTRY,
   LLM_PROVIDERS,
@@ -7,7 +7,9 @@ import {
   supportsBaseURL,
   getAllModelsForProvider,
   getCuratedModelsForProvider,
+  getCuratedModelRefsForProviders,
   getSupportedFileTypesForModel,
+  getLocalModelById,
   getReasoningProfile,
   LLMUpdatesSchema
 } from "@dexto/core";
@@ -16,14 +18,24 @@ import {
   loadCustomModels,
   saveCustomModel,
   deleteCustomModel,
+  loadModelPickerState,
+  saveModelPickerState,
+  recordRecentModel,
+  toggleFavoriteModel,
+  setFavoriteModels,
+  pruneModelPickerState,
+  toModelPickerKey,
+  getAllInstalledModels,
   CustomModelSchema,
   isDextoAuthEnabled
 } from "@dexto/agent-management";
 import {
   ProviderCatalogSchema,
   ModelFlatSchema,
-  LLMConfigResponseSchema
+  LLMConfigResponseSchema,
+  StandardErrorEnvelopeSchema
 } from "../schemas/responses.js";
+const MODEL_PICKER_FEATURED_LIMIT = 8;
 const CurrentQuerySchema = z.object({
   sessionId: z.string().optional().describe("Session identifier to retrieve session-specific LLM configuration")
 }).strict().describe("Query parameters for getting current LLM configuration");
@@ -51,6 +63,46 @@ const SwitchLLMBodySchema = LLMUpdatesSchema.and(
     sessionId: z.string().optional().describe("Session identifier for session-specific LLM configuration")
   })
 ).describe("LLM switch request body with optional session ID and LLM fields");
+const ModelPickerModelRefSchema = z.object({
+  provider: z.enum(LLM_PROVIDERS).describe("LLM provider"),
+  model: z.string().trim().min(1).describe("Model ID")
+}).strict().describe("Provider/model pair for model picker state operations");
+const ModelPickerEntrySchema = z.object({
+  provider: z.enum(LLM_PROVIDERS).describe("LLM provider"),
+  model: z.string().describe("Model ID"),
+  displayName: z.string().optional().describe("Human-readable model name"),
+  supportedFileTypes: z.array(z.enum(SUPPORTED_FILE_TYPES)).describe("File types supported by this model"),
+  source: z.enum(["catalog", "custom", "local-installed"]).describe("Where this model comes from")
+}).strict().describe("Hydrated model picker entry");
+const ModelPickerErrorSchema = StandardErrorEnvelopeSchema.describe(
+  "Standard error response for model picker endpoints"
+);
+const ModelPickerErrorResponses = {
+  400: {
+    description: "Validation or request error",
+    content: {
+      "application/json": {
+        schema: ModelPickerErrorSchema
+      }
+    }
+  },
+  404: {
+    description: "Resource not found",
+    content: {
+      "application/json": {
+        schema: ModelPickerErrorSchema
+      }
+    }
+  },
+  500: {
+    description: "Internal server error",
+    content: {
+      "application/json": {
+        schema: ModelPickerErrorSchema
+      }
+    }
+  }
+};
 function createLlmRouter(getAgent) {
   const app = new OpenAPIHono();
   const currentRoute = createRoute({
@@ -284,6 +336,217 @@ function createLlmRouter(getAgent) {
       }
     }
   });
+  const modelPickerStateRoute = createRoute({
+    method: "get",
+    path: "/llm/model-picker-state",
+    summary: "Model Picker State",
+    description: "Returns hydrated Featured, Recents, Favorites, and Custom sections for the model picker.",
+    tags: ["llm"],
+    responses: {
+      200: {
+        description: "Hydrated model picker sections",
+        content: {
+          "application/json": {
+            schema: z.object({
+              featured: z.array(ModelPickerEntrySchema).describe("Curated featured models"),
+              recents: z.array(ModelPickerEntrySchema).describe("Most recently used models"),
+              favorites: z.array(ModelPickerEntrySchema).describe("User favorited models"),
+              custom: z.array(ModelPickerEntrySchema).describe("User-defined custom models")
+            }).strict()
+          }
+        }
+      },
+      ...ModelPickerErrorResponses
+    }
+  });
+  const recordRecentModelRoute = createRoute({
+    method: "post",
+    path: "/llm/model-picker-state/recents",
+    summary: "Record Recent Model",
+    description: "Records a model selection in recents.",
+    tags: ["llm"],
+    request: {
+      body: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: ModelPickerModelRefSchema
+          }
+        }
+      }
+    },
+    responses: {
+      200: {
+        description: "Recent model recorded",
+        content: {
+          "application/json": {
+            schema: z.object({
+              ok: z.literal(true).describe("Success indicator")
+            }).strict()
+          }
+        }
+      },
+      ...ModelPickerErrorResponses
+    }
+  });
+  const toggleFavoriteModelRoute = createRoute({
+    method: "post",
+    path: "/llm/model-picker-state/favorites/toggle",
+    summary: "Toggle Favorite Model",
+    description: "Adds or removes a model from favorites.",
+    tags: ["llm"],
+    request: {
+      body: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: ModelPickerModelRefSchema
+          }
+        }
+      }
+    },
+    responses: {
+      200: {
+        description: "Favorite toggled",
+        content: {
+          "application/json": {
+            schema: z.object({
+              ok: z.literal(true).describe("Success indicator"),
+              isFavorite: z.boolean().describe("Whether the model is now favorited")
+            }).strict()
+          }
+        }
+      },
+      ...ModelPickerErrorResponses
+    }
+  });
+  const setFavoritesRoute = createRoute({
+    method: "put",
+    path: "/llm/model-picker-state/favorites",
+    summary: "Set Favorite Models",
+    description: "Replaces favorite models list. Used by migration or bulk updates.",
+    tags: ["llm"],
+    request: {
+      body: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: z.object({
+              favorites: z.array(ModelPickerModelRefSchema).describe("Complete list of favorite model references")
+            }).strict()
+          }
+        }
+      }
+    },
+    responses: {
+      200: {
+        description: "Favorites updated",
+        content: {
+          "application/json": {
+            schema: z.object({
+              ok: z.literal(true).describe("Success indicator"),
+              count: z.number().int().nonnegative().describe("Number of favorites persisted")
+            }).strict()
+          }
+        }
+      },
+      ...ModelPickerErrorResponses
+    }
+  });
+  const isProviderEnabled = (provider) => provider !== "dexto-nova" || isDextoAuthEnabled();
+  const dedupeEntries = (entries) => {
+    const seen = /* @__PURE__ */ new Set();
+    const deduped = [];
+    for (const entry of entries) {
+      const key = toModelPickerKey(entry);
+      if (seen.has(key)) {
+        continue;
+      }
+      seen.add(key);
+      deduped.push(entry);
+    }
+    return deduped;
+  };
+  const buildModelPickerSections = async () => {
+    const byKey = /* @__PURE__ */ new Map();
+    const customSection = [];
+    for (const provider of LLM_PROVIDERS) {
+      if (!isProviderEnabled(provider)) {
+        continue;
+      }
+      const providerInfo = LLM_REGISTRY[provider];
+      for (const model of getAllModelsForProvider(provider)) {
+        const supportedFileTypes = Array.isArray(model.supportedFileTypes) && model.supportedFileTypes.length > 0 ? model.supportedFileTypes : providerInfo.supportedFileTypes;
+        const entry = {
+          provider,
+          model: model.name,
+          displayName: model.displayName || model.name,
+          supportedFileTypes,
+          source: "catalog"
+        };
+        const key = toModelPickerKey(entry);
+        if (!byKey.has(key)) {
+          byKey.set(key, entry);
+        }
+      }
+    }
+    const customModels = await loadCustomModels();
+    for (const customModel of customModels) {
+      const provider = customModel.provider ?? "openai-compatible";
+      if (!isProviderEnabled(provider)) {
+        continue;
+      }
+      const providerInfo = LLM_REGISTRY[provider];
+      const entry = {
+        provider,
+        model: customModel.name,
+        displayName: customModel.displayName || customModel.name,
+        supportedFileTypes: providerInfo?.supportedFileTypes ?? [],
+        source: "custom"
+      };
+      byKey.set(toModelPickerKey(entry), entry);
+      customSection.push(entry);
+    }
+    const localProviderSupportedFileTypes = LLM_REGISTRY.local.supportedFileTypes;
+    const installedLocalModels = await getAllInstalledModels();
+    for (const installedModel of installedLocalModels) {
+      const modelInfo = getLocalModelById(installedModel.id);
+      const entry = {
+        provider: "local",
+        model: installedModel.id,
+        displayName: modelInfo?.name || installedModel.id,
+        supportedFileTypes: localProviderSupportedFileTypes,
+        source: "local-installed"
+      };
+      byKey.set(toModelPickerKey(entry), entry);
+    }
+    const featuredProviders = LLM_PROVIDERS.filter((provider) => isProviderEnabled(provider));
+    const featured = getCuratedModelRefsForProviders({
+      providers: featuredProviders,
+      max: MODEL_PICKER_FEATURED_LIMIT
+    }).map((ref) => byKey.get(toModelPickerKey(ref))).filter((entry) => Boolean(entry));
+    const state = await loadModelPickerState();
+    const pruned = pruneModelPickerState({
+      state,
+      allowedKeys: new Set(byKey.keys())
+    });
+    const shouldPersistPrunedState = state.recents.length !== pruned.recents.length || state.favorites.length !== pruned.favorites.length;
+    if (shouldPersistPrunedState) {
+      void saveModelPickerState(pruned).catch((error) => {
+        logger.warn(
+          `Failed to persist pruned model picker state: ${error instanceof Error ? error.message : String(error)}`
+        );
+      });
+    }
+    const recents = pruned.recents.map((entry) => byKey.get(toModelPickerKey(entry))).filter((entry) => Boolean(entry));
+    const favorites = pruned.favorites.map((entry) => byKey.get(toModelPickerKey(entry))).filter((entry) => Boolean(entry));
+    return {
+      featured: dedupeEntries(featured),
+      recents,
+      favorites,
+      custom: dedupeEntries(customSection)
+    };
+  };
   return app.openapi(currentRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("query");
@@ -405,6 +668,13 @@ function createLlmRouter(getAgent) {
     const raw = ctx.req.valid("json");
     const { sessionId, ...llmUpdates } = raw;
     const config = await agent.switchLLM(llmUpdates, sessionId);
+    try {
+      await recordRecentModel({
+        provider: config.provider,
+        model: config.model
+      });
+    } catch {
+    }
     const { apiKey, ...configWithoutKey } = config;
     return ctx.json({
       config: {
@@ -434,6 +704,29 @@ function createLlmRouter(getAgent) {
       );
     }
     return ctx.json({ ok: true, deleted: name }, 200);
+  }).openapi(modelPickerStateRoute, async (ctx) => {
+    const sections = await buildModelPickerSections();
+    return ctx.json(sections);
+  }).openapi(recordRecentModelRoute, async (ctx) => {
+    const modelRef = ctx.req.valid("json");
+    await recordRecentModel(modelRef);
+    return ctx.json({ ok: true });
+  }).openapi(toggleFavoriteModelRoute, async (ctx) => {
+    const modelRef = ctx.req.valid("json");
+    const result = await toggleFavoriteModel(modelRef);
+    return ctx.json({
+      ok: true,
+      isFavorite: result.isFavorite
+    });
+  }).openapi(setFavoritesRoute, async (ctx) => {
+    const payload = ctx.req.valid("json");
+    const state = await setFavoriteModels({
+      favorites: payload.favorites
+    });
+    return ctx.json({
+      ok: true,
+      count: state.favorites.length
+    });
   }).openapi(capabilitiesRoute, (ctx) => {
     const { provider, model } = ctx.req.valid("query");
     let supportedFileTypes;

package/dist/hono/routes/sessions.cjs

@@ -26,6 +26,17 @@ var import_responses = require("../schemas/responses.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");
+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 import_zod_openapi.OpenAPIHono();
   const listRoute = (0, import_zod_openapi.createRoute)({
@@ -91,6 +102,48 @@ function createSessionsRouter(getAgent) {
       }
     }
   });
+  const forkRoute = (0, import_zod_openapi.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: import_zod_openapi.z.object({
+        sessionId: import_zod_openapi.z.string().describe("Parent session identifier")
+      })
+    },
+    responses: {
+      201: {
+        description: "Forked session created successfully",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              session: import_responses.SessionMetadataSchema.describe(
+                "Newly created child session metadata"
+              )
+            }).strict()
+          }
+        }
+      },
+      400: {
+        description: "Invalid fork request (for example, max session limit reached)",
+        content: {
+          "application/json": {
+            schema: import_responses.StandardErrorEnvelopeSchema
+          }
+        }
+      },
+      404: {
+        description: "Parent session not found",
+        content: {
+          "application/json": {
+            schema: import_responses.StandardErrorEnvelopeSchema
+          }
+        }
+      }
+    }
+  });
   const historyRoute = (0, import_zod_openapi.createRoute)({
     method: "get",
     path: "/sessions/{sessionId}/history",
@@ -274,23 +327,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);
         }
       })
     );
@@ -302,14 +341,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
     );
@@ -320,12 +366,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
       }
     });
@@ -386,12 +427,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
         }
       },
@@ -404,14 +440,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);