@dexto/server 1.5.8 → 1.6.1

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
 });

package/dist/hono/schemas/responses.d.ts

@@ -593,28 +593,378 @@ export declare const LLMConfigSchema: z.ZodObject<{
 export type LLMConfigResponse = z.output<typeof LLMConfigResponseSchema>;
 export { AgentCardSchema, type AgentCard } from '@dexto/core';
 export { McpServerConfigSchema, StdioServerConfigSchema, SseServerConfigSchema, HttpServerConfigSchema, type McpServerConfig, type ValidatedMcpServerConfig, } from '@dexto/core';
-export { ToolConfirmationConfigSchema } from '@dexto/core';
-export { InternalResourceConfigSchema } from '@dexto/core';
+export { PermissionsConfigSchema } from '@dexto/core';
+export { ResourceConfigSchema } from '@dexto/core';
+export declare const SessionTokenUsageSchema: z.ZodObject<{
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    reasoningTokens: z.ZodNumber;
+    cacheReadTokens: z.ZodNumber;
+    cacheWriteTokens: z.ZodNumber;
+    totalTokens: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    inputTokens: number;
+    outputTokens: number;
+    reasoningTokens: number;
+    totalTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+}, {
+    inputTokens: number;
+    outputTokens: number;
+    reasoningTokens: number;
+    totalTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+}>;
+export declare const ModelStatisticsSchema: z.ZodObject<{
+    provider: z.ZodString;
+    model: z.ZodString;
+    messageCount: z.ZodNumber;
+    tokenUsage: z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        reasoningTokens: z.ZodNumber;
+        cacheReadTokens: z.ZodNumber;
+        cacheWriteTokens: z.ZodNumber;
+        totalTokens: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        inputTokens: number;
+        outputTokens: number;
+        reasoningTokens: number;
+        totalTokens: number;
+        cacheReadTokens: number;
+        cacheWriteTokens: number;
+    }, {
+        inputTokens: number;
+        outputTokens: number;
+        reasoningTokens: number;
+        totalTokens: number;
+        cacheReadTokens: number;
+        cacheWriteTokens: number;
+    }>;
+    estimatedCost: z.ZodNumber;
+    firstUsedAt: z.ZodNumber;
+    lastUsedAt: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    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;
+}, {
+    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;
+}>;
 export declare const SessionMetadataSchema: z.ZodObject<{
     id: z.ZodString;
     createdAt: z.ZodNullable<z.ZodNumber>;
     lastActivity: z.ZodNullable<z.ZodNumber>;
     messageCount: z.ZodNumber;
     title: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    tokenUsage: z.ZodOptional<z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        reasoningTokens: z.ZodNumber;
+        cacheReadTokens: z.ZodNumber;
+        cacheWriteTokens: z.ZodNumber;
+        totalTokens: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        inputTokens: number;
+        outputTokens: number;
+        reasoningTokens: number;
+        totalTokens: number;
+        cacheReadTokens: number;
+        cacheWriteTokens: number;
+    }, {
+        inputTokens: number;
+        outputTokens: number;
+        reasoningTokens: number;
+        totalTokens: number;
+        cacheReadTokens: number;
+        cacheWriteTokens: number;
+    }>>;
+    estimatedCost: z.ZodOptional<z.ZodNumber>;
+    modelStats: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+        messageCount: z.ZodNumber;
+        tokenUsage: z.ZodObject<{
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            reasoningTokens: z.ZodNumber;
+            cacheReadTokens: z.ZodNumber;
+            cacheWriteTokens: z.ZodNumber;
+            totalTokens: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            inputTokens: number;
+            outputTokens: number;
+            reasoningTokens: number;
+            totalTokens: number;
+            cacheReadTokens: number;
+            cacheWriteTokens: number;
+        }, {
+            inputTokens: number;
+            outputTokens: number;
+            reasoningTokens: number;
+            totalTokens: number;
+            cacheReadTokens: number;
+            cacheWriteTokens: number;
+        }>;
+        estimatedCost: z.ZodNumber;
+        firstUsedAt: z.ZodNumber;
+        lastUsedAt: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        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;
+    }, {
+        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;
+    }>, "many">>;
+    workspaceId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
 }, "strict", z.ZodTypeAny, {
     id: string;
+    messageCount: number;
     createdAt: number | null;
     lastActivity: number | null;
-    messageCount: number;
     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;
 }, {
     id: string;
+    messageCount: number;
     createdAt: number | null;
     lastActivity: number | null;
-    messageCount: number;
     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;
 }>;
