comisai 1.0.10 → 1.0.12

package/node_modules/@comis/core/dist/config/migrate.test.js

@@ -1,244 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { migrateConfig } from "./migrate.js";
-describe("config/migrate", () => {
-    // -----------------------------------------------------------------------
-    // Passthrough (no legacy keys)
-    // -----------------------------------------------------------------------
-    it("passes through config with no legacy keys unchanged", () => {
-        const input = {
-            tenantId: "test",
-            streaming: {
-                enabled: true,
-                defaultDeliveryTiming: { mode: "natural", minMs: 800, maxMs: 2500 },
-                defaultCoalescer: { maxChars: 500 },
-                perChannel: {
-                    telegram: {
-                        enabled: true,
-                        deliveryTiming: { mode: "adaptive" },
-                        coalescer: { maxChars: 800 },
-                    },
-                },
-            },
-        };
-        const result = migrateConfig(input);
-        expect(result).toEqual(input);
-    });
-    it("handles config with no streaming section", () => {
-        const input = { tenantId: "bare" };
-        const result = migrateConfig(input);
-        expect(result).toEqual({ tenantId: "bare" });
-    });
-    it("handles empty streaming config", () => {
-        const input = { streaming: {} };
-        const result = migrateConfig(input);
-        expect(result).toEqual({ streaming: {} });
-    });
-    // -----------------------------------------------------------------------
-    // Per-channel migration
-    // -----------------------------------------------------------------------
-    it("migrates per-channel pacingMinMs/pacingMaxMs to deliveryTiming", () => {
-        const input = {
-            streaming: {
-                perChannel: {
-                    telegram: {
-                        enabled: true,
-                        pacingMinMs: 500,
-                        pacingMaxMs: 1500,
-                    },
-                },
-            },
-        };
-        const result = migrateConfig(input);
-        const telegram = result.streaming.perChannel.telegram;
-        expect(telegram.deliveryTiming).toEqual({ minMs: 500, maxMs: 1500 });
-        expect(telegram.pacingMinMs).toBeUndefined();
-        expect(telegram.pacingMaxMs).toBeUndefined();
-        expect(telegram.enabled).toBe(true);
-    });
-    it("migrates per-channel coalesceMaxChars to coalescer.maxChars", () => {
-        const input = {
-            streaming: {
-                perChannel: {
-                    discord: {
-                        enabled: true,
-                        coalesceMaxChars: 300,
-                    },
-                },
-            },
-        };
-        const result = migrateConfig(input);
-        const discord = result.streaming.perChannel.discord;
-        expect(discord.coalescer).toEqual({ maxChars: 300 });
-        expect(discord.coalesceMaxChars).toBeUndefined();
-    });
-    // -----------------------------------------------------------------------
-    // Root-level migration
-    // -----------------------------------------------------------------------
-    it("migrates root defaultPacingMinMs/defaultPacingMaxMs to defaultDeliveryTiming", () => {
-        const input = {
-            streaming: {
-                defaultPacingMinMs: 600,
-                defaultPacingMaxMs: 2000,
-            },
-        };
-        const result = migrateConfig(input);
-        const streaming = result.streaming;
-        expect(streaming.defaultDeliveryTiming).toEqual({ minMs: 600, maxMs: 2000 });
-        expect(streaming.defaultPacingMinMs).toBeUndefined();
-        expect(streaming.defaultPacingMaxMs).toBeUndefined();
-    });
-    // -----------------------------------------------------------------------
-    // Partial migration (only some legacy keys present)
-    // -----------------------------------------------------------------------
-    it("handles partial migration (only some legacy keys present)", () => {
-        const input = {
-            streaming: {
-                perChannel: {
-                    telegram: {
-                        enabled: true,
-                        pacingMinMs: 400,
-                        // pacingMaxMs is absent
-                    },
-                },
-            },
-        };
-        const result = migrateConfig(input);
-        const telegram = result.streaming.perChannel.telegram;
-        expect(telegram.deliveryTiming).toEqual({ minMs: 400 });
-        expect(telegram.pacingMinMs).toBeUndefined();
-        // pacingMaxMs was never set, so deliveryTiming has no maxMs
-        expect(telegram.deliveryTiming.maxMs).toBeUndefined();
-    });
-    it("handles partial root migration (only defaultPacingMinMs present)", () => {
-        const input = {
-            streaming: {
-                defaultPacingMinMs: 300,
-            },
-        };
-        const result = migrateConfig(input);
-        const streaming = result.streaming;
-        expect(streaming.defaultDeliveryTiming).toEqual({ minMs: 300 });
-        expect(streaming.defaultPacingMinMs).toBeUndefined();
-        expect(streaming.defaultPacingMaxMs).toBeUndefined();
-    });
-    // -----------------------------------------------------------------------
-    // Preservation (does NOT overwrite existing nested objects)
-    // -----------------------------------------------------------------------
-    it("does NOT overwrite existing deliveryTiming object", () => {
-        const input = {
-            streaming: {
-                perChannel: {
-                    telegram: {
-                        enabled: true,
-                        pacingMinMs: 100,
-                        pacingMaxMs: 200,
-                        deliveryTiming: { mode: "adaptive", minMs: 999, maxMs: 1999 },
-                    },
-                },
-            },
-        };
-        const result = migrateConfig(input);
-        const telegram = result.streaming.perChannel.telegram;
-        // Existing deliveryTiming preserved, legacy values ignored
-        expect(telegram.deliveryTiming).toEqual({ mode: "adaptive", minMs: 999, maxMs: 1999 });
-        // Legacy keys are still deleted
-        expect(telegram.pacingMinMs).toBeUndefined();
-        expect(telegram.pacingMaxMs).toBeUndefined();
-    });
-    it("does NOT overwrite existing coalescer object", () => {
-        const input = {
-            streaming: {
-                perChannel: {
-                    discord: {
-                        enabled: true,
-                        coalesceMaxChars: 200,
-                        coalescer: { maxChars: 888, idleMs: 2000 },
-                    },
-                },
-            },
-        };
-        const result = migrateConfig(input);
-        const discord = result.streaming.perChannel.discord;
-        // Existing coalescer preserved, legacy value ignored
-        expect(discord.coalescer).toEqual({ maxChars: 888, idleMs: 2000 });
-        expect(discord.coalesceMaxChars).toBeUndefined();
-    });
-    it("does NOT overwrite existing root defaultDeliveryTiming object", () => {
-        const input = {
-            streaming: {
-                defaultPacingMinMs: 100,
-                defaultPacingMaxMs: 200,
-                defaultDeliveryTiming: { mode: "off" },
-            },
-        };
-        const result = migrateConfig(input);
-        const streaming = result.streaming;
-        expect(streaming.defaultDeliveryTiming).toEqual({ mode: "off" });
-        expect(streaming.defaultPacingMinMs).toBeUndefined();
-        expect(streaming.defaultPacingMaxMs).toBeUndefined();
-    });
-    // -----------------------------------------------------------------------
-    // Multiple per-channel entries
-    // -----------------------------------------------------------------------
-    it("migrates multiple per-channel entries independently", () => {
-        const input = {
-            streaming: {
-                perChannel: {
-                    telegram: {
-                        enabled: true,
-                        pacingMinMs: 500,
-                        pacingMaxMs: 1500,
-                        coalesceMaxChars: 300,
-                    },
-                    discord: {
-                        enabled: true,
-                        deliveryTiming: { mode: "adaptive" },
-                        coalescer: { maxChars: 800 },
-                    },
-                    slack: {
-                        enabled: false,
-                        pacingMinMs: 100,
-                        coalesceMaxChars: 400,
-                    },
-                },
-            },
-        };
-        const result = migrateConfig(input);
-        const perChannel = result.streaming.perChannel;
-        // telegram: fully migrated
-        expect(perChannel.telegram.deliveryTiming).toEqual({ minMs: 500, maxMs: 1500 });
-        expect(perChannel.telegram.coalescer).toEqual({ maxChars: 300 });
-        expect(perChannel.telegram.pacingMinMs).toBeUndefined();
-        expect(perChannel.telegram.pacingMaxMs).toBeUndefined();
-        expect(perChannel.telegram.coalesceMaxChars).toBeUndefined();
-        // discord: already migrated, untouched
-        expect(perChannel.discord.deliveryTiming).toEqual({ mode: "adaptive" });
-        expect(perChannel.discord.coalescer).toEqual({ maxChars: 800 });
-        // slack: partially migrated (pacingMinMs only, no pacingMaxMs)
-        expect(perChannel.slack.deliveryTiming).toEqual({ minMs: 100 });
-        expect(perChannel.slack.coalescer).toEqual({ maxChars: 400 });
-        expect(perChannel.slack.pacingMinMs).toBeUndefined();
-        expect(perChannel.slack.coalesceMaxChars).toBeUndefined();
-        expect(perChannel.slack.enabled).toBe(false);
-    });
-    // -----------------------------------------------------------------------
-    // Input immutability
-    // -----------------------------------------------------------------------
-    it("does not mutate the original input object", () => {
-        const input = {
-            streaming: {
-                defaultPacingMinMs: 600,
-                perChannel: {
-                    telegram: {
-                        pacingMinMs: 500,
-                        pacingMaxMs: 1500,
-                    },
-                },
-            },
-        };
-        const inputCopy = JSON.parse(JSON.stringify(input));
-        migrateConfig(input);
-        // Original unchanged
-        expect(input).toEqual(inputCopy);
-    });
-});

