llm-cli-gateway 1.15.3 → 1.16.1

package/dist/session-manager-pg.js

@@ -7,112 +7,16 @@ const DEFAULT_SESSION_DESCRIPTIONS = {
     mistral: "Mistral Session",
 };
 /**
- * PostgreSQL-backed session manager with Redis caching
+ * PostgreSQL-backed session manager. PostgreSQL is the source of truth and
+ * the only required service for this backend.
  */
 export class PostgreSQLSessionManager {
     pool;
-    redis;
-    cacheTtl;
-    logger;
-    constructor(pool, redis, cacheTtl, logger) {
+    constructor(pool) {
         this.pool = pool;
-        this.redis = redis;
-        this.cacheTtl = cacheTtl;
-        this.logger = logger;
     }
     /**
-     * Acquire distributed lock using Redis SET NX EX
-     * Returns [success, lockValue] tuple
-     */
-    async acquireLock(key, ttlSeconds) {
-        const lockKey = `lock:${key}`;
-        const lockValue = randomUUID();
-        // SET NX EX atomic operation
-        const result = await this.redis.set(lockKey, lockValue, "EX", ttlSeconds, "NX");
-        return [result === "OK", lockValue];
-    }
-    async sleep(ms) {
-        await new Promise(resolve => setTimeout(resolve, ms));
-    }
-    /**
-     * Acquire a distributed lock with bounded retries to smooth contention spikes.
-     */
-    async acquireLockWithRetry(key, ttlSeconds, errorLabel, maxWaitMs = 6000) {
-        const deadline = Date.now() + maxWaitMs;
-        while (true) {
-            const [lockAcquired, lockValue] = await this.acquireLock(key, ttlSeconds);
-            if (lockAcquired) {
-                return lockValue;
-            }
-            if (Date.now() >= deadline) {
-                throw new Error(`Failed to acquire lock for ${errorLabel}`);
-            }
-            // Small jitter avoids lock-step retries from concurrent callers.
-            await this.sleep(25 + Math.floor(Math.random() * 25));
-        }
-    }
-    /**
-     * Release distributed lock with optimistic Redis transaction semantics.
-     * Only releases if lockValue matches, which prevents releasing another
-     * process's lock after expiry/reacquire.
-     */
-    async releaseLock(key, lockValue) {
-        const lockKey = `lock:${key}`;
-        await this.redis.watch(lockKey);
-        try {
-            const currentValue = await this.redis.get(lockKey);
-            if (currentValue !== lockValue) {
-                await this.redis.unwatch();
-                return;
-            }
-            await this.redis.multi().del(lockKey).exec();
-        }
-        catch (error) {
-            await this.redis.unwatch().catch(() => undefined);
-            throw error;
-        }
-    }
-    /**
-     * Invalidate session cache
-     */
-    async invalidateCache(sessionId) {
-        try {
-            await this.redis.del(`session:${sessionId}`);
-        }
-        catch (error) {
-            // Graceful degradation - log but don't fail
-            this.logger.error(`Cache invalidation failed for session ${sessionId}`, { error, sessionId });
-        }
-    }
-    /**
-     * Invalidate session list cache using SCAN (non-blocking)
-     */
-    async invalidateListCache(cli) {
-        try {
-            if (cli) {
-                await this.redis.del(`session_list:${cli}`);
-            }
-            else {
-                // Use SCAN instead of KEYS to avoid blocking Redis
-                const keys = [];
-                let cursor = "0";
-                do {
-                    const [nextCursor, matchedKeys] = await this.redis.scan(cursor, "MATCH", "session_list:*", "COUNT", 100);
-                    cursor = nextCursor;
-                    keys.push(...matchedKeys);
-                } while (cursor !== "0");
-                // Delete in batches to avoid overwhelming Redis
-                if (keys.length > 0) {
-                    await this.redis.del(...keys);
-                }
-            }
-        }
-        catch (error) {
-            this.logger.error("List cache invalidation failed", { error });
-        }
-    }
-    /**
-     * Create a new session
+     * Create a new session.
      */
     async createSession(cli, description, sessionId) {
         const id = sessionId || randomUUID();
@@ -121,32 +25,19 @@ export class PostgreSQLSessionManager {
         const client = await this.pool.connect();
         try {
             await client.query("BEGIN");
-            // Insert session
             await client.query(`INSERT INTO sessions (id, cli, description, created_at, last_used_at)
          VALUES ($1, $2, $3, $4, $5)`, [id, cli, sessionDescription, now, now]);
-            // Set as active if none exists
             await client.query(`INSERT INTO active_sessions (cli, session_id, updated_at)
          VALUES ($1, $2, $3)
          ON CONFLICT (cli) DO NOTHING`, [cli, id, now]);
             await client.query("COMMIT");
-            const session = {
+            return {
                 id,
                 cli,
                 createdAt: now,
                 lastUsedAt: now,
                 description: sessionDescription,
             };
-            // Write-through to cache
-            try {
-                await this.redis.setex(`session:${id}`, this.cacheTtl.session, JSON.stringify(session));
-            }
-            catch (error) {
-                // Graceful degradation
-                this.logger.error("Cache write failed", { error });
-            }
-            // Invalidate list cache
-            await this.invalidateListCache(cli);
-            return session;
         }
         catch (error) {
             await client.query("ROLLBACK");
@@ -157,55 +48,18 @@ export class PostgreSQLSessionManager {
         }
     }
     /**
-     * Get session by ID (cache-aside pattern)
+     * Get session by ID.
      */
     async getSession(sessionId) {
-        // Try cache first
-        try {
-            const cached = await this.redis.get(`session:${sessionId}`);
-            if (cached) {
-                return JSON.parse(cached);
-            }
-        }
-        catch (error) {
-            // Graceful degradation - fallback to DB
-            this.logger.error("Cache read failed", { error });
-        }
-        // Cache miss - query database
         const result = await this.pool.query(`SELECT id, cli, description, metadata, created_at AS "createdAt", last_used_at AS "lastUsedAt"
        FROM sessions
        WHERE id = $1`, [sessionId]);
-        if (result.rows.length === 0) {
-            return null;
-        }
-        const session = result.rows[0];
-        // Populate cache
-        try {
-            await this.redis.setex(`session:${sessionId}`, this.cacheTtl.session, JSON.stringify(session));
-        }
-        catch (error) {
-            this.logger.error("Cache write failed", { error });
-        }
-        return session;
+        return result.rows[0] ?? null;
     }
     /**
-     * List all sessions, optionally filtered by CLI
+     * List all sessions, optionally filtered by CLI.
      */
     async listSessions(cli) {
-        // Try cache for CLI-specific lists
-        const cacheKey = cli ? `session_list:${cli}` : null;
-        if (cacheKey) {
-            try {
-                const cached = await this.redis.get(cacheKey);
-                if (cached) {
-                    return JSON.parse(cached);
-                }
-            }
-            catch (error) {
-                this.logger.error("Cache read failed", { error });
-            }
-        }
-        // Query database
         const query = cli
             ? `SELECT id, cli, description, metadata, created_at AS "createdAt", last_used_at AS "lastUsedAt"
          FROM sessions
@@ -217,176 +71,70 @@ export class PostgreSQLSessionManager {
         const result = cli
             ? await this.pool.query(query, [cli])
             : await this.pool.query(query);
-        const sessions = result.rows;
-        // Cache CLI-specific lists
-        if (cacheKey) {
-            try {
-                await this.redis.setex(cacheKey, this.cacheTtl.sessionList, JSON.stringify(sessions));
-            }
-            catch (error) {
-                this.logger.error("Cache write failed", { error });
-            }
-        }
-        return sessions;
+        return result.rows;
     }
     /**
-     * Delete a session
+     * Delete a session.
      */
     async deleteSession(sessionId) {
-        // Get session to find CLI type
         const session = await this.getSession(sessionId);
         if (!session) {
             return false;
         }
-        // Delete from database (CASCADE will handle active_sessions)
         const result = await this.pool.query("DELETE FROM sessions WHERE id = $1", [sessionId]);
-        if (result.rowCount === 0) {
-            return false;
-        }
-        // Invalidate caches (session, active session for this CLI, and list)
-        await this.invalidateCache(sessionId);
-        try {
-            await this.redis.del(`active_session:${session.cli}`);
-        }
-        catch (error) {
-            this.logger.error(`Failed to invalidate active session cache for ${session.cli}`, { error });
-        }
-        await this.invalidateListCache(session.cli);
-        return true;
+        return result.rowCount !== 0;
     }
     /**
-     * Set active session for a CLI (with distributed locking)
+     * Set active session for a CLI. The row-level update is serialized by
+     * PostgreSQL and the session FK keeps stale IDs from being recorded.
      */
     async setActiveSession(cli, sessionId) {
-        // Validate session exists if not null
         if (sessionId !== null) {
             const session = await this.getSession(sessionId);
             if (!session || session.cli !== cli) {
                 return false;
             }
         }
-        // Acquire lock with bounded retries to avoid failing benign concurrent updates.
-        const lockValue = await this.acquireLockWithRetry(`active_session:${cli}`, 5, `active session ${cli}`);
-        try {
-            // UPSERT active session
-            const now = new Date().toISOString();
-            await this.pool.query(`INSERT INTO active_sessions (cli, session_id, updated_at)
-         VALUES ($1, $2, $3)
-         ON CONFLICT (cli) DO UPDATE SET session_id = $2, updated_at = $3`, [cli, sessionId, now]);
-            // Update cache
-            try {
-                if (sessionId) {
-                    await this.redis.setex(`active_session:${cli}`, this.cacheTtl.activeSession, sessionId);
-                }
-                else {
-                    await this.redis.del(`active_session:${cli}`);
-                }
-            }
-            catch (error) {
-                this.logger.error("Cache update failed", { error });
-            }
-            return true;
-        }
-        finally {
-            // Release lock with ownership verification
-            try {
-                await this.releaseLock(`active_session:${cli}`, lockValue);
-            }
-            catch (error) {
-                this.logger.error(`Failed to release lock for active session ${cli}`, { error, cli });
-            }
-        }
+        const now = new Date().toISOString();
+        await this.pool.query(`INSERT INTO active_sessions (cli, session_id, updated_at)
+       VALUES ($1, $2, $3)
+       ON CONFLICT (cli) DO UPDATE SET session_id = $2, updated_at = $3`, [cli, sessionId, now]);
+        return true;
     }
     /**
-     * Get active session for a CLI
+     * Get active session for a CLI.
      */
     async getActiveSession(cli) {
-        // Try cache first
-        try {
-            const cachedId = await this.redis.get(`active_session:${cli}`);
-            if (cachedId) {
-                return await this.getSession(cachedId);
-            }
-        }
-        catch (error) {
-            this.logger.error("Cache read failed", { error });
-        }
-        // Query database
         const result = await this.pool.query("SELECT session_id FROM active_sessions WHERE cli = $1", [cli]);
-        if (result.rows.length === 0 || !result.rows[0].session_id) {
+        const sessionId = result.rows[0]?.session_id;
+        if (!sessionId) {
             return null;
         }
-        const sessionId = result.rows[0].session_id;
-        // Populate cache
-        try {
-            await this.redis.setex(`active_session:${cli}`, this.cacheTtl.activeSession, sessionId);
-        }
-        catch (error) {
-            this.logger.error("Cache write failed", { error });
-        }
         return await this.getSession(sessionId);
     }
     /**
-     * Update session usage timestamp
+     * Update session usage timestamp.
      */
     async updateSessionUsage(sessionId) {
         const now = new Date().toISOString();
         await this.pool.query("UPDATE sessions SET last_used_at = $1 WHERE id = $2", [now, sessionId]);
-        // Invalidate cache to force refresh
-        await this.invalidateCache(sessionId);
     }
     /**
-     * Update session metadata (atomic JSONB merge)
+     * Update session metadata using PostgreSQL's atomic JSONB merge.
      */
     async updateSessionMetadata(sessionId, metadata) {
-        // Use PostgreSQL JSONB || operator for atomic merge (prevents race conditions)
         const result = await this.pool.query(`UPDATE sessions
        SET metadata = COALESCE(metadata, '{}'::jsonb) || $1::jsonb
        WHERE id = $2
        RETURNING id`, [JSON.stringify(metadata), sessionId]);
-        if (result.rowCount === 0) {
-            return false;
-        }
-        // Invalidate cache
-        await this.invalidateCache(sessionId);
-        return true;
+        return result.rowCount !== 0;
     }
     /**
-     * Clear all sessions, optionally filtered by CLI
-     * Invalidates all related caches (session, active, list)
+     * Clear all sessions, optionally filtered by CLI.
      */
     async clearAllSessions(cli) {
-        // First get all sessions to invalidate their caches
-        const sessions = await this.listSessions(cli);
-        // Delete from database
         const query = cli ? "DELETE FROM sessions WHERE cli = $1" : "DELETE FROM sessions";
         const result = cli ? await this.pool.query(query, [cli]) : await this.pool.query(query);
-        // Invalidate individual session caches (concurrent — each has its own try/catch)
-        await Promise.all(sessions.map(session => this.invalidateCache(session.id)));
-        // Invalidate active session caches
-        if (cli) {
-            try {
-                await this.redis.del(`active_session:${cli}`);
-            }
-            catch (error) {
-                this.logger.error(`Failed to invalidate active session cache for ${cli}`, { error, cli });
-            }
-        }
-        else {
-            // Invalidate all active session caches
-            try {
-                await Promise.all([
-                    this.redis.del("active_session:claude"),
-                    this.redis.del("active_session:codex"),
-                    this.redis.del("active_session:gemini"),
-                ]);
-            }
-            catch (error) {
-                this.logger.error("Failed to invalidate active session caches", { error });
-            }
-        }
-        // Invalidate list caches
-        await this.invalidateListCache(cli);
         return result.rowCount || 0;
     }
 }

package/dist/session-manager.js

@@ -230,15 +230,15 @@ export const SessionManager = FileSessionManager;
  * @param logger - Logger instance for structured logging
  */
 export async function createSessionManager(config, db, logger, opts) {
-    if (config?.database && config?.redis) {
-        // Import dynamically to avoid loading pg/ioredis if not needed
+    if (config?.database) {
+        // Import dynamically to avoid loading pg if not needed.
         const { PostgreSQLSessionManager } = await import("./session-manager-pg.js");
         // Use provided db connection or create new one
         if (!db) {
             const { createDatabaseConnection } = await import("./db.js");
             db = await createDatabaseConnection(config, logger);
         }
-        return new PostgreSQLSessionManager(db.getPool(), db.getRedis(), config.cacheTtl, logger ?? noopLogger);
+        return new PostgreSQLSessionManager(db.getPool());
     }
     else {
         // Use file-based storage with TTL from config

package/dist/upstream-contracts.js

@@ -604,15 +604,16 @@ export const UPSTREAM_CLI_CONTRACTS = {
             // Phase 4 slice δ
             "maxTurns",
             "maxPrice",
+            "maxTokens",
             // Phase 4 slice ζ
             "workingDir",
             "addDir",
         ],
         flags: {
             "-p": { arity: "one", description: "Prompt text" },
-            "--output-format": {
+            "--output": {
                 arity: "one",
-                values: ["plain", "json", "stream-json"],
+                values: ["text", "json", "streaming"],
                 description: "Output format",
             },
             "--agent": {
@@ -641,6 +642,11 @@ export const UPSTREAM_CLI_CONTRACTS = {
                 pattern: /^(0|[1-9][0-9]*)(\.[0-9]+)?$/,
                 description: "Cumulative cost cap in USD (Phase 4 slice δ, programmatic mode only)",
             },
+            "--max-tokens": {
+                arity: "one",
+                pattern: /^[1-9][0-9]*$/,
+                description: "Cumulative prompt + completion token cap (Vibe 2.x programmatic mode)",
+            },
             "--workdir": {
                 arity: "one",
                 description: "Working directory for the invocation (Phase 4 slice ζ)",
@@ -686,6 +692,22 @@ export const UPSTREAM_CLI_CONTRACTS = {
                 env: { VIBE_ACTIVE_MODEL: "mistral-medium-3.5" },
                 expect: "pass",
             },
+            {
+                id: "mistral-output-streaming-and-max-tokens",
+                description: "Vibe 2.x: --output streaming and --max-tokens are accepted",
+                args: [
+                    "-p",
+                    "hello",
+                    "--agent",
+                    "auto-approve",
+                    "--output",
+                    "streaming",
+                    "--max-tokens",
+                    "1000",
+                ],
+                env: { VIBE_ACTIVE_MODEL: "mistral-medium-3.5" },
+                expect: "pass",
+            },
             {
                 id: "mistral-max-price-scientific-notation",
                 description: "Phase 4 slice δ: scientific-notation --max-price is rejected by contract pattern (matches MAX_PRICE_SCHEMA bounds)",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-cli-gateway",
-  "version": "1.15.3",
+  "version": "1.16.1",
   "mcpName": "io.github.verivus-oss/llm-cli-gateway",
   "description": "MCP server providing unified access to Claude Code, Codex, Gemini, Grok, and Mistral Vibe CLIs with session management, retry logic, async job orchestration, durable job results, and cross-LLM validation.",
   "license": "MIT",
@@ -90,13 +90,9 @@
     "zod": "^3.23.0"
   },
   "peerDependencies": {
-    "ioredis": "^5.4.1",
     "pg": "^8.12.0"
   },
   "peerDependenciesMeta": {
-    "ioredis": {
-      "optional": true
-    },
     "pg": {
       "optional": true
     }
@@ -111,7 +107,6 @@
     "eslint": "^8.57.1",
     "eslint-config-prettier": "^9.0.0",
     "eslint-plugin-security": "^3.0.1",
-    "ioredis": "5.9.2",
     "pg": "^8.12.0",
     "prettier": "^3.0.0",
     "typescript": "^5.0.0",