@dexto/server 1.5.7 → 1.6.0

package/dist/hono/routes/workspaces.js

@@ -0,0 +1,112 @@
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { WorkspaceSchema } from "../schemas/responses.js";
+const SetWorkspaceSchema = z.object({
+  path: z.string().min(1).describe("Absolute workspace root path"),
+  name: z.string().optional().describe("Optional workspace display name")
+}).strict().describe("Request body for setting the active workspace");
+function createWorkspacesRouter(getAgent) {
+  const app = new OpenAPIHono();
+  const listRoute = createRoute({
+    method: "get",
+    path: "/workspaces",
+    summary: "List Workspaces",
+    description: "Retrieves all known workspaces",
+    tags: ["workspaces"],
+    responses: {
+      200: {
+        description: "List of workspaces",
+        content: {
+          "application/json": {
+            schema: z.object({
+              workspaces: z.array(WorkspaceSchema).describe("Workspace list")
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  const getActiveRoute = createRoute({
+    method: "get",
+    path: "/workspaces/active",
+    summary: "Get Active Workspace",
+    description: "Returns the active workspace, if any",
+    tags: ["workspaces"],
+    responses: {
+      200: {
+        description: "Active workspace",
+        content: {
+          "application/json": {
+            schema: z.object({
+              workspace: WorkspaceSchema.nullable().describe(
+                "Active workspace or null if none is set"
+              )
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  const setActiveRoute = createRoute({
+    method: "post",
+    path: "/workspaces/active",
+    summary: "Set Active Workspace",
+    description: "Sets the active workspace for this runtime",
+    tags: ["workspaces"],
+    request: { body: { content: { "application/json": { schema: SetWorkspaceSchema } } } },
+    responses: {
+      200: {
+        description: "Active workspace updated",
+        content: {
+          "application/json": {
+            schema: z.object({
+              workspace: WorkspaceSchema.describe("Updated active workspace")
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  const clearActiveRoute = createRoute({
+    method: "delete",
+    path: "/workspaces/active",
+    summary: "Clear Active Workspace",
+    description: "Clears the active workspace for this runtime",
+    tags: ["workspaces"],
+    responses: {
+      200: {
+        description: "Active workspace cleared",
+        content: {
+          "application/json": {
+            schema: z.object({
+              workspace: WorkspaceSchema.nullable().describe(
+                "Active workspace or null if none is set"
+              )
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  return app.openapi(listRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const workspaces = await agent.listWorkspaces();
+    return ctx.json({ workspaces });
+  }).openapi(getActiveRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const workspace = await agent.getWorkspace();
+    return ctx.json({ workspace: workspace ?? null });
+  }).openapi(setActiveRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const input = ctx.req.valid("json");
+    const workspaceInput = input.name === void 0 ? { path: input.path } : { path: input.path, name: input.name };
+    const workspace = await agent.setWorkspace(workspaceInput);
+    return ctx.json({ workspace });
+  }).openapi(clearActiveRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    await agent.clearWorkspace();
+    return ctx.json({ workspace: null });
+  });
+}
+export {
+  createWorkspacesRouter
+};

package/dist/hono/schemas/responses.cjs

@@ -24,11 +24,11 @@ __export(responses_exports, {
   ContentPartSchema: () => ContentPartSchema,
   DeleteResponseSchema: () => DeleteResponseSchema,
   ErrorResponseSchema: () => ErrorResponseSchema,
+  ExecutionLogSchema: () => ExecutionLogSchema,
   FilePartSchema: () => FilePartSchema,
   HttpServerConfigSchema: () => import_core5.HttpServerConfigSchema,
   ImagePartSchema: () => ImagePartSchema,
   InternalMessageSchema: () => InternalMessageSchema,
-  InternalResourceConfigSchema: () => import_core7.InternalResourceConfigSchema,
   LLMConfigBaseSchema: () => import_core3.LLMConfigBaseSchema,
   LLMConfigResponseSchema: () => LLMConfigResponseSchema,
   LLMConfigSchema: () => LLMConfigSchema,
@@ -36,27 +36,33 @@ __export(responses_exports, {
   MemorySchema: () => import_core2.MemorySchema,
   MessageSearchResponseSchema: () => MessageSearchResponseSchema,
   ModelFlatSchema: () => ModelFlatSchema,
+  ModelStatisticsSchema: () => ModelStatisticsSchema,
   OkResponseSchema: () => OkResponseSchema,
+  PermissionsConfigSchema: () => import_core6.PermissionsConfigSchema,
   PromptArgumentSchema: () => PromptArgumentSchema,
   PromptDefinitionSchema: () => PromptDefinitionSchema,
   PromptInfoSchema: () => PromptInfoSchema,
   PromptSchema: () => PromptSchema,
   ProviderCatalogSchema: () => ProviderCatalogSchema,
+  ResourceConfigSchema: () => import_core7.ResourceConfigSchema,
   ResourceSchema: () => ResourceSchema,
+  ScheduleSchema: () => ScheduleSchema,
+  ScheduleTaskSchema: () => ScheduleTaskSchema,
   SearchResultSchema: () => SearchResultSchema,
   SessionMetadataSchema: () => SessionMetadataSchema,
   SessionSearchResponseSchema: () => SessionSearchResponseSchema,
   SessionSearchResultSchema: () => SessionSearchResultSchema,
+  SessionTokenUsageSchema: () => SessionTokenUsageSchema,
   SseServerConfigSchema: () => import_core5.SseServerConfigSchema,
   StatusResponseSchema: () => StatusResponseSchema,
   StdioServerConfigSchema: () => import_core5.StdioServerConfigSchema,
   TextPartSchema: () => TextPartSchema,
   TokenUsageSchema: () => TokenUsageSchema,
   ToolCallSchema: () => ToolCallSchema,
-  ToolConfirmationConfigSchema: () => import_core6.ToolConfirmationConfigSchema,
   ToolSchema: () => ToolSchema,
   UIResourcePartSchema: () => UIResourcePartSchema,
-  WebhookSchema: () => WebhookSchema
+  WebhookSchema: () => WebhookSchema,
+  WorkspaceSchema: () => WorkspaceSchema
 });
 module.exports = __toCommonJS(responses_exports);
 var import_zod = require("zod");
@@ -134,13 +140,76 @@ const LLMConfigResponseSchema = import_core.LLMConfigBaseSchema.omit({ apiKey: t
   hasApiKey: import_zod.z.boolean().optional().describe("Whether an API key is configured")
 }).describe("LLM configuration (apiKey omitted for security)");
 const LLMConfigSchema = import_core.LLMConfigBaseSchema.describe("LLM configuration with API key");
+const SessionTokenUsageSchema = import_zod.z.object({
+  inputTokens: import_zod.z.number().int().nonnegative().describe("Number of input tokens"),
+  outputTokens: import_zod.z.number().int().nonnegative().describe("Number of output tokens"),
+  reasoningTokens: import_zod.z.number().int().nonnegative().describe("Number of reasoning tokens"),
+  cacheReadTokens: import_zod.z.number().int().nonnegative().describe("Number of cache read tokens"),
+  cacheWriteTokens: import_zod.z.number().int().nonnegative().describe("Number of cache write tokens"),
+  totalTokens: import_zod.z.number().int().nonnegative().describe("Total tokens used")
+}).strict().describe("Session-level token usage (all fields required for cumulative totals)");
+const ModelStatisticsSchema = import_zod.z.object({
+  provider: import_zod.z.string().describe("LLM provider identifier"),
+  model: import_zod.z.string().describe("Model identifier"),
+  messageCount: import_zod.z.number().int().nonnegative().describe("Number of messages using this model"),
+  tokenUsage: SessionTokenUsageSchema.describe("Token usage for this model"),
+  estimatedCost: import_zod.z.number().nonnegative().describe("Estimated cost in USD for this model"),
+  firstUsedAt: import_zod.z.number().int().positive().describe("First use timestamp (Unix ms)"),
+  lastUsedAt: import_zod.z.number().int().positive().describe("Last use timestamp (Unix ms)")
+}).strict().describe("Per-model statistics within a session");
 const SessionMetadataSchema = import_zod.z.object({
   id: import_zod.z.string().describe("Unique session identifier"),
   createdAt: import_zod.z.number().int().positive().nullable().describe("Creation timestamp (Unix ms, null if unavailable)"),
   lastActivity: import_zod.z.number().int().positive().nullable().describe("Last activity timestamp (Unix ms, null if unavailable)"),
   messageCount: import_zod.z.number().int().nonnegative().describe("Total number of messages in session"),
-  title: import_zod.z.string().optional().nullable().describe("Optional session title")
+  title: import_zod.z.string().optional().nullable().describe("Optional session title"),
+  tokenUsage: SessionTokenUsageSchema.optional().describe(
+    "Aggregate token usage across all models"
+  ),
+  estimatedCost: import_zod.z.number().nonnegative().optional().describe("Total estimated cost in USD across all models"),
+  modelStats: import_zod.z.array(ModelStatisticsSchema).optional().describe("Per-model usage statistics (for multi-model sessions)"),
+  workspaceId: import_zod.z.string().optional().nullable().describe("Associated workspace ID, if any")
 }).strict().describe("Session metadata");
+const WorkspaceSchema = import_zod.z.object({
+  id: import_zod.z.string().describe("Workspace identifier"),
+  path: import_zod.z.string().describe("Workspace root path"),
+  name: import_zod.z.string().optional().nullable().describe("Optional workspace display name"),
+  createdAt: import_zod.z.number().int().positive().describe("Creation timestamp (Unix ms)"),
+  lastActiveAt: import_zod.z.number().int().positive().describe("Last active timestamp (Unix ms)")
+}).strict().describe("Workspace metadata");
+const ScheduleTaskSchema = import_zod.z.object({
+  instruction: import_zod.z.string().describe("Instruction to execute"),
+  metadata: import_zod.z.record(import_zod.z.unknown()).optional().describe("Optional task metadata")
+}).strict().describe("Schedule task definition");
+const ScheduleSchema = import_zod.z.object({
+  id: import_zod.z.string().describe("Schedule ID"),
+  name: import_zod.z.string().describe("Schedule name"),
+  cronExpression: import_zod.z.string().describe("Cron expression"),
+  timezone: import_zod.z.string().describe("Timezone for schedule"),
+  enabled: import_zod.z.boolean().describe("Whether the schedule is enabled"),
+  task: ScheduleTaskSchema.describe("Schedule task configuration"),
+  sessionMode: import_zod.z.enum(["ephemeral", "dedicated", "inherit", "fixed"]).describe("Session context mode"),
+  sessionId: import_zod.z.string().optional().describe("Session ID when using fixed/inherit mode"),
+  workspacePath: import_zod.z.string().optional().describe("Workspace path override"),
+  createdAt: import_zod.z.number().int().positive().describe("Creation timestamp (Unix ms)"),
+  updatedAt: import_zod.z.number().int().positive().describe("Last update timestamp (Unix ms)"),
+  lastRunAt: import_zod.z.number().int().positive().optional().describe("Last run timestamp (Unix ms)"),
+  nextRunAt: import_zod.z.number().int().positive().optional().describe("Next run timestamp (Unix ms)"),
+  runCount: import_zod.z.number().int().nonnegative().describe("Total executions"),
+  successCount: import_zod.z.number().int().nonnegative().describe("Successful executions"),
+  failureCount: import_zod.z.number().int().nonnegative().describe("Failed executions"),
+  lastError: import_zod.z.string().optional().describe("Last execution error, if any")
+}).strict().describe("Automation schedule");
+const ExecutionLogSchema = import_zod.z.object({
+  id: import_zod.z.string().describe("Execution log ID"),
+  scheduleId: import_zod.z.string().describe("Schedule ID"),
+  triggeredAt: import_zod.z.number().int().positive().describe("Trigger timestamp (Unix ms)"),
+  completedAt: import_zod.z.number().int().positive().optional().describe("Completion timestamp (Unix ms)"),
+  status: import_zod.z.enum(["pending", "success", "failed", "timeout"]).describe("Execution status"),
+  duration: import_zod.z.number().int().nonnegative().optional().describe("Execution duration in ms"),
+  error: import_zod.z.string().optional().describe("Execution error, if any"),
+  result: import_zod.z.string().optional().describe("Execution result, if any")
+}).strict().describe("Schedule execution log");
 const SearchResultSchema = import_zod.z.object({
   sessionId: import_zod.z.string().describe("Session ID where the message was found"),
   message: InternalMessageSchema.describe("The message that matched the search"),
@@ -282,11 +351,11 @@ const DeleteResponseSchema = import_zod.z.object({
   ContentPartSchema,
   DeleteResponseSchema,
   ErrorResponseSchema,
+  ExecutionLogSchema,
   FilePartSchema,
   HttpServerConfigSchema,
   ImagePartSchema,
   InternalMessageSchema,
-  InternalResourceConfigSchema,
   LLMConfigBaseSchema,
   LLMConfigResponseSchema,
   LLMConfigSchema,
@@ -294,25 +363,31 @@ const DeleteResponseSchema = import_zod.z.object({
   MemorySchema,
   MessageSearchResponseSchema,
   ModelFlatSchema,
+  ModelStatisticsSchema,
   OkResponseSchema,
+  PermissionsConfigSchema,
   PromptArgumentSchema,
   PromptDefinitionSchema,
   PromptInfoSchema,
   PromptSchema,
   ProviderCatalogSchema,
+  ResourceConfigSchema,
   ResourceSchema,
+  ScheduleSchema,
+  ScheduleTaskSchema,
   SearchResultSchema,
   SessionMetadataSchema,
   SessionSearchResponseSchema,
   SessionSearchResultSchema,
+  SessionTokenUsageSchema,
   SseServerConfigSchema,
   StatusResponseSchema,
   StdioServerConfigSchema,
   TextPartSchema,
   TokenUsageSchema,
   ToolCallSchema,
-  ToolConfirmationConfigSchema,
   ToolSchema,
   UIResourcePartSchema,
-  WebhookSchema
+  WebhookSchema,
+  WorkspaceSchema
 });