package/node_modules/@comis/core/dist/config/partial-validator.test.d.ts

@@ -1 +0,0 @@
-export {};

package/node_modules/@comis/core/dist/config/partial-validator.test.js

@@ -1,98 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { validatePartial } from "./partial-validator.js";
-describe("config/partial-validator", () => {
-    describe("validatePartial", () => {
-        it("valid config returns all sections with no errors", () => {
-            const raw = {
-                tenantId: "my-tenant",
-                logLevel: "info",
-                dataDir: "/data",
-                security: {},
-                gateway: {},
-            };
-            const result = validatePartial(raw);
-            expect(result.errors).toHaveLength(0);
-            expect(result.validSections).toContain("tenantId");
-            expect(result.validSections).toContain("logLevel");
-            expect(result.validSections).toContain("dataDir");
-            expect(result.validSections).toContain("security");
-            expect(result.validSections).toContain("gateway");
-            expect(result.config.tenantId).toBe("my-tenant");
-            expect(result.config.logLevel).toBe("info");
-            expect(result.config.dataDir).toBe("/data");
-        });
-        it("one invalid section returns error for that section, other sections are valid with defaults", () => {
-            const raw = {
-                tenantId: "my-tenant",
-                logLevel: "info",
-                // security expects an object, not a string
-                security: "invalid-value",
-                gateway: {},
-            };
-            const result = validatePartial(raw);
-            // security should be in errors
-            const securityError = result.errors.find((e) => e.section === "security");
-            expect(securityError).toBeDefined();
-            expect(securityError.error.code).toBe("VALIDATION_ERROR");
-            // Valid sections should still be present
-            expect(result.validSections).toContain("tenantId");
-            expect(result.validSections).toContain("logLevel");
-            expect(result.validSections).toContain("gateway");
-            expect(result.validSections).not.toContain("security");
-            expect(result.config.tenantId).toBe("my-tenant");
-        });
-        it("multiple invalid sections return multiple errors, all valid sections preserved", () => {
-            const raw = {
-                tenantId: "my-tenant",
-                security: "not-an-object",
-                gateway: "also-not-an-object",
-                memory: {},
-            };
-            const result = validatePartial(raw);
-            expect(result.errors.length).toBeGreaterThanOrEqual(2);
-            const errorSections = result.errors.map((e) => e.section);
-            expect(errorSections).toContain("security");
-            expect(errorSections).toContain("gateway");
-            // Valid sections preserved
-            expect(result.validSections).toContain("tenantId");
-            expect(result.validSections).toContain("memory");
-            expect(result.config.tenantId).toBe("my-tenant");
-        });
-        it("unknown top-level keys are ignored (not treated as errors)", () => {
-            const raw = {
-                tenantId: "my-tenant",
-                unknownKey: "should-be-ignored",
-                anotherUnknown: { nested: true },
-            };
-            const result = validatePartial(raw);
-            // Unknown keys should not appear in errors
-            const errorSections = result.errors.map((e) => e.section);
-            expect(errorSections).not.toContain("unknownKey");
-            expect(errorSections).not.toContain("anotherUnknown");
-            // Valid sections should still work
-            expect(result.validSections).toContain("tenantId");
-        });
-        it("scalar top-level fields (tenantId, logLevel, dataDir) are validated independently", () => {
-            const raw = {
-                tenantId: 12345, // Should be a string, not number
-                logLevel: "invalid-level", // Not a valid enum value
-                dataDir: "/data",
-            };
-            const result = validatePartial(raw);
-            // dataDir should be valid
-            expect(result.validSections).toContain("dataDir");
-            expect(result.config.dataDir).toBe("/data");
-            // tenantId and/or logLevel should have errors
-            expect(result.errors.length).toBeGreaterThanOrEqual(1);
-            const errorSections = result.errors.map((e) => e.section);
-            // At least logLevel should fail (invalid enum)
-            expect(errorSections).toContain("logLevel");
-        });
-        it("return type includes validSections, config, and errors arrays", () => {
-            const result = validatePartial({});
-            expect(Array.isArray(result.validSections)).toBe(true);
-            expect(typeof result.config).toBe("object");
-            expect(Array.isArray(result.errors)).toBe(true);
-        });
-    });
-});

