@illalabs/interfaces 0.5.0-canary-beta-4e84c5d8 → 0.5.0-canary-dev-400316a7

package/dist/interfaces/chat/response.d.ts

@@ -2,10 +2,11 @@ import type { ChatError } from "../../errors/endpoints/chat/index.js";
 import type { IllaToolErrorJSON } from "../../internal.js";
 import type { MessageHistoryType, PendingToolCallType } from "../../types/messages.js";
 import type { BaseApiSuccessResponse } from "../base.js";
+import type { PlanningResponseFields } from "../planning/index.js";
 /**
  * Success response for chat endpoint
  */
-export interface CoreApiChatSuccessResponse extends BaseApiSuccessResponse {
+export interface CoreApiChatSuccessResponse extends BaseApiSuccessResponse, PlanningResponseFields {
     readonly messages: MessageHistoryType;
     readonly text: string;
     readonly pendingTools?: ReadonlyArray<PendingToolCallType>;

package/dist/interfaces/chat/response.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../../src/interfaces/chat/response.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AACtE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,KAAK,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACvF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEzD;;GAEG;AACH,MAAM,WAAW,0BAA2B,SAAQ,sBAAsB;IACtE,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,CAAC;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,YAAY,CAAC,EAAE,aAAa,CAAC,mBAAmB,CAAC,CAAC;IAC3D,QAAQ,CAAC,UAAU,CAAC,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAC;IACvD,qDAAqD;IACrD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG,SAAS,CAAC;AAEjD;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,0BAA0B,GAAG,wBAAwB,CAAC"}
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../../src/interfaces/chat/response.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AACtE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,KAAK,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACvF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AACzD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAEnE;;GAEG;AACH,MAAM,WAAW,0BAA2B,SAAQ,sBAAsB,EAAE,sBAAsB;IAC9F,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,CAAC;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,YAAY,CAAC,EAAE,aAAa,CAAC,mBAAmB,CAAC,CAAC;IAC3D,QAAQ,CAAC,UAAU,CAAC,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAC;IACvD,qDAAqD;IACrD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG,SAAS,CAAC;AAEjD;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,0BAA0B,GAAG,wBAAwB,CAAC"}

package/dist/interfaces/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./chat/index.js";
 export * from "./executionChecker/index.js";
+export * from "./planning/index.js";
 export * from "./base.js";
 export * from "./autoRouter.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/interfaces/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/interfaces/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/interfaces/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC"}

package/dist/interfaces/index.js

@@ -1,5 +1,6 @@
 export * from "./chat/index.js";
 export * from "./executionChecker/index.js";
+export * from "./planning/index.js";
 export * from "./base.js";
 export * from "./autoRouter.js";
 //# sourceMappingURL=index.js.map

package/dist/interfaces/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/interfaces/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/interfaces/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC"}

package/dist/interfaces/planning/index.d.ts

@@ -0,0 +1,3 @@
+export type { PlanningRequestFields } from "./request.js";
+export type { PlanningResponseFields } from "./response.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/interfaces/planning/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/interfaces/planning/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAC1D,YAAY,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC"}

package/dist/interfaces/planning/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map

package/dist/interfaces/planning/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/interfaces/planning/index.ts"],"names":[],"mappings":""}

package/dist/interfaces/planning/request.d.ts

@@ -0,0 +1,14 @@
+import type { AgentPlanningConfig, ExecutionPlan, StepDecision } from "../../types/index.js";
+/**
+ * Planning-specific fields that extend the chat request body
+ * when planning mode is enabled.
+ */
+export interface PlanningRequestFields {
+    /** Per-request planning configuration */
+    readonly agentPlanningConfig?: AgentPlanningConfig;
+    /** Accepted plan for execution (sent on the follow-up request after approval) */
+    readonly acceptedPlan?: ExecutionPlan;
+    /** Step-level user decision (sent when rejecting/retrying a step) */
+    readonly stepDecision?: StepDecision;
+}
+//# sourceMappingURL=request.d.ts.map

package/dist/interfaces/planning/request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../../../src/interfaces/planning/request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAE7F;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IAClC,yCAAyC;IACzC,QAAQ,CAAC,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;IACnD,iFAAiF;IACjF,QAAQ,CAAC,YAAY,CAAC,EAAE,aAAa,CAAC;IACtC,qEAAqE;IACrE,QAAQ,CAAC,YAAY,CAAC,EAAE,YAAY,CAAC;CACxC"}

package/dist/interfaces/planning/request.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=request.js.map

