llm-cli-gateway 2.13.2 → 2.14.0

package/dist/flight-recorder.js

@@ -54,6 +54,16 @@ function ensureCacheControlTtlSecondsColumn(db) {
         db.exec("ALTER TABLE requests ADD COLUMN cache_control_ttl_seconds INTEGER");
     }
 }
+function ensureMetadataProviderSessionColumns(db) {
+    const rows = db.prepare("PRAGMA table_info(gateway_metadata)").all();
+    const names = new Set(rows.map((row) => (row && typeof row.name === "string" ? row.name : "")));
+    if (!names.has("provider_session_id")) {
+        db.exec("ALTER TABLE gateway_metadata ADD COLUMN provider_session_id TEXT");
+    }
+    if (!names.has("stop_reason")) {
+        db.exec("ALTER TABLE gateway_metadata ADD COLUMN stop_reason TEXT");
+    }
+}
 export function resolveFlightRecorderDbPath() {
     const configured = process.env.LLM_GATEWAY_LOGS_DB;
     if (configured !== undefined) {
@@ -147,6 +157,8 @@ export class FlightRecorder {
         http_status INTEGER,
         error_message TEXT,
         async_job_id TEXT,
+        provider_session_id TEXT,
+        stop_reason TEXT,
         status TEXT NOT NULL DEFAULT 'started'
       );
 
@@ -180,6 +192,10 @@ export class FlightRecorder {
         this.db
             .prepare("INSERT OR IGNORE INTO _migrations(version, applied_at) VALUES(6, ?)")
             .run(new Date().toISOString());
+        ensureMetadataProviderSessionColumns(this.db);
+        this.db
+            .prepare("INSERT OR IGNORE INTO _migrations(version, applied_at) VALUES(7, ?)")
+            .run(new Date().toISOString());
         if (process.platform !== "win32") {
             try {
                 chmodSync(dbPath, 0o600);
@@ -240,6 +256,8 @@ export class FlightRecorder {
           exit_code = @exit_code,
           http_status = @http_status,
           error_message = @error_message,
+          provider_session_id = @provider_session_id,
+          stop_reason = @stop_reason,
           status = @status
       WHERE request_id = @id AND status = 'started'
     `);
@@ -267,6 +285,8 @@ export class FlightRecorder {
                 exit_code: result.exitCode,
                 http_status: result.httpStatus ?? null,
                 error_message: result.errorMessage ?? null,
+                provider_session_id: result.providerSessionId ?? null,
+                stop_reason: result.stopReason ?? null,
                 status: result.status,
             });
         });

package/dist/gemini-json-parser.d.ts

@@ -6,6 +6,8 @@ export interface GeminiUsage {
 export interface GeminiJsonParseResult {
     usage?: GeminiUsage;
     response?: string;
+    sessionId?: string;
+    stopReason?: string;
 }
 export declare function parseGeminiJson(stdout: string): GeminiJsonParseResult | null;
 export declare function parseGeminiStreamJson(stdout: string): GeminiJsonParseResult | null;

package/dist/gemini-json-parser.js

@@ -1,22 +1,47 @@
-export function parseGeminiJson(stdout) {
-    const trimmed = stdout.trim();
-    if (!trimmed) {
-        return null;
-    }
-    let parsed;
+function parseTolerantJsonObject(text) {
     try {
-        parsed = JSON.parse(trimmed);
+        const v = JSON.parse(text);
+        if (v && typeof v === "object")
+            return v;
     }
     catch {
+    }
+    const start = text.indexOf("{");
+    const end = text.lastIndexOf("}");
+    if (start >= 0 && end > start) {
+        try {
+            const v = JSON.parse(text.slice(start, end + 1));
+            if (v && typeof v === "object")
+                return v;
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+export function parseGeminiJson(stdout) {
+    const trimmed = stdout.trim();
+    if (!trimmed) {
         return null;
     }
-    if (!parsed || typeof parsed !== "object") {
+    const parsed = parseTolerantJsonObject(trimmed);
+    if (!parsed) {
         return null;
     }
     const result = {};
     if (typeof parsed.response === "string") {
         result.response = parsed.response;
     }
+    if (typeof parsed.session_id === "string") {
+        result.sessionId = parsed.session_id;
+    }
+    else if (typeof parsed.sessionId === "string") {
+        result.sessionId = parsed.sessionId;
+    }
+    if (typeof parsed.status === "string") {
+        result.stopReason = parsed.status;
+    }
     const meta = parsed.usageMetadata;
     if (meta && typeof meta === "object") {
         const input = typeof meta.promptTokenCount === "number" ? meta.promptTokenCount : undefined;
@@ -56,12 +81,24 @@ export function parseGeminiStreamJson(stdout) {
         if (!event || typeof event !== "object")
             continue;
         sawAnyLine = true;
+        if (event.type === "init" && typeof event.session_id === "string") {
+            result.sessionId = event.session_id;
+            continue;
+        }
         if (event.type === "message" &&
             event.role === "assistant" &&
             typeof event.content === "string") {
+            if (event.delta === false || event.is_delta === false) {
+                assistantChunks.length = 0;
+            }
             assistantChunks.push(event.content);
             continue;
         }
+        if (event.type === "result") {
+            if (typeof event.status === "string") {
+                result.stopReason = event.status;
+            }
+        }
         if (event.type === "result" && event.stats && typeof event.stats === "object") {
             const stats = event.stats;
             const input = typeof stats.input_tokens === "number" ? stats.input_tokens : undefined;

package/dist/grok-json-parser.d.ts

@@ -0,0 +1,14 @@
+export interface GrokJsonParseResult {
+    text?: string;
+    stopReason?: string;
+    sessionId?: string;
+    requestId?: string;
+    thought?: string;
+    error?: string;
+    sawEvent?: boolean;
+    usageAbsent: true;
+}
+export declare function parseGrokJson(stdout: string): GrokJsonParseResult | null;
+export declare function parseGrokStreamingJson(stdout: string): GrokJsonParseResult | null;
+export declare function parseGrokOutput(outputFormat: string | undefined, stdout: string): GrokJsonParseResult | null;
+export declare function grokDisplayText(outputFormat: string | undefined, stdout: string): string;

package/dist/grok-json-parser.js

@@ -0,0 +1,156 @@
+function str(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function deltaText(event) {
+    return str(event.data) ?? str(event.text) ?? str(event.content) ?? str(event.delta);
+}
+function deltaThought(event) {
+    return (str(event.data) ??
+        str(event.thought) ??
+        str(event.text) ??
+        str(event.content) ??
+        str(event.delta));
+}
+function parseTolerantGrokObject(text) {
+    try {
+        const v = JSON.parse(text);
+        if (v && typeof v === "object" && !Array.isArray(v))
+            return v;
+    }
+    catch {
+    }
+    const start = text.indexOf("{");
+    const end = text.lastIndexOf("}");
+    if (start >= 0 && end > start) {
+        try {
+            const v = JSON.parse(text.slice(start, end + 1));
+            if (v && typeof v === "object" && !Array.isArray(v))
+                return v;
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+export function parseGrokJson(stdout) {
+    const trimmed = stdout.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const parsed = parseTolerantGrokObject(trimmed);
+    if (!parsed) {
+        return null;
+    }
+    const result = { sawEvent: true, usageAbsent: true };
+    const text = str(parsed.text);
+    if (text !== undefined)
+        result.text = text;
+    const stopReason = str(parsed.stopReason);
+    if (stopReason !== undefined)
+        result.stopReason = stopReason;
+    const sessionId = str(parsed.sessionId);
+    if (sessionId !== undefined)
+        result.sessionId = sessionId;
+    const requestId = str(parsed.requestId);
+    if (requestId !== undefined)
+        result.requestId = requestId;
+    const thought = str(parsed.thought);
+    if (thought !== undefined)
+        result.thought = thought;
+    const error = str(parsed.error);
+    if (error !== undefined)
+        result.error = error;
+    return result;
+}
+export function parseGrokStreamingJson(stdout) {
+    if (!stdout) {
+        return null;
+    }
+    const lines = stdout.split(/\r?\n/);
+    const result = { usageAbsent: true };
+    const textChunks = [];
+    const thoughtChunks = [];
+    let sawAnyLine = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let event;
+        try {
+            event = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        if (!event || typeof event !== "object" || Array.isArray(event))
+            continue;
+        sawAnyLine = true;
+        switch (str(event.type)) {
+            case "text": {
+                const t = deltaText(event);
+                if (t !== undefined)
+                    textChunks.push(t);
+                break;
+            }
+            case "thought": {
+                const t = deltaThought(event);
+                if (t !== undefined)
+                    thoughtChunks.push(t);
+                break;
+            }
+            case "end": {
+                const stopReason = str(event.stopReason);
+                if (stopReason !== undefined)
+                    result.stopReason = stopReason;
+                const sessionId = str(event.sessionId);
+                if (sessionId !== undefined)
+                    result.sessionId = sessionId;
+                const requestId = str(event.requestId);
+                if (requestId !== undefined)
+                    result.requestId = requestId;
+                break;
+            }
+            case "error": {
+                const error = str(event.error) ?? str(event.message);
+                if (error !== undefined)
+                    result.error = error;
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    if (!sawAnyLine) {
+        return null;
+    }
+    result.sawEvent = true;
+    if (textChunks.length > 0)
+        result.text = textChunks.join("");
+    if (thoughtChunks.length > 0)
+        result.thought = thoughtChunks.join("");
+    return result;
+}
+export function parseGrokOutput(outputFormat, stdout) {
+    if (outputFormat === "json")
+        return parseGrokJson(stdout);
+    if (outputFormat === "streaming-json")
+        return parseGrokStreamingJson(stdout);
+    return null;
+}
+export function grokDisplayText(outputFormat, stdout) {
+    if (outputFormat === "json") {
+        return stdout;
+    }
+    if (outputFormat === "streaming-json") {
+        const parsed = parseGrokStreamingJson(stdout);
+        if (!parsed)
+            return stdout;
+        if (parsed.text !== undefined)
+            return parsed.text;
+        if (parsed.error !== undefined)
+            return parsed.error;
+        return "";
+    }
+    return stdout;
+}

package/dist/index.d.ts

@@ -4,13 +4,14 @@ import { z } from "zod/v3";
 import { ISessionManager, type CliType, type ProviderType } from "./session-manager.js";
 import { ResourceProvider } from "./resources.js";
 import { PerformanceMetrics } from "./metrics.js";
-import { type PersistenceConfig, type CacheAwarenessConfig, type ProvidersConfig, type ApiProviderRuntime, type AcpConfig } from "./config.js";
+import { type PersistenceConfig, type CacheAwarenessConfig, type ProvidersConfig, type ApiProviderRuntime, type AcpConfig, type AdminConfig } from "./config.js";
 import { DatabaseConnection } from "./db.js";
+import { type DevinAcpAgentType } from "./provider-definitions.js";
 import { AsyncJobManager } from "./async-job-manager.js";
 import { ApprovalManager, ApprovalPolicy, ApprovalRecord } from "./approval-manager.js";
 import { ReviewIntegrityResult } from "./review-integrity.js";
 import { ClaudeMcpConfigResult, ClaudeMcpServerName } from "./claude-mcp-config.js";
-import { type MistralAgentMode, type ClaudePermissionMode, type CodexSandboxMode, type CodexAskForApproval, type ClaudeEffortLevel } from "./request-helpers.js";
+import { type MistralAgentMode, type ClaudePermissionMode, type CodexSandboxMode, type CodexAskForApproval, type CodexLocalProvider, type CodexColorMode, type ClaudeEffortLevel } from "./request-helpers.js";
 import { FlightRecorderLike } from "./flight-recorder.js";
 import { type PromptParts } from "./prompt-parts.js";
 import { type WorkspaceRegistry } from "./workspace-registry.js";
@@ -77,6 +78,7 @@ export interface GatewayServerDeps {
     cacheAwareness?: CacheAwarenessConfig;
     providers?: ProvidersConfig;
     acpConfig?: AcpConfig;
+    adminConfig?: AdminConfig;
     workspaces?: WorkspaceRegistry;
 }
 export interface GatewayServerRuntime {
@@ -92,6 +94,7 @@ export interface GatewayServerRuntime {
     cacheAwareness: CacheAwarenessConfig;
     providers: ProvidersConfig;
     acpConfig: AcpConfig;
+    adminConfig: AdminConfig;
     workspaces: WorkspaceRegistry;
 }
 export declare function resolveGatewayServerRuntime(deps?: GatewayServerDeps, options?: {
@@ -104,6 +107,7 @@ export declare function runAcpTransport(deps: HandlerDeps, params: {
     model?: string;
     sessionId?: string;
     correlationId?: string;
+    agentType?: string;
 }): Promise<ExtendedToolResponse>;
 export interface ResolvedWorktree {
     cwd?: string;
@@ -165,6 +169,7 @@ export declare function extractUsageAndCost(cli: CliType, output: string, output
     cacheCreationTokens?: number;
     costUsd?: number;
 };
+export declare function registerBaseResources(server: McpServer, runtime: GatewayServerRuntime): void;
 interface CliRequestPrep {
     corrId: string;
     effectivePrompt: string;
@@ -213,6 +218,17 @@ export declare function prepareClaudeRequest(params: {
     settingSources?: string;
     settings?: string;
     tools?: string[];
+    includeHookEvents?: boolean;
+    replayUserMessages?: boolean;
+    systemPromptFile?: string;
+    appendSystemPromptFile?: string;
+    name?: string;
+    pluginDir?: string[];
+    pluginUrl?: string[];
+    safeMode?: boolean;
+    bare?: boolean;
+    debug?: string | boolean;
+    debugFile?: string;
 }, runtime?: GatewayServerRuntime): CliRequestPrep | ExtendedToolResponse;
 export interface CodexRequestPrep extends CliRequestPrep {
     cleanup?: () => void;
@@ -246,6 +262,14 @@ export declare function prepareCodexRequest(params: {
     ignoreRules?: boolean;
     workingDir?: string;
     addDir?: string[];
+    enable?: string[];
+    disable?: string[];
+    strictConfig?: boolean;
+    oss?: boolean;
+    localProvider?: CodexLocalProvider;
+    color?: CodexColorMode;
+    outputLastMessage?: string;
+    dangerouslyBypassHookTrust?: boolean;
 }, runtime?: GatewayServerRuntime): CodexRequestPrep | ExtendedToolResponse;
 export declare function prepareGeminiRequest(params: {
     prompt?: string;
@@ -269,6 +293,7 @@ export declare function prepareGeminiRequest(params: {
     yolo?: boolean;
     project?: string;
     newProject?: boolean;
+    printTimeout?: string;
 }, runtime?: GatewayServerRuntime): CliRequestPrep | ExtendedToolResponse;
 export declare function prepareGrokRequest(params: {
     prompt?: string;
@@ -413,6 +438,7 @@ export interface GeminiRequestParams {
     yolo?: boolean;
     project?: string;
     newProject?: boolean;
+    printTimeout?: string;
     workspace?: string;
     worktree?: boolean | {
         name?: string;
@@ -502,6 +528,12 @@ export interface DevinRequestParams {
     model?: string;
     permissionMode?: "auto" | "smart" | "dangerous";
     promptFile?: string;
+    config?: string;
+    sandbox?: boolean;
+    exportSession?: boolean | string;
+    respectWorkspaceTrust?: boolean;
+    agentConfig?: string;
+    agentType?: DevinAcpAgentType;
     transport?: "cli" | "acp";
     sessionId?: string;
     resumeLatest?: boolean;
@@ -517,6 +549,11 @@ export declare function prepareDevinRequest(params: {
     model?: string;
     permissionMode?: DevinRequestParams["permissionMode"];
     promptFile?: string;
+    config?: string;
+    sandbox?: boolean;
+    exportSession?: boolean | string;
+    respectWorkspaceTrust?: boolean;
+    agentConfig?: string;
     correlationId?: string;
     optimizePrompt: boolean;
     operation: string;
@@ -629,6 +666,14 @@ export declare function handleCodexRequestAsync(deps: AsyncHandlerDeps, params:
     ignoreRules?: boolean;
     workingDir?: string;
     addDir?: string[];
+    enable?: string[];
+    disable?: string[];
+    strictConfig?: boolean;
+    oss?: boolean;
+    localProvider?: CodexLocalProvider;
+    color?: CodexColorMode;
+    outputLastMessage?: string;
+    dangerouslyBypassHookTrust?: boolean;
     workspace?: string;
     worktree?: boolean | {
         name?: string;