package/node_modules/@comis/core/dist/config/schema-agent-model.test.d.ts

@@ -1 +0,0 @@
-export {};

package/node_modules/@comis/core/dist/config/schema-agent-model.test.js

@@ -1,279 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { BudgetConfigSchema, CircuitBreakerConfigSchema, ModelRoutesSchema, FallbackModelSchema, AuthProfileSchema, ModelFailoverConfigSchema, PromptTimeoutConfigSchema, OperationModelsSchema, } from "./schema-agent.js";
-describe("BudgetConfigSchema", () => {
-    it("parses valid input with all fields", () => {
-        const result = BudgetConfigSchema.safeParse({
-            perExecution: 50_000,
-            perHour: 200_000,
-            perDay: 1_000_000,
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.perExecution).toBe(50_000);
-            expect(result.data.perHour).toBe(200_000);
-            expect(result.data.perDay).toBe(1_000_000);
-        }
-    });
-    it("applies correct defaults for empty object", () => {
-        const result = BudgetConfigSchema.parse({});
-        expect(result.perExecution).toBe(2_000_000);
-        expect(result.perHour).toBe(10_000_000);
-        expect(result.perDay).toBe(100_000_000);
-    });
-    it("rejects negative values", () => {
-        const result = BudgetConfigSchema.safeParse({ perExecution: -1 });
-        expect(result.success).toBe(false);
-    });
-    it("rejects zero values", () => {
-        const result = BudgetConfigSchema.safeParse({ perHour: 0 });
-        expect(result.success).toBe(false);
-    });
-    it("rejects non-integer values", () => {
-        const result = BudgetConfigSchema.safeParse({ perDay: 1.5 });
-        expect(result.success).toBe(false);
-    });
-});
-describe("CircuitBreakerConfigSchema", () => {
-    it("parses valid input", () => {
-        const result = CircuitBreakerConfigSchema.safeParse({
-            failureThreshold: 3,
-            resetTimeoutMs: 30_000,
-            halfOpenTimeoutMs: 15_000,
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.failureThreshold).toBe(3);
-            expect(result.data.resetTimeoutMs).toBe(30_000);
-            expect(result.data.halfOpenTimeoutMs).toBe(15_000);
-        }
-    });
-    it("applies defaults for empty object", () => {
-        const result = CircuitBreakerConfigSchema.parse({});
-        expect(result.failureThreshold).toBe(5);
-        expect(result.resetTimeoutMs).toBe(60_000);
-        expect(result.halfOpenTimeoutMs).toBe(30_000);
-    });
-    it("rejects negative failureThreshold", () => {
-        const result = CircuitBreakerConfigSchema.safeParse({ failureThreshold: -1 });
-        expect(result.success).toBe(false);
-    });
-    it("rejects zero resetTimeoutMs", () => {
-        const result = CircuitBreakerConfigSchema.safeParse({ resetTimeoutMs: 0 });
-        expect(result.success).toBe(false);
-    });
-});
-describe("ModelRoutesSchema", () => {
-    it("parses valid route mappings", () => {
-        const result = ModelRoutesSchema.safeParse({
-            default: "claude-sonnet-4-5-20250929",
-            summarization: "claude-haiku-3",
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.default).toBe("claude-sonnet-4-5-20250929");
-            expect(result.data.summarization).toBe("claude-haiku-3");
-        }
-    });
-    it("defaults to empty object", () => {
-        const result = ModelRoutesSchema.parse(undefined);
-        expect(result).toEqual({});
-    });
-    it("allows empty object", () => {
-        const result = ModelRoutesSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data).toEqual({});
-        }
-    });
-    it("rejects empty string for default key", () => {
-        const result = ModelRoutesSchema.safeParse({ default: "" });
-        expect(result.success).toBe(false);
-    });
-});
-describe("FallbackModelSchema", () => {
-    it("parses valid fallback configuration", () => {
-        const result = FallbackModelSchema.safeParse({
-            provider: "openai",
-            modelId: "gpt-4o",
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.provider).toBe("openai");
-            expect(result.data.modelId).toBe("gpt-4o");
-        }
-    });
-    it("requires provider field", () => {
-        const result = FallbackModelSchema.safeParse({ modelId: "gpt-4o" });
-        expect(result.success).toBe(false);
-    });
-    it("requires modelId field", () => {
-        const result = FallbackModelSchema.safeParse({ provider: "openai" });
-        expect(result.success).toBe(false);
-    });
-    it("rejects empty provider string", () => {
-        const result = FallbackModelSchema.safeParse({ provider: "", modelId: "gpt-4o" });
-        expect(result.success).toBe(false);
-    });
-});
-describe("AuthProfileSchema", () => {
-    it("parses valid auth profile entries", () => {
-        const result = AuthProfileSchema.safeParse({
-            keyName: "ANTHROPIC_API_KEY_2",
-            provider: "anthropic",
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.keyName).toBe("ANTHROPIC_API_KEY_2");
-            expect(result.data.provider).toBe("anthropic");
-        }
-    });
-    it("requires keyName field", () => {
-        const result = AuthProfileSchema.safeParse({ provider: "anthropic" });
-        expect(result.success).toBe(false);
-    });
-    it("requires provider field", () => {
-        const result = AuthProfileSchema.safeParse({ keyName: "ANTHROPIC_API_KEY_2" });
-        expect(result.success).toBe(false);
-    });
-    it("rejects empty keyName string", () => {
-        const result = AuthProfileSchema.safeParse({ keyName: "", provider: "anthropic" });
-        expect(result.success).toBe(false);
-    });
-});
-describe("ModelFailoverConfigSchema", () => {
-    it("parses valid failover config with all fields", () => {
-        const result = ModelFailoverConfigSchema.safeParse({
-            fallbackModels: [{ provider: "openai", modelId: "gpt-4o" }],
-            authProfiles: [{ keyName: "KEY_2", provider: "anthropic" }],
-            allowedModels: ["claude-sonnet-4-5-20250929", "gpt-4o"],
-            maxAttempts: 3,
-            cooldownInitialMs: 30_000,
-            cooldownMultiplier: 2,
-            cooldownCapMs: 1_800_000,
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.fallbackModels).toHaveLength(1);
-            expect(result.data.authProfiles).toHaveLength(1);
-            expect(result.data.allowedModels).toHaveLength(2);
-            expect(result.data.maxAttempts).toBe(3);
-            expect(result.data.cooldownMultiplier).toBe(2);
-        }
-    });
-    it("applies defaults for empty object", () => {
-        const result = ModelFailoverConfigSchema.parse({});
-        expect(result.fallbackModels).toEqual([]);
-        expect(result.authProfiles).toEqual([]);
-        expect(result.allowedModels).toEqual([]);
-        expect(result.maxAttempts).toBe(6);
-        expect(result.cooldownInitialMs).toBe(60_000);
-        expect(result.cooldownMultiplier).toBe(5);
-        expect(result.cooldownCapMs).toBe(3_600_000);
-    });
-    it("rejects negative maxAttempts", () => {
-        const result = ModelFailoverConfigSchema.safeParse({ maxAttempts: -1 });
-        expect(result.success).toBe(false);
-    });
-    it("rejects zero cooldownInitialMs", () => {
-        const result = ModelFailoverConfigSchema.safeParse({ cooldownInitialMs: 0 });
-        expect(result.success).toBe(false);
-    });
-    it("round-trip: parse then re-parse produces identical result", () => {
-        const first = ModelFailoverConfigSchema.parse({
-            fallbackModels: [{ provider: "openai", modelId: "gpt-4o" }],
-            maxAttempts: 4,
-        });
-        const second = ModelFailoverConfigSchema.parse(first);
-        expect(second).toEqual(first);
-    });
-});
-describe("PromptTimeoutConfigSchema", () => {
-    it("applies defaults for empty object", () => {
-        const result = PromptTimeoutConfigSchema.parse({});
-        expect(result.promptTimeoutMs).toBe(180_000);
-        expect(result.retryPromptTimeoutMs).toBe(60_000);
-    });
-    it("rejects negative values", () => {
-        const result = PromptTimeoutConfigSchema.safeParse({ promptTimeoutMs: -1 });
-        expect(result.success).toBe(false);
-    });
-    it("rejects zero values", () => {
-        const result = PromptTimeoutConfigSchema.safeParse({ promptTimeoutMs: 0 });
-        expect(result.success).toBe(false);
-    });
-    it("rejects non-integer values", () => {
-        const result = PromptTimeoutConfigSchema.safeParse({ promptTimeoutMs: 1.5 });
-        expect(result.success).toBe(false);
-    });
-    it("accepts custom positive integers", () => {
-        const result = PromptTimeoutConfigSchema.safeParse({
-            promptTimeoutMs: 300_000,
-            retryPromptTimeoutMs: 120_000,
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.promptTimeoutMs).toBe(300_000);
-            expect(result.data.retryPromptTimeoutMs).toBe(120_000);
-        }
-    });
-});
-describe("OperationModelsSchema", () => {
-    it("defaults to empty object when not provided", () => {
-        const result = OperationModelsSchema.parse(undefined);
-        expect(result).toEqual({});
-    });
-    it("parses empty object (all fields optional)", () => {
-        const result = OperationModelsSchema.parse({});
-        expect(result).toEqual({});
-    });
-    it("parses a valid operationModels block with model and timeout fields", () => {
-        const result = OperationModelsSchema.parse({
-            cron: "anthropic:claude-haiku-4-5",
-            cronTimeout: 150_000,
-        });
-        expect(result.cron).toBe("anthropic:claude-haiku-4-5");
-        expect(result.cronTimeout).toBe(150_000);
-    });
-    it("accepts 'primary' keyword as a model value", () => {
-        const result = OperationModelsSchema.parse({ heartbeat: "primary" });
-        expect(result.heartbeat).toBe("primary");
-    });
-    it("rejects unknown keys (z.strictObject behavior)", () => {
-        const result = OperationModelsSchema.safeParse({ interactive: "model" });
-        expect(result.success).toBe(false);
-    });
-    it("rejects invalid timeout (negative value)", () => {
-        const result = OperationModelsSchema.safeParse({ cronTimeout: -1 });
-        expect(result.success).toBe(false);
-    });
-    it("rejects zero timeout", () => {
-        const result = OperationModelsSchema.safeParse({ cronTimeout: 0 });
-        expect(result.success).toBe(false);
-    });
-    it("rejects non-integer timeout", () => {
-        const result = OperationModelsSchema.safeParse({ heartbeatTimeout: 1.5 });
-        expect(result.success).toBe(false);
-    });
-    it("rejects empty string model", () => {
-        const result = OperationModelsSchema.safeParse({ cron: "" });
-        expect(result.success).toBe(false);
-    });
-    it("parses all 12 fields correctly (6 model strings + 6 timeout numbers)", () => {
-        const input = {
-            cron: "anthropic:claude-haiku-4-5",
-            cronTimeout: 150_000,
-            heartbeat: "anthropic:claude-haiku-4-5",
-            heartbeatTimeout: 60_000,
-            subagent: "primary",
-            subagentTimeout: 180_000,
-            compaction: "anthropic:claude-haiku-4-5",
-            compactionTimeout: 60_000,
-            taskExtraction: "anthropic:claude-haiku-4-5",
-            taskExtractionTimeout: 30_000,
-            condensation: "anthropic:claude-haiku-4-5",
-            condensationTimeout: 45_000,
-        };
-        const result = OperationModelsSchema.parse(input);
-        expect(result).toEqual(input);
-    });
-});

package/node_modules/@comis/core/dist/config/schema-agent-session.test.d.ts

@@ -1 +0,0 @@
-export {};