comisai 1.0.11 → 1.0.13

package/node_modules/@comis/core/dist/config/schema-context-guard.test.d.ts

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

package/node_modules/@comis/core/dist/config/schema-context-guard.test.js

@@ -1,111 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { ContextPruningConfigSchema, SourceGateConfigSchema } from "./schema-agent.js";
-// ---------------------------------------------------------------------------
-// ContextPruningConfigSchema
-// ---------------------------------------------------------------------------
-describe("ContextPruningConfigSchema", () => {
-    it("produces valid defaults from empty object", () => {
-        const result = ContextPruningConfigSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.enabled).toBe(true);
-            expect(result.data.softTrimRatio).toBe(0.3);
-            expect(result.data.hardClearRatio).toBe(0.5);
-            expect(result.data.keepLastAssistants).toBe(3);
-            expect(result.data.minPrunableToolChars).toBe(4000);
-            expect(result.data.protectedTools).toHaveLength(4);
-            expect(result.data.protectedTools).toEqual([
-                "memory_search", "memory_get", "memory_store", "file_read",
-            ]);
-        }
-    });
-    it("accepts custom values that override defaults", () => {
-        const result = ContextPruningConfigSchema.safeParse({
-            enabled: false,
-            softTrimRatio: 0.2,
-            hardClearRatio: 0.6,
-            keepLastAssistants: 5,
-            minPrunableToolChars: 8000,
-            protectedTools: ["bash"],
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.enabled).toBe(false);
-            expect(result.data.softTrimRatio).toBe(0.2);
-            expect(result.data.hardClearRatio).toBe(0.6);
-            expect(result.data.keepLastAssistants).toBe(5);
-            expect(result.data.minPrunableToolChars).toBe(8000);
-            expect(result.data.protectedTools).toEqual(["bash"]);
-        }
-    });
-    it("rejects softTrimRatio equal to hardClearRatio", () => {
-        const result = ContextPruningConfigSchema.safeParse({
-            softTrimRatio: 0.5,
-            hardClearRatio: 0.5,
-        });
-        expect(result.success).toBe(false);
-    });
-    it("rejects softTrimRatio greater than hardClearRatio", () => {
-        const result = ContextPruningConfigSchema.safeParse({
-            softTrimRatio: 0.6,
-            hardClearRatio: 0.3,
-        });
-        expect(result.success).toBe(false);
-    });
-    it("rejects softTrimRatio > 1", () => {
-        const result = ContextPruningConfigSchema.safeParse({ softTrimRatio: 1.1 });
-        expect(result.success).toBe(false);
-    });
-    it("rejects softTrimRatio < 0", () => {
-        const result = ContextPruningConfigSchema.safeParse({ softTrimRatio: -0.1 });
-        expect(result.success).toBe(false);
-    });
-    it("rejects hardClearRatio > 1", () => {
-        const result = ContextPruningConfigSchema.safeParse({ hardClearRatio: 1.1 });
-        expect(result.success).toBe(false);
-    });
-    it("rejects hardClearRatio < 0", () => {
-        const result = ContextPruningConfigSchema.safeParse({ hardClearRatio: -0.1 });
-        expect(result.success).toBe(false);
-    });
-    it("rejects non-positive minPrunableToolChars", () => {
-        const result = ContextPruningConfigSchema.safeParse({ minPrunableToolChars: 0 });
-        expect(result.success).toBe(false);
-        const result2 = ContextPruningConfigSchema.safeParse({ minPrunableToolChars: -1 });
-        expect(result2.success).toBe(false);
-    });
-    it("rejects negative keepLastAssistants", () => {
-        const result = ContextPruningConfigSchema.safeParse({ keepLastAssistants: -1 });
-        expect(result.success).toBe(false);
-    });
-});
-// ---------------------------------------------------------------------------
-// SourceGateConfigSchema
-// ---------------------------------------------------------------------------
-describe("SourceGateConfigSchema", () => {
-    it("produces valid defaults from empty object", () => {
-        const result = SourceGateConfigSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.maxResponseBytes).toBe(2_000_000);
-            expect(result.data.stripHiddenHtml).toBe(true);
-        }
-    });
-    it("accepts custom values that override defaults", () => {
-        const result = SourceGateConfigSchema.safeParse({
-            maxResponseBytes: 1_000_000,
-            stripHiddenHtml: false,
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.maxResponseBytes).toBe(1_000_000);
-            expect(result.data.stripHiddenHtml).toBe(false);
-        }
-    });
-    it("rejects non-positive maxResponseBytes", () => {
-        const result = SourceGateConfigSchema.safeParse({ maxResponseBytes: 0 });
-        expect(result.success).toBe(false);
-        const result2 = SourceGateConfigSchema.safeParse({ maxResponseBytes: -1 });
-        expect(result2.success).toBe(false);
-    });
-});

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

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

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

