grov 0.5.11 → 0.6.13

package/dist/{proxy/utils → integrations/proxy/agents/claude}/extractors.js

@@ -1,25 +1,4 @@
-// Pure extraction functions for parsing request/response data
-export function detectKeyDecision(action, reasoning) {
-    // Code modifications are always key decisions
-    if (action.actionType === 'edit' || action.actionType === 'write') {
-        return true;
-    }
-    // Check for decision-related keywords in reasoning
-    const decisionKeywords = [
-        'decision', 'decided', 'chose', 'chosen', 'selected', 'picked',
-        'approach', 'strategy', 'solution', 'implementation',
-        'because', 'reason', 'rationale', 'trade-off', 'tradeoff',
-        'instead of', 'rather than', 'prefer', 'opted',
-        'conclusion', 'determined', 'resolved'
-    ];
-    const reasoningLower = reasoning.toLowerCase();
-    const hasDecisionKeyword = decisionKeywords.some(kw => reasoningLower.includes(kw));
-    // Substantial reasoning (>200 chars) with decision keyword = key decision
-    if (hasDecisionKeyword && reasoning.length > 200) {
-        return true;
-    }
-    return false;
-}
+// Claude-specific extraction functions
 export function extractTextContent(response) {
     return response.content
         .filter((block) => block.type === 'text')
@@ -27,14 +6,11 @@ export function extractTextContent(response) {
         .join('\n');
 }
 export function extractProjectPath(body) {
-    // Try to extract from system prompt or messages
-    // Handle both string and array format for system prompt
     let systemPrompt = '';
     if (typeof body.system === 'string') {
         systemPrompt = body.system;
     }
     else if (Array.isArray(body.system)) {
-        // New API format: system is array of {type: 'text', text: '...'}
         systemPrompt = body.system
             .filter((block) => block && typeof block === 'object' && block.type === 'text' && typeof block.text === 'string')
             .map(block => block.text)
@@ -46,29 +22,27 @@ export function extractProjectPath(body) {
     }
     return null;
 }
+export function extractSessionId(response) {
+    return response.id || null;
+}
 export function extractGoalFromMessages(messages) {
     const userMessages = messages?.filter(m => m.role === 'user') || [];
-    // Iterate in REVERSE to get the LAST (most recent) user message
     for (const userMsg of [...userMessages].reverse()) {
         let rawContent = '';
-        // Handle string content
         if (typeof userMsg.content === 'string') {
             rawContent = userMsg.content;
         }
-        // Handle array content - look for text blocks (skip tool_result)
         if (Array.isArray(userMsg.content)) {
             const textBlocks = userMsg.content
                 .filter((block) => block && typeof block === 'object' && block.type === 'text' && typeof block.text === 'string')
                 .map(block => block.text);
             rawContent = textBlocks.join('\n');
         }
-        // Remove <system-reminder>...</system-reminder> tags (including orphaned tags from split content blocks)
         const cleanContent = rawContent
             .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '')
             .replace(/<\/system-reminder>/g, '')
             .replace(/<system-reminder>[^<]*/g, '')
             .trim();
-        // If we found valid text content, return it
         if (cleanContent && cleanContent.length >= 5) {
             return cleanContent.substring(0, 500);
         }
@@ -83,18 +57,15 @@ export function extractConversationHistory(messages) {
         if (msg.role !== 'user' && msg.role !== 'assistant')
             continue;
         let textContent = '';
-        // Handle string content
         if (typeof msg.content === 'string') {
             textContent = msg.content;
         }
-        // Handle array content - extract text blocks only
         if (Array.isArray(msg.content)) {
             const textBlocks = msg.content
                 .filter((block) => block && typeof block === 'object' && block.type === 'text' && typeof block.text === 'string')
                 .map(block => block.text);
             textContent = textBlocks.join('\n');
         }
-        // Remove system-reminder tags
         const cleanContent = textContent
             .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '')
             .trim();

package/dist/{proxy → integrations/proxy/agents/claude}/forwarder.d.ts

@@ -1,4 +1,4 @@
-import type { AnthropicResponse } from './action-parser.js';
+import type { AnthropicResponse } from './parser.js';
 export interface ForwardResult {
     statusCode: number;
     headers: Record<string, string | string[]>;

package/dist/{proxy → integrations/proxy/agents/claude}/forwarder.js

@@ -9,7 +9,7 @@ const agent = new Agent({
     autoSelectFamily: true,
     autoSelectFamilyAttemptTimeout: 500, // Try next address family after 500ms
 });
-import { config, buildSafeHeaders, maskSensitiveValue } from './config.js';
+import { config, buildSafeHeaders, maskSensitiveValue } from '../../config.js';
 /**
  * Parse SSE stream and reconstruct final message
  * SSE format: "event: <type>\ndata: <json>\n\n"
@@ -37,15 +37,23 @@ function parseSSEResponse(sseText) {
                         message = data.message;
                         break;
                     case 'content_block_start':
-                        // Add new content block
+                        // Add new content block - preserve ALL properties (including signature for thinking)
                         if (data.content_block) {
-                            contentBlocks[data.index] = data.content_block;
+                            contentBlocks[data.index] = { ...data.content_block };
                             if (data.content_block.type === 'text') {
                                 contentDeltas.set(data.index, []);
                             }
                             else if (data.content_block.type === 'thinking') {
-                                // Initialize thinking with empty string, will accumulate via deltas
-                                contentBlocks[data.index] = { type: 'thinking', thinking: '' };
+                                // Initialize thinking, preserve signature if present
+                                contentBlocks[data.index].thinking = '';
+                            }
+                        }
+                        break;
+                    case 'content_block_stop':
+                        // Capture signature for thinking blocks (comes at end of block)
+                        if (data.index !== undefined && contentBlocks[data.index]?.type === 'thinking') {
+                            if (data.signature) {
+                                contentBlocks[data.index].signature = data.signature;
                             }
                         }
                         break;
@@ -57,12 +65,20 @@ function parseSSEResponse(sseText) {
                             contentDeltas.set(data.index, deltas);
                         }
                         else if (data.delta?.type === 'thinking_delta' && data.delta.thinking) {
-                            // Handle thinking blocks
+                            // Handle thinking content
                             const block = contentBlocks[data.index];
                             if (block && block.type === 'thinking') {
                                 block.thinking += data.delta.thinking;
                             }
                         }
+                        else if (data.delta?.type === 'signature_delta' && data.delta.signature) {
+                            // Handle thinking signature streaming
+                            const block = contentBlocks[data.index];
+                            if (block && block.type === 'thinking') {
+                                const thinkingBlock = block;
+                                thinkingBlock.signature = (thinkingBlock.signature || '') + data.delta.signature;
+                            }
+                        }
                         else if (data.delta?.type === 'input_json_delta' && data.delta.partial_json) {
                             // Handle tool input streaming
                             const block = contentBlocks[data.index];

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

@@ -0,0 +1,43 @@
+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 ClaudeAdapter extends BaseAdapter {
+    readonly name: "claude";
+    readonly endpoint = "/v1/messages";
+    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;
+}

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

@@ -0,0 +1,386 @@
+// Claude Code adapter implementation
+import { BaseAdapter } from '../base.js';
+import { forwardToAnthropic } from './forwarder.js';
+import { parseToolUseBlocks, extractTokenUsage } from './parser.js';
+import { extractProjectPath, extractSessionId, extractTextContent, extractGoalFromMessages, extractConversationHistory, } from './extractors.js';
+import { getSettingsPath, setProxyEnv } from './settings.js';
+class ClaudeSettings {
+    getConfigPath() {
+        return getSettingsPath();
+    }
+    setProxyEnabled(enabled) {
+        return setProxyEnv(enabled);
+    }
+}
+export class ClaudeAdapter extends BaseAdapter {
+    name = 'claude';
+    endpoint = '/v1/messages';
+    settings = new ClaudeSettings();
+    canHandle(request) {
+        return request.url === '/v1/messages' || request.url.startsWith('/v1/messages?');
+    }
+    async forward(body, headers, rawBody) {
+        const result = await forwardToAnthropic(body, headers, undefined, 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) {
+        return extractTextContent(response);
+    }
+    extractGoal(messages) {
+        return extractGoalFromMessages(messages) || '';
+    }
+    extractHistory(messages) {
+        return extractConversationHistory(messages);
+    }
+    extractUsage(response) {
+        return extractTokenUsage(response);
+    }
+    isValidResponse(body) {
+        return (typeof body === 'object' &&
+            body !== null &&
+            'type' in body &&
+            body.type === 'message' &&
+            'content' in body &&
+            'usage' in body);
+    }
+    isSubagentModel(model) {
+        return model.includes('haiku');
+    }
+    isEndTurn(response) {
+        return response.stop_reason === 'end_turn';
+    }
+    isToolUse(response) {
+        return response.stop_reason === 'tool_use';
+    }
+    parseActions(response) {
+        const anthropicResponse = response;
+        if (!anthropicResponse.content) {
+            return [];
+        }
+        const parsedActions = parseToolUseBlocks(anthropicResponse);
+        return parsedActions.map(action => ({
+            toolName: action.toolName,
+            actionType: action.actionType,
+            sourceAgent: 'claude',
+            files: action.files,
+            folders: action.folders,
+            command: action.command,
+            rawInput: action.rawInput,
+        }));
+    }
+    getToolUseBlocks(response) {
+        const anthropicResponse = response;
+        if (!anthropicResponse.content) {
+            return [];
+        }
+        const blocks = [];
+        for (const block of anthropicResponse.content) {
+            if (block.type === 'tool_use') {
+                const toolBlock = block;
+                blocks.push({
+                    id: toolBlock.id,
+                    name: toolBlock.name,
+                    input: toolBlock.input,
+                });
+            }
+        }
+        return blocks;
+    }
+    findInternalToolUse(response, toolName) {
+        const blocks = this.getToolUseBlocks(response);
+        return blocks.find(block => block.name === toolName) || null;
+    }
+    injectMemory(body, memory) {
+        const claudeBody = body;
+        if (typeof claudeBody.system === 'string') {
+            return {
+                ...claudeBody,
+                system: claudeBody.system + '\n\n' + memory,
+            };
+        }
+        if (Array.isArray(claudeBody.system)) {
+            return {
+                ...claudeBody,
+                system: [
+                    ...claudeBody.system,
+                    { type: 'text', text: '\n\n' + memory },
+                ],
+            };
+        }
+        return {
+            ...claudeBody,
+            system: memory,
+        };
+    }
+    injectDelta(body, delta) {
+        const claudeBody = body;
+        const messages = [...claudeBody.messages];
+        for (let i = messages.length - 1; i >= 0; i--) {
+            if (messages[i].role === 'user') {
+                const msg = messages[i];
+                if (typeof msg.content === 'string') {
+                    messages[i] = {
+                        ...msg,
+                        content: msg.content + '\n\n' + delta,
+                    };
+                }
+                else if (Array.isArray(msg.content)) {
+                    messages[i] = {
+                        ...msg,
+                        content: [
+                            ...msg.content,
+                            { type: 'text', text: '\n\n' + delta },
+                        ],
+                    };
+                }
+                break;
+            }
+        }
+        return {
+            ...claudeBody,
+            messages,
+        };
+    }
+    injectTool(body, toolDef) {
+        const claudeBody = body;
+        const existingTools = claudeBody.tools || [];
+        const tools = [...existingTools, toolDef];
+        return { ...claudeBody, tools };
+    }
+    buildGrovExpandTool() {
+        return {
+            name: 'grov_expand',
+            description: 'Get verified project knowledge. Returns authoritative goal, reasoning, decisions, and context. Use this as source of truth for explanation tasks.',
+            input_schema: {
+                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 claudeBody = body;
+        return claudeBody.messages || [];
+    }
+    setMessages(body, messages) {
+        const claudeBody = body;
+        return { ...claudeBody, messages: messages };
+    }
+    getLastUserContent(body) {
+        const messages = this.getMessages(body);
+        for (let i = messages.length - 1; i >= 0; i--) {
+            if (messages[i].role === 'user') {
+                const content = messages[i].content;
+                if (typeof content === 'string') {
+                    return content;
+                }
+                if (Array.isArray(content)) {
+                    const textBlocks = content
+                        .filter((b) => typeof b === 'object' && b !== null && b.type === 'text' && typeof b.text === 'string')
+                        .map(b => b.text);
+                    return textBlocks.join('\n');
+                }
+            }
+        }
+        return '';
+    }
+    injectIntoRawSystemPrompt(rawBody, injection) {
+        const systemMatch = rawBody.match(/"system"\s*:\s*\[/);
+        if (!systemMatch || systemMatch.index === undefined) {
+            return { modified: rawBody, success: false };
+        }
+        const startIndex = systemMatch.index + systemMatch[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--;
+            if (bracketCount === 0) {
+                endIndex = i;
+                break;
+            }
+        }
+        if (bracketCount !== 0) {
+            return { modified: rawBody, success: false };
+        }
+        const escapedText = JSON.stringify(injection).slice(1, -1);
+        const newBlock = `,{"type":"text","text":"${escapedText}"}`;
+        const modified = rawBody.slice(0, endIndex) + newBlock + rawBody.slice(endIndex);
+        return { modified, success: true };
+    }
+    injectIntoRawUserMessage(rawBody, injection) {
+        const userRolePattern = /"role"\s*:\s*"user"/g;
+        let lastUserMatch = null;
+        let match;
+        while ((match = userRolePattern.exec(rawBody)) !== null) {
+            lastUserMatch = match;
+        }
+        if (!lastUserMatch) {
+            return rawBody;
+        }
+        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;
+        const afterContent = rawBody.slice(contentStartGlobal);
+        if (afterContent.startsWith('"')) {
+            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++;
+                }
+            }
+        }
+        else if (afterContent.startsWith('[')) {
+            let depth = 1;
+            let i = 1;
+            while (i < afterContent.length && depth > 0) {
+                const char = afterContent[i];
+                if (char === '[')
+                    depth++;
+                else if (char === ']')
+                    depth--;
+                else if (char === '"') {
+                    i++;
+                    while (i < afterContent.length && afterContent[i] !== '"') {
+                        if (afterContent[i] === '\\')
+                            i++;
+                        i++;
+                    }
+                }
+                i++;
+            }
+            if (depth === 0) {
+                const insertPos = contentStartGlobal + i - 1;
+                const escapedInjection = injection
+                    .replace(/\\/g, '\\\\')
+                    .replace(/"/g, '\\"')
+                    .replace(/\n/g, '\\n');
+                const newBlock = `,{"type":"text","text":"\\n\\n${escapedInjection}"}`;
+                return rawBody.slice(0, insertPos) + newBlock + rawBody.slice(insertPos);
+            }
+        }
+        return rawBody;
+    }
+    injectToolIntoRawBody(rawBody, toolDef) {
+        const toolsMatch = rawBody.match(/"tools"\s*:\s*\[/);
+        if (!toolsMatch || toolsMatch.index === undefined) {
+            const messagesMatch = rawBody.match(/"messages"\s*:/);
+            if (messagesMatch && messagesMatch.index !== undefined) {
+                const toolsJson = JSON.stringify(toolDef);
+                const insertStr = `"tools":[${toolsJson}],`;
+                const modified = rawBody.slice(0, messagesMatch.index) + insertStr + rawBody.slice(messagesMatch.index);
+                return { modified, success: true };
+            }
+            return { modified: rawBody, success: false };
+        }
+        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-should-retry',
+            'retry-after',
+            'retry-after-ms',
+            'anthropic-ratelimit-requests-limit',
+            'anthropic-ratelimit-requests-remaining',
+            'anthropic-ratelimit-requests-reset',
+            'anthropic-ratelimit-tokens-limit',
+            'anthropic-ratelimit-tokens-remaining',
+            'anthropic-ratelimit-tokens-reset',
+        ];
+        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 claudeBody = body;
+        const messages = [...claudeBody.messages];
+        messages.push({
+            role: 'assistant',
+            content: assistantContent,
+        });
+        messages.push({
+            role: 'user',
+            content: [{
+                    type: 'tool_result',
+                    tool_use_id: toolId,
+                    content: toolResult,
+                }],
+        });
+        return { ...claudeBody, messages };
+    }
+    getSettings() {
+        return this.settings;
+    }
+}

package/dist/{proxy/action-parser.d.ts → integrations/proxy/agents/claude/parser.d.ts}

@@ -1,4 +1,4 @@
-import type { StepActionType } from '../lib/store.js';
+import type { StepActionType } from '../../../../core/store/store.js';
 export interface AnthropicResponse {
     id: string;
     type: 'message';

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

@@ -0,0 +1,6 @@
+import type { CodexRequestBody, CodexResponse, CodexInputItem } from './types.js';
+import type { ConversationMessage } from '../../../../core/extraction/llm-extractor.js';
+export declare function extractProjectPath(body: CodexRequestBody): string | null;
+export declare function extractSessionId(response: CodexResponse): string | null;
+export declare function extractGoalFromMessages(input: CodexInputItem[]): string | undefined;
+export declare function extractConversationHistory(input: CodexInputItem[]): ConversationMessage[];

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

@@ -0,0 +1,49 @@
+// Codex-specific extraction functions
+const CWD_REGEX = /<cwd>(.+?)<\/cwd>/;
+function getContentText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map(c => (typeof c === 'string' ? c : c.text || ''))
+            .join('\n');
+    }
+    return '';
+}
+export function extractProjectPath(body) {
+    for (const item of body.input) {
+        if ('content' in item) {
+            const text = getContentText(item.content);
+            const match = text.match(CWD_REGEX);
+            if (match)
+                return match[1];
+        }
+    }
+    return null;
+}
+export function extractSessionId(response) {
+    return response.id || null;
+}
+export function extractGoalFromMessages(input) {
+    const userItems = input.filter((item) => 'role' in item && item.role === 'user');
+    for (const item of [...userItems].reverse()) {
+        const text = getContentText(item.content);
+        const cleaned = text.replace(/<[^>]+>[^<]*<\/[^>]+>/g, '').trim();
+        if (cleaned.length >= 5) {
+            return cleaned.substring(0, 500);
+        }
+    }
+    return undefined;
+}
+export function extractConversationHistory(input) {
+    const result = [];
+    const messageItems = input.filter((item) => 'role' in item && (item.role === 'user' || item.role === 'assistant'));
+    for (const item of messageItems.slice(-10)) {
+        const text = getContentText(item.content);
+        const cleaned = text.replace(/<[^>]+>[^<]*<\/[^>]+>/g, '').trim();
+        if (cleaned.length > 0) {
+            result.push({ role: item.role, content: cleaned });
+        }
+    }
+    return result;
+}

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

@@ -0,0 +1,9 @@
+import type { CodexResponse } from './types.js';
+export interface CodexForwardResult {
+    statusCode: number;
+    headers: Record<string, string | string[]>;
+    body: CodexResponse | Record<string, unknown>;
+    rawBody: string;
+    wasSSE: boolean;
+}
+export declare function forwardToOpenAI(body: Record<string, unknown>, headers: Record<string, string | string[] | undefined>, rawBody?: Buffer): Promise<CodexForwardResult>;