package/dist/interfaces/planning/request.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.js","sourceRoot":"","sources":["../../../src/interfaces/planning/request.ts"],"names":[],"mappings":""}

package/dist/interfaces/planning/response.d.ts

@@ -0,0 +1,16 @@
+import type { ExecutionPlan, PlanRejectionActionValue } from "../../types/index.js";
+/**
+ * Planning-specific fields that extend the chat success response
+ * when planning mode is active.
+ */
+export interface PlanningResponseFields {
+    /** The generated or updated execution plan */
+    readonly plan?: ExecutionPlan;
+    /** Whether the plan requires user approval before execution */
+    readonly requiresApproval?: boolean;
+    /** Reason for re-planning (present when a re-plan was triggered) */
+    readonly replanReason?: string;
+    /** Available rejection actions for the current state */
+    readonly availableActions?: ReadonlyArray<PlanRejectionActionValue>;
+}
+//# sourceMappingURL=response.d.ts.map

package/dist/interfaces/planning/response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../../src/interfaces/planning/response.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAEpF;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACnC,8CAA8C;IAC9C,QAAQ,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC;IAC9B,+DAA+D;IAC/D,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IACpC,oEAAoE;IACpE,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,wDAAwD;IACxD,QAAQ,CAAC,gBAAgB,CAAC,EAAE,aAAa,CAAC,wBAAwB,CAAC,CAAC;CACvE"}

package/dist/interfaces/planning/response.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=response.js.map

package/dist/interfaces/planning/response.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.js","sourceRoot":"","sources":["../../../src/interfaces/planning/response.ts"],"names":[],"mappings":""}

package/dist/schemas/chatContext.d.ts

@@ -195,6 +195,347 @@ export declare const ChatContextSchema: z.ZodObject<Pick<{
         channel: "text" | "voice";
     }>>>;
     requestId: z.ZodOptional<z.ZodString>;