@@ -1,107 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { DaemonConfigSchema } from "./schema-daemon.js";
-describe("DaemonConfigSchema", () => {
-    describe("logging sub-schema", () => {
-        it("provides defaults for all logging fields when daemon is empty", () => {
-            const result = DaemonConfigSchema.safeParse({});
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data.logging).toEqual({
-                    filePath: "~/.comis/logs/daemon.log",
-                    maxSize: "10m",
-                    maxFiles: 5,
-                    compress: false,
-                    tracing: {
-                        outputDir: "~/.comis/traces",
-                        maxSize: "5m",
-                        maxFiles: 3,
-                    },
-                });
-            }
-        });
-        it("accepts valid logging overrides", () => {
-            const result = DaemonConfigSchema.safeParse({
-                logging: {
-                    filePath: "/var/log/comis/daemon.log",
-                    maxSize: "50m",
-                    maxFiles: 10,
-                    compress: true,
-                },
-            });
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data.logging.filePath).toBe("/var/log/comis/daemon.log");
-                expect(result.data.logging.maxSize).toBe("50m");
-                expect(result.data.logging.maxFiles).toBe(10);
-                expect(result.data.logging.compress).toBe(true);
-            }
-        });
-        it("accepts maxSize with various valid suffixes", () => {
-            for (const size of ["100", "10k", "10K", "50m", "50M", "1g", "1G"]) {
-                const result = DaemonConfigSchema.safeParse({ logging: { maxSize: size } });
-                expect(result.success).toBe(true);
-            }
-        });
-        it("rejects negative maxFiles", () => {
-            const result = DaemonConfigSchema.safeParse({ logging: { maxFiles: -1 } });
-            expect(result.success).toBe(false);
-        });
-        it("rejects maxFiles exceeding 100", () => {
-            const result = DaemonConfigSchema.safeParse({ logging: { maxFiles: 101 } });
-            expect(result.success).toBe(false);
-        });
-        it("rejects non-integer maxFiles", () => {
-            const result = DaemonConfigSchema.safeParse({ logging: { maxFiles: 2.5 } });
-            expect(result.success).toBe(false);
-        });
-        it("rejects non-string filePath", () => {
-            const result = DaemonConfigSchema.safeParse({ logging: { filePath: 123 } });
-            expect(result.success).toBe(false);
-        });
-        it("rejects invalid maxSize format", () => {
-            for (const bad of ["banana", "10mb", "1.5g", "m10", ""]) {
-                const result = DaemonConfigSchema.safeParse({ logging: { maxSize: bad } });
-                expect(result.success).toBe(false);
-            }
-        });
-        it("rejects non-boolean compress", () => {
-            const result = DaemonConfigSchema.safeParse({ logging: { compress: "yes" } });
-            expect(result.success).toBe(false);
-        });
-        it("rejects unknown keys in logging (strictObject)", () => {
-            const result = DaemonConfigSchema.safeParse({ logging: { unknownKey: "value" } });
-            expect(result.success).toBe(false);
-        });
-        it("allows partial logging overrides with defaults for rest", () => {
-            const result = DaemonConfigSchema.safeParse({ logging: { maxFiles: 20 } });
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data.logging.maxFiles).toBe(20);
-                expect(result.data.logging.filePath).toBe("~/.comis/logs/daemon.log");
-                expect(result.data.logging.maxSize).toBe("10m");
-                expect(result.data.logging.compress).toBe(false);
-            }
-        });
-        it("allows maxFiles of 0 (disable retention)", () => {
-            const result = DaemonConfigSchema.safeParse({ logging: { maxFiles: 0 } });
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data.logging.maxFiles).toBe(0);
-            }
-        });
-    });
-    describe("existing daemon fields preserved", () => {
-        it("preserves existing defaults alongside logging", () => {
-            const result = DaemonConfigSchema.safeParse({});
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data.watchdogIntervalMs).toBe(30_000);
-                expect(result.data.shutdownTimeoutMs).toBe(30_000);
-                expect(result.data.metricsIntervalMs).toBe(30_000);
-                expect(result.data.eventLoopDelayThresholdMs).toBe(500);
-                expect(result.data.logLevels).toEqual({});
-                expect(result.data.logging).toBeDefined();
-            }
-        });
-    });
-});

package/node_modules/@comis/core/dist/config/schema-delivery-timing.test.d.ts

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

package/node_modules/@comis/core/dist/config/schema-delivery-timing.test.js

@@ -1,51 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { DeliveryTimingConfigSchema } from "./schema-delivery.js";
-describe("DeliveryTimingConfigSchema", () => {
-    it("produces valid defaults from empty object", () => {
-        const result = DeliveryTimingConfigSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.mode).toBe("natural");
-            expect(result.data.minMs).toBe(800);
-            expect(result.data.maxMs).toBe(2500);
-            expect(result.data.jitterMs).toBe(200);
-            expect(result.data.firstBlockDelayMs).toBe(0);
-        }
-    });
-    it("accepts fully specified config", () => {
-        const result = DeliveryTimingConfigSchema.safeParse({
-            mode: "custom",
-            minMs: 500,
-            maxMs: 3000,
-            jitterMs: 100,
-            firstBlockDelayMs: 1000,
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.mode).toBe("custom");
-            expect(result.data.minMs).toBe(500);
-            expect(result.data.maxMs).toBe(3000);
-            expect(result.data.jitterMs).toBe(100);
-            expect(result.data.firstBlockDelayMs).toBe(1000);
-        }
-    });
-    it("rejects unknown keys (strictObject)", () => {
-        const result = DeliveryTimingConfigSchema.safeParse({
-            mode: "natural",
-            unknownField: "should-fail",
-        });
-        expect(result.success).toBe(false);
-    });
-    it("rejects invalid mode enum value", () => {
-        const result = DeliveryTimingConfigSchema.safeParse({
-            mode: "turbo",
-        });
-        expect(result.success).toBe(false);
-    });
-    it("rejects negative timing values", () => {
-        const result = DeliveryTimingConfigSchema.safeParse({
-            minMs: -100,
-        });
-        expect(result.success).toBe(false);
-    });
-});

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

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

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

@@ -1,63 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { DocumentationConfigSchema } from "./schema-documentation.js";
-describe("DocumentationConfigSchema", () => {
-    it("produces valid defaults from empty object", () => {
-        const result = DocumentationConfigSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.enabled).toBe(false);
-            expect(result.data.localDocsPath).toBe("");
-            expect(result.data.publicDocsUrl).toBe("");
-            expect(result.data.sourceUrl).toBe("");
-            expect(result.data.communityUrl).toBe("");
-            expect(result.data.skillsMarketplaceUrl).toBe("");
-            expect(result.data.mcpRegistryUrl).toBe("");
-            expect(result.data.customLinks).toEqual([]);
-        }
-    });
-    it("accepts fully specified config", () => {
-        const result = DocumentationConfigSchema.safeParse({
-            enabled: true,
-            localDocsPath: "/opt/docs",
-            publicDocsUrl: "https://docs.example.com",
-            sourceUrl: "https://github.com/org/repo",
-            communityUrl: "https://discord.gg/invite",
-            skillsMarketplaceUrl: "https://skills.example.com",
-            mcpRegistryUrl: "https://mcp.example.com/registry",
-            customLinks: [
-                { label: "API Reference", url: "https://api.example.com/docs" },
-                { label: "Changelog", url: "https://example.com/changelog" },
-            ],
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.enabled).toBe(true);
-            expect(result.data.localDocsPath).toBe("/opt/docs");
-            expect(result.data.skillsMarketplaceUrl).toBe("https://skills.example.com");
-            expect(result.data.mcpRegistryUrl).toBe("https://mcp.example.com/registry");
-            expect(result.data.customLinks).toHaveLength(2);
-            expect(result.data.customLinks[0]?.label).toBe("API Reference");
-        }
-    });
-    it("rejects unknown keys (strictObject)", () => {
-        const result = DocumentationConfigSchema.safeParse({
-            enabled: true,
-            unknownField: "should-fail",
-        });
-        expect(result.success).toBe(false);
-    });
-    it("rejects unknown keys in customLinks entries (strictObject)", () => {
-        const result = DocumentationConfigSchema.safeParse({
-            customLinks: [
-                { label: "API", url: "https://api.example.com", icon: "book" },
-            ],
-        });
-        expect(result.success).toBe(false);
-    });
-    it("rejects customLinks entry missing required label", () => {
-        const result = DocumentationConfigSchema.safeParse({
-            customLinks: [{ url: "https://example.com" }],
-        });
-        expect(result.success).toBe(false);
-    });
-});

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

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

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

