llm-cli-gateway 1.1.0 → 1.5.4

package/dist/resources.js

@@ -54,6 +54,28 @@ export class ResourceProvider {
                     priority: 0.6,
                 },
             },
+            {
+                uri: "sessions://grok",
+                name: "Grok Sessions",
+                title: "⚡ Grok Sessions",
+                description: "List of Grok conversation sessions",
+                mimeType: "application/json",
+                annotations: {
+                    audience: ["user", "assistant"],
+                    priority: 0.6,
+                },
+            },
+            {
+                uri: "sessions://mistral",
+                name: "Mistral Sessions",
+                title: "🌬 Mistral Sessions",
+                description: "List of Mistral Vibe conversation sessions",
+                mimeType: "application/json",
+                annotations: {
+                    audience: ["user", "assistant"],
+                    priority: 0.6,
+                },
+            },
             {
                 uri: "models://claude",
                 name: "Claude Models",
@@ -87,6 +109,28 @@ export class ResourceProvider {
                     priority: 0.8,
                 },
             },
+            {
+                uri: "models://grok",
+                name: "Grok Models",
+                title: "⚡ Grok Models & Capabilities",
+                description: "Available Grok models and their capabilities",
+                mimeType: "application/json",
+                annotations: {
+                    audience: ["user", "assistant"],
+                    priority: 0.8,
+                },
+            },
+            {
+                uri: "models://mistral",
+                name: "Mistral Models",
+                title: "🌬 Mistral Models & Capabilities",
+                description: "Available Mistral Vibe models and their capabilities",
+                mimeType: "application/json",
+                annotations: {
+                    audience: ["user", "assistant"],
+                    priority: 0.8,
+                },
+            },
             {
                 uri: "metrics://performance",
                 name: "Performance Metrics",
@@ -121,6 +165,8 @@ export class ResourceProvider {
                         claude: (await this.sessionManager.getActiveSession("claude"))?.id || null,
                         codex: (await this.sessionManager.getActiveSession("codex"))?.id || null,
                         gemini: (await this.sessionManager.getActiveSession("gemini"))?.id || null,
+                        grok: (await this.sessionManager.getActiveSession("grok"))?.id || null,
+                        mistral: (await this.sessionManager.getActiveSession("mistral"))?.id || null,
                     },
                 }, null, 2),
             };
@@ -164,6 +210,32 @@ export class ResourceProvider {
                 }, null, 2),
             };
         }
+        if (uri === "sessions://grok") {
+            const sessions = await this.sessionManager.listSessions("grok");
+            return {
+                uri,
+                mimeType: "application/json",
+                text: JSON.stringify({
+                    cli: "grok",
+                    total: sessions.length,
+                    sessions,
+                    activeSession: (await this.sessionManager.getActiveSession("grok"))?.id || null,
+                }, null, 2),
+            };
+        }
+        if (uri === "sessions://mistral") {
+            const sessions = await this.sessionManager.listSessions("mistral");
+            return {
+                uri,
+                mimeType: "application/json",
+                text: JSON.stringify({
+                    cli: "mistral",
+                    total: sessions.length,
+                    sessions,
+                    activeSession: (await this.sessionManager.getActiveSession("mistral"))?.id || null,
+                }, null, 2),
+            };
+        }
         // Model capability resources
         if (uri === "models://claude") {
             const cliInfo = getCliInfo();
@@ -189,6 +261,22 @@ export class ResourceProvider {
                 text: JSON.stringify(cliInfo.gemini, null, 2),
             };
         }
