@dexto/server 1.5.8 → 1.6.1

package/dist/hono/routes/schedules.js

@@ -0,0 +1,439 @@
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import {
+  ErrorResponseSchema,
+  ExecutionLogSchema,
+  ScheduleSchema
+} from "../schemas/responses.js";
+import { SchedulerErrorCode } from "@dexto/tools-scheduler";
+import {
+  ensureSchedulerManagerForAgent,
+  getSchedulerManager
+} from "@dexto/tools-scheduler/service";
+import { DextoRuntimeError, ErrorType } from "@dexto/core";
+const CreateScheduleSchema = z.object({
+  name: z.string().min(1).describe("Schedule name"),
+  instruction: z.string().min(1).describe("Instruction to run on schedule"),
+  cronExpression: z.string().min(1).describe("Cron expression"),
+  timezone: z.string().optional().describe("Timezone for schedule"),
+  enabled: z.boolean().optional().describe("Whether the schedule is enabled"),
+  workspacePath: z.string().optional().nullable().describe("Optional workspace path for scheduled runs")
+}).strict().describe("Request body for creating a schedule");
+const UpdateScheduleSchema = CreateScheduleSchema.partial().strict().describe("Request body for updating a schedule");
+const isScheduleNotFoundError = (error) => error instanceof DextoRuntimeError && error.type === ErrorType.NOT_FOUND && error.code === SchedulerErrorCode.SCHEDULE_NOT_FOUND;
+const logSchedulerError = (agent, message, error) => {
+  if (!agent?.logger) {
+    return;
+  }
+  agent.logger.error(message, {
+    error: error instanceof Error ? error.message : String(error ?? "Unknown error"),
+    stack: error instanceof Error ? error.stack : void 0,
+    code: error instanceof DextoRuntimeError ? error.code : void 0
+  });
+};
+const toErrorResponse = (message, code) => ({
+  ok: false,
+  error: {
+    message,
+    ...code ? { code } : {}
+  }
+});
+function createSchedulesRouter(getAgent) {
+  const app = new OpenAPIHono();
+  const resolveScheduler = async (ctx) => {
+    const agent = await getAgent(ctx);
+    const agentId = agent.config?.agentId ?? "default";
+    let scheduler = getSchedulerManager(agentId) ?? null;
+    if (!scheduler) {
+      scheduler = await ensureSchedulerManagerForAgent(agent);
+    }
+    return { scheduler, agent };
+  };
+  const listRoute = createRoute({
+    method: "get",
+    path: "/schedules",
+    summary: "List Schedules",
+    description: "Retrieves all automation schedules",
+    tags: ["schedules"],
+    responses: {
+      200: {
+        description: "List of schedules",
+        content: {
+          "application/json": {
+            schema: z.object({
+              schedules: z.array(ScheduleSchema).describe("Schedule list")
+            }).strict()
+          }
+        }
+      },
+      500: {
+        description: "Failed to list schedules",
+        content: {
+          "application/json": {
+            schema: ErrorResponseSchema
+          }
+        }
+      },
+      503: {
+        description: "Scheduler tools are not enabled",
+        content: {
+          "application/json": {
+            schema: ErrorResponseSchema
+          }
+        }
+      }
+    }
+  });
+  const createRouteDef = createRoute({
+    method: "post",
+    path: "/schedules",
+    summary: "Create Schedule",
+    description: "Creates a new automation schedule",
+    tags: ["schedules"],
+    request: { body: { content: { "application/json": { schema: CreateScheduleSchema } } } },
+    responses: {
+      201: {
+        description: "Created schedule",
+        content: {
+          "application/json": {
+            schema: z.object({ schedule: ScheduleSchema }).strict()
+          }
+        }
+      },
+      400: {
+        description: "Validation error",
+        content: {
+          "application/json": {
+            schema: ErrorResponseSchema
+          }
+        }
+      },
+      429: {
+        description: "Schedule limit reached",
+        content: {
+          "application/json": {
+            schema: ErrorResponseSchema
+          }
+        }
+      },
+      500: {
+        description: "Failed to create schedule",
+        content: {
+          "application/json": {
+            schema: ErrorResponseSchema
+          }
+        }
+      },
+      503: {
+        description: "Scheduler tools are not enabled",
+        content: {
+          "application/json": {
+            schema: ErrorResponseSchema
+          }
+        }
+      }
+    }
+  });
+  const updateRoute = createRoute({
+    method: "patch",
+    path: "/schedules/{scheduleId}",
+    summary: "Update Schedule",
+    description: "Updates an existing schedule",
+    tags: ["schedules"],
+    request: {
+      params: z.object({
+        scheduleId: z.string().min(1).describe("Schedule ID")
+      }).strict().describe("Schedule identifier params"),
+      body: { content: { "application/json": { schema: UpdateScheduleSchema } } }
+    },
+    responses: {
+      200: {
+        description: "Updated schedule",
+        content: {
+          "application/json": {
+            schema: z.object({ schedule: ScheduleSchema }).strict()
+          }
+        }
+      },
+      400: {
+        description: "Validation error",
+        content: {
+          "application/json": {
+            schema: ErrorResponseSchema
+          }
+        }
+      },
+      404: {
+        description: "Schedule not found",
+        content: {
+          "application/json": {
+            schema: ErrorResponseSchema
+          }
+        }
+      },
+      500: {
+        description: "Failed to update schedule",
+        content: {
+          "application/json": {
+            schema: ErrorResponseSchema
+          }
+        }
+      },
+      503: {
+        description: "Scheduler tools are not enabled",
+        content: {
+          "application/json": {
+            schema: ErrorResponseSchema
+          }
+        }
+      }
+    }
+  });
+  const deleteRoute = createRoute({
+    method: "delete",
+    path: "/schedules/{scheduleId}",
+    summary: "Delete Schedule",
+    description: "Deletes an automation schedule",
+    tags: ["schedules"],
+    request: {
+      params: z.object({
+        scheduleId: z.string().min(1).describe("Schedule ID")
+      }).strict().describe("Schedule identifier params")
+    },
+    responses: {
+      200: {
+        description: "Schedule deleted",
+        content: {
+          "application/json": {
+            schema: z.object({
+              deleted: z.boolean().describe("Whether the schedule was deleted")
+            }).strict().describe("Delete schedule response")
+          }
+        }
+      },
+      404: {
+        description: "Schedule not found",
+        content: {
+          "application/json": {
+            schema: ErrorResponseSchema
+          }
+        }
+      },
+      500: {
+        description: "Failed to delete schedule",
+        content: {
+          "application/json": {
+            schema: ErrorResponseSchema
+          }
+        }
+      },
+      503: {
+        description: "Scheduler tools are not enabled",
+        content: {
+          "application/json": {
+            schema: ErrorResponseSchema
+          }
+        }
+      }
+    }
+  });
+  const triggerRoute = createRoute({
+    method: "post",
+    path: "/schedules/{scheduleId}/trigger",
+    summary: "Trigger Schedule",
+    description: "Runs a schedule immediately and waits for execution to complete (bounded by executionTimeout, default 5 minutes). Clients should set timeouts accordingly.",
+    tags: ["schedules"],
+    request: {
+      params: z.object({
+        scheduleId: z.string().min(1).describe("Schedule ID")
+      }).strict().describe("Schedule identifier params")
+    },
+    responses: {
+      200: {
+        description: "Schedule triggered",
+        content: {
+          "application/json": {
+            schema: z.object({
+              scheduled: z.boolean().describe(
+                "Whether the schedule was queued. Execution is omitted when false."
+              ),
+              execution: ExecutionLogSchema.optional().describe(
+                "Execution log (present when scheduled is true)"
+              )
+            }).strict().describe("Trigger schedule response")
+          }
+        }
+      },
+      404: {
+        description: "Schedule not found",
+        content: {
+          "application/json": {
+            schema: ErrorResponseSchema
+          }
+        }
+      },
+      500: {
+        description: "Failed to trigger schedule",
+        content: {
+          "application/json": {
+            schema: ErrorResponseSchema
+          }
+        }
+      },
+      503: {
+        description: "Scheduler tools are not enabled",
+        content: {
+          "application/json": {
+            schema: ErrorResponseSchema
+          }
+        }
+      }
+    }
+  });
+  return app.openapi(listRoute, async (ctx) => {
+    const { scheduler, agent } = await resolveScheduler(ctx);
+    if (!scheduler) {
+      return ctx.json(
+        toErrorResponse("Scheduler tools are not enabled for this agent."),
+        503
+      );
+    }
+    try {
+      const schedules = await scheduler.listSchedules();
+      return ctx.json({ schedules }, 200);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error ?? "Unknown error");
+      logSchedulerError(agent, "Failed to list schedules", error);
+      if (error instanceof DextoRuntimeError) {
+        return ctx.json(toErrorResponse(message, String(error.code)), 500);
+      }
+      return ctx.json(toErrorResponse("Failed to list schedules"), 500);
+    }
+  }).openapi(createRouteDef, async (ctx) => {
+    const { scheduler, agent } = await resolveScheduler(ctx);
+    if (!scheduler) {
+      return ctx.json(
+        toErrorResponse("Scheduler tools are not enabled for this agent."),
+        503
+      );
+    }
+    const input = ctx.req.valid("json");
+    const createPayload = {
+      name: input.name,
+      instruction: input.instruction,
+      cronExpression: input.cronExpression,
+      ...input.timezone !== void 0 ? { timezone: input.timezone } : {},
+      enabled: input.enabled ?? true,
+      ...input.workspacePath !== void 0 ? { workspacePath: input.workspacePath } : {},
+      sessionMode: "dedicated"
+    };
+    try {
+      const schedule = await scheduler.createSchedule(createPayload);
+      return ctx.json({ schedule }, 201);
+    } catch (error) {
+      if (error instanceof DextoRuntimeError && error.code === SchedulerErrorCode.SCHEDULE_INVALID_CRON) {
+        return ctx.json(toErrorResponse(error.message, String(error.code)), 400);
+      }
+      if (error instanceof DextoRuntimeError && error.code === SchedulerErrorCode.SCHEDULE_INVALID_INPUT) {
+        return ctx.json(toErrorResponse(error.message, String(error.code)), 400);
+      }
+      if (error instanceof DextoRuntimeError && error.code === SchedulerErrorCode.SCHEDULE_LIMIT_REACHED) {
+        return ctx.json(toErrorResponse(error.message, String(error.code)), 429);
+      }
+      logSchedulerError(agent, "Failed to create schedule", error);
+      return ctx.json(toErrorResponse("Failed to create schedule"), 500);
+    }
+  }).openapi(updateRoute, async (ctx) => {
+    const { scheduler, agent } = await resolveScheduler(ctx);
+    if (!scheduler) {
+      return ctx.json(
+        toErrorResponse("Scheduler tools are not enabled for this agent."),
+        503
+      );
+    }
+    const { scheduleId } = ctx.req.valid("param");
+    const input = ctx.req.valid("json");
+    const updatePayload = {
+      ...input.name !== void 0 ? { name: input.name } : {},
+      ...input.instruction !== void 0 ? { instruction: input.instruction } : {},
+      ...input.cronExpression !== void 0 ? { cronExpression: input.cronExpression } : {},
+      ...input.timezone !== void 0 ? { timezone: input.timezone } : {},
+      ...input.enabled !== void 0 ? { enabled: input.enabled } : {},
+      ...input.workspacePath !== void 0 ? { workspacePath: input.workspacePath } : {}
+    };
+    try {
+      const schedule = await scheduler.updateSchedule(scheduleId, updatePayload);
+      return ctx.json({ schedule }, 200);
+    } catch (error) {
+      if (isScheduleNotFoundError(error)) {
+        return ctx.json(
+          toErrorResponse(
+            "Schedule not found",
+            SchedulerErrorCode.SCHEDULE_NOT_FOUND
+          ),
+          404
+        );
+      }
+      if (error instanceof DextoRuntimeError && error.code === SchedulerErrorCode.SCHEDULE_INVALID_CRON) {
+        return ctx.json(toErrorResponse(error.message, String(error.code)), 400);
+      }
+      if (error instanceof DextoRuntimeError && error.code === SchedulerErrorCode.SCHEDULE_INVALID_INPUT) {
+        return ctx.json(toErrorResponse(error.message, String(error.code)), 400);
+      }
+      logSchedulerError(agent, "Failed to update schedule", error);
+      return ctx.json(toErrorResponse("Failed to update schedule"), 500);
+    }
+  }).openapi(deleteRoute, async (ctx) => {
+    const { scheduler, agent } = await resolveScheduler(ctx);
+    if (!scheduler) {
+      return ctx.json(
+        toErrorResponse("Scheduler tools are not enabled for this agent."),
+        503
+      );
+    }
+    const { scheduleId } = ctx.req.valid("param");
+    try {
+      await scheduler.deleteSchedule(scheduleId);
+      return ctx.json({ deleted: true }, 200);
+    } catch (error) {
+      if (isScheduleNotFoundError(error)) {
+        return ctx.json(
+          toErrorResponse(
+            "Schedule not found",
+            SchedulerErrorCode.SCHEDULE_NOT_FOUND
+          ),
+          404
+        );
+      }
+      logSchedulerError(agent, "Failed to delete schedule", error);
+      return ctx.json(toErrorResponse("Failed to delete schedule"), 500);
+    }
+  }).openapi(triggerRoute, async (ctx) => {
+    const { scheduler, agent } = await resolveScheduler(ctx);
+    if (!scheduler) {
+      return ctx.json(
+        toErrorResponse("Scheduler tools are not enabled for this agent."),
+        503
+      );
+    }
+    const { scheduleId } = ctx.req.valid("param");
+    try {
+      const execution = await scheduler.triggerScheduleNow(scheduleId);
+      return ctx.json({ scheduled: true, execution }, 200);
+    } catch (error) {
+      if (isScheduleNotFoundError(error)) {
+        return ctx.json(
+          toErrorResponse(
+            "Schedule not found",
+            SchedulerErrorCode.SCHEDULE_NOT_FOUND
+          ),
+          404
+        );
+      }
+      logSchedulerError(agent, "Failed to trigger schedule", error);
+      return ctx.json(toErrorResponse("Failed to trigger schedule"), 500);
+    }
+  });
+}
+export {
+  createSchedulesRouter
+};

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

@@ -93,9 +93,9 @@ export declare function createSearchRouter(getAgent: GetAgentFn): OpenAPIHono<im
                 results: {
                     sessionId: string;
                     metadata: {
+                        messageCount: number;
                         createdAt: number;
                         lastActivity: number;
-                        messageCount: number;
                     };
                     matchCount: number;
                     firstMatch: {

package/dist/hono/routes/sessions.cjs

@@ -279,7 +279,8 @@ function createSessionsRouter(getAgent) {
             createdAt: metadata?.createdAt || null,
             lastActivity: metadata?.lastActivity || null,
             messageCount: metadata?.messageCount || 0,
-            title: metadata?.title || null
+            title: metadata?.title || null,
+            workspaceId: metadata?.workspaceId || null
           };
         } catch {
           return {
@@ -287,7 +288,8 @@ function createSessionsRouter(getAgent) {
             createdAt: null,
             lastActivity: null,
             messageCount: 0,
-            title: null
+            title: null,
+            workspaceId: null
           };
         }
       })
@@ -305,7 +307,8 @@ function createSessionsRouter(getAgent) {
           createdAt: metadata?.createdAt || Date.now(),
           lastActivity: metadata?.lastActivity || Date.now(),
           messageCount: metadata?.messageCount || 0,
-          title: metadata?.title || null
+          title: metadata?.title || null,
+          workspaceId: metadata?.workspaceId || null
         }
       },
       201
@@ -322,6 +325,7 @@ function createSessionsRouter(getAgent) {
         lastActivity: metadata?.lastActivity || null,
         messageCount: metadata?.messageCount || 0,
         title: metadata?.title || null,
+        workspaceId: metadata?.workspaceId || null,
         history: history.length
       }
     });
@@ -387,6 +391,7 @@ function createSessionsRouter(getAgent) {
           lastActivity: metadata?.lastActivity || null,
           messageCount: metadata?.messageCount || 0,
           title: metadata?.title || null,
+          workspaceId: metadata?.workspaceId || null,
           isBusy
         }
       },
@@ -404,7 +409,8 @@ function createSessionsRouter(getAgent) {
         createdAt: metadata?.createdAt || null,
         lastActivity: metadata?.lastActivity || null,
         messageCount: metadata?.messageCount || 0,
-        title: metadata?.title || title
+        title: metadata?.title || title,
+        workspaceId: metadata?.workspaceId || null
       }
     });
   }).openapi(generateTitleRoute, async (ctx) => {

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

@@ -7,10 +7,36 @@ export declare function createSessionsRouter(getAgent: GetAgentFn): OpenAPIHono<
             output: {
                 sessions: {
                     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;
                 }[];
             };
             outputFormat: "json";
@@ -28,10 +54,36 @@ export declare function createSessionsRouter(getAgent: GetAgentFn): OpenAPIHono<
             output: {
                 session: {
                     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;
                 };
             };
             outputFormat: "json";
@@ -49,11 +101,37 @@ export declare function createSessionsRouter(getAgent: GetAgentFn): OpenAPIHono<
             output: {
                 session: {
                     id: string;
+                    messageCount: number;
                     createdAt: number | null;
                     lastActivity: number | null;
-                    messageCount: number;
                     history: 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;
                 };
             };
             outputFormat: "json";
@@ -175,11 +253,37 @@ export declare function createSessionsRouter(getAgent: GetAgentFn): OpenAPIHono<
             output: {
                 session: {
                     id: string;
+                    messageCount: number;
                     createdAt: number | null;
                     lastActivity: number | null;
-                    messageCount: number;
                     isBusy: boolean;
                     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;
                 };
             };
             outputFormat: "json";
@@ -212,10 +316,36 @@ export declare function createSessionsRouter(getAgent: GetAgentFn): OpenAPIHono<
             output: {
                 session: {
                     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;
                 };
             };
             outputFormat: "json";

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

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