@@ -1,219 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { GatewayConfigSchema, GatewayTlsConfigSchema, GatewayTokenSchema, GatewayRateLimitSchema, } from "./schema-gateway.js";
-// ---------------------------------------------------------------------------
-// GatewayConfigSchema
-// ---------------------------------------------------------------------------
-describe("GatewayConfigSchema", () => {
-    it("produces valid defaults from empty object", () => {
-        const result = GatewayConfigSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.enabled).toBe(true);
-            expect(result.data.host).toBe("127.0.0.1");
-            expect(result.data.port).toBe(4766);
-            expect(result.data.tokens).toEqual([]);
-            expect(result.data.maxBatchSize).toBe(50);
-            expect(result.data.wsHeartbeatMs).toBe(30_000);
-            expect(result.data.corsOrigins).toEqual([]);
-            expect(result.data.allowInsecureHttp).toBe(false);
-            expect(result.data.trustedProxies).toEqual([]);
-            expect(result.data.httpBodyLimitBytes).toBe(1_048_576);
-            expect(result.data.wsMaxMessageBytes).toBe(1_048_576);
-        }
-    });
-    it("includes rateLimit defaults", () => {
-        const result = GatewayConfigSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.rateLimit.windowMs).toBe(60_000);
-            expect(result.data.rateLimit.maxRequests).toBe(100);
-        }
-    });
-    it("includes wsMessageRateLimit defaults", () => {
-        const result = GatewayConfigSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.wsMessageRateLimit.maxMessages).toBe(60);
-            expect(result.data.wsMessageRateLimit.windowMs).toBe(60_000);
-        }
-    });
-    it("tls is optional (undefined when omitted)", () => {
-        const result = GatewayConfigSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.tls).toBeUndefined();
-        }
-    });
-    it("rejects port below 1", () => {
-        const result = GatewayConfigSchema.safeParse({ port: 0 });
-        expect(result.success).toBe(false);
-    });
-    it("rejects port above 65535", () => {
-        const result = GatewayConfigSchema.safeParse({ port: 65536 });
-        expect(result.success).toBe(false);
-    });
-    it("accepts valid port at boundaries", () => {
-        const r1 = GatewayConfigSchema.safeParse({ port: 1 });
-        expect(r1.success).toBe(true);
-        const rMax = GatewayConfigSchema.safeParse({ port: 65535 });
-        expect(rMax.success).toBe(true);
-    });
-    it("rejects unknown fields (strictObject enforcement)", () => {
-        const result = GatewayConfigSchema.safeParse({ unknownField: "test" });
-        expect(result.success).toBe(false);
-    });
-});
-// ---------------------------------------------------------------------------
-// GatewayTlsConfigSchema
-// ---------------------------------------------------------------------------
-describe("GatewayTlsConfigSchema", () => {
-    it("requires certPath, keyPath, caPath", () => {
-        const result = GatewayTlsConfigSchema.safeParse({
-            certPath: "/etc/tls/cert.pem",
-            keyPath: "/etc/tls/key.pem",
-            caPath: "/etc/tls/ca.pem",
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.certPath).toBe("/etc/tls/cert.pem");
-            expect(result.data.keyPath).toBe("/etc/tls/key.pem");
-            expect(result.data.caPath).toBe("/etc/tls/ca.pem");
-        }
-    });
-    it("defaults requireClientCert to true", () => {
-        const result = GatewayTlsConfigSchema.safeParse({
-            certPath: "/cert.pem",
-            keyPath: "/key.pem",
-            caPath: "/ca.pem",
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.requireClientCert).toBe(true);
-        }
-    });
-    it("rejects empty certPath", () => {
-        const result = GatewayTlsConfigSchema.safeParse({
-            certPath: "",
-            keyPath: "/key.pem",
-            caPath: "/ca.pem",
-        });
-        expect(result.success).toBe(false);
-    });
-    it("rejects missing required fields", () => {
-        const result = GatewayTlsConfigSchema.safeParse({});
-        expect(result.success).toBe(false);
-    });
-});
-// ---------------------------------------------------------------------------
-// GatewayTokenSchema
-// ---------------------------------------------------------------------------
-describe("GatewayTokenSchema", () => {
-    it("accepts token with id and scopes (no secret)", () => {
-        const result = GatewayTokenSchema.safeParse({
-            id: "token-1",
-            scopes: ["rpc", "ws"],
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.id).toBe("token-1");
-            expect(result.data.secret).toBeUndefined();
-            expect(result.data.scopes).toEqual(["rpc", "ws"]);
-        }
-    });
-    it("scopes defaults to empty array", () => {
-        const result = GatewayTokenSchema.safeParse({ id: "token-2" });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.scopes).toEqual([]);
-        }
-    });
-    it("accepts secret string with min 32 chars", () => {
-        const secret = "a".repeat(32);
-        const result = GatewayTokenSchema.safeParse({ id: "token-3", secret });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.secret).toBe(secret);
-        }
-    });
-    it("rejects short secret string (< 32 chars)", () => {
-        const result = GatewayTokenSchema.safeParse({
-            id: "token-4",
-            secret: "too-short",
-        });
-        expect(result.success).toBe(false);
-    });
-    it("accepts SecretRef object for secret field", () => {
-        const result = GatewayTokenSchema.safeParse({
-            id: "token-5",
-            secret: { source: "env", provider: "gateway", id: "GW_TOKEN_SECRET" },
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.secret).toEqual({
-                source: "env",
-                provider: "gateway",
-                id: "GW_TOKEN_SECRET",
-            });
-        }
-    });
-    it("rejects empty id", () => {
-        const result = GatewayTokenSchema.safeParse({ id: "" });
-        expect(result.success).toBe(false);
-    });
-});
-// ---------------------------------------------------------------------------
-// GatewayRateLimitSchema
-// ---------------------------------------------------------------------------
-describe("GatewayRateLimitSchema", () => {
-    it("produces valid defaults", () => {
-        const result = GatewayRateLimitSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.windowMs).toBe(60_000);
-            expect(result.data.maxRequests).toBe(100);
-        }
-    });
-    it("rejects non-positive windowMs", () => {
-        const result = GatewayRateLimitSchema.safeParse({ windowMs: 0 });
-        expect(result.success).toBe(false);
-    });
-    it("rejects non-positive maxRequests", () => {
-        const result = GatewayRateLimitSchema.safeParse({ maxRequests: 0 });
-        expect(result.success).toBe(false);
-    });
-});
-// ---------------------------------------------------------------------------
-// Trusted proxies IP validation
-// ---------------------------------------------------------------------------
-describe("Trusted proxies validation", () => {
-    it("accepts valid IPv4 addresses", () => {
-        const result = GatewayConfigSchema.safeParse({
-            trustedProxies: ["10.0.0.1", "192.168.1.100"],
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.trustedProxies).toEqual(["10.0.0.1", "192.168.1.100"]);
-        }
-    });
-    it("accepts valid IPv6 addresses", () => {
-        const result = GatewayConfigSchema.safeParse({
-            trustedProxies: ["::1", "2001:db8::1"],
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.trustedProxies).toHaveLength(2);
-        }
-    });
-    it("rejects invalid IP strings", () => {
-        const result = GatewayConfigSchema.safeParse({
-            trustedProxies: ["not-an-ip"],
-        });
-        expect(result.success).toBe(false);
-    });
-    it("rejects mixed valid/invalid IPs", () => {
-        const result = GatewayConfigSchema.safeParse({
-            trustedProxies: ["10.0.0.1", "invalid"],
-        });
-        expect(result.success).toBe(false);
-    });
-});

