@dexto/server 1.6.20 → 1.6.21

package/dist/hono/routes/llm.cjs

@@ -96,356 +96,374 @@ const ModelPickerErrorResponses = {
     }
   }
 };
-function createLlmRouter(getAgent) {
-  const app = new import_zod_openapi.OpenAPIHono();
-  const currentRoute = (0, import_zod_openapi.createRoute)({
-    method: "get",
-    path: "/llm/current",
-    summary: "Get Current LLM Config",
-    description: "Retrieves the current LLM configuration for the agent or a specific session",
-    tags: ["llm"],
-    request: { query: CurrentQuerySchema },
-    responses: {
-      200: {
-        description: "Current LLM config",
-        content: {
-          "application/json": {
-            schema: import_zod_openapi.z.object({
-              config: import_responses.LLMConfigResponseSchema.partial({
-                maxIterations: true
-              }).extend({
-                displayName: import_zod_openapi.z.string().optional().describe("Human-readable model display name")
-              }),
-              routing: import_zod_openapi.z.object({
-                viaDexto: import_zod_openapi.z.boolean().describe(
-                  "Whether requests route through Dexto gateway"
-                )
-              }).describe(
-                "Routing information for the current LLM configuration"
+const CapabilitiesQuerySchema = import_zod_openapi.z.object({
+  provider: import_zod_openapi.z.enum(import_core2.LLM_PROVIDERS).describe("LLM provider name"),
+  model: import_zod_openapi.z.string().min(1).describe("Model name (supports both native and OpenRouter format)")
+}).strict().describe("Query parameters for model capability lookup");
+const SetFavoritesBodySchema = import_zod_openapi.z.object({
+  favorites: import_zod_openapi.z.array(ModelPickerModelRefSchema).describe("Complete list of favorite model references")
+}).strict().describe("Request body for setting favorite models");
+const currentRoute = (0, import_zod_openapi.createRoute)({
+  method: "get",
+  path: "/llm/current",
+  summary: "Get Current LLM Config",
+  description: "Retrieves the current LLM configuration for the agent or a specific session",
+  tags: ["llm"],
+  request: { query: CurrentQuerySchema },
+  responses: {
+    200: {
+      description: "Current LLM config",
+      content: {
+        "application/json": {
+          schema: import_zod_openapi.z.object({
+            config: import_responses.LLMConfigResponseSchema.partial({
+              maxIterations: true
+            }).extend({
+              displayName: import_zod_openapi.z.string().optional().describe("Human-readable model display name")
+            }),
+            routing: import_zod_openapi.z.object({
+              viaDexto: import_zod_openapi.z.boolean().describe("Whether requests route through Dexto gateway")
+            }).describe("Routing information for the current LLM configuration")
+          }).describe("Response containing current LLM configuration")
+        }
+      }
+    },
+    400: import_responses.BadRequestErrorResponse,
+    404: import_responses.NotFoundErrorResponse,
+    500: import_responses.InternalErrorResponse
+  }
+});
+const catalogRoute = (0, import_zod_openapi.createRoute)({
+  method: "get",
+  path: "/llm/catalog",
+  summary: "LLM Catalog",
+  description: "Providers, models, capabilities, and API key status",
+  tags: ["llm"],
+  request: { query: CatalogQuerySchema },
+  responses: {
+    200: {
+      description: "LLM catalog",
+      content: {
+        "application/json": {
+          schema: import_zod_openapi.z.union([
+            import_zod_openapi.z.object({
+              providers: import_zod_openapi.z.record(import_zod_openapi.z.enum(import_core2.LLM_PROVIDERS), import_responses.ProviderCatalogSchema).describe(
+                "Providers grouped by ID with their models and capabilities"
+              )
+            }).strict().describe("Grouped catalog response (mode=grouped)"),
+            import_zod_openapi.z.object({
+              models: import_zod_openapi.z.array(import_responses.ModelFlatSchema).describe(
+                "Flat list of all models with provider information"
               )
-            }).describe("Response containing current LLM configuration")
-          }
+            }).strict().describe("Flat catalog response (mode=flat)")
+          ]).describe(
+            "LLM catalog in grouped or flat format based on mode query parameter"
+          )
         }
       }
-    }
-  });
-  const catalogRoute = (0, import_zod_openapi.createRoute)({
-    method: "get",
-    path: "/llm/catalog",
-    summary: "LLM Catalog",
-    description: "Providers, models, capabilities, and API key status",
-    tags: ["llm"],
-    request: { query: CatalogQuerySchema },
-    responses: {
-      200: {
-        description: "LLM catalog",
-        content: {
-          "application/json": {
-            schema: import_zod_openapi.z.union([
-              import_zod_openapi.z.object({
-                providers: import_zod_openapi.z.record(import_zod_openapi.z.enum(import_core2.LLM_PROVIDERS), import_responses.ProviderCatalogSchema).describe(
-                  "Providers grouped by ID with their models and capabilities"
-                )
-              }).strict().describe("Grouped catalog response (mode=grouped)"),
-              import_zod_openapi.z.object({
-                models: import_zod_openapi.z.array(import_responses.ModelFlatSchema).describe(
-                  "Flat list of all models with provider information"
-                )
-              }).strict().describe("Flat catalog response (mode=flat)")
-            ]).describe(
-              "LLM catalog in grouped or flat format based on mode query parameter"
-            )
-          }
+    },
+    400: import_responses.BadRequestErrorResponse,
+    404: import_responses.NotFoundErrorResponse,
+    500: import_responses.InternalErrorResponse
+  }
+});
+const switchRoute = (0, import_zod_openapi.createRoute)({
+  method: "post",
+  path: "/llm/switch",
+  summary: "Switch LLM",
+  description: "Switches the LLM configuration for the agent or a specific session",
+  tags: ["llm"],
+  request: {
+    body: {
+      content: {
+        "application/json": {
+          schema: SwitchLLMBodySchema
         }
       }
     }
-  });
-  const switchRoute = (0, import_zod_openapi.createRoute)({
-    method: "post",
-    path: "/llm/switch",
-    summary: "Switch LLM",
-    description: "Switches the LLM configuration for the agent or a specific session",
-    tags: ["llm"],
-    request: {
-      body: {
-        content: {
-          "application/json": {
-            schema: SwitchLLMBodySchema
-          }
+  },
+  responses: {
+    200: {
+      description: "LLM switch result",
+      content: {
+        "application/json": {
+          schema: import_zod_openapi.z.object({
+            config: import_responses.LLMConfigResponseSchema.describe(
+              "New LLM configuration with all defaults applied (apiKey omitted)"
+            ),
+            sessionId: import_zod_openapi.z.string().optional().describe("Session ID if session-specific switch")
+          }).describe("LLM switch result")
         }
       }
     },
-    responses: {
-      200: {
-        description: "LLM switch result",
-        content: {
-          "application/json": {
-            schema: import_zod_openapi.z.object({
-              config: import_responses.LLMConfigResponseSchema.describe(
-                "New LLM configuration with all defaults applied (apiKey omitted)"
-              ),
-              sessionId: import_zod_openapi.z.string().optional().describe("Session ID if session-specific switch")
-            }).describe("LLM switch result")
-          }
+    400: import_responses.BadRequestErrorResponse,
+    404: import_responses.NotFoundErrorResponse,
+    409: import_responses.ConflictErrorResponse,
+    500: import_responses.InternalErrorResponse
+  }
+});
+const listCustomModelsRoute = (0, import_zod_openapi.createRoute)({
+  method: "get",
+  path: "/llm/custom-models",
+  summary: "List Custom Models",
+  description: "Returns all saved custom openai-compatible model configurations",
+  tags: ["llm"],
+  responses: {
+    200: {
+      description: "List of custom models",
+      content: {
+        "application/json": {
+          schema: import_zod_openapi.z.object({
+            models: import_zod_openapi.z.array(import_agent_management.CustomModelSchema).describe("List of custom models")
+          })
         }
       }
-    }
-  });
-  const listCustomModelsRoute = (0, import_zod_openapi.createRoute)({
-    method: "get",
-    path: "/llm/custom-models",
-    summary: "List Custom Models",
-    description: "Returns all saved custom openai-compatible model configurations",
-    tags: ["llm"],
-    responses: {
-      200: {
-        description: "List of custom models",
-        content: {
-          "application/json": {
-            schema: import_zod_openapi.z.object({
-              models: import_zod_openapi.z.array(import_agent_management.CustomModelSchema).describe("List of custom models")
-            })
-          }
+    },
+    400: import_responses.BadRequestErrorResponse,
+    404: import_responses.NotFoundErrorResponse,
+    500: import_responses.InternalErrorResponse
+  }
+});
+const createCustomModelRoute = (0, import_zod_openapi.createRoute)({
+  method: "post",
+  path: "/llm/custom-models",
+  summary: "Create Custom Model",
+  description: "Saves a new custom openai-compatible model configuration",
+  tags: ["llm"],
+  request: {
+    body: { content: { "application/json": { schema: import_agent_management.CustomModelSchema } } }
+  },
+  responses: {
+    200: {
+      description: "Custom model saved",
+      content: {
+        "application/json": {
+          schema: import_zod_openapi.z.object({
+            ok: import_zod_openapi.z.literal(true).describe("Success indicator"),
+            model: import_agent_management.CustomModelSchema
+          })
         }
       }
-    }
-  });
-  const createCustomModelRoute = (0, import_zod_openapi.createRoute)({
-    method: "post",
-    path: "/llm/custom-models",
-    summary: "Create Custom Model",
-    description: "Saves a new custom openai-compatible model configuration",
-    tags: ["llm"],
-    request: {
-      body: { content: { "application/json": { schema: import_agent_management.CustomModelSchema } } }
     },
-    responses: {
-      200: {
-        description: "Custom model saved",
-        content: {
-          "application/json": {
-            schema: import_zod_openapi.z.object({
-              ok: import_zod_openapi.z.literal(true).describe("Success indicator"),
-              model: import_agent_management.CustomModelSchema
-            })
-          }
+    400: import_responses.BadRequestErrorResponse,
+    404: import_responses.NotFoundErrorResponse,
+    409: import_responses.ConflictErrorResponse,
+    500: import_responses.InternalErrorResponse
+  }
+});
+const deleteCustomModelRoute = (0, import_zod_openapi.createRoute)({
+  method: "delete",
+  path: "/llm/custom-models/{name}",
+  summary: "Delete Custom Model",
+  description: "Deletes a custom model by name",
+  tags: ["llm"],
+  request: {
+    params: import_zod_openapi.z.object({
+      name: import_zod_openapi.z.string().min(1).describe("Model name to delete")
+    })
+  },
+  responses: {
+    200: {
+      description: "Custom model deleted",
+      content: {
+        "application/json": {
+          schema: import_zod_openapi.z.object({
+            ok: import_zod_openapi.z.literal(true).describe("Success indicator"),
+            deleted: import_zod_openapi.z.string().describe("Name of the deleted model")
+          })
         }
       }
-    }
-  });
-  const deleteCustomModelRoute = (0, import_zod_openapi.createRoute)({
-    method: "delete",
-    path: "/llm/custom-models/{name}",
-    summary: "Delete Custom Model",
-    description: "Deletes a custom model by name",
-    tags: ["llm"],
-    request: {
-      params: import_zod_openapi.z.object({
-        name: import_zod_openapi.z.string().min(1).describe("Model name to delete")
-      })
     },
-    responses: {
-      200: {
-        description: "Custom model deleted",
-        content: {
-          "application/json": {
-            schema: import_zod_openapi.z.object({
-              ok: import_zod_openapi.z.literal(true).describe("Success indicator"),
-              deleted: import_zod_openapi.z.string().describe("Name of the deleted model")
-            })
-          }
-        }
-      },
-      404: {
-        description: "Custom model not found",
-        content: {
-          "application/json": {
-            schema: import_zod_openapi.z.object({
-              ok: import_zod_openapi.z.literal(false).describe("Failure indicator"),
-              error: import_zod_openapi.z.string().describe("Error message")
-            })
-          }
+    400: import_responses.BadRequestErrorResponse,
+    404: import_responses.NotFoundErrorResponse,
+    500: import_responses.InternalErrorResponse
+  }
+});
+const capabilitiesRoute = (0, import_zod_openapi.createRoute)({
+  method: "get",
+  path: "/llm/capabilities",
+  summary: "Get Model Capabilities",
+  description: "Returns the capabilities (supported file types) for a specific provider/model combination. Handles gateway providers (dexto-nova, openrouter) by resolving to the underlying model capabilities.",
+  tags: ["llm"],
+  request: {
+    query: CapabilitiesQuerySchema
+  },
+  responses: {
+    200: {
+      description: "Model capabilities",
+      content: {
+        "application/json": {
+          schema: import_zod_openapi.z.object({
+            provider: import_zod_openapi.z.enum(import_core2.LLM_PROVIDERS).describe("Provider name"),
+            model: import_zod_openapi.z.string().describe("Model name as provided"),
+            supportedFileTypes: import_zod_openapi.z.array(import_zod_openapi.z.enum(import_core2.SUPPORTED_FILE_TYPES)).describe("File types supported by this model"),
+            reasoning: import_zod_openapi.z.object({
+              capable: import_zod_openapi.z.boolean().describe(
+                "Whether Dexto considers this provider/model reasoning-capable (derived from registry metadata plus explicit provider/model rules)"
+              ),
+              paradigm: import_zod_openapi.z.enum([
+                "effort",
+                "adaptive-effort",
+                "thinking-level",
+                "budget",
+                "none"
+              ]).describe("Reasoning control paradigm for this model"),
+              variants: import_zod_openapi.z.array(
+                import_zod_openapi.z.object({
+                  id: import_zod_openapi.z.string().describe(
+                    "Native reasoning variant identifier"
+                  ),
+                  label: import_zod_openapi.z.string().describe(
+                    "Display label for the native reasoning variant"
+                  )
+                }).strict()
+              ).describe("Native reasoning variants exposed to users"),
+              supportedVariants: import_zod_openapi.z.array(import_zod_openapi.z.string()).describe(
+                "Native reasoning variant IDs supported for this model/provider"
+              ),
+              defaultVariant: import_zod_openapi.z.string().optional().describe(
+                "Default reasoning variant used when no explicit override is set"
+              ),
+              supportsBudgetTokens: import_zod_openapi.z.boolean().describe(
+                "Whether this provider/model supports a budgetTokens-style escape hatch"
+              )
+            }).strict().describe(
+              "Reasoning tuning capabilities derived from registry metadata and explicit provider/model rules"
+            )
+          })
         }
       }
-    }
-  });
-  const capabilitiesRoute = (0, import_zod_openapi.createRoute)({
-    method: "get",
-    path: "/llm/capabilities",
-    summary: "Get Model Capabilities",
-    description: "Returns the capabilities (supported file types) for a specific provider/model combination. Handles gateway providers (dexto-nova, openrouter) by resolving to the underlying model capabilities.",
-    tags: ["llm"],
-    request: {
-      query: import_zod_openapi.z.object({
-        provider: import_zod_openapi.z.enum(import_core2.LLM_PROVIDERS).describe("LLM provider name"),
-        model: import_zod_openapi.z.string().min(1).describe("Model name (supports both native and OpenRouter format)")
-      })
     },
-    responses: {
-      200: {
-        description: "Model capabilities",
-        content: {
-          "application/json": {
-            schema: import_zod_openapi.z.object({
-              provider: import_zod_openapi.z.enum(import_core2.LLM_PROVIDERS).describe("Provider name"),
-              model: import_zod_openapi.z.string().describe("Model name as provided"),
-              supportedFileTypes: import_zod_openapi.z.array(import_zod_openapi.z.enum(import_core2.SUPPORTED_FILE_TYPES)).describe("File types supported by this model"),
-              reasoning: import_zod_openapi.z.object({
-                capable: import_zod_openapi.z.boolean().describe(
-                  "Whether Dexto considers this provider/model reasoning-capable (derived from registry metadata plus explicit provider/model rules)"
-                ),
-                paradigm: import_zod_openapi.z.enum([
-                  "effort",
-                  "adaptive-effort",
-                  "thinking-level",
-                  "budget",
-                  "none"
-                ]).describe("Reasoning control paradigm for this model"),
-                variants: import_zod_openapi.z.array(
-                  import_zod_openapi.z.object({
-                    id: import_zod_openapi.z.string().describe(
-                      "Native reasoning variant identifier"
-                    ),
-                    label: import_zod_openapi.z.string().describe(
-                      "Display label for the native reasoning variant"
-                    )
-                  }).strict()
-                ).describe("Native reasoning variants exposed to users"),
-                supportedVariants: import_zod_openapi.z.array(import_zod_openapi.z.string()).describe(
-                  "Native reasoning variant IDs supported for this model/provider"
-                ),
-                defaultVariant: import_zod_openapi.z.string().optional().describe(
-                  "Default reasoning variant used when no explicit override is set"
-                ),
-                supportsBudgetTokens: import_zod_openapi.z.boolean().describe(
-                  "Whether this provider/model supports a budgetTokens-style escape hatch"
-                )
-              }).strict().describe(
-                "Reasoning tuning capabilities derived from registry metadata and explicit provider/model rules"
-              )
-            })
-          }
+    400: import_responses.BadRequestErrorResponse,
+    404: import_responses.NotFoundErrorResponse,
+    500: import_responses.InternalErrorResponse
+  }
+});
+const modelPickerStateRoute = (0, import_zod_openapi.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: import_zod_openapi.z.object({
+            featured: import_zod_openapi.z.array(ModelPickerEntrySchema).describe("Curated featured models"),
+            recents: import_zod_openapi.z.array(ModelPickerEntrySchema).describe("Most recently used models"),
+            favorites: import_zod_openapi.z.array(ModelPickerEntrySchema).describe("User favorited models"),
+            custom: import_zod_openapi.z.array(ModelPickerEntrySchema).describe("User-defined custom models")
+          }).strict()
         }
       }
-    }
-  });
-  const modelPickerStateRoute = (0, import_zod_openapi.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: import_zod_openapi.z.object({
-              featured: import_zod_openapi.z.array(ModelPickerEntrySchema).describe("Curated featured models"),
-              recents: import_zod_openapi.z.array(ModelPickerEntrySchema).describe("Most recently used models"),
-              favorites: import_zod_openapi.z.array(ModelPickerEntrySchema).describe("User favorited models"),
-              custom: import_zod_openapi.z.array(ModelPickerEntrySchema).describe("User-defined custom models")
-            }).strict()
-          }
+    },
+    400: ModelPickerErrorResponses[400],
+    404: ModelPickerErrorResponses[404],
+    500: ModelPickerErrorResponses[500]
+  }
+});
+const recordRecentModelRoute = (0, import_zod_openapi.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
         }
-      },
-      ...ModelPickerErrorResponses
+      }
     }
-  });
-  const recordRecentModelRoute = (0, import_zod_openapi.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: import_zod_openapi.z.object({
+            ok: import_zod_openapi.z.literal(true).describe("Success indicator")
+          }).strict()
         }
       }
     },
-    responses: {
-      200: {
-        description: "Recent model recorded",
-        content: {
-          "application/json": {
-            schema: import_zod_openapi.z.object({
-              ok: import_zod_openapi.z.literal(true).describe("Success indicator")
-            }).strict()
-          }
+    400: ModelPickerErrorResponses[400],
+    404: ModelPickerErrorResponses[404],
+    500: ModelPickerErrorResponses[500]
+  }
+});
+const toggleFavoriteModelRoute = (0, import_zod_openapi.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
         }
-      },
-      ...ModelPickerErrorResponses
+      }
     }
-  });
-  const toggleFavoriteModelRoute = (0, import_zod_openapi.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: import_zod_openapi.z.object({
+            ok: import_zod_openapi.z.literal(true).describe("Success indicator"),
+            isFavorite: import_zod_openapi.z.boolean().describe("Whether the model is now favorited")
+          }).strict()
         }
       }
     },
-    responses: {
-      200: {
-        description: "Favorite toggled",
-        content: {
-          "application/json": {
-            schema: import_zod_openapi.z.object({
-              ok: import_zod_openapi.z.literal(true).describe("Success indicator"),
-              isFavorite: import_zod_openapi.z.boolean().describe("Whether the model is now favorited")
-            }).strict()
-          }
+    400: ModelPickerErrorResponses[400],
+    404: ModelPickerErrorResponses[404],
+    500: ModelPickerErrorResponses[500]
+  }
+});
+const setFavoritesRoute = (0, import_zod_openapi.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: SetFavoritesBodySchema
         }
-      },
-      ...ModelPickerErrorResponses
+      }
     }
-  });
-  const setFavoritesRoute = (0, import_zod_openapi.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: import_zod_openapi.z.object({
-              favorites: import_zod_openapi.z.array(ModelPickerModelRefSchema).describe("Complete list of favorite model references")
-            }).strict()
-          }
+  },
+  responses: {
+    200: {
+      description: "Favorites updated",
+      content: {
+        "application/json": {
+          schema: import_zod_openapi.z.object({
+            ok: import_zod_openapi.z.literal(true).describe("Success indicator"),
+            count: import_zod_openapi.z.number().int().nonnegative().describe("Number of favorites persisted")
+          }).strict()
         }
       }
     },
-    responses: {
-      200: {
-        description: "Favorites updated",
-        content: {
-          "application/json": {
-            schema: import_zod_openapi.z.object({
-              ok: import_zod_openapi.z.literal(true).describe("Success indicator"),
-              count: import_zod_openapi.z.number().int().nonnegative().describe("Number of favorites persisted")
-            }).strict()
-          }
-        }
-      },
-      ...ModelPickerErrorResponses
-    }
-  });
+    400: ModelPickerErrorResponses[400],
+    404: ModelPickerErrorResponses[404],
+    500: ModelPickerErrorResponses[500]
+  }
+});
+function createLlmRouter(getAgent) {
+  const app = new import_zod_openapi.OpenAPIHono();
   const isProviderEnabled = (provider) => provider !== "dexto-nova" || (0, import_agent_management.isDextoAuthEnabled)();
   const dedupeEntries = (entries) => {
     const seen = /* @__PURE__ */ new Set();
@@ -585,16 +603,19 @@ function createLlmRouter(getAgent) {
     }
     const { apiKey, ...configWithoutKey } = currentConfig;
     const viaDexto = (0, import_agent_management.isDextoAuthEnabled)() && currentConfig.provider === "dexto-nova";
-    return ctx.json({
-      config: {
-        ...configWithoutKey,
-        hasApiKey: !!apiKey,
-        ...displayName && { displayName }
+    return ctx.json(
+      {
+        config: {
+          ...configWithoutKey,
+          hasApiKey: !!apiKey,
+          ...displayName && { displayName }
+        },
+        routing: {
+          viaDexto
+        }
       },
-      routing: {
-        viaDexto
-      }
-    });
+      200
+    );
   }).openapi(catalogRoute, (ctx) => {
     const queryParams = ctx.req.valid("query");
     const includeModels = queryParams.includeModels ?? true;
@@ -677,9 +698,9 @@ function createLlmRouter(getAgent) {
           flat.push({ provider: id, ...model });
         }
       }
-      return ctx.json({ models: flat });
+      return ctx.json({ models: flat }, 200);
     }
-    return ctx.json({ providers: filtered });
+    return ctx.json({ providers: filtered }, 200);
   }).openapi(switchRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const raw = ctx.req.valid("json");
@@ -694,20 +715,23 @@ function createLlmRouter(getAgent) {
     } catch {
     }
     const { apiKey, ...configWithoutKey } = config;
-    return ctx.json({
-      config: {
-        ...configWithoutKey,
-        hasApiKey: !!apiKey
+    return ctx.json(
+      {
+        config: {
+          ...configWithoutKey,
+          hasApiKey: !!apiKey
+        },
+        sessionId
       },
-      sessionId
-    });
+      200
+    );
   }).openapi(listCustomModelsRoute, async (ctx) => {
     const models = await (0, import_agent_management.loadCustomModels)();
-    return ctx.json({ models });
+    return ctx.json({ models }, 200);
   }).openapi(createCustomModelRoute, async (ctx) => {
     const model = ctx.req.valid("json");
     await (0, import_agent_management.saveCustomModel)(model);
-    return ctx.json({ ok: true, model });
+    return ctx.json({ ok: true, model }, 200);
   }).openapi(deleteCustomModelRoute, async (ctx) => {
     const { name: encodedName } = ctx.req.valid("param");
     const name = decodeURIComponent(encodedName);
@@ -724,27 +748,33 @@ function createLlmRouter(getAgent) {
     return ctx.json({ ok: true, deleted: name }, 200);
   }).openapi(modelPickerStateRoute, async (ctx) => {
     const sections = await buildModelPickerSections();
-    return ctx.json(sections);
+    return ctx.json(sections, 200);
   }).openapi(recordRecentModelRoute, async (ctx) => {
     const modelRef = ctx.req.valid("json");
     await (0, import_agent_management.recordRecentModel)(modelRef);
-    return ctx.json({ ok: true });
+    return ctx.json({ ok: true }, 200);
   }).openapi(toggleFavoriteModelRoute, async (ctx) => {
     const modelRef = ctx.req.valid("json");
     const result = await (0, import_agent_management.toggleFavoriteModel)(modelRef);
-    return ctx.json({
-      ok: true,
-      isFavorite: result.isFavorite
-    });
+    return ctx.json(
+      {
+        ok: true,
+        isFavorite: result.isFavorite
+      },
+      200
+    );
   }).openapi(setFavoritesRoute, async (ctx) => {
     const payload = ctx.req.valid("json");
     const state = await (0, import_agent_management.setFavoriteModels)({
       favorites: payload.favorites
     });
-    return ctx.json({
-      ok: true,
-      count: state.favorites.length
-    });
+    return ctx.json(
+      {
+        ok: true,
+        count: state.favorites.length
+      },
+      200
+    );
   }).openapi(capabilitiesRoute, (ctx) => {
     const { provider, model } = ctx.req.valid("query");
     let supportedFileTypes;
@@ -755,12 +785,15 @@ function createLlmRouter(getAgent) {
       supportedFileTypes = providerInfo?.supportedFileTypes ?? [];
     }
     const reasoning = (0, import_core2.getReasoningProfile)(provider, model);
-    return ctx.json({
-      provider,
-      model,
-      supportedFileTypes,
-      reasoning
-    });
+    return ctx.json(
+      {
+        provider,
+        model,
+        supportedFileTypes,
+        reasoning
+      },
+      200
+    );
   });
 }
 // Annotate the CommonJS export names for ESM import in node: