@dexto/server 1.3.0 → 1.5.0

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

@@ -1,6 +1,6 @@
 import { OpenAPIHono } from '@hono/zod-openapi';
-import type { DextoAgent } from '@dexto/core';
-export declare function createResourcesRouter(getAgent: () => DextoAgent): OpenAPIHono<import("hono").Env, {
+import type { GetAgentFn } from '../index.js';
+export declare function createResourcesRouter(getAgent: GetAgentFn): OpenAPIHono<import("hono").Env, {
     "/resources": {
         $get: {
             input: {};
@@ -11,10 +11,10 @@ export declare function createResourcesRouter(getAgent: () => DextoAgent): OpenA
                     source: "mcp" | "internal";
                     description?: string | undefined;
                     mimeType?: string | undefined;
-                    name?: string | undefined;
                     metadata?: {
                         [x: string]: import("hono/utils/types").JSONValue;
                     } | undefined;
+                    name?: string | undefined;
                     serverName?: string | undefined;
                     size?: number | undefined;
                     lastModified?: string | undefined;

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

@@ -1 +1 @@
-{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/resources.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAyD9C,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAqE/D"}
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/resources.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAEhE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAwD9C,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAqEzD"}

package/dist/hono/routes/resources.js

@@ -66,16 +66,16 @@ function createResourcesRouter(getAgent) {
     }
   });
   return app.openapi(listRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const resources = await agent.listResources();
     return ctx.json({ ok: true, resources: Object.values(resources) });
   }).openapi(getContentRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { resourceId } = ctx.req.valid("param");
     const content = await agent.readResource(resourceId);
     return ctx.json({ ok: true, content });
   }).openapi(headRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { resourceId } = ctx.req.valid("param");
     const exists = await agent.hasResource(resourceId);
     return ctx.body(null, exists ? 200 : 404);

package/dist/hono/routes/search.cjs

@@ -64,7 +64,7 @@ function createSearchRouter(getAgent) {
     }
   });
   return app.openapi(messagesRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { q, limit, offset, sessionId, role } = ctx.req.valid("query");
     const options = {
       limit: limit || 20,
@@ -75,7 +75,7 @@ function createSearchRouter(getAgent) {
     const searchResults = await agent.searchMessages(q, options);
     return ctx.json(searchResults);
   }).openapi(sessionsRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { q } = ctx.req.valid("query");
     const searchResults = await agent.searchSessions(q);
     return ctx.json(searchResults);

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

@@ -1,6 +1,8 @@
 import { OpenAPIHono } from '@hono/zod-openapi';
 import type { DextoAgent } from '@dexto/core';
-export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIHono<import("hono").Env, {
+import type { Context } from 'hono';
+type GetAgentFn = (ctx: Context) => DextoAgent | Promise<DextoAgent>;
+export declare function createSearchRouter(getAgent: GetAgentFn): OpenAPIHono<import("hono").Env, {
     "/search/messages": {
         $get: {
             input: {
@@ -28,6 +30,19 @@ export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIH
                             mimeType: string;
                             data: string;
                             filename?: string | undefined;
+                        } | {
+                            type: "ui-resource";
+                            mimeType: string;
+                            uri: string;
+                            content?: string | undefined;
+                            blob?: string | undefined;
+                            metadata?: {
+                                title?: string | undefined;
+                                preferredSize?: {
+                                    width: number;
+                                    height: number;
+                                } | undefined;
+                            } | undefined;
                         })[] | null;
                         role: "system" | "user" | "assistant" | "tool";
                         id?: string | undefined;
@@ -41,8 +56,7 @@ export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIH
                             totalTokens?: number | undefined;
                         } | undefined;
                         model?: string | undefined;
-                        provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
-                        router?: "vercel" | "in-built" | undefined;
+                        provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | undefined;
                         toolCalls?: {
                             function: {
                                 name: string;
@@ -52,6 +66,7 @@ export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIH
                             id: string;
                         }[] | undefined;
                         toolCallId?: string | undefined;
+                        success?: boolean | undefined;
                     };
                     sessionId: string;
                     matchedText: string;
@@ -77,6 +92,11 @@ export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIH
                 query: string;
                 results: {
                     sessionId: string;
+                    metadata: {
+                        createdAt: number;
+                        lastActivity: number;
+                        messageCount: number;
+                    };
                     matchCount: number;
                     firstMatch: {
                         message: {
@@ -92,6 +112,19 @@ export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIH
                                 mimeType: string;
                                 data: string;
                                 filename?: string | undefined;
+                            } | {
+                                type: "ui-resource";
+                                mimeType: string;
+                                uri: string;
+                                content?: string | undefined;
+                                blob?: string | undefined;
+                                metadata?: {
+                                    title?: string | undefined;
+                                    preferredSize?: {
+                                        width: number;
+                                        height: number;
+                                    } | undefined;
+                                } | undefined;
                             })[] | null;
                             role: "system" | "user" | "assistant" | "tool";
                             id?: string | undefined;
@@ -105,8 +138,7 @@ export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIH
                                 totalTokens?: number | undefined;
                             } | undefined;
                             model?: string | undefined;
-                            provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
-                            router?: "vercel" | "in-built" | undefined;
+                            provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | undefined;
                             toolCalls?: {
                                 function: {
                                     name: string;
@@ -116,17 +148,13 @@ export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIH
                                 id: string;
                             }[] | undefined;
                             toolCallId?: string | undefined;
+                            success?: boolean | undefined;
                         };
                         sessionId: string;
                         matchedText: string;
                         context: string;
                         messageIndex: number;
                     };
-                    metadata: {
-                        createdAt: number;
-                        lastActivity: number;
-                        messageCount: number;
-                    };
                 }[];
                 total: number;
                 hasMore: boolean;
@@ -136,4 +164,5 @@ export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIH
         };
     };
 }, "/">;
+export {};
 //# sourceMappingURL=search.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA2B9C,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAwD5D"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AA0BrE,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAwDtD"}

package/dist/hono/routes/search.js

@@ -41,7 +41,7 @@ function createSearchRouter(getAgent) {
     }
   });
   return app.openapi(messagesRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { q, limit, offset, sessionId, role } = ctx.req.valid("query");
     const options = {
       limit: limit || 20,
@@ -52,7 +52,7 @@ function createSearchRouter(getAgent) {
     const searchResults = await agent.searchMessages(q, options);
     return ctx.json(searchResults);
   }).openapi(sessionsRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { q } = ctx.req.valid("query");
     const searchResults = await agent.searchSessions(q);
     return ctx.json(searchResults);

package/dist/hono/routes/sessions.cjs

@@ -95,7 +95,7 @@ function createSessionsRouter(getAgent) {
     method: "get",
     path: "/sessions/{sessionId}/history",
     summary: "Get Session History",
-    description: "Retrieves the conversation history for a session",
+    description: "Retrieves the conversation history for a session along with processing status",
     tags: ["sessions"],
     request: { params: import_zod_openapi.z.object({ sessionId: import_zod_openapi.z.string().describe("Session identifier") }) },
     responses: {
@@ -104,7 +104,10 @@ function createSessionsRouter(getAgent) {
         content: {
           "application/json": {
             schema: import_zod_openapi.z.object({
-              history: import_zod_openapi.z.array(import_responses.InternalMessageSchema).describe("Array of messages in conversation history")
+              history: import_zod_openapi.z.array(import_responses.InternalMessageSchema).describe("Array of messages in conversation history"),
+              isBusy: import_zod_openapi.z.boolean().describe(
+                "Whether the session is currently processing a message"
+              )
             }).strict()
           }
         }
@@ -136,9 +139,23 @@ function createSessionsRouter(getAgent) {
     method: "post",
     path: "/sessions/{sessionId}/cancel",
     summary: "Cancel Session Run",
-    description: "Cancels an in-flight agent run for the specified session",
+    description: "Cancels an in-flight agent run for the specified session. By default (soft cancel), only the current LLM call is cancelled and queued messages continue processing. Set clearQueue=true for hard cancel to also clear any queued messages.",
     tags: ["sessions"],
-    request: { params: import_zod_openapi.z.object({ sessionId: import_zod_openapi.z.string().describe("Session identifier") }) },
+    request: {
+      params: import_zod_openapi.z.object({ sessionId: import_zod_openapi.z.string().describe("Session identifier") }),
+      body: {
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              clearQueue: import_zod_openapi.z.boolean().optional().default(false).describe(
+                "If true (hard cancel), clears queued messages. If false (soft cancel, default), queued messages continue processing."
+              )
+            }).strict()
+          }
+        },
+        required: false
+      }
+    },
     responses: {
       200: {
         description: "Cancel operation result",
@@ -146,7 +163,11 @@ function createSessionsRouter(getAgent) {
           "application/json": {
             schema: import_zod_openapi.z.object({
               cancelled: import_zod_openapi.z.boolean().describe("Whether a run was cancelled"),
-              sessionId: import_zod_openapi.z.string().describe("Session ID")
+              sessionId: import_zod_openapi.z.string().describe("Session ID"),
+              queueCleared: import_zod_openapi.z.boolean().describe("Whether queued messages were cleared"),
+              clearedCount: import_zod_openapi.z.number().describe(
+                "Number of queued messages cleared (0 if soft cancel)"
+              )
             }).strict()
           }
         }
@@ -157,7 +178,7 @@ function createSessionsRouter(getAgent) {
     method: "get",
     path: "/sessions/{sessionId}/load",
     summary: "Load Session",
-    description: "Validates and retrieves session information. The client should track the active session.",
+    description: "Validates and retrieves session information including processing status. The client should track the active session.",
     tags: ["sessions"],
     request: {
       params: import_zod_openapi.z.object({ sessionId: import_zod_openapi.z.string().describe("Session identifier") })
@@ -168,7 +189,11 @@ function createSessionsRouter(getAgent) {
         content: {
           "application/json": {
             schema: import_zod_openapi.z.object({
-              session: import_responses.SessionMetadataSchema.describe("Session metadata")
+              session: import_responses.SessionMetadataSchema.extend({
+                isBusy: import_zod_openapi.z.boolean().describe(
+                  "Whether the session is currently processing a message"
+                )
+              }).describe("Session metadata with processing status")
             }).strict()
           }
         }
@@ -243,7 +268,7 @@ function createSessionsRouter(getAgent) {
     }
   });
   return app.openapi(listRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const sessionIds = await agent.listSessions();
     const sessions = await Promise.all(
       sessionIds.map(async (id) => {
@@ -269,7 +294,7 @@ function createSessionsRouter(getAgent) {
     );
     return ctx.json({ sessions });
   }).openapi(createRouteDef, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("json");
     const session = await agent.createSession(sessionId);
     const metadata = await agent.getSessionMetadata(session.id);
@@ -286,7 +311,7 @@ function createSessionsRouter(getAgent) {
       201
     );
   }).openapi(getRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.param();
     const metadata = await agent.getSessionMetadata(sessionId);
     const history = await agent.getSessionHistory(sessionId);
@@ -301,31 +326,59 @@ function createSessionsRouter(getAgent) {
       }
     });
   }).openapi(historyRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.param();
-    const history = await agent.getSessionHistory(sessionId);
-    return ctx.json({ history });
+    const [history, isBusy] = await Promise.all([
+      agent.getSessionHistory(sessionId),
+      agent.isSessionBusy(sessionId)
+    ]);
+    return ctx.json({
+      history,
+      isBusy
+    });
   }).openapi(deleteRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.param();
     await agent.deleteSession(sessionId);
     return ctx.json({ status: "deleted", sessionId });
   }).openapi(cancelRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("param");
+    let clearQueue = false;
+    try {
+      const body = ctx.req.valid("json");
+      clearQueue = body?.clearQueue ?? false;
+    } catch {
+    }
+    let clearedCount = 0;
+    if (clearQueue) {
+      try {
+        clearedCount = await agent.clearMessageQueue(sessionId);
+        agent.logger.debug(
+          `Hard cancel: cleared ${clearedCount} queued message(s) for session: ${sessionId}`
+        );
+      } catch {
+      }
+    }
     const cancelled = await agent.cancel(sessionId);
     if (!cancelled) {
       agent.logger.debug(`No in-flight run to cancel for session: ${sessionId}`);
     }
-    return ctx.json({ cancelled, sessionId });
+    return ctx.json({
+      cancelled,
+      sessionId,
+      queueCleared: clearQueue,
+      clearedCount
+    });
   }).openapi(loadRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("param");
     const sessionIds = await agent.listSessions();
     if (!sessionIds.includes(sessionId)) {
       return ctx.json({ error: `Session not found: ${sessionId}` }, 404);
     }
     const metadata = await agent.getSessionMetadata(sessionId);
+    const isBusy = await agent.isSessionBusy(sessionId);
     return ctx.json(
       {
         session: {
@@ -333,13 +386,14 @@ function createSessionsRouter(getAgent) {
           createdAt: metadata?.createdAt || null,
           lastActivity: metadata?.lastActivity || null,
           messageCount: metadata?.messageCount || 0,
-          title: metadata?.title || null
+          title: metadata?.title || null,
+          isBusy
         }
       },
       200
     );
   }).openapi(patchRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("param");
     const { title } = ctx.req.valid("json");
     await agent.setSessionTitle(sessionId, title);
@@ -354,7 +408,7 @@ function createSessionsRouter(getAgent) {
       }
     });
   }).openapi(generateTitleRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("param");
     const title = await agent.generateSessionTitle(sessionId);
     return ctx.json({ title, sessionId });

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

@@ -1,6 +1,6 @@
 import { OpenAPIHono } from '@hono/zod-openapi';
-import type { DextoAgent } from '@dexto/core';
-export declare function createSessionsRouter(getAgent: () => DextoAgent): OpenAPIHono<import("hono").Env, {
+import type { GetAgentFn } from '../index.js';
+export declare function createSessionsRouter(getAgent: GetAgentFn): OpenAPIHono<import("hono").Env, {
     "/sessions": {
         $get: {
             input: {};
@@ -82,6 +82,19 @@ export declare function createSessionsRouter(getAgent: () => DextoAgent): OpenAP
                         mimeType: string;
                         data: string;
                         filename?: string | undefined;
+                    } | {
+                        type: "ui-resource";
+                        mimeType: string;
+                        uri: string;
+                        content?: string | undefined;
+                        blob?: string | undefined;
+                        metadata?: {
+                            title?: string | undefined;
+                            preferredSize?: {
+                                width: number;
+                                height: number;
+                            } | undefined;
+                        } | undefined;
                     })[] | null;
                     role: "system" | "user" | "assistant" | "tool";
                     id?: string | undefined;
@@ -95,8 +108,7 @@ export declare function createSessionsRouter(getAgent: () => DextoAgent): OpenAP
                         totalTokens?: number | undefined;
                     } | undefined;
                     model?: string | undefined;
-                    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
-                    router?: "vercel" | "in-built" | undefined;
+                    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | undefined;
                     toolCalls?: {
                         function: {
                             name: string;
@@ -106,7 +118,9 @@ export declare function createSessionsRouter(getAgent: () => DextoAgent): OpenAP
                         id: string;
                     }[] | undefined;
                     toolCallId?: string | undefined;
+                    success?: boolean | undefined;
                 }[];
+                isBusy: boolean;
             };
             outputFormat: "json";
             status: 200;
@@ -135,10 +149,16 @@ export declare function createSessionsRouter(getAgent: () => DextoAgent): OpenAP
                 param: {
                     sessionId: string;
                 };
+            } & {
+                json: {
+                    clearQueue?: boolean | undefined;
+                };
             };
             output: {
                 sessionId: string;
                 cancelled: boolean;
+                queueCleared: boolean;
+                clearedCount: number;
             };
             outputFormat: "json";
             status: 200;
@@ -158,6 +178,7 @@ export declare function createSessionsRouter(getAgent: () => DextoAgent): OpenAP
                     createdAt: number | null;
                     lastActivity: number | null;
                     messageCount: number;
+                    isBusy: boolean;
                     title?: string | null | undefined;
                 };
             };

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;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAS9C,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAgZ9D"}
+{"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"}