skimpyclaw 0.3.14 → 0.4.0

package/dist/providers/codex.js

@@ -2,17 +2,10 @@
 import { readFileSync, existsSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
-import { stripProvider, truncateToolResult } from './utils.js';
-import { toErrorMessage } from '../utils.js';
-import { compactCodexMessages } from './context-manager.js';
-import { toCodexContent, toCodexToolDefinitions } from './content.js';
-import { toNumericUsageDetails, toCostDetails } from './observability.js';
-import { executeTool } from '../tools.js';
-import { ToolCallGuard } from './tool-guard.js';
-import { startTrace, addEvent } from '../audit.js';
-import { startObservation } from '@langfuse/tracing';
+import { toCostDetails } from './observability.js';
 import { buildUsageRecord, recordUsage } from '../usage.js';
-const DEFAULT_CODEX_AUTH_PATH = join(homedir(), '.codex', 'auth.json');
+const DEFAULT_CODEX_HOME = join(homedir(), '.codex');
+const DEFAULT_CODEX_AUTH_PATH = join(DEFAULT_CODEX_HOME, 'auth.json');
 const DEFAULT_CODEX_BASE_URL = 'https://chatgpt.com/backend-api';
 const DEFAULT_CODEX_FETCH_TIMEOUT_MS = 120_000;
 let codexAuthPath = DEFAULT_CODEX_AUTH_PATH;
@@ -33,12 +26,34 @@ export function resetCodexProviderState() {
     codexAuth = null;
 }
 export function setCodexAuthPath(path) {
-    codexAuthPath = path;
+    codexAuthPath = resolveCodexAuthPath(path);
 }
 export function setCodexBaseUrl(url) {
     codexBaseUrl = url;
 }
+export function resolveCodexAuthPath(authPath) {
+    if (!authPath)
+        return DEFAULT_CODEX_AUTH_PATH;
+    if (authPath === '~')
+        return homedir();
+    if (authPath.startsWith('~/'))
+        return join(homedir(), authPath.slice(2));
+    return authPath;
+}
+function decodeJwtPayload(token) {
+    const payloadPart = token.split('.')[1];
+    if (!payloadPart)
+        return null;
+    try {
+        const normalized = payloadPart.replace(/-/g, '+').replace(/_/g, '/');
+        return JSON.parse(Buffer.from(normalized, 'base64').toString());
+    }
+    catch {
+        return null;
+    }
+}
 export function loadCodexAuth(authPath = codexAuthPath) {
+    authPath = resolveCodexAuthPath(authPath);
     if (!existsSync(authPath)) {
         console.log(`[codex] No auth file at ${authPath}`);
         return null;
@@ -46,28 +61,32 @@ export function loadCodexAuth(authPath = codexAuthPath) {
     try {
         const raw = JSON.parse(readFileSync(authPath, 'utf-8'));
         const token = raw?.tokens?.access_token;
-        if (!token) {
+        if (typeof token !== 'string' || token.length === 0) {
             console.log('[codex] No access_token in auth file');
             return null;
         }
         // Decode JWT to check expiry and extract account ID
-        const payload = JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString());
-        const exp = payload.exp * 1000;
-        const now = Date.now();
-        if (now > exp) {
-            const expiredAgo = Math.round((now - exp) / 60000);
-            console.warn(`[codex] Token expired ${expiredAgo} min ago. Run 'codex' to re-auth.`);
-            return null;
+        const payload = decodeJwtPayload(token);
+        if (payload?.exp) {
+            const exp = payload.exp * 1000;
+            const now = Date.now();
+            if (now > exp) {
+                const expiredAgo = Math.round((now - exp) / 60000);
+                console.warn(`[codex] Token expired ${expiredAgo} min ago. Run 'codex' to re-auth.`);
+                return null;
+            }
         }
-        // Extract account ID from JWT claims
-        const authClaims = payload['https://api.openai.com/auth'];
-        const accountId = authClaims?.chatgpt_account_id;
-        if (!accountId) {
-            console.error('[codex] No account ID in token');
+        // Current Codex CLI auth files include tokens.account_id; older files only
+        // expose it in the JWT claims.
+        const authClaims = payload?.['https://api.openai.com/auth'];
+        const accountId = raw?.tokens?.account_id || authClaims?.chatgpt_account_id;
+        if (typeof accountId !== 'string' || accountId.length === 0) {
+            console.error('[codex] No account ID in auth file');
             return null;
         }
-        const expiresIn = Math.round((exp - now) / 60000);
-        console.log(`[codex] Token valid (expires in ${expiresIn} min, account: ${accountId.slice(0, 8)}...)`);
+        const expiresIn = payload?.exp ? Math.round((payload.exp * 1000 - Date.now()) / 60000) : null;
+        const expiryDetail = expiresIn === null ? 'expiry unknown' : `expires in ${expiresIn} min`;
+        console.log(`[codex] Token valid (${expiryDetail}, account: ${accountId.slice(0, 8)}...)`);
         return { accessToken: token, accountId };
     }
     catch (error) {
@@ -77,7 +96,7 @@ export function loadCodexAuth(authPath = codexAuthPath) {
 }
 export function initCodexAuth(path, baseUrl) {
     if (path)
-        codexAuthPath = path;
+        codexAuthPath = resolveCodexAuthPath(path);
     if (baseUrl)
         codexBaseUrl = baseUrl;
     codexAuth = loadCodexAuth();
@@ -90,7 +109,7 @@ export function isCodexAvailable() {
     return codexAuth !== null;
 }
 const LANGFUSE_APP_NAME = 'skimpyclaw';
-function recordCodexUsage(params) {
+export function recordCodexUsage(params) {
     const usage = params.usage;
     const inputTokens = typeof usage?.input_tokens === 'number' ? usage.input_tokens : 0;
     const outputTokens = typeof usage?.output_tokens === 'number' ? usage.output_tokens : 0;
@@ -115,12 +134,13 @@ async function startGenerationObservation(name, attributes) {
     if (!isLangfuseEnabled())
         return null;
     attributes.metadata = { app: LANGFUSE_APP_NAME, ...attributes.metadata };
+    const { startObservation } = await import('@langfuse/tracing');
     return startObservation(name, attributes, { asType: 'generation' });
 }
 /**
  * Make a single Codex API call. Returns raw SSE text.
  */
-async function codexFetch(body, timeoutMs = DEFAULT_CODEX_FETCH_TIMEOUT_MS) {
+export async function codexFetch(body, timeoutMs = DEFAULT_CODEX_FETCH_TIMEOUT_MS) {
     if (!codexAuth) {
         throw new Error('Codex auth not initialized. Run "codex" CLI to authenticate.');
     }
@@ -160,9 +180,14 @@ async function codexFetch(body, timeoutMs = DEFAULT_CODEX_FETCH_TIMEOUT_MS) {
  * Parse an SSE response from the Codex backend.
  * Extracts function calls from the completed response object.
  */
-function parseCodexSSE(text) {
+export function parseCodexSSE(text) {
     let outputText = '';
     let completedResponse = null;
+    // Track streaming function calls and output items
+    const streamingFunctionCalls = new Map();
+    const streamingOutputTexts = new Map();
+    let currentOutputIndex = -1;
+    let currentFcIndex = -1;
     for (const line of text.split('\n')) {
         if (!line.startsWith('data: '))
             continue;
@@ -172,7 +197,38 @@ function parseCodexSSE(text) {
         try {
             const event = JSON.parse(data);
             if (event.type === 'response.output_text.delta') {
-                outputText += event.delta || '';
+                // Text delta — accumulate by output_index or globally
+                const idx = event.output_index ?? currentOutputIndex;
+                if (idx >= 0) {
+                    streamingOutputTexts.set(idx, (streamingOutputTexts.get(idx) || '') + (event.delta || ''));
+                }
+                else {
+                    outputText += event.delta || '';
+                }
+            }
+            else if (event.type === 'response.output_item.added') {
+                // New output item — track its type
+                const item = event.item;
+                const idx = event.output_index ?? -1;
+                if (item?.type === 'function_call') {
+                    currentFcIndex = idx;
+                    streamingFunctionCalls.set(idx, {
+                        callId: item.call_id || item.id || `fc-${idx}`,
+                        name: item.name || '',
+                        arguments: '',
+                    });
+                }
+                else if (item?.type === 'output_text' || item?.type === 'message') {
+                    currentOutputIndex = idx;
+                }
+            }
+            else if (event.type === 'response.function_call_arguments.delta') {
+                // Function call argument delta
+                const idx = event.output_index ?? currentFcIndex;
+                const fc = streamingFunctionCalls.get(idx);
+                if (fc) {
+                    fc.arguments += event.delta || '';
+                }
             }
             else if (event.type === 'response.completed' && event.response) {
                 completedResponse = event.response;
@@ -182,9 +238,9 @@ function parseCodexSSE(text) {
         }
         catch { /* skip non-JSON lines */ }
     }
-    // Extract function calls and output_text items from completed response
+    // Build function calls — prefer completed response, fall back to streaming
     const functionCalls = [];
-    if (completedResponse?.output) {
+    if (completedResponse?.output?.length) {
         for (const item of completedResponse.output) {
             if (item.type === 'function_call') {
                 functionCalls.push({
@@ -194,10 +250,43 @@ function parseCodexSSE(text) {
                 });
             }
             else if (item.type === 'output_text' && item.text) {
-                // Capture output_text items that may not appear at top-level
                 if (!outputText)
                     outputText = item.text;
             }
+            else if (item.type === 'message' && item.content) {
+                for (const c of item.content) {
+                    if (c.type === 'output_text' && c.text) {
+                        outputText += c.text;
+                    }
+                }
+            }
+        }
+    }
+    else {
+        // Completed response had empty output — use streaming data
+        // Also patch the rawResponse so appendAssistantResponse includes these items
+        const patchedOutput = [];
+        for (const [, fc] of streamingFunctionCalls) {
+            if (fc.name) {
+                functionCalls.push(fc);
+                patchedOutput.push({
+                    type: 'function_call',
+                    call_id: fc.callId,
+                    name: fc.name,
+                    arguments: fc.arguments,
+                });
+            }
+        }
+        for (const [, txt] of streamingOutputTexts) {
+            if (txt) {
+                if (!outputText)
+                    outputText = txt;
+                patchedOutput.push({ type: 'output_text', text: txt });
+            }
+        }
+        if (completedResponse && patchedOutput.length > 0) {
+            completedResponse.output = patchedOutput;
+            console.log(`[codex] Patched empty response.output with ${patchedOutput.length} streaming items`);
         }
     }
     if (completedResponse?.usage) {
@@ -206,305 +295,35 @@ function parseCodexSSE(text) {
     else {
         console.log('[codex] No usage data in response');
     }
+    // Fallback: Codex may put text in response.text instead of output_text or output[]
+    if (!outputText && completedResponse?.text) {
+        const textContent = typeof completedResponse.text === 'string'
+            ? completedResponse.text
+            : typeof completedResponse.text?.content === 'string'
+                ? completedResponse.text.content
+                : '';
+        if (textContent)
+            outputText = textContent;
+    }
+    // Debug: log when output is empty despite having tokens
+    if (!outputText && completedResponse) {
+        const outputTypes = (completedResponse.output || []).map((item) => `${item.type}${item.content ? `[${(item.content || []).map((c) => c.type).join(',')}]` : ''}`);
+        console.warn(`[codex] Empty outputText! status: ${completedResponse.status}, output: ${JSON.stringify(completedResponse.output)?.slice(0, 1000)}, text: ${JSON.stringify(completedResponse.text)?.slice(0, 200)}, reasoning: ${JSON.stringify(completedResponse.reasoning)?.slice(0, 200)}`);
+    }
     return { outputText, functionCalls, response: completedResponse };
 }
+/** @deprecated Use adapter.chat() via the provider registry instead. */
 export async function chatCodex(params) {
-    const { messages, options } = params;
-    const modelId = stripProvider(options.model);
-    // Build input — system messages go to `instructions`, rest to `input`
-    let instructions = 'You are a helpful assistant.';
-    const input = [];
-    for (const m of messages) {
-        if (m.role === 'system') {
-            // Convert content to text
-            const { contentToText } = await import('./utils.js');
-            instructions = contentToText(m.content);
-        }
-        else {
-            const contentType = m.role === 'assistant' ? 'output_text' : 'input_text';
-            const content = toCodexContent(m.content, contentType);
-            input.push({
-                type: 'message',
-                role: m.role,
-                content,
-            });
-        }
-    }
-    const body = {
-        model: modelId,
-        instructions,
-        input,
-        store: false,
-        stream: true,
-        reasoning: { effort: 'medium', summary: 'auto' },
-        include: ['reasoning.encrypted_content'],
-    };
-    const genObs = await startGenerationObservation(`codex:${modelId}`, {
-        input: { instructions, input },
-        model: modelId,
-        modelParameters: { stream: true, reasoning: body.reasoning },
-        metadata: { provider: 'codex' },
-    });
-    try {
-        const sseText = await codexFetch(body);
-        const parsed = parseCodexSSE(sseText);
-        recordCodexUsage({ model: modelId, usage: parsed.response?.usage, trigger: 'api' });
-        genObs?.update({
-            output: { text: parsed.outputText },
-            usageDetails: toNumericUsageDetails(parsed.response?.usage),
-            costDetails: toCostDetails(modelId, parsed.response?.usage),
-        });
-        genObs?.end();
-        return parsed.outputText || '[No response from Codex]';
-    }
-    catch (err) {
-        const errorMessage = toErrorMessage(err);
-        genObs?.update({ level: 'ERROR', statusMessage: errorMessage, output: { error: errorMessage } });
-        genObs?.end();
-        throw err;
-    }
+    const { CodexAdapter } = await import('./adapters/codex-adapter.js');
+    const adapter = new CodexAdapter();
+    return adapter.chat(params.messages, params.options, params.config);
 }
 export async function chatWithToolsCodex(params) {
-    const { messages, options, config, toolConfig, toolContext } = params;
-    const modelId = stripProvider(options.model);
-    const maxIterations = toolConfig.maxIterations || 100;
-    // Build input — system messages go to `instructions`, rest to `input`
-    let instructions = 'You are a helpful assistant.';
-    const input = [];
-    for (const m of messages) {
-        if (m.role === 'system') {
-            const { contentToText } = await import('./utils.js');
-            instructions = contentToText(m.content);
-        }
-        else {
-            const contentType = m.role === 'assistant' ? 'output_text' : 'input_text';
-            const content = toCodexContent(m.content, contentType);
-            input.push({
-                type: 'message',
-                role: m.role,
-                content,
-            });
-        }
-    }
-    // Get tool definitions
-    const { getToolDefinitions } = await import('../tools.js');
-    const includeSpawn = !!(toolContext?.fullConfig && (toolContext?.chatId || toolContext?.isCronJob));
-    const toolDefs = await getToolDefinitions(toolConfig, {
-        includeAgentTools: includeSpawn,
-        includeMcp: false,
-        projects: toolContext?.fullConfig?.projects
-    });
-    const tools = toolDefs ? toCodexToolDefinitions(toolDefs) : undefined;
-    const toolLog = [];
-    const auditTraceId = toolContext?.auditTraceId || startTrace((toolContext?.trigger || 'api'));
-    // Guard: spin detection, no-progress detection, token budget
-    const guard = new ToolCallGuard(toolConfig.maxTurnTokens);
-    for (let i = 0; i < maxIterations; i++) {
-        // Check abort signal before each iteration
-        if (toolContext?.abortSignal?.aborted) {
-            return {
-                response: `[Cancelled after ${toolLog.length} tool calls]`,
-                toolCalls: toolLog,
-            };
-        }
-        // Compact old tool results if context is growing large
-        const compactionResult = await compactCodexMessages(input, toolConfig.contextManagement, i + 1, config);
-        const inputForApi = compactionResult.messages;
-        if (compactionResult.compacted) {
-            const method = compactionResult.method === 'llm' ? 'LLM summary' : 'truncation';
-            const detail = `~${Math.round((compactionResult.tokensBefore || 0) / 1000)}k → ~${Math.round((compactionResult.tokensAfter || 0) / 1000)}k tokens`;
-            toolLog.push(`[context compacted via ${method}: ${detail}]`);
-        }
-        const body = {
-            model: modelId,
-            instructions,
-            input: inputForApi,
-            store: false,
-            stream: true,
-            reasoning: { effort: 'medium', summary: 'auto' },
-            include: ['reasoning.encrypted_content'],
-        };
-        if (tools)
-            body.tools = tools;
-        console.log(`[codex] Iteration ${i + 1}/${maxIterations} (model: ${modelId})`);
-        const genObs = await startGenerationObservation(`codex:${modelId}`, {
-            input: { instructions, input },
-            model: modelId,
-            modelParameters: { stream: true, reasoning: body.reasoning },
-            metadata: { provider: 'codex', iteration: i + 1 },
-        });
-        let parsed;
-        try {
-            const sseText = await codexFetch(body);
-            parsed = parseCodexSSE(sseText);
-            recordCodexUsage({
-                model: modelId,
-                usage: parsed.response?.usage,
-                trigger: toolContext?.trigger || 'api',
-                agentId: toolContext?.agentId,
-            });
-            genObs?.update({
-                output: { text: parsed.outputText },
-                usageDetails: toNumericUsageDetails(parsed.response?.usage),
-                costDetails: toCostDetails(modelId, parsed.response?.usage),
-            });
-            genObs?.end();
-            // Guard: track token usage (stats only, no enforcement)
-            guard.recordTokens(parsed.response?.usage?.input_tokens ?? 0, parsed.response?.usage?.output_tokens ?? 0);
-        }
-        catch (err) {
-            const errorMessage = toErrorMessage(err);
-            genObs?.update({ level: 'ERROR', statusMessage: errorMessage, output: { error: errorMessage } });
-            genObs?.end();
-            throw err;
-        }
-        // No function calls — we're done
-        if (parsed.functionCalls.length === 0) {
-            // Debug: log what Codex actually returned when outputText is empty
-            if (!parsed.outputText) {
-                console.log(`[codex] Empty outputText. Response output items:`, JSON.stringify(parsed.response?.output?.map((i) => ({ type: i.type, text: i.text?.slice(0, 200) })), null, 2));
-            }
-            let finalText = parsed.outputText;
-            if (!finalText && toolLog.length > 0) {
-                try {
-                    // Some Codex runs finish tool execution but omit final text. Ask once more
-                    // (without tools) for a user-facing answer from the gathered context.
-                    const finalizeInput = [...input];
-                    if (parsed.response?.output) {
-                        for (const item of parsed.response.output) {
-                            finalizeInput.push(item);
-                        }
-                    }
-                    finalizeInput.push({
-                        type: 'message',
-                        role: 'user',
-                        content: [
-                            {
-                                type: 'input_text',
-                                text: 'Provide the final answer to the user using the tool results above. Do not call tools. Be concise.',
-                            },
-                        ],
-                    });
-                    const finalizeBody = {
-                        model: modelId,
-                        instructions,
-                        input: finalizeInput,
-                        store: false,
-                        stream: true,
-                        reasoning: { effort: 'medium', summary: 'auto' },
-                        include: ['reasoning.encrypted_content'],
-                    };
-                    console.log('[codex] Finalizing tool run with a text-only follow-up');
-                    const finalizeSse = await codexFetch(finalizeBody);
-                    const finalized = parseCodexSSE(finalizeSse);
-                    finalText = finalized.outputText?.trim() || '';
-                }
-                catch (err) {
-                    const msg = toErrorMessage(err);
-                    console.warn(`[codex] Finalization pass failed: ${msg}`);
-                }
-            }
-            if (!finalText && toolLog.length > 0) {
-                finalText = `[Completed ${toolLog.length} tool calls, but no final text response was generated.]`;
-            }
-            const usage = parsed.response?.usage;
-            return {
-                response: finalText || '[No response from Codex]',
-                toolCalls: toolLog,
-                usage: {
-                    prompt_tokens: usage?.input_tokens ?? 0,
-                    completion_tokens: usage?.output_tokens ?? 0,
-                    total_tokens: (usage?.input_tokens ?? 0) + (usage?.output_tokens ?? 0),
-                },
-                cost: toCostDetails(modelId, usage),
-            };
-        }
-        // Add the assistant's output items to input for next turn
-        if (parsed.response?.output) {
-            for (const item of parsed.response.output) {
-                input.push(item);
-            }
-        }
-        // Execute each function call and add results to input
-        for (const fc of parsed.functionCalls) {
-            const argsStr = fc.arguments || '{}';
-            let args;
-            try {
-                args = JSON.parse(argsStr);
-            }
-            catch {
-                args = {};
-            }
-            const inputStr = argsStr.slice(0, 200);
-            console.log(`[codex:tools] -> ${fc.name}(${inputStr})`);
-            // Guard: spin detection
-            const guardResult = guard.recordCall(fc.name, args);
-            if (guardResult.warning)
-                console.warn(`[codex:tools:guard] ${guardResult.warning}`);
-            if (guardResult.blocked) {
-                input.push({
-                    type: 'function_call_output',
-                    call_id: fc.callId,
-                    output: guardResult.warning || 'Blocked: repeated identical call',
-                });
-                toolLog.push(`${fc.name} [BLOCKED: spin detected]`);
-                continue;
-            }
-            const { isLangfuseEnabled } = await import('../langfuse.js');
-            const toolObs = isLangfuseEnabled()
-                ? startObservation(`tool:${fc.name}`, { input: args, metadata: { app: LANGFUSE_APP_NAME, tool: fc.name } }, { asType: 'tool' })
-                : null;
-            const toolStart = Date.now();
-            try {
-                const result = await executeTool(fc.name, args, toolConfig, toolContext) || '';
-                const truncatedResult = truncateToolResult(result);
-                const resultPreview = result.slice(0, 200) + (result.length > 200 ? '...' : '');
-                console.log(`[codex:tools] <- ${resultPreview}`);
-                toolLog.push(`${fc.name}(${inputStr}) → ${resultPreview}`);
-                toolObs?.update({ output: result });
-                toolObs?.end();
-                if (toolContext?.auditTraceId) {
-                    addEvent(toolContext.auditTraceId, {
-                        type: 'tool_use',
-                        summary: `${fc.name}(${inputStr})`,
-                        durationMs: Date.now() - toolStart,
-                    });
-                }
-                input.push({
-                    type: 'function_call_output',
-                    call_id: fc.callId,
-                    output: truncatedResult,
-                });
-                // Guard: no-progress detection
-                const progressResult = guard.recordResult(result);
-                if (progressResult.nudge) {
-                    console.warn(`[codex:tools:guard] ${progressResult.nudge}`);
-                    input[input.length - 1].output += `\n\n[System: ${progressResult.nudge}]`;
-                }
-            }
-            catch (err) {
-                const errorMessage = toErrorMessage(err);
-                toolObs?.update({ level: 'ERROR', statusMessage: errorMessage, output: { error: errorMessage } });
-                toolObs?.end();
-                if (toolContext?.auditTraceId) {
-                    addEvent(toolContext.auditTraceId, {
-                        type: 'tool_error',
-                        summary: `${fc.name} error: ${errorMessage.slice(0, 150)}`,
-                        durationMs: Date.now() - toolStart,
-                    });
-                }
-                throw err;
-            }
-        }
-    }
-    console.warn(`[codex:tools] Max iterations (${maxIterations}) reached`);
-    return { response: '[Tool use loop reached maximum iterations]', toolCalls: toolLog };
-}
-/** Build UsageDetails from Codex usage response */
-function buildCodexUsageDetails(usage) {
-    return {
-        prompt_tokens: usage?.input_tokens ?? 0,
-        completion_tokens: usage?.output_tokens ?? 0,
-        total_tokens: (usage?.input_tokens ?? 0) + (usage?.output_tokens ?? 0),
-    };
+    const { runToolLoop } = await import('./tool-loop.js');
+    const { CodexAdapter } = await import('./adapters/codex-adapter.js');
+    const adapter = new CodexAdapter();
+    const unifiedToolConfig = params.toolConfig.maxIterations
+        ? params.toolConfig
+        : { ...params.toolConfig, maxIterations: 100 };
+    return runToolLoop(adapter, params.messages, params.options, params.config, unifiedToolConfig, params.toolContext);
 }

package/dist/providers/content.d.ts

@@ -1,7 +1,7 @@
 import type { ContentBlock } from '../types.js';
 /**
  * Convert content array to OpenAI vision-compatible format.
- * Preserves images as data URIs for multimodal models (Kimi, MiniMax, etc.).
+ * Preserves images as data URIs for multimodal model formats.
  */
 export declare function toOpenAIContent(content: string | ContentBlock[]): string | Array<{
     type: string;

package/dist/providers/content.js

@@ -1,7 +1,7 @@
 // Content Format Conversions for Different Providers
 /**
  * Convert content array to OpenAI vision-compatible format.
- * Preserves images as data URIs for multimodal models (Kimi, MiniMax, etc.).
+ * Preserves images as data URIs for multimodal model formats.
  */
 export function toOpenAIContent(content) {
     if (typeof content === 'string')
@@ -50,6 +50,6 @@ export function toCodexToolDefinitions(tools) {
         type: 'function',
         name: t.name,
         description: t.description,
-        parameters: t.input_schema,
+        parameters: t.input_schema && t.input_schema.type ? t.input_schema : { type: 'object', properties: {} },
     }));
 }

package/dist/providers/context-manager.d.ts

@@ -1,5 +1,6 @@
 import type { ContextManagementConfig } from './types.js';
 import type { Config } from '../types.js';
+import type { MessageFormatHelper } from './adapter.js';
 export type { ContextManagementConfig };
 /** Result of a compaction attempt, including metadata about what happened. */
 export interface CompactionResult<T> {
@@ -17,6 +18,20 @@ export interface CompactionResult<T> {
 }
 /** Rough token estimate: 1 token ≈ 4 chars of JSON. */
 export declare function estimateTokens(data: any[]): number;
+/**
+ * Generic compaction function for any message format.
+ * Delegates format-specific concerns (truncation, serialization, summary building)
+ * to the provided MessageFormatHelper.
+ *
+ * Does NOT mutate the input array — returns a new array.
+ */
+export declare function compactMessages<T>(items: T[], helper: MessageFormatHelper<T>, config?: ContextManagementConfig, iteration?: number, fullConfig?: Config): Promise<CompactionResult<T>>;
+/** Anthropic message format helper. */
+export declare const anthropicFormatHelper: MessageFormatHelper<any>;
+/** OpenAI message format helper. */
+export declare const openaiFormatHelper: MessageFormatHelper<any>;
+/** Codex message format helper. */
+export declare const codexFormatHelper: MessageFormatHelper<any>;
 /**
  * Serialize Anthropic-format messages into a human-readable conversation transcript
  * suitable for LLM summarization.
@@ -32,20 +47,17 @@ declare function serializeOpenAIMessages(messages: any[]): string;
 declare function serializeCodexMessages(items: any[]): string;
 /**
  * Compact Anthropic-format apiMessages when over threshold.
- * Uses LLM summarization for old messages; falls back to truncation on failure.
- * Does NOT mutate the input array — returns a new array.
+ * @deprecated Use compactMessages() with anthropicFormatHelper instead.
  */
 export declare function compactAnthropicMessages(messages: any[], config?: ContextManagementConfig, iteration?: number, fullConfig?: Config): Promise<CompactionResult<any>>;
 /**
  * Compact OpenAI-format apiMessages when over threshold.
- * Uses LLM summarization for old messages; falls back to truncation on failure.
- * Does NOT mutate the input array — returns a new array.
+ * @deprecated Use compactMessages() with openaiFormatHelper instead.
  */
 export declare function compactOpenAIMessages(messages: any[], config?: ContextManagementConfig, iteration?: number, fullConfig?: Config): Promise<CompactionResult<any>>;
 /**
  * Compact Codex-format input items when over threshold.
- * Uses LLM summarization for old items; falls back to truncation on failure.
- * Does NOT mutate the input array — returns a new array.
+ * @deprecated Use compactMessages() with codexFormatHelper instead.
  */
 export declare function compactCodexMessages(input: any[], config?: ContextManagementConfig, iteration?: number, fullConfig?: Config): Promise<CompactionResult<any>>;
 export { serializeAnthropicMessages, serializeOpenAIMessages, serializeCodexMessages };