comisai 1.0.11 → 1.0.13

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

@@ -1,294 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { ProviderEntrySchema, ProvidersConfigSchema, UserModelSchema, ModelCostSchema, } from "./schema-providers.js";
-import { ModelCompatConfigSchema } from "../domain/model-compat.js";
-import { ProviderCapabilitiesSchema } from "../domain/provider-capabilities.js";
-// ---------------------------------------------------------------------------
-// ModelCompatConfigSchema
-// ---------------------------------------------------------------------------
-describe("ModelCompatConfigSchema", () => {
-    it("parses empty object (all fields optional)", () => {
-        const result = ModelCompatConfigSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.supportsTools).toBeUndefined();
-            expect(result.data.toolSchemaProfile).toBeUndefined();
-            expect(result.data.toolCallArgumentsEncoding).toBeUndefined();
-            expect(result.data.nativeWebSearchTool).toBeUndefined();
-        }
-    });
-    it("parses valid full config", () => {
-        const result = ModelCompatConfigSchema.safeParse({
-            supportsTools: true,
-            toolSchemaProfile: "xai",
-            toolCallArgumentsEncoding: "html-entities",
-            nativeWebSearchTool: false,
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.supportsTools).toBe(true);
-            expect(result.data.toolSchemaProfile).toBe("xai");
-            expect(result.data.toolCallArgumentsEncoding).toBe("html-entities");
-            expect(result.data.nativeWebSearchTool).toBe(false);
-        }
-    });
-    it("rejects unknown fields (z.strictObject enforcement)", () => {
-        const result = ModelCompatConfigSchema.safeParse({
-            supportsTools: true,
-            unknownField: true,
-        });
-        expect(result.success).toBe(false);
-    });
-    it("rejects invalid enum values", () => {
-        const result = ModelCompatConfigSchema.safeParse({
-            toolSchemaProfile: "invalid",
-        });
-        expect(result.success).toBe(false);
-    });
-});
-// ---------------------------------------------------------------------------
-// ProviderCapabilitiesSchema
-// ---------------------------------------------------------------------------
-describe("ProviderCapabilitiesSchema", () => {
-    it("parses empty object and produces correct defaults", () => {
-        const result = ProviderCapabilitiesSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.providerFamily).toBe("default");
-            expect(result.data.dropThinkingBlockModelHints).toEqual([]);
-            expect(result.data.transcriptToolCallIdMode).toBe("default");
-            expect(result.data.transcriptToolCallIdModelHints).toEqual([]);
-        }
-    });
-    it("parses full override", () => {
-        const result = ProviderCapabilitiesSchema.safeParse({
-            providerFamily: "anthropic",
-            dropThinkingBlockModelHints: ["claude"],
-            transcriptToolCallIdMode: "strict9",
-            transcriptToolCallIdModelHints: ["mistral"],
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.providerFamily).toBe("anthropic");
-            expect(result.data.dropThinkingBlockModelHints).toEqual(["claude"]);
-            expect(result.data.transcriptToolCallIdMode).toBe("strict9");
-            expect(result.data.transcriptToolCallIdModelHints).toEqual(["mistral"]);
-        }
-    });
-    it("rejects unknown fields", () => {
-        const result = ProviderCapabilitiesSchema.safeParse({
-            providerFamily: "default",
-            unknownField: true,
-        });
-        expect(result.success).toBe(false);
-    });
-    it("rejects invalid providerFamily enum", () => {
-        const result = ProviderCapabilitiesSchema.safeParse({
-            providerFamily: "azure",
-        });
-        expect(result.success).toBe(false);
-    });
-});
-// ---------------------------------------------------------------------------
-// UserModelSchema
-// ---------------------------------------------------------------------------
-describe("UserModelSchema", () => {
-    it("parses minimal config with correct defaults", () => {
-        const result = UserModelSchema.safeParse({ id: "test-model" });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.id).toBe("test-model");
-            expect(result.data.reasoning).toBe(false);
-            expect(result.data.input).toEqual(["text"]);
-            expect(result.data.name).toBeUndefined();
-            expect(result.data.contextWindow).toBeUndefined();
-            expect(result.data.maxTokens).toBeUndefined();
-            expect(result.data.cost).toBeUndefined();
-            expect(result.data.comisCompat).toBeUndefined();
-            expect(result.data.sdkCompat).toBeUndefined();
-        }
-    });
-    it("parses full config with comisCompat and sdkCompat", () => {
-        const result = UserModelSchema.safeParse({
-            id: "my-custom-model",
-            name: "My Custom Model",
-            reasoning: true,
-            contextWindow: 128_000,
-            maxTokens: 8192,
-            input: ["text", "image"],
-            cost: { input: 3.0, output: 15.0 },
-            comisCompat: { supportsTools: true, toolSchemaProfile: "xai" },
-            sdkCompat: { streamOptions: { includeUsage: true } },
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.reasoning).toBe(true);
-            expect(result.data.contextWindow).toBe(128_000);
-            expect(result.data.comisCompat?.supportsTools).toBe(true);
-            expect(result.data.sdkCompat?.streamOptions).toEqual({ includeUsage: true });
-        }
-    });
-    it("rejects empty id string", () => {
-        const result = UserModelSchema.safeParse({ id: "" });
-        expect(result.success).toBe(false);
-    });
-    it("sdkCompat accepts arbitrary keys (z.record loose validation)", () => {
-        const result = UserModelSchema.safeParse({
-            id: "test",
-            sdkCompat: { anyKey: "anyValue", nested: { deep: true } },
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.sdkCompat?.anyKey).toBe("anyValue");
-        }
-    });
-    it("comisCompat rejects unknown fields (strict)", () => {
-        const result = UserModelSchema.safeParse({
-            id: "test",
-            comisCompat: { supportsTools: true, unknownField: true },
-        });
-        expect(result.success).toBe(false);
-    });
-});
-// ---------------------------------------------------------------------------
-// ModelCostSchema
-// ---------------------------------------------------------------------------
-describe("ModelCostSchema", () => {
-    it("parses empty object (all fields optional)", () => {
-        const result = ModelCostSchema.safeParse({});
-        expect(result.success).toBe(true);
-    });
-    it("parses full cost entry", () => {
-        const result = ModelCostSchema.safeParse({
-            input: 3.0,
-            output: 15.0,
-            cacheRead: 0.3,
-            cacheWrite: 3.75,
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.input).toBe(3.0);
-            expect(result.data.output).toBe(15.0);
-            expect(result.data.cacheRead).toBe(0.3);
-            expect(result.data.cacheWrite).toBe(3.75);
-        }
-    });
-    it("rejects negative cost values", () => {
-        const result = ModelCostSchema.safeParse({ input: -1 });
-        expect(result.success).toBe(false);
-    });
-    it("accepts zero cost (free models)", () => {
-        const result = ModelCostSchema.safeParse({ input: 0, output: 0 });
-        expect(result.success).toBe(true);
-    });
-});
-// ---------------------------------------------------------------------------
-// ProviderEntrySchema (extended)
-// ---------------------------------------------------------------------------
-describe("ProviderEntrySchema (extended)", () => {
-    it("parses existing minimal config -- backward compatibility", () => {
-        const result = ProviderEntrySchema.safeParse({ type: "openai" });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.type).toBe("openai");
-            expect(result.data.enabled).toBe(true);
-            expect(result.data.timeoutMs).toBe(120_000);
-        }
-    });
-    it("capabilities defaults to empty ProviderCapabilities (with all defaults)", () => {
-        const result = ProviderEntrySchema.safeParse({ type: "openai" });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.capabilities).toBeDefined();
-            expect(result.data.capabilities.providerFamily).toBe("default");
-            expect(result.data.capabilities.dropThinkingBlockModelHints).toEqual([]);
-            expect(result.data.capabilities.transcriptToolCallIdMode).toBe("default");
-            expect(result.data.capabilities.transcriptToolCallIdModelHints).toEqual([]);
-        }
-    });
-    it("models defaults to empty array", () => {
-        const result = ProviderEntrySchema.safeParse({ type: "openai" });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.models).toEqual([]);
-        }
-    });
-    it("parses full config with capabilities and models array", () => {
-        const result = ProviderEntrySchema.safeParse({
-            type: "deepseek",
-            name: "DeepSeek",
-            baseUrl: "https://api.deepseek.com/v1",
-            apiKeyName: "deepseek-key",
-            capabilities: {
-                providerFamily: "openai",
-                transcriptToolCallIdMode: "strict9",
-                transcriptToolCallIdModelHints: ["deepseek-chat"],
-            },
-            models: [
-                { id: "deepseek-chat", reasoning: false },
-                { id: "deepseek-reasoner", reasoning: true, contextWindow: 64_000 },
-            ],
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.capabilities.providerFamily).toBe("openai");
-            expect(result.data.models).toHaveLength(2);
-            expect(result.data.models[1].reasoning).toBe(true);
-            expect(result.data.models[1].contextWindow).toBe(64_000);
-        }
-    });
-    it("rejects unknown capabilities fields (strict)", () => {
-        const result = ProviderEntrySchema.safeParse({
-            type: "openai",
-            capabilities: { providerFamily: "openai", unknownField: true },
-        });
-        expect(result.success).toBe(false);
-    });
-});
-// ---------------------------------------------------------------------------
-// ProvidersConfigSchema
-// ---------------------------------------------------------------------------
-describe("ProvidersConfigSchema", () => {
-    it("accepts provider entries with custom string keys", () => {
-        const result = ProvidersConfigSchema.safeParse({
-            entries: {
-                anthropic: { type: "anthropic" },
-                openai: { type: "openai" },
-            },
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(Object.keys(result.data.entries)).toEqual(["anthropic", "openai"]);
-        }
-    });
-    it("full integration: nested provider with capabilities + models", () => {
-        const result = ProvidersConfigSchema.safeParse({
-            entries: {
-                deepseek: {
-                    type: "deepseek",
-                    capabilities: {
-                        providerFamily: "openai",
-                        dropThinkingBlockModelHints: ["deepseek-reasoner"],
-                    },
-                    models: [
-                        {
-                            id: "deepseek-reasoner",
-                            reasoning: true,
-                            contextWindow: 64_000,
-                            maxTokens: 8192,
-                            input: ["text"],
-                            cost: { input: 0.55, output: 2.19 },
-                            comisCompat: { supportsTools: false },
-                        },
-                    ],
-                },
-            },
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            const ds = result.data.entries.deepseek;
-            expect(ds.capabilities.dropThinkingBlockModelHints).toEqual(["deepseek-reasoner"]);
-            expect(ds.models).toHaveLength(1);
-            expect(ds.models[0].comisCompat?.supportsTools).toBe(false);
-        }
-    });
-});

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

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

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

@@ -1,234 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { QueueModeSchema, OverflowPolicySchema, OverflowConfigSchema, DebounceBufferConfigSchema, PerChannelQueueConfigSchema, FollowupConfigSchema, PriorityLaneConfigSchema, LaneAssignmentConfigSchema, QueueConfigSchema, } from "./schema-queue.js";
-// ---------------------------------------------------------------------------
-// QueueModeSchema
-// ---------------------------------------------------------------------------
-describe("QueueModeSchema", () => {
-    it("accepts all 4 valid values", () => {
-        for (const mode of ["followup", "collect", "steer", "steer+followup"]) {
-            const result = QueueModeSchema.safeParse(mode);
-            expect(result.success).toBe(true);
-        }
-    });
-    it("defaults to steer+followup", () => {
-        const result = QueueModeSchema.safeParse(undefined);
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data).toBe("steer+followup");
-        }
-    });
-    it("rejects invalid string", () => {
-        const result = QueueModeSchema.safeParse("queue-all");
-        expect(result.success).toBe(false);
-    });
-});
-// ---------------------------------------------------------------------------
-// OverflowPolicySchema
-// ---------------------------------------------------------------------------
-describe("OverflowPolicySchema", () => {
-    it("accepts drop-old, drop-new, summarize", () => {
-        for (const policy of ["drop-old", "drop-new", "summarize"]) {
-            const result = OverflowPolicySchema.safeParse(policy);
-            expect(result.success).toBe(true);
-        }
-    });
-    it("defaults to drop-new", () => {
-        const result = OverflowPolicySchema.safeParse(undefined);
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data).toBe("drop-new");
-        }
-    });
-});
-// ---------------------------------------------------------------------------
-// OverflowConfigSchema
-// ---------------------------------------------------------------------------
-describe("OverflowConfigSchema", () => {
-    it("produces valid defaults", () => {
-        const result = OverflowConfigSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.maxDepth).toBe(20);
-            expect(result.data.policy).toBe("drop-new");
-        }
-    });
-    it("rejects non-positive maxDepth", () => {
-        const result = OverflowConfigSchema.safeParse({ maxDepth: 0 });
-        expect(result.success).toBe(false);
-    });
-});
-// ---------------------------------------------------------------------------
-// DebounceBufferConfigSchema
-// ---------------------------------------------------------------------------
-describe("DebounceBufferConfigSchema", () => {
-    it("produces valid defaults", () => {
-        const result = DebounceBufferConfigSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.windowMs).toBe(0);
-            expect(result.data.maxBufferedMessages).toBe(10);
-            expect(result.data.firstMessageImmediate).toBe(true);
-        }
-    });
-    it("accepts windowMs=0 (disabled)", () => {
-        const result = DebounceBufferConfigSchema.safeParse({ windowMs: 0 });
-        expect(result.success).toBe(true);
-    });
-    it("rejects negative windowMs", () => {
-        const result = DebounceBufferConfigSchema.safeParse({ windowMs: -1 });
-        expect(result.success).toBe(false);
-    });
-});
-// ---------------------------------------------------------------------------
-// PerChannelQueueConfigSchema
-// ---------------------------------------------------------------------------
-describe("PerChannelQueueConfigSchema", () => {
-    it("produces valid defaults", () => {
-        const result = PerChannelQueueConfigSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.mode).toBe("steer+followup");
-            expect(result.data.overflow.maxDepth).toBe(20);
-            expect(result.data.overflow.policy).toBe("drop-new");
-            expect(result.data.debounceMs).toBe(0);
-        }
-    });
-});
-// ---------------------------------------------------------------------------
-// FollowupConfigSchema
-// ---------------------------------------------------------------------------
-describe("FollowupConfigSchema", () => {
-    it("produces valid defaults", () => {
-        const result = FollowupConfigSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.maxFollowupRuns).toBe(3);
-            expect(result.data.followupOnCompaction).toBe(true);
-        }
-    });
-    it("accepts maxFollowupRuns=0 (disabled)", () => {
-        const result = FollowupConfigSchema.safeParse({ maxFollowupRuns: 0 });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.maxFollowupRuns).toBe(0);
-        }
-    });
-});
-// ---------------------------------------------------------------------------
-// PriorityLaneConfigSchema
-// ---------------------------------------------------------------------------
-describe("PriorityLaneConfigSchema", () => {
-    it("produces valid defaults for optional fields", () => {
-        const result = PriorityLaneConfigSchema.safeParse({ name: "normal" });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.concurrency).toBe(3);
-            expect(result.data.priority).toBe(0);
-            expect(result.data.agingPromotionMs).toBe(30_000);
-        }
-    });
-    it("rejects empty name", () => {
-        const result = PriorityLaneConfigSchema.safeParse({ name: "" });
-        expect(result.success).toBe(false);
-    });
-});
-// ---------------------------------------------------------------------------
-// LaneAssignmentConfigSchema
-// ---------------------------------------------------------------------------
-describe("LaneAssignmentConfigSchema", () => {
-    it("produces valid defaults", () => {
-        const result = LaneAssignmentConfigSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.defaultLane).toBe("normal");
-            expect(result.data.dmLane).toBe("high");
-            expect(result.data.mentionLane).toBe("normal");
-            expect(result.data.followupLane).toBe("normal");
-            expect(result.data.scheduledLane).toBe("low");
-        }
-    });
-});
-// ---------------------------------------------------------------------------
-// QueueConfigSchema
-// ---------------------------------------------------------------------------
-describe("QueueConfigSchema", () => {
-    it("produces valid defaults from empty object", () => {
-        const result = QueueConfigSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.enabled).toBe(true);
-            expect(result.data.maxConcurrentSessions).toBe(10);
-            expect(result.data.cleanupIdleMs).toBe(600_000);
-            expect(result.data.defaultMode).toBe("steer+followup");
-            expect(result.data.defaultDebounceMs).toBe(0);
-            expect(result.data.perChannel).toEqual({});
-            expect(result.data.perChannelDebounce).toEqual({});
-            expect(result.data.priorityEnabled).toBe(false);
-        }
-    });
-    it("includes default priorityLanes with 3 lanes (high/normal/low)", () => {
-        const result = QueueConfigSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.priorityLanes).toHaveLength(3);
-            const high = result.data.priorityLanes.find((l) => l.name === "high");
-            expect(high).toBeDefined();
-            expect(high.concurrency).toBe(3);
-            expect(high.priority).toBe(2);
-            const normal = result.data.priorityLanes.find((l) => l.name === "normal");
-            expect(normal).toBeDefined();
-            expect(normal.concurrency).toBe(5);
-            expect(normal.priority).toBe(1);
-            const low = result.data.priorityLanes.find((l) => l.name === "low");
-            expect(low).toBeDefined();
-            expect(low.concurrency).toBe(2);
-            expect(low.priority).toBe(0);
-        }
-    });
-    it("includes laneAssignment defaults", () => {
-        const result = QueueConfigSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.laneAssignment.defaultLane).toBe("normal");
-            expect(result.data.laneAssignment.dmLane).toBe("high");
-            expect(result.data.laneAssignment.scheduledLane).toBe("low");
-        }
-    });
-    it("includes followup defaults", () => {
-        const result = QueueConfigSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.followup.maxFollowupRuns).toBe(3);
-            expect(result.data.followup.followupOnCompaction).toBe(true);
-        }
-    });
-    it("includes debounce defaults", () => {
-        const result = QueueConfigSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.debounce.windowMs).toBe(0);
-            expect(result.data.debounce.maxBufferedMessages).toBe(10);
-            expect(result.data.debounce.firstMessageImmediate).toBe(true);
-        }
-    });
-    it("includes defaultOverflow defaults", () => {
-        const result = QueueConfigSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.defaultOverflow.maxDepth).toBe(20);
-            expect(result.data.defaultOverflow.policy).toBe("drop-new");
-        }
-    });
-    it("accepts perChannel overrides", () => {
-        const result = QueueConfigSchema.safeParse({
-            perChannel: {
-                telegram: { mode: "collect", debounceMs: 500 },
-            },
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.perChannel.telegram.mode).toBe("collect");
-            expect(result.data.perChannel.telegram.debounceMs).toBe(500);
-        }
-    });
-});

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

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

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

