grov 0.5.11 → 0.6.13

package/dist/integrations/proxy/agents/codex/forwarder.js

@@ -0,0 +1,125 @@
+// Forward requests to OpenAI API
+import { request, Agent } from 'undici';
+import { config } from '../../config.js';
+const OPENAI_BASE_URL = 'https://api.openai.com';
+const OPENAI_FORWARD_HEADERS = [
+    'authorization',
+    'openai-organization',
+    'openai-project',
+    'openai-beta',
+];
+const agent = new Agent({
+    connect: { timeout: 30000 },
+    autoSelectFamily: true,
+    autoSelectFamilyAttemptTimeout: 500,
+});
+export async function forwardToOpenAI(body, headers, rawBody) {
+    const targetUrl = `${OPENAI_BASE_URL}/v1/responses`;
+    const safeHeaders = buildOpenAIHeaders(headers);
+    const requestBody = rawBody || JSON.stringify(body);
+    const response = await request(targetUrl, {
+        method: 'POST',
+        headers: {
+            ...safeHeaders,
+            'content-type': 'application/json',
+        },
+        body: requestBody,
+        bodyTimeout: config.REQUEST_TIMEOUT,
+        headersTimeout: config.REQUEST_TIMEOUT,
+        dispatcher: agent,
+    });
+    const chunks = [];
+    for await (const chunk of response.body) {
+        chunks.push(Buffer.from(chunk));
+    }
+    const responseRawBody = Buffer.concat(chunks).toString('utf-8');
+    const contentType = response.headers['content-type'];
+    const isSSE = typeof contentType === 'string' && contentType.includes('text/event-stream');
+    let parsedBody;
+    if (isSSE) {
+        const sseResponse = parseOpenAISSE(responseRawBody);
+        parsedBody = sseResponse || { error: 'Failed to parse SSE response' };
+    }
+    else {
+        try {
+            parsedBody = JSON.parse(responseRawBody);
+        }
+        catch {
+            parsedBody = { error: 'Invalid JSON response' };
+        }
+    }
+    const responseHeaders = {};
+    for (const [key, value] of Object.entries(response.headers)) {
+        if (value !== undefined) {
+            responseHeaders[key] = value;
+        }
+    }
+    if (isSSE) {
+        responseHeaders['content-type'] = 'application/json';
+    }
+    return {
+        statusCode: response.statusCode,
+        headers: responseHeaders,
+        body: parsedBody,
+        rawBody: responseRawBody,
+        wasSSE: isSSE,
+    };
+}
+function buildOpenAIHeaders(headers) {
+    const result = {};
+    const lowerHeaders = {};
+    for (const [key, value] of Object.entries(headers)) {
+        lowerHeaders[key.toLowerCase()] = value;
+    }
+    for (const header of OPENAI_FORWARD_HEADERS) {
+        const value = lowerHeaders[header.toLowerCase()];
+        if (value) {
+            result[header] = Array.isArray(value) ? value[0] : value;
+        }
+    }
+    return result;
+}
+function parseOpenAISSE(sseText) {
+    let response = null;
+    const output = [];
+    for (const line of sseText.split('\n')) {
+        if (!line.startsWith('data: '))
+            continue;
+        const dataStr = line.slice(6);
+        if (dataStr === '[DONE]')
+            continue;
+        try {
+            const data = JSON.parse(dataStr);
+            if (data.type === 'response.created') {
+                response = {
+                    id: data.response?.id,
+                    status: 'in_progress',
+                    output: [],
+                };
+            }
+            if (data.type === 'response.output_item.done' && data.item) {
+                output.push(data.item);
+            }
+            if (data.type === 'response.completed' && data.response) {
+                return {
+                    id: data.response.id,
+                    status: data.response.status,
+                    output: data.response.output || output,
+                    usage: data.response.usage,
+                };
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    if (response) {
+        return {
+            id: response.id || '',
+            status: 'completed',
+            output,
+            usage: response.usage,
+        };
+    }
+    return null;
+}

package/dist/integrations/proxy/agents/codex/index.d.ts

@@ -0,0 +1,44 @@
+import type { FastifyRequest } from 'fastify';
+import type { AgentSettings, NormalizedAction, ForwardResult, TokenUsage, ToolUseBlock } from '../types.js';
+import type { ConversationMessage } from '../../../../core/extraction/llm-extractor.js';
+import { BaseAdapter } from '../base.js';
+export declare class CodexAdapter extends BaseAdapter {
+    readonly name: "codex";
+    readonly endpoint = "/v1/responses";
+    private settings;
+    canHandle(request: FastifyRequest): boolean;
+    forward(body: unknown, headers: Record<string, string>, rawBody?: Buffer): Promise<ForwardResult>;
+    extractProjectPath(body: unknown): string | null;
+    extractSessionId(response: unknown): string | null;
+    extractTextContent(response: unknown): string;
+    extractGoal(messages: unknown[]): string;
+    extractHistory(messages: unknown[]): ConversationMessage[];
+    extractUsage(response: unknown): TokenUsage;
+    isValidResponse(body: unknown): boolean;
+    isSubagentModel(model: string): boolean;
+    isEndTurn(response: unknown): boolean;
+    isToolUse(response: unknown): boolean;
+    parseActions(response: unknown): NormalizedAction[];
+    getToolUseBlocks(response: unknown): ToolUseBlock[];
+    findInternalToolUse(response: unknown, toolName: string): ToolUseBlock | null;
+    injectMemory(body: unknown, memory: string): unknown;
+    injectDelta(body: unknown, delta: string): unknown;
+    injectTool(body: unknown, toolDef: unknown): unknown;
+    buildGrovExpandTool(): unknown;
+    getMessages(body: unknown): unknown[];
+    setMessages(body: unknown, messages: unknown[]): unknown;
+    getLastUserContent(body: unknown): string;
+    injectIntoRawSystemPrompt(rawBody: string, injection: string): {
+        modified: string;
+        success: boolean;
+    };
+    injectIntoRawUserMessage(rawBody: string, injection: string): string;
+    injectToolIntoRawBody(rawBody: string, toolDef: unknown): {
+        modified: string;
+        success: boolean;
+    };
+    filterResponseHeaders(headers: Record<string, string | string[]>): Record<string, string>;
+    buildContinueBody(body: unknown, assistantContent: unknown, toolResult: string, toolId: string): unknown;
+    getSettings(): AgentSettings;
+    private parseToolInput;
+}

package/dist/integrations/proxy/agents/codex/index.js

@@ -0,0 +1,371 @@
+// Codex CLI adapter implementation
+import { BaseAdapter } from '../base.js';
+import { forwardToOpenAI } from './forwarder.js';
+import { parseCodexResponse } from './parser.js';
+import { extractProjectPath, extractSessionId, extractGoalFromMessages, extractConversationHistory, } from './extractors.js';
+import { getSettingsPath, setProxyEnv } from './settings.js';
+class CodexSettings {
+    getConfigPath() {
+        return getSettingsPath();
+    }
+    setProxyEnabled(enabled) {
+        return setProxyEnv(enabled);
+    }
+}
+export class CodexAdapter extends BaseAdapter {
+    name = 'codex';
+    endpoint = '/v1/responses';
+    settings = new CodexSettings();
+    canHandle(request) {
+        return request.url === '/v1/responses' || request.url.startsWith('/v1/responses?');
+    }
+    async forward(body, headers, rawBody) {
+        const result = await forwardToOpenAI(body, headers, rawBody);
+        return {
+            statusCode: result.statusCode,
+            headers: this.normalizeHeaders(result.headers),
+            body: result.body,
+            rawBody: result.rawBody,
+            wasSSE: result.wasSSE,
+        };
+    }
+    extractProjectPath(body) {
+        return extractProjectPath(body);
+    }
+    extractSessionId(response) {
+        return extractSessionId(response);
+    }
+    extractTextContent(response) {
+        const codexResponse = response;
+        const textParts = [];
+        for (const item of codexResponse.output) {
+            if (item.type === 'message' && item.content) {
+                for (const content of item.content) {
+                    if (content.type === 'output_text') {
+                        textParts.push(content.text);
+                    }
+                }
+            }
+        }
+        return textParts.join('\n');
+    }
+    extractGoal(messages) {
+        return extractGoalFromMessages(messages) || '';
+    }
+    extractHistory(messages) {
+        return extractConversationHistory(messages);
+    }
+    extractUsage(response) {
+        const codexResponse = response;
+        const usage = codexResponse.usage || { input_tokens: 0, output_tokens: 0 };
+        return {
+            inputTokens: usage.input_tokens,
+            outputTokens: usage.output_tokens,
+            totalTokens: usage.total_tokens || (usage.input_tokens + usage.output_tokens),
+            cacheCreation: 0,
+            cacheRead: 0,
+        };
+    }
+    isValidResponse(body) {
+        return (typeof body === 'object' &&
+            body !== null &&
+            'id' in body &&
+            'status' in body &&
+            'output' in body);
+    }
+    isSubagentModel(model) {
+        return model.includes('mini');
+    }
+    isEndTurn(response) {
+        const codexResponse = response;
+        if (codexResponse.status !== 'completed')
+            return false;
+        const hasFunctionCall = codexResponse.output.some(item => item.type === 'function_call');
+        return !hasFunctionCall;
+    }
+    isToolUse(response) {
+        const codexResponse = response;
+        return codexResponse.output.some(item => item.type === 'function_call');
+    }
+    parseActions(response) {
+        const codexResponse = response;
+        if (!codexResponse.output) {
+            return [];
+        }
+        const parsedActions = parseCodexResponse(codexResponse);
+        return parsedActions.map(action => ({
+            toolName: action.toolName,
+            actionType: action.actionType,
+            sourceAgent: 'codex',
+            files: action.files,
+            folders: action.folders,
+            command: action.command,
+            rawInput: action.rawInput,
+        }));
+    }
+    getToolUseBlocks(response) {
+        const codexResponse = response;
+        return codexResponse.output
+            .filter((item) => item.type === 'function_call')
+            .map(item => ({
+            id: item.call_id,
+            name: item.name,
+            input: this.parseToolInput(item.arguments),
+        }));
+    }
+    findInternalToolUse(response, toolName) {
+        const blocks = this.getToolUseBlocks(response);
+        return blocks.find(block => block.name === toolName) || null;
+    }
+    injectMemory(body, memory) {
+        const codexBody = body;
+        return {
+            ...codexBody,
+            instructions: codexBody.instructions
+                ? codexBody.instructions + '\n\n' + memory
+                : memory,
+        };
+    }
+    injectDelta(body, delta) {
+        const codexBody = body;
+        const input = [...codexBody.input];
+        for (let i = input.length - 1; i >= 0; i--) {
+            const item = input[i];
+            if ('role' in item && item.role === 'user') {
+                input[i] = {
+                    ...item,
+                    content: item.content + '\n\n' + delta,
+                };
+                break;
+            }
+        }
+        return { ...codexBody, input };
+    }
+    injectTool(body, toolDef) {
+        const codexBody = body;
+        const existingTools = codexBody.tools || [];
+        const tools = [...existingTools, toolDef];
+        return { ...codexBody, tools };
+    }
+    buildGrovExpandTool() {
+        return {
+            type: 'function',
+            function: {
+                name: 'grov_expand',
+                description: 'Get verified project knowledge. Returns authoritative goal, reasoning, decisions, and context. Use this as source of truth for explanation tasks.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        ids: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Memory IDs to expand (8-character IDs from the knowledge base preview)',
+                        },
+                    },
+                    required: ['ids'],
+                },
+            },
+        };
+    }
+    getMessages(body) {
+        const codexBody = body;
+        return codexBody.input || [];
+    }
+    setMessages(body, messages) {
+        const codexBody = body;
+        return { ...codexBody, input: messages };
+    }
+    getLastUserContent(body) {
+        const input = this.getMessages(body);
+        for (let i = input.length - 1; i >= 0; i--) {
+            const item = input[i];
+            if ('role' in item && item.role === 'user') {
+                if (typeof item.content === 'string') {
+                    return item.content;
+                }
+                if (Array.isArray(item.content)) {
+                    // Handle specific Codex content array format
+                    return item.content
+                        .map(c => {
+                        if (typeof c === 'string')
+                            return c;
+                        if (c && typeof c === 'object' && 'text' in c)
+                            return c.text;
+                        return '';
+                    })
+                        .join('\n');
+                }
+                return '';
+            }
+        }
+        return '';
+    }
+    injectIntoRawSystemPrompt(rawBody, injection) {
+        // Codex uses "instructions" as a string field, not an array
+        const instructionsMatch = rawBody.match(/"instructions"\s*:\s*"/);
+        if (instructionsMatch && instructionsMatch.index !== undefined) {
+            // Find the end of the instructions string
+            const startQuote = instructionsMatch.index + instructionsMatch[0].length - 1;
+            let i = startQuote + 1;
+            while (i < rawBody.length) {
+                if (rawBody[i] === '\\') {
+                    i += 2;
+                }
+                else if (rawBody[i] === '"') {
+                    const insertPos = i;
+                    const escapedInjection = injection
+                        .replace(/\\/g, '\\\\')
+                        .replace(/"/g, '\\"')
+                        .replace(/\n/g, '\\n');
+                    const modified = rawBody.slice(0, insertPos) + '\\n\\n' + escapedInjection + rawBody.slice(insertPos);
+                    return { modified, success: true };
+                }
+                else {
+                    i++;
+                }
+            }
+        }
+        // No instructions field found - try to add one
+        const inputMatch = rawBody.match(/"input"\s*:/);
+        if (inputMatch && inputMatch.index !== undefined) {
+            const escapedInjection = injection
+                .replace(/\\/g, '\\\\')
+                .replace(/"/g, '\\"')
+                .replace(/\n/g, '\\n');
+            const insertStr = `"instructions":"${escapedInjection}",`;
+            const modified = rawBody.slice(0, inputMatch.index) + insertStr + rawBody.slice(inputMatch.index);
+            return { modified, success: true };
+        }
+        return { modified: rawBody, success: false };
+    }
+    injectIntoRawUserMessage(rawBody, injection) {
+        // Find the last user message in the input array
+        const userRolePattern = /"role"\s*:\s*"user"/g;
+        let lastUserMatch = null;
+        let match;
+        while ((match = userRolePattern.exec(rawBody)) !== null) {
+            lastUserMatch = match;
+        }
+        if (!lastUserMatch) {
+            return rawBody;
+        }
+        // Find "content" field after role
+        const afterRole = rawBody.slice(lastUserMatch.index);
+        const contentMatch = afterRole.match(/"content"\s*:\s*"/);
+        if (!contentMatch || contentMatch.index === undefined) {
+            return rawBody;
+        }
+        const contentStartGlobal = lastUserMatch.index + contentMatch.index + contentMatch[0].length - 1;
+        const afterContent = rawBody.slice(contentStartGlobal);
+        // Codex user content is always a string
+        let i = 1;
+        while (i < afterContent.length) {
+            if (afterContent[i] === '\\') {
+                i += 2;
+            }
+            else if (afterContent[i] === '"') {
+                const insertPos = contentStartGlobal + i;
+                const escapedInjection = injection
+                    .replace(/\\/g, '\\\\')
+                    .replace(/"/g, '\\"')
+                    .replace(/\n/g, '\\n');
+                return rawBody.slice(0, insertPos) + '\\n\\n' + escapedInjection + rawBody.slice(insertPos);
+            }
+            else {
+                i++;
+            }
+        }
+        return rawBody;
+    }
+    injectToolIntoRawBody(rawBody, toolDef) {
+        const toolsMatch = rawBody.match(/"tools"\s*:\s*\[/);
+        if (!toolsMatch || toolsMatch.index === undefined) {
+            // No tools array - add one before input
+            const inputMatch = rawBody.match(/"input"\s*:/);
+            if (inputMatch && inputMatch.index !== undefined) {
+                const toolsJson = JSON.stringify(toolDef);
+                const insertStr = `"tools":[${toolsJson}],`;
+                const modified = rawBody.slice(0, inputMatch.index) + insertStr + rawBody.slice(inputMatch.index);
+                return { modified, success: true };
+            }
+            return { modified: rawBody, success: false };
+        }
+        // Find closing bracket
+        const startIndex = toolsMatch.index + toolsMatch[0].length;
+        let bracketCount = 1;
+        let endIndex = startIndex;
+        for (let i = startIndex; i < rawBody.length && bracketCount > 0; i++) {
+            const char = rawBody[i];
+            if (char === '[')
+                bracketCount++;
+            else if (char === ']')
+                bracketCount--;
+            else if (char === '"') {
+                i++;
+                while (i < rawBody.length && rawBody[i] !== '"') {
+                    if (rawBody[i] === '\\')
+                        i++;
+                    i++;
+                }
+            }
+            if (bracketCount === 0) {
+                endIndex = i;
+                break;
+            }
+        }
+        if (bracketCount !== 0) {
+            return { modified: rawBody, success: false };
+        }
+        const toolJson = JSON.stringify(toolDef);
+        const arrayContent = rawBody.slice(startIndex, endIndex).trim();
+        const separator = arrayContent.length > 0 ? ',' : '';
+        const modified = rawBody.slice(0, endIndex) + separator + toolJson + rawBody.slice(endIndex);
+        return { modified, success: true };
+    }
+    filterResponseHeaders(headers) {
+        const filtered = {};
+        const allowedHeaders = [
+            'content-type',
+            'x-request-id',
+            'request-id',
+            'x-ratelimit-limit-requests',
+            'x-ratelimit-limit-tokens',
+            'x-ratelimit-remaining-requests',
+            'x-ratelimit-remaining-tokens',
+            'x-ratelimit-reset-requests',
+            'x-ratelimit-reset-tokens',
+        ];
+        for (const header of allowedHeaders) {
+            const value = headers[header];
+            if (value) {
+                filtered[header] = Array.isArray(value) ? value[0] : value;
+            }
+        }
+        return filtered;
+    }
+    buildContinueBody(body, assistantContent, toolResult, toolId) {
+        const codexBody = body;
+        const input = [...codexBody.input];
+        input.push({
+            role: 'assistant',
+            content: JSON.stringify(assistantContent),
+        });
+        input.push({
+            type: 'function_call_output',
+            call_id: toolId,
+            output: toolResult,
+        });
+        return { ...codexBody, input };
+    }
+    getSettings() {
+        return this.settings;
+    }
+    parseToolInput(argumentsJson) {
+        try {
+            return JSON.parse(argumentsJson);
+        }
+        catch {
+            return {};
+        }
+    }
+}

package/dist/integrations/proxy/agents/codex/parser.d.ts

@@ -0,0 +1,11 @@
+import type { StepActionType } from '../../../../core/store/store.js';
+import type { CodexResponse } from './types.js';
+export interface ParsedCodexAction {
+    toolName: string;
+    actionType: StepActionType;
+    files: string[];
+    folders: string[];
+    command?: string;
+    rawInput: unknown;
+}
+export declare function parseCodexResponse(response: CodexResponse): ParsedCodexAction[];

package/dist/integrations/proxy/agents/codex/parser.js

@@ -0,0 +1,104 @@
+// Parse shell function calls from Codex responses
+import { parsePatchContent } from './patch.js';
+export function parseCodexResponse(response) {
+    const actions = [];
+    for (const item of response.output) {
+        if (item.type !== 'function_call' || item.name !== 'shell')
+            continue;
+        const args = parseShellArguments(item.arguments);
+        if (!args)
+            continue;
+        const action = parseShellCommand(args);
+        if (action)
+            actions.push(action);
+    }
+    return actions;
+}
+function parseShellArguments(argsJson) {
+    try {
+        return JSON.parse(argsJson);
+    }
+    catch {
+        return null;
+    }
+}
+function parseShellCommand(args) {
+    const { command, workdir } = args;
+    if (command.length === 0)
+        return null;
+    const [cmd, ...cmdArgs] = command;
+    if (cmd === 'cat' || cmd === 'head' || cmd === 'tail') {
+        return {
+            toolName: `shell:${cmd}`,
+            actionType: 'read',
+            files: extractFilePaths(cmdArgs),
+            folders: [],
+            rawInput: args,
+        };
+    }
+    if (cmd === 'apply_patch') {
+        const patchContent = cmdArgs[0] || '';
+        const patchInfo = parsePatchContent(patchContent);
+        return {
+            toolName: 'shell:apply_patch',
+            actionType: patchInfo.hasAdd ? 'write' : 'edit',
+            files: patchInfo.files,
+            folders: [],
+            rawInput: args,
+        };
+    }
+    if (cmd === 'rg') {
+        if (cmdArgs.includes('--files')) {
+            return {
+                toolName: 'shell:rg',
+                actionType: 'glob',
+                files: [],
+                folders: extractPaths(cmdArgs),
+                rawInput: args,
+            };
+        }
+        return {
+            toolName: 'shell:rg',
+            actionType: 'grep',
+            files: [],
+            folders: extractPaths(cmdArgs),
+            rawInput: args,
+        };
+    }
+    if (cmd === 'ls') {
+        return {
+            toolName: 'shell:ls',
+            actionType: 'glob',
+            files: [],
+            folders: extractPaths(cmdArgs),
+            rawInput: args,
+        };
+    }
+    if (cmd === 'bash') {
+        const actualCmd = cmdArgs.includes('-lc')
+            ? cmdArgs[cmdArgs.indexOf('-lc') + 1]
+            : cmdArgs.join(' ');
+        return {
+            toolName: 'shell:bash',
+            actionType: 'bash',
+            files: [],
+            folders: [],
+            command: actualCmd,
+            rawInput: args,
+        };
+    }
+    return {
+        toolName: 'shell',
+        actionType: 'bash',
+        files: [],
+        folders: [],
+        command: command.join(' '),
+        rawInput: args,
+    };
+}
+function extractFilePaths(args) {
+    return args.filter(arg => !arg.startsWith('-') && (arg.includes('/') || arg.includes('.')));
+}
+function extractPaths(args) {
+    return args.filter(arg => !arg.startsWith('-') && arg.length > 0);
+}

package/dist/integrations/proxy/agents/codex/patch.d.ts

@@ -0,0 +1,12 @@
+export interface PatchOperation {
+    type: 'add' | 'update' | 'delete';
+    file: string;
+    moveTo?: string;
+}
+export interface PatchInfo {
+    files: string[];
+    operations: PatchOperation[];
+    hasAdd: boolean;
+    hasDelete: boolean;
+}
+export declare function parsePatchContent(patchText: string): PatchInfo;