+export type SessionTokenUsage = z.output<typeof SessionTokenUsageSchema>;
+export type ModelStatistics = z.output<typeof ModelStatisticsSchema>;
 export type SessionMetadata = z.output<typeof SessionMetadataSchema>;
+export declare const WorkspaceSchema: z.ZodObject<{
+    id: z.ZodString;
+    path: z.ZodString;
+    name: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    createdAt: z.ZodNumber;
+    lastActiveAt: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    path: string;
+    id: string;
+    createdAt: number;
+    lastActiveAt: number;
+    name?: string | null | undefined;
+}, {
+    path: string;
+    id: string;
+    createdAt: number;
+    lastActiveAt: number;
+    name?: string | null | undefined;
+}>;
+export type Workspace = z.output<typeof WorkspaceSchema>;
+export declare const ScheduleTaskSchema: z.ZodObject<{
+    instruction: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strict", z.ZodTypeAny, {
+    instruction: string;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    instruction: string;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+export declare const ScheduleSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    cronExpression: z.ZodString;
+    timezone: z.ZodString;
+    enabled: z.ZodBoolean;
+    task: z.ZodObject<{
+        instruction: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strict", z.ZodTypeAny, {
+        instruction: string;
+        metadata?: Record<string, unknown> | undefined;
+    }, {
+        instruction: string;
+        metadata?: Record<string, unknown> | undefined;
+    }>;
+    sessionMode: z.ZodEnum<["ephemeral", "dedicated", "inherit", "fixed"]>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    workspacePath: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    lastRunAt: z.ZodOptional<z.ZodNumber>;
+    nextRunAt: z.ZodOptional<z.ZodNumber>;
+    runCount: z.ZodNumber;
+    successCount: z.ZodNumber;
+    failureCount: z.ZodNumber;
+    lastError: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    createdAt: number;
+    cronExpression: string;
+    timezone: string;
+    enabled: boolean;
+    task: {
+        instruction: string;
+        metadata?: Record<string, unknown> | undefined;
+    };
+    sessionMode: "fixed" | "ephemeral" | "dedicated" | "inherit";
+    updatedAt: number;
+    runCount: number;
+    successCount: number;
+    failureCount: number;
+    sessionId?: string | undefined;
+    workspacePath?: string | undefined;
+    lastRunAt?: number | undefined;
+    nextRunAt?: number | undefined;
+    lastError?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    createdAt: number;
+    cronExpression: string;
+    timezone: string;
+    enabled: boolean;
+    task: {
+        instruction: string;
+        metadata?: Record<string, unknown> | undefined;
+    };
+    sessionMode: "fixed" | "ephemeral" | "dedicated" | "inherit";
+    updatedAt: number;
+    runCount: number;
+    successCount: number;
+    failureCount: number;
+    sessionId?: string | undefined;
+    workspacePath?: string | undefined;
+    lastRunAt?: number | undefined;
+    nextRunAt?: number | undefined;
+    lastError?: string | undefined;
+}>;
+export type Schedule = z.output<typeof ScheduleSchema>;
+export declare const ExecutionLogSchema: z.ZodObject<{
+    id: z.ZodString;
+    scheduleId: z.ZodString;
+    triggeredAt: z.ZodNumber;
+    completedAt: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodEnum<["pending", "success", "failed", "timeout"]>;
+    duration: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodString>;
+    result: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    status: "success" | "pending" | "failed" | "timeout";
+    id: string;
+    scheduleId: string;
+    triggeredAt: number;
+    completedAt?: number | undefined;
+    duration?: number | undefined;
+    error?: string | undefined;
+    result?: string | undefined;
+}, {
+    status: "success" | "pending" | "failed" | "timeout";
+    id: string;
+    scheduleId: string;
+    triggeredAt: number;
+    completedAt?: number | undefined;
+    duration?: number | undefined;
+    error?: string | undefined;
+    result?: string | undefined;
+}>;
+export type ExecutionLog = z.output<typeof ExecutionLogSchema>;
 export declare const SearchResultSchema: z.ZodObject<{
     sessionId: z.ZodString;
     message: z.ZodObject<{
@@ -1358,20 +1708,20 @@ export declare const SessionSearchResultSchema: z.ZodObject<{
         lastActivity: z.ZodNumber;
         messageCount: z.ZodNumber;
     }, "strict", z.ZodTypeAny, {
+        messageCount: number;
         createdAt: number;
         lastActivity: number;
-        messageCount: number;
     }, {
+        messageCount: number;
         createdAt: number;
         lastActivity: number;
-        messageCount: number;
     }>;
 }, "strict", z.ZodTypeAny, {
     sessionId: string;
     metadata: {
+        messageCount: number;
         createdAt: number;
         lastActivity: number;
-        messageCount: number;
     };
     matchCount: number;
     firstMatch: {
@@ -1434,9 +1784,9 @@ export declare const SessionSearchResultSchema: z.ZodObject<{
 }, {
     sessionId: string;
     metadata: {
+        messageCount: number;
         createdAt: number;
         lastActivity: number;
-        messageCount: number;
     };
     matchCount: number;
     firstMatch: {
@@ -2369,20 +2719,20 @@ export declare const SessionSearchResponseSchema: z.ZodObject<{
             lastActivity: z.ZodNumber;
             messageCount: z.ZodNumber;
         }, "strict", z.ZodTypeAny, {
+            messageCount: number;
             createdAt: number;
             lastActivity: number;
-            messageCount: number;
         }, {
+            messageCount: number;
             createdAt: number;
             lastActivity: number;
-            messageCount: number;
         }>;
     }, "strict", z.ZodTypeAny, {
         sessionId: string;
         metadata: {
+            messageCount: number;
             createdAt: number;
             lastActivity: number;
-            messageCount: number;
         };
         matchCount: number;
         firstMatch: {
@@ -2445,9 +2795,9 @@ export declare const SessionSearchResponseSchema: z.ZodObject<{
     }, {
         sessionId: string;
         metadata: {
+            messageCount: number;
             createdAt: number;
             lastActivity: number;
-            messageCount: number;
         };
         matchCount: number;
         firstMatch: {
@@ -2516,9 +2866,9 @@ export declare const SessionSearchResponseSchema: z.ZodObject<{
     results: {
         sessionId: string;
         metadata: {
+            messageCount: number;
             createdAt: number;
             lastActivity: number;
-            messageCount: number;
         };
         matchCount: number;
         firstMatch: {
@@ -2586,9 +2936,9 @@ export declare const SessionSearchResponseSchema: z.ZodObject<{
     results: {
         sessionId: string;
         metadata: {
+            messageCount: number;
             createdAt: number;
             lastActivity: number;
-            messageCount: number;
         };
         matchCount: number;
         firstMatch: {
@@ -3106,19 +3456,19 @@ export declare const ErrorResponseSchema: z.ZodObject<{
         details?: unknown;
     }>;
 }, "strict", z.ZodTypeAny, {
-    ok: false;
     error: {
         message: string;
         code?: string | undefined;
         details?: unknown;
     };
-}, {
     ok: false;
+}, {
     error: {
         message: string;
         code?: string | undefined;
         details?: unknown;
     };
+    ok: false;
 }>;
 export type ErrorResponse = z.output<typeof ErrorResponseSchema>;
 export declare const StatusResponseSchema: z.ZodObject<{