+        if (uri === "models://grok") {
+            const cliInfo = getCliInfo();
+            return {
+                uri,
+                mimeType: "application/json",
+                text: JSON.stringify(cliInfo.grok, null, 2),
+            };
+        }
+        if (uri === "models://mistral") {
+            const cliInfo = getCliInfo();
+            return {
+                uri,
+                mimeType: "application/json",
+                text: JSON.stringify(cliInfo.mistral, null, 2),
+            };
+        }
         if (uri === "metrics://performance") {
             return {
                 uri,

package/dist/session-manager-pg.js

@@ -3,6 +3,8 @@ const DEFAULT_SESSION_DESCRIPTIONS = {
     claude: "Claude Session",
     codex: "Codex Session",
     gemini: "Gemini Session",
+    grok: "Grok Session",
+    mistral: "Mistral Session",
 };
 /**
  * PostgreSQL-backed session manager with Redis caching

package/dist/session-manager.d.ts

@@ -1,7 +1,7 @@
 import type { Config } from "./config.js";
 import type { DatabaseConnection } from "./db.js";
 import type { Logger } from "./logger.js";
-export declare const CLI_TYPES: readonly ["claude", "codex", "gemini"];
+export declare const CLI_TYPES: readonly ["claude", "codex", "gemini", "grok", "mistral"];
 export type CliType = (typeof CLI_TYPES)[number];
 export interface Session {
     id: string;

package/dist/session-manager.js

@@ -4,12 +4,14 @@ import { join, dirname } from "path";
 import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, openSync, fsyncSync, closeSync, chmodSync, } from "fs";
 import { DEFAULT_SESSION_TTL_SECONDS } from "./config.js";
 import { noopLogger } from "./logger.js";
-export const CLI_TYPES = ["claude", "codex", "gemini"];
+export const CLI_TYPES = ["claude", "codex", "gemini", "grok", "mistral"];
 const createEmptyActiveSessions = () => Object.fromEntries(CLI_TYPES.map(cli => [cli, null]));
 const DEFAULT_SESSION_DESCRIPTIONS = {
     claude: "Claude Session",
     codex: "Codex Session",
     gemini: "Gemini Session",
+    grok: "Grok Session",
+    mistral: "Mistral Session",
 };
 export class FileSessionManager {
     storagePath;

package/dist/validation-normalizer.d.ts

@@ -0,0 +1,23 @@
+import type { AsyncJobResult, AsyncJobSnapshot } from "./async-job-manager.js";
+export type ValidationProvider = "claude" | "codex" | "gemini" | "grok" | "mistral";
+export type NormalizedValidationStatus = "running" | "completed" | "failed" | "canceled" | "orphaned" | "skipped";
+export interface RawJobReference {
+    jobId: string;
+    correlationId: string;
+    statusTool: "job_status";
+    resultTool: "job_result";
+}
+export interface NormalizedValidationResult {
+    provider: ValidationProvider;
+    model: string | null;
+    status: NormalizedValidationStatus;
+    verdict: string | null;
+    rationale: string | null;
+    risks: string[];
+    rawJobReference: RawJobReference | null;
+    error: string | null;
+    warning?: string;
+}
+export declare function normalizeStartedJob(provider: ValidationProvider, model: string | null, snapshot: AsyncJobSnapshot, warning?: string): NormalizedValidationResult;
+export declare function normalizeSkippedProvider(provider: ValidationProvider, reason: string): NormalizedValidationResult;
+export declare function normalizeJobResult(provider: ValidationProvider, model: string | null, result: AsyncJobResult): NormalizedValidationResult;

package/dist/validation-normalizer.js

@@ -0,0 +1,79 @@
+export function normalizeStartedJob(provider, model, snapshot, warning) {
+    return {
+        provider,
+        model,
+        status: snapshot.status,
+        verdict: snapshot.status === "running" ? "pending" : null,
+        rationale: snapshot.status === "running" ? "Provider job is running asynchronously." : null,
+        risks: [],
+        rawJobReference: {
+            jobId: snapshot.id,
+            correlationId: snapshot.correlationId,
+            statusTool: "job_status",
+            resultTool: "job_result",
+        },
+        error: snapshot.error,
+        warning,
+    };
+}
+export function normalizeSkippedProvider(provider, reason) {
+    return {
+        provider,
+        model: null,
+        status: "skipped",
+        verdict: "not_run",
+        rationale: reason,
+        risks: [reason],
+        rawJobReference: null,
+        error: reason,
+    };
+}
+export function normalizeJobResult(provider, model, result) {
+    const output = result.stdout.trim();
+    const error = result.error || (result.status === "failed" ? result.stderr.trim() : null);
+    return {
+        provider,
+        model,
+        status: result.status,
+        verdict: inferVerdict(output, result.status),
+        rationale: output ? excerpt(output, 1800) : error,
+        risks: extractRisks(output, error),
+        rawJobReference: {
+            jobId: result.id,
+            correlationId: result.correlationId,
+            statusTool: "job_status",
+            resultTool: "job_result",
+        },
+        error,
+    };
+}
+function inferVerdict(output, status) {
+    if (status === "running")
+        return "pending";
+    if (status === "canceled" || status === "orphaned")
+        return status;
+    if (status === "failed")
+        return "failed";
+    const verdictMatch = output.match(/(?:^|\n)\s*verdict\s*:\s*(.+)/i);
+    if (verdictMatch?.[1])
+        return excerpt(verdictMatch[1].trim(), 240);
+    if (output)
+        return "answered";
+    return null;
+}
+function extractRisks(output, error) {
+    const risks = output
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .filter(line => /^(?:[-*]\s*)?(?:risk|risks|concern|caution|limitation)\b/i.test(line))
+        .slice(0, 5)
+        .map(line => excerpt(line, 300));
+    if (error && risks.length === 0)
+        risks.push(excerpt(error, 300));
+    return risks;
+}
+function excerpt(value, max) {
+    if (value.length <= max)
+        return value;
+    return `${value.slice(0, max - 3)}...`;
+}

package/dist/validation-orchestrator.d.ts

@@ -0,0 +1,47 @@
+import type { AsyncJobManager } from "./async-job-manager.js";
+import { type ProviderRuntimeStatus } from "./provider-status.js";
+import { type NormalizedValidationResult, type ValidationProvider } from "./validation-normalizer.js";
+import { type ValidationReport } from "./validation-report.js";
+import { type ValidationIntent } from "./validation-prompts.js";
+export interface ValidationOrchestratorDeps {
+    asyncJobManager: AsyncJobManager;
+    getProviderRuntimeStatus?: (provider: ValidationProvider) => ProviderRuntimeStatus;
+}
+export interface StartValidationInput {
+    intent: ValidationIntent;
+    question?: string;
+    content?: string;
+    providers: ValidationProvider[];
+    focus?: string;
+    riskLevel?: "normal" | "high";
+    judgeProvider?: ValidationProvider;
+}
+export interface ValidationRunReport {
+    success: boolean;
+    validationId: string;
+    status: "running" | "partial" | "not_started";
+    startedAt: string;
+    intent: ValidationIntent;
+    originalRequest: {
+        question?: string;
+        content?: string;
+        focus?: string;
+    };
+    modelList: ValidationProvider[];
+    results: NormalizedValidationResult[];
+    synthesis: {
+        status: "not_requested" | "waiting_for_provider_results" | "running" | "skipped";
+        judgeModel: ValidationProvider | null;
+        rawJobReference: NormalizedValidationResult["rawJobReference"];
+        note: string;
+    };
+    report: ValidationReport;
+    next: string;
+}
+export declare function startValidationRun(deps: ValidationOrchestratorDeps, input: StartValidationInput): ValidationRunReport;
+export declare function startJudgeSynthesis(deps: ValidationOrchestratorDeps, input: {
+    question: string;
+    providerResults: NormalizedValidationResult[];
+    judgeProvider: ValidationProvider;
+}): ValidationRunReport["synthesis"];
+export declare function collectValidationJobResult(deps: ValidationOrchestratorDeps, provider: ValidationProvider, jobId: string, model: string | null, maxChars?: number): NormalizedValidationResult | null;

package/dist/validation-orchestrator.js

@@ -0,0 +1,145 @@
+import { randomUUID } from "node:crypto";
+import { getProviderRuntimeStatus } from "./provider-status.js";
+import { normalizeJobResult, normalizeSkippedProvider, normalizeStartedJob, } from "./validation-normalizer.js";
+import { buildValidationReport } from "./validation-report.js";
+import { buildJudgePrompt, buildValidationPrompt, } from "./validation-prompts.js";
+export function startValidationRun(deps, input) {
+    const validationId = randomUUID();
+    const startedAt = new Date().toISOString();
+    const prompt = buildValidationPrompt({
+        intent: input.intent,
+        question: input.question,
+        content: input.content,
+        focus: input.focus,
+        riskLevel: input.riskLevel,
+    });
+    const providers = uniqueProviders(input.providers);
+    const results = providers.map(provider => startProviderJob(deps, provider, prompt, validationId));
+    const runningCount = results.filter(result => result.status === "running").length;
+    const skippedCount = results.filter(result => result.status === "skipped").length;
+    const synthesis = plannedJudgeSynthesis(input);
+    const status = runningCount === 0 ? "not_started" : skippedCount > 0 ? "partial" : "running";
+    const reportInput = {
+        validationId,
+        status,
+        startedAt,
+        intent: input.intent,
+        originalRequest: {
+            question: input.question,
+            content: input.content,
+            focus: input.focus,
+        },
+        modelList: providers,
+        results,
+        synthesis,
+    };
+    return {
+        success: runningCount > 0,
+        validationId,
+        status,
+        startedAt,
+        intent: input.intent,
+        originalRequest: reportInput.originalRequest,
+        modelList: providers,
+        results,
+        synthesis,
+        report: buildValidationReport(reportInput),
+        next: "Use job_status to poll each rawJobReference.jobId, job_result to collect provider outputs, then synthesize_validation if a judge summary is needed.",
+    };
+}
+export function startJudgeSynthesis(deps, input) {
+    const pending = input.providerResults.find(result => result.status === "running" || result.verdict === "pending");
+    if (pending) {
+        return {
+            status: "waiting_for_provider_results",
+            judgeModel: input.judgeProvider,
+            rawJobReference: null,
+            note: `Provider result for ${pending.provider} is still pending; collect terminal provider results before judge synthesis.`,
+        };
+    }
+    const completedResults = input.providerResults.filter(result => result.status === "completed");
+    const omittedResults = input.providerResults.filter(result => result.status !== "completed");
+    if (completedResults.length === 0) {
+        return {
+            status: "skipped",
+            judgeModel: input.judgeProvider,
+            rawJobReference: null,
+            note: "Judge synthesis requires at least one completed provider result; skipped, failed, canceled, or orphaned results are preserved in the report but are not judge evidence.",
+        };
+    }
+    const runtimeStatus = deps.getProviderRuntimeStatus ?? getProviderRuntimeStatus;
+    const runtime = runtimeStatus(input.judgeProvider);
+    if (!runtime.installed) {
+        return {
+            status: "skipped",
+            judgeModel: input.judgeProvider,
+            rawJobReference: null,
+            note: `${runtime.displayName} was selected as judge but is not installed.`,
+        };
+    }
+    const snapshot = deps.asyncJobManager.startJob(input.judgeProvider, buildProviderArgs(input.judgeProvider, buildJudgePrompt({
+        question: input.question,
+        providerResults: completedResults,
+    })), `validation-judge-${randomUUID()}-${input.judgeProvider}`);
+    return {
+        status: "running",
+        judgeModel: input.judgeProvider,
+        rawJobReference: {
+            jobId: snapshot.id,
+            correlationId: snapshot.correlationId,
+            statusTool: "job_status",
+            resultTool: "job_result",
+        },
+        note: omittedResults.length > 0
+            ? `Judge synthesis is running on ${runtime.displayName} using ${completedResults.length} completed provider result(s); ${omittedResults.length} non-completed result(s) were preserved but omitted.`
+            : `Judge synthesis is running on ${runtime.displayName} using completed provider results.`,
+    };
+}
+export function collectValidationJobResult(deps, provider, jobId, model, maxChars = 200000) {
+    const result = deps.asyncJobManager.getJobResult(jobId, maxChars);
+    if (!result)
+        return null;
+    return normalizeJobResult(provider, model, result);
+}
+function startProviderJob(deps, provider, prompt, validationId) {
+    const runtimeStatus = deps.getProviderRuntimeStatus ?? getProviderRuntimeStatus;
+    const runtime = runtimeStatus(provider);
+    if (!runtime.installed) {
+        return normalizeSkippedProvider(provider, `${runtime.displayName} runtime is not installed.`);
+    }
+    const warning = runtime.loginStatus === "authenticated"
+        ? undefined
+        : `${runtime.displayName} login status is ${runtime.loginStatus}; the job may fail until login is complete.`;
+    const snapshot = deps.asyncJobManager.startJob(provider, buildProviderArgs(provider, prompt), `validation-${validationId}-${provider}`);
+    return normalizeStartedJob(provider, runtime.version, snapshot, warning);
+}
+function plannedJudgeSynthesis(input) {
+    if (!input.judgeProvider) {
+        return {
+            status: "not_requested",
+            judgeModel: null,
+            rawJobReference: null,
+            note: "No judge synthesis was requested; provider disagreement is preserved for the caller.",
+        };
+    }
+    return {
+        status: "waiting_for_provider_results",
+        judgeModel: input.judgeProvider,
+        rawJobReference: null,
+        note: "Collect provider results first, then call synthesize_validation with those results.",
+    };
+}
+function buildProviderArgs(provider, prompt) {
+    if (provider === "claude" || provider === "grok" || provider === "mistral") {
+        // Mistral Vibe mirrors Grok's `-p PROMPT` headless surface. Model selection
+        // is via VIBE_ACTIVE_MODEL env var (no --model flag); for validation runs we
+        // let the user's environment pick the active model.
+        return ["-p", prompt];
+    }
+    if (provider === "codex")
+        return ["exec", "--skip-git-repo-check", prompt];
+    return [prompt];
+}
+function uniqueProviders(providers) {
+    return Array.from(new Set(providers));
+}

package/dist/validation-prompts.d.ts

@@ -0,0 +1,15 @@
+import type { NormalizedValidationResult } from "./validation-normalizer.js";
+export type ValidationIntent = "validate" | "second_opinion" | "red_team" | "consensus" | "ask_model";
+interface BasePromptInput {
+    intent: ValidationIntent;
+    question?: string;
+    content?: string;
+    focus?: string;
+    riskLevel?: "normal" | "high";
+}
+export declare function buildValidationPrompt(input: BasePromptInput): string;
+export declare function buildJudgePrompt(input: {
+    question: string;
+    providerResults: NormalizedValidationResult[];
+}): string;
+export {};

package/dist/validation-prompts.js

@@ -0,0 +1,52 @@
+export function buildValidationPrompt(input) {
+    const focus = input.focus || "correctness, missing assumptions, and practical next steps";
+    const header = [
+        "You are one independent reviewer in a personal cross-LLM validation run.",
+        "Return a concise answer with these headings: Verdict, Rationale, Risks, Suggested next step.",
+        "Do not claim consensus; other model responses will be compared separately.",
+    ];
+    if (input.intent === "second_opinion") {
+        return [
+            ...header,
+            `Focus: ${focus}`,
+            "",
+            `Original question: ${input.question || "(not provided)"}`,
+            "",
+            "Answer to review:",
+            input.content || "",
+        ].join("\n");
+    }
+    if (input.intent === "red_team") {
+        return [
+            ...header,
+            `Review intensity: ${input.riskLevel || "normal"}`,
+            "Challenge assumptions, unsafe advice, unsupported claims, and likely failure modes.",
+            "",
+            input.content || "",
+        ].join("\n");
+    }
+    if (input.intent === "consensus") {
+        return [
+            ...header,
+            "Assess whether the claim is true, false, uncertain, or context-dependent.",
+            "",
+            `Claim: ${input.content || input.question || ""}`,
+        ].join("\n");
+    }
+    if (input.intent === "ask_model") {
+        return [input.question || input.content || ""].join("\n");
+    }
+    return [...header, `Focus: ${focus}`, "", input.question || input.content || ""].join("\n");
+}
+export function buildJudgePrompt(input) {
+    return [
+        "You are the explicit judge model for a personal cross-LLM validation run.",
+        "Synthesize only from the provider results below. Preserve material disagreement.",
+        "Return: Summary, Agreements, Disagreements, Recommendation, Confidence, Limitations.",
+        "",
+        `Original request: ${input.question}`,
+        "",
+        "Provider results:",
+        JSON.stringify(input.providerResults, null, 2),
+    ].join("\n");
+}

package/dist/validation-report.d.ts

@@ -0,0 +1,57 @@
+import type { NormalizedValidationResult, ValidationProvider } from "./validation-normalizer.js";
+import type { ValidationIntent } from "./validation-prompts.js";
+export type ValidationReportConfidence = "none" | "low" | "medium" | "high";
+export interface ValidationReportInput {
+    validationId: string;
+    status: "running" | "partial" | "not_started";
+    startedAt: string;
+    intent: ValidationIntent;
+    originalRequest: {
+        question?: string;
+        content?: string;
+        focus?: string;
+    };
+    modelList: ValidationProvider[];
+    results: NormalizedValidationResult[];
+    synthesis: {
+        status: "not_requested" | "waiting_for_provider_results" | "running" | "skipped";
+        judgeModel: ValidationProvider | null;
+        rawJobReference: NormalizedValidationResult["rawJobReference"];
+        note: string;
+    };
+}
+export interface ValidationReport {
+    schemaVersion: "validation-report.v1";
+    humanReadable: string;
+    structuredContent: {
+        validationId: string;
+        status: ValidationReportInput["status"];
+        startedAt: string;
+        intent: ValidationIntent;
+        originalRequest: ValidationReportInput["originalRequest"];
+        modelList: ValidationProvider[];
+        perModelOutputs: Array<{
+            provider: ValidationProvider;
+            model: string | null;
+            status: NormalizedValidationResult["status"];
+            verdict: string | null;
+            rationale: string | null;
+            risks: string[];
+            jobId: string | null;
+            correlationId: string | null;
+            warning: string | null;
+            error: string | null;
+        }>;
+        disagreements: {
+            hasMaterialDisagreement: boolean;
+            summary: string;
+            signals: string[];
+        };
+        finalRecommendation: string;
+        confidence: ValidationReportConfidence;
+        limitations: string[];
+        jobIds: string[];
+        synthesis: ValidationReportInput["synthesis"];
+    };
+}
+export declare function buildValidationReport(input: ValidationReportInput): ValidationReport;