comisai 1.0.4

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

@@ -0,0 +1,279 @@
+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.d.ts

@@ -0,0 +1,177 @@
+import { z } from "zod";
+/**
+ * Session lifecycle configuration schemas.
+ *
+ * Owns session reset policy, DM scope isolation, pruning of oversized
+ * tool results, and per-agent compaction thresholds.
+ */
+/**
+ * Per-session-type reset policy override.
+ * All fields are optional -- omitted fields inherit from the parent policy.
+ */
+export declare const ResetPolicyOverrideSchema: z.ZodObject<{
+    /** Override reset mode for this session type */
+    mode: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        daily: "daily";
+        idle: "idle";
+        hybrid: "hybrid";
+    }>>;
+    /** Override daily reset hour (0-23) */
+    dailyResetHour: z.ZodOptional<z.ZodNumber>;
+    /** Override IANA timezone for daily reset */
+    dailyResetTimezone: z.ZodOptional<z.ZodString>;
+    /** Override idle timeout in milliseconds */
+    idleTimeoutMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+/**
+ * Session reset policy configuration.
+ * Controls automatic session expiry via daily, idle, or hybrid modes.
+ */
+export declare const SessionResetPolicySchema: z.ZodObject<{
+    /** Reset mode: daily, idle, hybrid (first-to-expire), or none (disabled) */
+    mode: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        daily: "daily";
+        idle: "idle";
+        hybrid: "hybrid";
+    }>>;
+    /** Hour of day for daily reset (0-23, default 4 = 4 AM) */
+    dailyResetHour: z.ZodDefault<z.ZodNumber>;
+    /** IANA timezone for daily reset (empty string = system local) */
+    dailyResetTimezone: z.ZodDefault<z.ZodString>;
+    /** Idle timeout in milliseconds (default 4 hours = 14_400_000) */
+    idleTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    /** Sweep interval in milliseconds (how often to check sessions, default 5 min) */
+    sweepIntervalMs: z.ZodDefault<z.ZodNumber>;
+    /** Phrases that trigger immediate session reset when sent as a message */
+    resetTriggers: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    /** Per-session-type overrides (dm, group, thread) */
+    perType: z.ZodDefault<z.ZodObject<{
+        dm: z.ZodOptional<z.ZodObject<{
+            /** Override reset mode for this session type */
+            mode: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                daily: "daily";
+                idle: "idle";
+                hybrid: "hybrid";
+            }>>;
+            /** Override daily reset hour (0-23) */
+            dailyResetHour: z.ZodOptional<z.ZodNumber>;
+            /** Override IANA timezone for daily reset */
+            dailyResetTimezone: z.ZodOptional<z.ZodString>;
+            /** Override idle timeout in milliseconds */
+            idleTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        group: z.ZodOptional<z.ZodObject<{
+            /** Override reset mode for this session type */
+            mode: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                daily: "daily";
+                idle: "idle";
+                hybrid: "hybrid";
+            }>>;
+            /** Override daily reset hour (0-23) */
+            dailyResetHour: z.ZodOptional<z.ZodNumber>;
+            /** Override IANA timezone for daily reset */
+            dailyResetTimezone: z.ZodOptional<z.ZodString>;
+            /** Override idle timeout in milliseconds */
+            idleTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        thread: z.ZodOptional<z.ZodObject<{
+            /** Override reset mode for this session type */
+            mode: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                daily: "daily";
+                idle: "idle";
+                hybrid: "hybrid";
+            }>>;
+            /** Override daily reset hour (0-23) */
+            dailyResetHour: z.ZodOptional<z.ZodNumber>;
+            /** Override IANA timezone for daily reset */
+            dailyResetTimezone: z.ZodOptional<z.ZodString>;
+            /** Override idle timeout in milliseconds */
+            idleTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/**
+ * DM scope configuration for session key isolation granularity.
+ *
+ * Controls how DM (direct message) conversations are scoped:
+ * - "main": all DMs share a single session (userId="main", channelId="dm")
+ * - "per-peer": one session per peer across all channels
+ * - "per-channel-peer": one session per channel+peer (default)
+ * - "per-account-channel-peer": includes bot account identifier in channel for multi-bot isolation
+ */
+export declare const DmScopeConfigSchema: z.ZodObject<{
+    /** DM scope mode controlling session isolation granularity */
+    mode: z.ZodDefault<z.ZodEnum<{
+        main: "main";
+        "per-peer": "per-peer";
+        "per-channel-peer": "per-channel-peer";
+        "per-account-channel-peer": "per-account-channel-peer";
+    }>>;
+    /** Prepend agent:<agentId>: to session keys for multi-agent isolation */
+    agentPrefix: z.ZodDefault<z.ZodBoolean>;
+    /** Append :thread:<threadId> to session keys for forum/thread isolation */
+    threadIsolation: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+/**
+ * Session pruning configuration for in-memory tool result trimming.
+ *
+ * Controls how oversized tool results are trimmed before each LLM call.
+ * Pruning operates on copies only -- persisted session data is never affected.
+ */
+export declare const PruningConfigSchema: z.ZodObject<{
+    /** Enable session pruning of oversized tool results */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /** Character threshold above which tool results are soft-trimmed (head + tail with marker) */
+    softTrimThresholdChars: z.ZodDefault<z.ZodNumber>;
+    /** Character threshold above which tool results are hard-cleared (entire content replaced) */
+    hardClearThresholdChars: z.ZodDefault<z.ZodNumber>;
+    /** Number of characters to preserve at the start of a soft-trimmed result */
+    preserveHeadChars: z.ZodDefault<z.ZodNumber>;
+    /** Number of characters to preserve at the end of a soft-trimmed result */
+    preserveTailChars: z.ZodDefault<z.ZodNumber>;
+    /** Tools whose results are eligible for pruning (empty = all tools eligible) */
+    pruneableTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    /** Tools whose results are never pruned (takes precedence over pruneableTools) */
+    protectedTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    /** Protect tool results containing image content blocks from pruning */
+    protectImageBlocks: z.ZodDefault<z.ZodBoolean>;
+    /** Number of recent messages (from end of array) exempt from pruning */
+    preserveRecentCount: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+/**
+ * Session compaction configuration.
+ *
+ * Controls when pre-compaction memory flushes and hard compaction triggers
+ * fire, based on context window usage ratios. The flushModel option allows
+ * using a cheaper model for memory extraction.
+ */
+export declare const SessionCompactionConfigSchema: z.ZodObject<{
+    /** Fraction of maxContextChars at which soft flush triggers (memory extraction only) */
+    softThresholdRatio: z.ZodDefault<z.ZodNumber>;
+    /** Fraction of maxContextChars at which hard compaction triggers (flush + trim) */
+    hardThresholdRatio: z.ZodDefault<z.ZodNumber>;
+    /** Model to use for memory extraction during flush (defaults to cheap model) */
+    flushModel: z.ZodOptional<z.ZodString>;
+    /** Max characters per summarization chunk. Default: 50_000. */
+    chunkMaxChars: z.ZodDefault<z.ZodNumber>;
+    /** Number of overlap messages between chunks. Default: 2. */
+    chunkOverlapMessages: z.ZodDefault<z.ZodNumber>;
+    /** Whether to merge chunk summaries via LLM. Default: true. */
+    chunkMergeSummaries: z.ZodDefault<z.ZodBoolean>;
+    /** Tokens reserved for summary during SDK auto-compaction. Default: 16384. */
+    reserveTokens: z.ZodDefault<z.ZodNumber>;
+    /** Tokens worth of recent messages to keep after SDK auto-compaction. Default: 32768. */
+    keepRecentTokens: z.ZodDefault<z.ZodNumber>;
+    /** AGENTS.md section names to re-inject after compaction (COMP-04). */
+    postCompactionSections: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type SessionResetPolicyConfig = z.infer<typeof SessionResetPolicySchema>;
+export type ResetPolicyOverride = z.infer<typeof ResetPolicyOverrideSchema>;
+export type DmScopeConfig = z.infer<typeof DmScopeConfigSchema>;
+export type PruningConfig = z.infer<typeof PruningConfigSchema>;
+export type SessionCompactionConfig = z.infer<typeof SessionCompactionConfigSchema>;

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

@@ -0,0 +1,116 @@
+import { z } from "zod";
+/**
+ * Session lifecycle configuration schemas.
+ *
+ * Owns session reset policy, DM scope isolation, pruning of oversized
+ * tool results, and per-agent compaction thresholds.
+ */
+/**
+ * Per-session-type reset policy override.
+ * All fields are optional -- omitted fields inherit from the parent policy.
+ */
+export const ResetPolicyOverrideSchema = z.strictObject({
+    /** Override reset mode for this session type */
+    mode: z.enum(["daily", "idle", "hybrid", "none"]).optional(),
+    /** Override daily reset hour (0-23) */
+    dailyResetHour: z.number().int().min(0).max(23).optional(),
+    /** Override IANA timezone for daily reset */
+    dailyResetTimezone: z.string().optional(),
+    /** Override idle timeout in milliseconds */
+    idleTimeoutMs: z.number().int().positive().optional(),
+});
+/**
+ * Session reset policy configuration.
+ * Controls automatic session expiry via daily, idle, or hybrid modes.
+ */
+export const SessionResetPolicySchema = z.strictObject({
+    /** Reset mode: daily, idle, hybrid (first-to-expire), or none (disabled) */
+    mode: z.enum(["daily", "idle", "hybrid", "none"]).default("none"),
+    /** Hour of day for daily reset (0-23, default 4 = 4 AM) */
+    dailyResetHour: z.number().int().min(0).max(23).default(4),
+    /** IANA timezone for daily reset (empty string = system local) */
+    dailyResetTimezone: z.string().default(""),
+    /** Idle timeout in milliseconds (default 4 hours = 14_400_000) */
+    idleTimeoutMs: z.number().int().positive().default(14_400_000),
+    /** Sweep interval in milliseconds (how often to check sessions, default 5 min) */
+    sweepIntervalMs: z.number().int().positive().default(300_000),
+    /** Phrases that trigger immediate session reset when sent as a message */
+    resetTriggers: z.array(z.string()).default([]),
+    /** Per-session-type overrides (dm, group, thread) */
+    perType: z.strictObject({
+        dm: ResetPolicyOverrideSchema.optional(),
+        group: ResetPolicyOverrideSchema.optional(),
+        thread: ResetPolicyOverrideSchema.optional(),
+    }).default({}),
+});
+/**
+ * DM scope configuration for session key isolation granularity.
+ *
+ * Controls how DM (direct message) conversations are scoped:
+ * - "main": all DMs share a single session (userId="main", channelId="dm")
+ * - "per-peer": one session per peer across all channels
+ * - "per-channel-peer": one session per channel+peer (default)
+ * - "per-account-channel-peer": includes bot account identifier in channel for multi-bot isolation
+ */
+export const DmScopeConfigSchema = z.strictObject({
+    /** DM scope mode controlling session isolation granularity */
+    mode: z.enum(["main", "per-peer", "per-channel-peer", "per-account-channel-peer"])
+        .default("per-channel-peer"),
+    /** Prepend agent:<agentId>: to session keys for multi-agent isolation */
+    agentPrefix: z.boolean().default(false),
+    /** Append :thread:<threadId> to session keys for forum/thread isolation */
+    threadIsolation: z.boolean().default(true),
+});
+/**
+ * Session pruning configuration for in-memory tool result trimming.
+ *
+ * Controls how oversized tool results are trimmed before each LLM call.
+ * Pruning operates on copies only -- persisted session data is never affected.
+ */
+export const PruningConfigSchema = z.strictObject({
+    /** Enable session pruning of oversized tool results */
+    enabled: z.boolean().default(true),
+    /** Character threshold above which tool results are soft-trimmed (head + tail with marker) */
+    softTrimThresholdChars: z.number().int().positive().default(8_000),
+    /** Character threshold above which tool results are hard-cleared (entire content replaced) */
+    hardClearThresholdChars: z.number().int().positive().default(30_000),
+    /** Number of characters to preserve at the start of a soft-trimmed result */
+    preserveHeadChars: z.number().int().nonnegative().default(500),
+    /** Number of characters to preserve at the end of a soft-trimmed result */
+    preserveTailChars: z.number().int().nonnegative().default(500),
+    /** Tools whose results are eligible for pruning (empty = all tools eligible) */
+    pruneableTools: z.array(z.string()).default([]),
+    /** Tools whose results are never pruned (takes precedence over pruneableTools) */
+    protectedTools: z.array(z.string()).default([]),
+    /** Protect tool results containing image content blocks from pruning */
+    protectImageBlocks: z.boolean().default(true),
+    /** Number of recent messages (from end of array) exempt from pruning */
+    preserveRecentCount: z.number().int().nonnegative().default(6),
+});
+/**
+ * Session compaction configuration.
+ *
+ * Controls when pre-compaction memory flushes and hard compaction triggers
+ * fire, based on context window usage ratios. The flushModel option allows
+ * using a cheaper model for memory extraction.
+ */
+export const SessionCompactionConfigSchema = z.strictObject({
+    /** Fraction of maxContextChars at which soft flush triggers (memory extraction only) */
+    softThresholdRatio: z.number().min(0).max(1).default(0.75),
+    /** Fraction of maxContextChars at which hard compaction triggers (flush + trim) */
+    hardThresholdRatio: z.number().min(0).max(1).default(0.90),
+    /** Model to use for memory extraction during flush (defaults to cheap model) */
+    flushModel: z.string().optional(),
+    /** Max characters per summarization chunk. Default: 50_000. */
+    chunkMaxChars: z.number().int().positive().default(50_000),
+    /** Number of overlap messages between chunks. Default: 2. */
+    chunkOverlapMessages: z.number().int().nonnegative().default(2),
+    /** Whether to merge chunk summaries via LLM. Default: true. */
+    chunkMergeSummaries: z.boolean().default(true),
+    /** Tokens reserved for summary during SDK auto-compaction. Default: 16384. */
+    reserveTokens: z.number().int().positive().default(16384),
+    /** Tokens worth of recent messages to keep after SDK auto-compaction. Default: 32768. */
+    keepRecentTokens: z.number().int().positive().default(32768),
+    /** AGENTS.md section names to re-inject after compaction (COMP-04). */
+    postCompactionSections: z.array(z.string()).default(["Session Startup", "Red Lines"]),
+});

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

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