package/node_modules/@comis/core/dist/config/schema-gemini-cache.test.d.ts

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

package/node_modules/@comis/core/dist/config/schema-gemini-cache.test.js

@@ -1,41 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { GeminiCacheConfigSchema } from "./schema-gemini-cache.js";
-import { AgentConfigSchema } from "./schema-agent.js";
-// ---------------------------------------------------------------------------
-// GeminiCacheConfigSchema
-// ---------------------------------------------------------------------------
-describe("GeminiCacheConfigSchema", () => {
-    it("produces correct defaults from empty object", () => {
-        const result = GeminiCacheConfigSchema.parse({});
-        expect(result).toEqual({ enabled: false, maxActiveCaches: 20 });
-    });
-    it("accepts explicit values", () => {
-        const result = GeminiCacheConfigSchema.parse({ enabled: true, maxActiveCaches: 10 });
-        expect(result).toEqual({ enabled: true, maxActiveCaches: 10 });
-    });
-    it("rejects maxActiveCaches: 0 (must be positive)", () => {
-        const result = GeminiCacheConfigSchema.safeParse({ maxActiveCaches: 0 });
-        expect(result.success).toBe(false);
-    });
-    it("rejects maxActiveCaches: 1.5 (must be integer)", () => {
-        const result = GeminiCacheConfigSchema.safeParse({ maxActiveCaches: 1.5 });
-        expect(result.success).toBe(false);
-    });
-    it("rejects unknown keys (strictObject)", () => {
-        const result = GeminiCacheConfigSchema.safeParse({ enabled: true, unknownField: "bad" });
-        expect(result.success).toBe(false);
-    });
-});
-// ---------------------------------------------------------------------------
-// AgentConfigSchema geminiCache integration
-// ---------------------------------------------------------------------------
-describe("AgentConfigSchema geminiCache integration", () => {
-    it("includes geminiCache with correct defaults when omitted", () => {
-        const config = AgentConfigSchema.parse({});
-        expect(config.geminiCache).toEqual({ enabled: false, maxActiveCaches: 20 });
-    });
-    it("applies maxActiveCaches default when only enabled is set", () => {
-        const config = AgentConfigSchema.parse({ geminiCache: { enabled: true } });
-        expect(config.geminiCache.maxActiveCaches).toBe(20);
-    });
-});

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

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