llm-cli-gateway 2.13.2 → 2.14.0-rc.1

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;