@@ -1,36 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { ResponsePrefixConfigSchema } from "./schema-response-prefix.js";
-describe("ResponsePrefixConfigSchema", () => {
-    it("produces valid defaults from empty object", () => {
-        const result = ResponsePrefixConfigSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.template).toBe("");
-            expect(result.data.position).toBe("prepend");
-        }
-    });
-    it("accepts fully specified config", () => {
-        const result = ResponsePrefixConfigSchema.safeParse({
-            template: "{agent.emoji} {model|short}{?thinking: | think}",
-            position: "append",
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.template).toBe("{agent.emoji} {model|short}{?thinking: | think}");
-            expect(result.data.position).toBe("append");
-        }
-    });
-    it("rejects unknown keys (strictObject)", () => {
-        const result = ResponsePrefixConfigSchema.safeParse({
-            template: "test",
-            unknownField: "should-fail",
-        });
-        expect(result.success).toBe(false);
-    });
-    it("rejects invalid position enum value", () => {
-        const result = ResponsePrefixConfigSchema.safeParse({
-            position: "inline",
-        });
-        expect(result.success).toBe(false);
-    });
-});

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

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

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

@@ -1,54 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { AgentToAgentConfigSchema, SecurityConfigSchema } from "./schema-security.js";
-// ---------------------------------------------------------------------------
-// AgentToAgentConfigSchema.subAgentSessionPersistence
-// ---------------------------------------------------------------------------
-describe("AgentToAgentConfigSchema.subAgentSessionPersistence", () => {
-    it("defaults to false when omitted", () => {
-        const result = AgentToAgentConfigSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.subAgentSessionPersistence).toBe(false);
-        }
-    });
-    it("accepts explicit true", () => {
-        const result = AgentToAgentConfigSchema.safeParse({
-            subAgentSessionPersistence: true,
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.subAgentSessionPersistence).toBe(true);
-        }
-    });
-    it("accepts explicit false", () => {
-        const result = AgentToAgentConfigSchema.safeParse({
-            subAgentSessionPersistence: false,
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.subAgentSessionPersistence).toBe(false);
-        }
-    });
-    it("rejects non-boolean value", () => {
-        const result = AgentToAgentConfigSchema.safeParse({
-            subAgentSessionPersistence: "yes",
-        });
-        expect(result.success).toBe(false);
-    });
-    it("is present in SecurityConfigSchema parsed output", () => {
-        const result = SecurityConfigSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.agentToAgent.subAgentSessionPersistence).toBe(false);
-        }
-    });
-    it("is present in SecurityConfigSchema when set to true", () => {
-        const result = SecurityConfigSchema.safeParse({
-            agentToAgent: { subAgentSessionPersistence: true },
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.agentToAgent.subAgentSessionPersistence).toBe(true);
-        }
-    });
-});

package/node_modules/@comis/core/dist/config/schema-sender-trust-display.test.d.ts

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