+    agentPlanningConfig: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+    }, {
+        enabled?: boolean | undefined;
+    }>>;
+    acceptedPlan: z.ZodOptional<z.ZodObject<{
+        planId: z.ZodString;
+        version: z.ZodNumber;
+        isExecutable: z.ZodBoolean;
+        autoExecutable: z.ZodBoolean;
+        userSummary: z.ZodObject<{
+            title: z.ZodString;
+            description: z.ZodString;
+            steps: z.ZodArray<z.ZodObject<{
+                number: z.ZodNumber;
+                description: z.ZodString;
+                status: z.ZodEnum<["pending", "in_progress", "completed", "failed", "skipped"]>;
+                requiresApproval: z.ZodBoolean;
+            }, "strip", z.ZodTypeAny, {
+                number: number;
+                status: "pending" | "in_progress" | "completed" | "failed" | "skipped";
+                description: string;
+                requiresApproval: boolean;
+            }, {
+                number: number;
+                status: "pending" | "in_progress" | "completed" | "failed" | "skipped";
+                description: string;
+                requiresApproval: boolean;
+            }>, "many">;
+            warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            description: string;
+            title: string;
+            steps: {
+                number: number;
+                status: "pending" | "in_progress" | "completed" | "failed" | "skipped";
+                description: string;
+                requiresApproval: boolean;
+            }[];
+            warnings?: string[] | undefined;
+        }, {
+            description: string;
+            title: string;
+            steps: {
+                number: number;
+                status: "pending" | "in_progress" | "completed" | "failed" | "skipped";
+                description: string;
+                requiresApproval: boolean;
+            }[];
+            warnings?: string[] | undefined;
+        }>;
+        executionSchema: z.ZodObject<{
+            steps: z.ZodArray<z.ZodObject<{
+                stepNumber: z.ZodNumber;
+                description: z.ZodString;
+                operationType: z.ZodEnum<["read", "write"]>;
+                requiresUserApproval: z.ZodBoolean;
+                dependsOn: z.ZodArray<z.ZodNumber, "many">;
+                status: z.ZodEnum<["pending", "in_progress", "completed", "failed", "skipped"]>;
+                toolName: z.ZodOptional<z.ZodString>;
+                result: z.ZodOptional<z.ZodUnknown>;
+                executionInstructions: z.ZodObject<{
+                    objective: z.ZodString;
+                    inputSource: z.ZodRecord<z.ZodString, z.ZodString>;
+                    expectedOutput: z.ZodString;
+                    errorHandling: z.ZodString;
+                    constraints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                }, "strip", z.ZodTypeAny, {
+                    objective: string;
+                    inputSource: Record<string, string>;
+                    expectedOutput: string;
+                    errorHandling: string;
+                    constraints?: string[] | undefined;
+                }, {
+                    objective: string;
+                    inputSource: Record<string, string>;
+                    expectedOutput: string;
+                    errorHandling: string;
+                    constraints?: string[] | undefined;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                status: "pending" | "in_progress" | "completed" | "failed" | "skipped";
+                description: string;
+                stepNumber: number;
+                operationType: "read" | "write";
+                requiresUserApproval: boolean;
+                dependsOn: number[];
+                executionInstructions: {
+                    objective: string;
+                    inputSource: Record<string, string>;
+                    expectedOutput: string;
+                    errorHandling: string;
+                    constraints?: string[] | undefined;
+                };
+                result?: unknown;
+                toolName?: string | undefined;
+            }, {
+                status: "pending" | "in_progress" | "completed" | "failed" | "skipped";
+                description: string;
+                stepNumber: number;
+                operationType: "read" | "write";
+                requiresUserApproval: boolean;
+                dependsOn: number[];
+                executionInstructions: {
+                    objective: string;
+                    inputSource: Record<string, string>;
+                    expectedOutput: string;
+                    errorHandling: string;
+                    constraints?: string[] | undefined;
+                };
+                result?: unknown;
+                toolName?: string | undefined;
+            }>, "many">;
+            complexity: z.ZodEnum<["low", "medium", "high"]>;
+            recommendedModel: z.ZodString;
+            toolSequence: z.ZodArray<z.ZodString, "many">;
+            readOperations: z.ZodArray<z.ZodString, "many">;
+            writeOperations: z.ZodArray<z.ZodString, "many">;
+            pendingApprovals: z.ZodNumber;
+            availableTools: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            steps: {
+                status: "pending" | "in_progress" | "completed" | "failed" | "skipped";
+                description: string;
+                stepNumber: number;
+                operationType: "read" | "write";
+                requiresUserApproval: boolean;
+                dependsOn: number[];
+                executionInstructions: {
+                    objective: string;
+                    inputSource: Record<string, string>;
+                    expectedOutput: string;
+                    errorHandling: string;
+                    constraints?: string[] | undefined;
+                };
+                result?: unknown;
+                toolName?: string | undefined;
+            }[];
+            complexity: "low" | "medium" | "high";
+            recommendedModel: string;
+            toolSequence: string[];
+            readOperations: string[];
+            writeOperations: string[];
+            pendingApprovals: number;
+            availableTools: string[];
+        }, {
+            steps: {
+                status: "pending" | "in_progress" | "completed" | "failed" | "skipped";
+                description: string;
+                stepNumber: number;
+                operationType: "read" | "write";
+                requiresUserApproval: boolean;
+                dependsOn: number[];
+                executionInstructions: {
+                    objective: string;
+                    inputSource: Record<string, string>;
+                    expectedOutput: string;
+                    errorHandling: string;
+                    constraints?: string[] | undefined;
+                };
+                result?: unknown;
+                toolName?: string | undefined;
+            }[];
+            complexity: "low" | "medium" | "high";
+            recommendedModel: string;
+            toolSequence: string[];
+            readOperations: string[];
+            writeOperations: string[];
+            pendingApprovals: number;
+            availableTools: string[];
+        }>;
+        conflicts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<["conflicting_intent", "impossible_task", "missing_tool", "unsupported_operation"]>;
+            message: z.ZodString;
+            suggestion: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            type: "conflicting_intent" | "impossible_task" | "missing_tool" | "unsupported_operation";
+            suggestion?: string | undefined;
+        }, {
+            message: string;
+            type: "conflicting_intent" | "impossible_task" | "missing_tool" | "unsupported_operation";
+            suggestion?: string | undefined;
+        }>, "many">>;
+        replanContext: z.ZodOptional<z.ZodObject<{
+            previousPlanId: z.ZodString;
+            replanReason: z.ZodString;
+            preservedSteps: z.ZodArray<z.ZodNumber, "many">;
+        }, "strip", z.ZodTypeAny, {
+            previousPlanId: string;
+            replanReason: string;
+            preservedSteps: number[];
+        }, {
+            previousPlanId: string;
+            replanReason: string;
+            preservedSteps: number[];
+        }>>;
+        createdAt: z.ZodString;
+        expiresAt: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        planId: string;
+        version: number;
+        isExecutable: boolean;
+        autoExecutable: boolean;
+        userSummary: {
+            description: string;
+            title: string;
+            steps: {
+                number: number;
+                status: "pending" | "in_progress" | "completed" | "failed" | "skipped";
+                description: string;
+                requiresApproval: boolean;
+            }[];
+            warnings?: string[] | undefined;
+        };
+        executionSchema: {
+            steps: {
+                status: "pending" | "in_progress" | "completed" | "failed" | "skipped";
+                description: string;
+                stepNumber: number;
+                operationType: "read" | "write";
+                requiresUserApproval: boolean;
+                dependsOn: number[];
+                executionInstructions: {
+                    objective: string;
+                    inputSource: Record<string, string>;
+                    expectedOutput: string;
+                    errorHandling: string;
+                    constraints?: string[] | undefined;
+                };
+                result?: unknown;
+                toolName?: string | undefined;
+            }[];
+            complexity: "low" | "medium" | "high";
+            recommendedModel: string;
+            toolSequence: string[];
+            readOperations: string[];
+            writeOperations: string[];
+            pendingApprovals: number;
+            availableTools: string[];
+        };
+        createdAt: string;
+        conflicts?: {
+            message: string;
+            type: "conflicting_intent" | "impossible_task" | "missing_tool" | "unsupported_operation";
+            suggestion?: string | undefined;
+        }[] | undefined;
+        replanContext?: {
+            previousPlanId: string;
+            replanReason: string;
+            preservedSteps: number[];
+        } | undefined;
+        expiresAt?: string | undefined;
+    }, {
+        planId: string;
+        version: number;
+        isExecutable: boolean;
+        autoExecutable: boolean;
+        userSummary: {
+            description: string;
+            title: string;
+            steps: {
+                number: number;
+                status: "pending" | "in_progress" | "completed" | "failed" | "skipped";
+                description: string;
+                requiresApproval: boolean;
+            }[];
+            warnings?: string[] | undefined;
+        };
+        executionSchema: {
+            steps: {
+                status: "pending" | "in_progress" | "completed" | "failed" | "skipped";
+                description: string;
+                stepNumber: number;
+                operationType: "read" | "write";
+                requiresUserApproval: boolean;
+                dependsOn: number[];
+                executionInstructions: {
+                    objective: string;
+                    inputSource: Record<string, string>;
+                    expectedOutput: string;
+                    errorHandling: string;
+                    constraints?: string[] | undefined;
+                };
+                result?: unknown;
+                toolName?: string | undefined;
+            }[];
+            complexity: "low" | "medium" | "high";
+            recommendedModel: string;
+            toolSequence: string[];
+            readOperations: string[];
+            writeOperations: string[];
+            pendingApprovals: number;
+            availableTools: string[];
+        };
+        createdAt: string;
+        conflicts?: {
+            message: string;
+            type: "conflicting_intent" | "impossible_task" | "missing_tool" | "unsupported_operation";
+            suggestion?: string | undefined;
+        }[] | undefined;
+        replanContext?: {
+            previousPlanId: string;
+            replanReason: string;
+            preservedSteps: number[];
+        } | undefined;
+        expiresAt?: string | undefined;
+    }>>;
+    stepDecision: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+        planId: z.ZodString;
+        planVersion: z.ZodNumber;
+        stepNumber: z.ZodNumber;
+        action: z.ZodEnum<["retry", "stop", "edit_request"]>;
+        editedIntent: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        stepNumber: number;
+        planId: string;
+        planVersion: number;
+        action: "retry" | "stop" | "edit_request";
+        editedIntent?: string | undefined;
+    }, {
+        stepNumber: number;
+        planId: string;
+        planVersion: number;
+        action: "retry" | "stop" | "edit_request";
+        editedIntent?: string | undefined;
+    }>, {
+        stepNumber: number;
+        planId: string;
+        planVersion: number;
+        action: "retry" | "stop" | "edit_request";
+        editedIntent?: string | undefined;
+    }, {
+        stepNumber: number;
+        planId: string;
+        planVersion: number;
+        action: "retry" | "stop" | "edit_request";
+        editedIntent?: string | undefined;
+    }>>;
 }, "messages"> & {
     toolsConfig: z.ZodObject<{
         autoRouter: z.ZodOptional<z.ZodObject<{

package/dist/schemas/chatContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chatContext.d.ts","sourceRoot":"","sources":["../../src/schemas/chatContext.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI7B,CAAC"}
+{"version":3,"file":"chatContext.d.ts","sourceRoot":"","sources":["../../src/schemas/chatContext.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI7B,CAAC"}