@illalabs/interfaces 0.3.0-canary.f3dad1f7 → 0.4.0-canary-beta-52713059

package/dist/schemas/modelContext.d.ts

@@ -2,13 +2,13 @@ import type { TypeOf } from "zod";
 import { z } from "zod";
 export declare const ModelContextSchema: z.ZodDiscriminatedUnion<"provider", [z.ZodObject<{
     provider: z.ZodLiteral<"openrouter">;
-    model: z.ZodEnum<["anthropic/claude-sonnet-4.5", "google/gemini-2.5-pro", "openai/gpt-5", "qwen/qwen3-vl-30b-a3b-thinking", "openai/gpt-5-mini"]>;
+    model: z.ZodEnum<["anthropic/claude-sonnet-4.5", "google/gemini-2.5-pro", "openai/gpt-5", "qwen/qwen3-vl-30b-a3b-thinking", "openai/gpt-5-mini", "moonshotai/kimi-k2-thinking", "google/gemini-3-flash-preview", "z-ai/glm-4.7-flash", "anthropic/claude-haiku-4.5", "deepseek/deepseek-v3.2"]>;
 }, "strip", z.ZodTypeAny, {
     provider: "openrouter";
-    model: "anthropic/claude-sonnet-4.5" | "google/gemini-2.5-pro" | "openai/gpt-5" | "qwen/qwen3-vl-30b-a3b-thinking" | "openai/gpt-5-mini";
+    model: "anthropic/claude-sonnet-4.5" | "google/gemini-2.5-pro" | "openai/gpt-5" | "qwen/qwen3-vl-30b-a3b-thinking" | "openai/gpt-5-mini" | "moonshotai/kimi-k2-thinking" | "google/gemini-3-flash-preview" | "z-ai/glm-4.7-flash" | "anthropic/claude-haiku-4.5" | "deepseek/deepseek-v3.2";
 }, {
     provider: "openrouter";
-    model: "anthropic/claude-sonnet-4.5" | "google/gemini-2.5-pro" | "openai/gpt-5" | "qwen/qwen3-vl-30b-a3b-thinking" | "openai/gpt-5-mini";
+    model: "anthropic/claude-sonnet-4.5" | "google/gemini-2.5-pro" | "openai/gpt-5" | "qwen/qwen3-vl-30b-a3b-thinking" | "openai/gpt-5-mini" | "moonshotai/kimi-k2-thinking" | "google/gemini-3-flash-preview" | "z-ai/glm-4.7-flash" | "anthropic/claude-haiku-4.5" | "deepseek/deepseek-v3.2";
 }>, z.ZodObject<{
     provider: z.ZodLiteral<"openai">;
     model: z.ZodEnum<["gpt-4o", "gpt-4o-mini", "gpt-5", "gpt-5-mini-2025-08-07"]>;

package/dist/schemas/planning.d.ts

@@ -0,0 +1,666 @@
+import { z } from "zod";
+/**
+ * Plan step status values
+ */
+export declare const planStepStatusValues: readonly ["pending", "in_progress", "completed", "failed", "skipped"];
+/**
+ * Plan complexity levels
+ */
+export declare const planComplexityValues: readonly ["low", "medium", "high"];
+/**
+ * Operation types for plan steps
+ */
+export declare const operationTypeValues: readonly ["read", "write"];
+/**
+ * Conflict types for plan validation
+ */
+export declare const planConflictTypeValues: readonly ["conflicting_intent", "impossible_task", "missing_tool", "missing_context", "unsupported_operation"];
+/**
+ * Plan execution status values
+ */
+export declare const planExecutionStatusValues: readonly ["success", "partial", "failed"];
+/**
+ * Schema for plan step execution instructions
+ */
+export declare const PlanStepExecutionInstructionsSchema: z.ZodObject<{
+    objective: z.ZodString;
+    /** Maps input parameter names to their source references (e.g., "from_context.userContext.address") */
+    inputSource: z.ZodRecord<z.ZodString, z.ZodString>;
+    expectedOutput: z.ZodString;
+    errorHandling: z.ZodString;
+    constraints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strict", 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;
+}>;
+/**
+ * Schema for individual plan steps
+ */
+export declare const PlanStepSchema: 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"]>;
+    /** Step execution result. Structure varies by tool - typically contains tool-specific output data. */
+    result: z.ZodOptional<z.ZodUnknown>;
+    toolName: z.ZodOptional<z.ZodString>;
+    executionInstructions: z.ZodObject<{
+        objective: z.ZodString;
+        /** Maps input parameter names to their source references (e.g., "from_context.userContext.address") */
+        inputSource: z.ZodRecord<z.ZodString, z.ZodString>;
+        expectedOutput: z.ZodString;
+        errorHandling: z.ZodString;
+        constraints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", 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;
+    }>;
+}, "strict", 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;
+}>;
+/**
+ * Schema for user-readable summary step
+ */
+export declare const PlanUserSummaryStepSchema: z.ZodObject<{
+    number: z.ZodNumber;
+    description: z.ZodString;
+    status: z.ZodEnum<["pending", "in_progress", "completed", "failed", "skipped"]>;
+    requiresApproval: z.ZodBoolean;
+}, "strict", 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;
+}>;
+/**
+ * Schema for human-readable plan summary
+ */
+export declare const PlanUserSummarySchema: 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;
+    }, "strict", 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">>;
+}, "strict", 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;
+}>;
+/**
+ * Schema for machine-readable execution details
+ */
+export declare const PlanExecutionDetailsSchema: 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"]>;
+        /** Step execution result. Structure varies by tool - typically contains tool-specific output data. */
+        result: z.ZodOptional<z.ZodUnknown>;
+        toolName: z.ZodOptional<z.ZodString>;
+        executionInstructions: z.ZodObject<{
+            objective: z.ZodString;
+            /** Maps input parameter names to their source references (e.g., "from_context.userContext.address") */
+            inputSource: z.ZodRecord<z.ZodString, z.ZodString>;
+            expectedOutput: z.ZodString;
+            errorHandling: z.ZodString;
+            constraints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strict", 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;
+        }>;
+    }, "strict", 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;
+    /** Ordered tool names for execution — may differ from steps[].toolName when steps run in parallel or tools are reused */
+    toolSequence: z.ZodArray<z.ZodString, "many">;
+    /** Descriptions of read operations for quick plan summary (derived from read-type steps) */
+    readOperations: z.ZodArray<z.ZodString, "many">;
+    /** Descriptions of write operations for quick plan summary (derived from write-type steps) */
+    writeOperations: z.ZodArray<z.ZodString, "many">;
+    pendingApprovals: z.ZodNumber;
+    /** All tools the plan may invoke, including conditional/fallback tools not tied to specific steps */
+    availableTools: z.ZodArray<z.ZodString, "many">;
+}, "strict", 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[];
+}>;
+/**
+ * Schema for plan conflicts
+ */
+export declare const PlanConflictSchema: z.ZodObject<{
+    type: z.ZodEnum<["conflicting_intent", "impossible_task", "missing_tool", "missing_context", "unsupported_operation"]>;
+    message: z.ZodString;
+    suggestion: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    message: string;
+    type: "conflicting_intent" | "impossible_task" | "missing_tool" | "missing_context" | "unsupported_operation";
+    suggestion?: string | undefined;
+}, {
+    message: string;
+    type: "conflicting_intent" | "impossible_task" | "missing_tool" | "missing_context" | "unsupported_operation";
+    suggestion?: string | undefined;
+}>;
+/**
+ * Schema for re-plan context
+ */
+export declare const ReplanContextSchema: z.ZodObject<{
+    previousPlanId: z.ZodString;
+    replanReason: z.ZodString;
+    preservedSteps: z.ZodArray<z.ZodNumber, "many">;
+}, "strict", z.ZodTypeAny, {
+    previousPlanId: string;
+    replanReason: string;
+    preservedSteps: number[];
+}, {
+    previousPlanId: string;
+    replanReason: string;
+    preservedSteps: number[];
+}>;
+/**
+ * Schema for complete execution plan
+ */
+export declare const ExecutionPlanSchema: 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;
+        }, "strict", 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">>;
+    }, "strict", 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"]>;
+            /** Step execution result. Structure varies by tool - typically contains tool-specific output data. */
+            result: z.ZodOptional<z.ZodUnknown>;
+            toolName: z.ZodOptional<z.ZodString>;
+            executionInstructions: z.ZodObject<{
+                objective: z.ZodString;
+                /** Maps input parameter names to their source references (e.g., "from_context.userContext.address") */
+                inputSource: z.ZodRecord<z.ZodString, z.ZodString>;
+                expectedOutput: z.ZodString;
+                errorHandling: z.ZodString;
+                constraints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            }, "strict", 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;
+            }>;
+        }, "strict", 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;
+        /** Ordered tool names for execution — may differ from steps[].toolName when steps run in parallel or tools are reused */
+        toolSequence: z.ZodArray<z.ZodString, "many">;
+        /** Descriptions of read operations for quick plan summary (derived from read-type steps) */
+        readOperations: z.ZodArray<z.ZodString, "many">;
+        /** Descriptions of write operations for quick plan summary (derived from write-type steps) */
+        writeOperations: z.ZodArray<z.ZodString, "many">;
+        pendingApprovals: z.ZodNumber;
+        /** All tools the plan may invoke, including conditional/fallback tools not tied to specific steps */
+        availableTools: z.ZodArray<z.ZodString, "many">;
+    }, "strict", 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", "missing_context", "unsupported_operation"]>;
+        message: z.ZodString;
+        suggestion: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        message: string;
+        type: "conflicting_intent" | "impossible_task" | "missing_tool" | "missing_context" | "unsupported_operation";
+        suggestion?: string | undefined;
+    }, {
+        message: string;
+        type: "conflicting_intent" | "impossible_task" | "missing_tool" | "missing_context" | "unsupported_operation";
+        suggestion?: string | undefined;
+    }>, "many">>;
+    replanContext: z.ZodOptional<z.ZodObject<{
+        previousPlanId: z.ZodString;
+        replanReason: z.ZodString;
+        preservedSteps: z.ZodArray<z.ZodNumber, "many">;
+    }, "strict", z.ZodTypeAny, {
+        previousPlanId: string;
+        replanReason: string;
+        preservedSteps: number[];
+    }, {
+        previousPlanId: string;
+        replanReason: string;
+        preservedSteps: number[];
+    }>>;
+    createdAt: z.ZodString;
+}, "strict", 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" | "missing_context" | "unsupported_operation";
+        suggestion?: string | undefined;
+    }[] | undefined;
+    replanContext?: {
+        previousPlanId: string;
+        replanReason: string;
+        preservedSteps: number[];
+    } | 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" | "missing_context" | "unsupported_operation";
+        suggestion?: string | undefined;
+    }[] | undefined;
+    replanContext?: {
+        previousPlanId: string;
+        replanReason: string;
+        preservedSteps: number[];
+    } | undefined;
+}>;
+/**
+ * Schema for planning configuration
+ */
+export declare const AgentPlanningConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    cacheEnabled: z.ZodOptional<z.ZodBoolean>;
+    cacheTTL: z.ZodOptional<z.ZodNumber>;
+    forceRefresh: z.ZodOptional<z.ZodBoolean>;
+    planningModel: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    enabled?: boolean | undefined;
+    cacheEnabled?: boolean | undefined;
+    cacheTTL?: number | undefined;
+    forceRefresh?: boolean | undefined;
+    planningModel?: string | undefined;
+}, {
+    enabled?: boolean | undefined;
+    cacheEnabled?: boolean | undefined;
+    cacheTTL?: number | undefined;
+    forceRefresh?: boolean | undefined;
+    planningModel?: string | undefined;
+}>;
+//# sourceMappingURL=planning.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"planning.d.ts","sourceRoot":"","sources":["../../src/schemas/planning.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,oBAAoB,uEAMvB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,oBAAoB,oCAAqC,CAAC;AAEvE;;GAEG;AACH,eAAO,MAAM,mBAAmB,4BAA6B,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,sBAAsB,gHAMzB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,yBAAyB,2CAA4C,CAAC;AAEnF;;GAEG;AACH,eAAO,MAAM,mCAAmC;;IAGxC,uGAAuG;;;;;;;;;;;;;;;;;EAMlG,CAAC;AAEd;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;IAQnB,sGAAsG;;;;;QAnBtG,uGAAuG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwBlG,CAAC;AAEd;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;EAOzB,CAAC;AAEd;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOrB,CAAC;AAEd;;GAEG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;QAlC/B,sGAAsG;;;;;YAnBtG,uGAAuG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA0DvG,yHAAyH;;IAEzH,4FAA4F;;IAE5F,8FAA8F;;;IAG9F,qGAAqG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGhG,CAAC;AAEd;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAMlB,CAAC;AAEd;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;EAMnB,CAAC;AAEd;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA5ExB,sGAAsG;;;;;gBAnBtG,uGAAuG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA0DvG,yHAAyH;;QAEzH,4FAA4F;;QAE5F,8FAA8F;;;QAG9F,qGAAqG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0ChG,CAAC;AAEd;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;EAQzB,CAAC"}