skimpyclaw 0.1.5 → 0.1.7

package/dist/__tests__/tool-guard.test.js

@@ -57,25 +57,12 @@ describe('ToolCallGuard', () => {
             }
         });
     });
-    describe('token budget', () => {
-        it('does not exceed with small usage', () => {
-            const guard = new ToolCallGuard(100_000);
-            const r = guard.recordTokens(1000, 500);
-            expect(r.exceeded).toBe(false);
-            expect(r.warning).toBeUndefined();
-        });
-        it('warns at 80% usage', () => {
-            const guard = new ToolCallGuard(10_000);
-            const r = guard.recordTokens(4000, 4100);
-            expect(r.exceeded).toBe(false);
-            expect(r.warning).toBeDefined();
-            expect(r.warning).toContain('warning');
-        });
-        it('exceeds at 100% usage', () => {
-            const guard = new ToolCallGuard(10_000);
-            const r = guard.recordTokens(5000, 5000);
-            expect(r.exceeded).toBe(true);
-            expect(r.warning).toContain('exceeded');
+    describe('token tracking', () => {
+        it('tracks tokens without enforcement', () => {
+            const guard = new ToolCallGuard();
+            guard.recordTokens(5000, 5000);
+            const stats = guard.getStats();
+            expect(stats.totalTokens).toBe(10000);
         });
     });
     describe('reset', () => {

package/dist/providers/anthropic.js

@@ -191,16 +191,8 @@ export async function chatWithToolsAnthropic(params) {
                 costDetails: toCostDetails(modelId, usage),
             });
             genObs?.end();
-            // Guard: track token usage
-            const tokenResult = guard.recordTokens(response.usage?.input_tokens ?? 0, response.usage?.output_tokens ?? 0);
-            if (tokenResult.warning)
-                console.warn(`[agent:tools:guard] ${tokenResult.warning}`);
-            if (tokenResult.exceeded) {
-                return {
-                    response: `[Stopped: ${tokenResult.warning}]`,
-                    toolCalls: toolLog,
-                };
-            }
+            // Guard: track token usage (stats only, no enforcement)
+            guard.recordTokens(response.usage?.input_tokens ?? 0, response.usage?.output_tokens ?? 0);
         }
         catch (err) {
             const errorMessage = err instanceof Error ? err.message : String(err);

package/dist/providers/codex.js

@@ -339,16 +339,8 @@ export async function chatWithToolsCodex(params) {
                 costDetails: toCostDetails(modelId, parsed.response?.usage),
             });
             genObs?.end();
-            // Guard: track token usage
-            const tokenResult = guard.recordTokens(parsed.response?.usage?.input_tokens ?? 0, parsed.response?.usage?.output_tokens ?? 0);
-            if (tokenResult.warning)
-                console.warn(`[codex:tools:guard] ${tokenResult.warning}`);
-            if (tokenResult.exceeded) {
-                return {
-                    response: `[Stopped: ${tokenResult.warning}]`,
-                    toolCalls: toolLog,
-                };
-            }
+            // 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 = err instanceof Error ? err.message : String(err);

package/dist/providers/index.js

@@ -86,8 +86,14 @@ export async function initProviders(config) {
         if (!apiKey)
             continue;
         const opts = { apiKey };
-        if (providerConfig.baseURL)
-            opts.baseURL = providerConfig.baseURL;
+        if (providerConfig.baseURL) {
+            let normalizedBaseURL = providerConfig.baseURL;
+            if (name === 'minimax') {
+                const trimmed = normalizedBaseURL.replace(/\/+$/, '');
+                normalizedBaseURL = trimmed.endsWith('/v1') ? trimmed : `${trimmed}/v1`;
+            }
+            opts.baseURL = normalizedBaseURL;
+        }
         // Kimi Code API requires a coding-agent User-Agent with version string
         if (providerConfig.baseURL?.includes('kimi.com')) {
             opts.defaultHeaders = { 'User-Agent': 'claude-code/2.1.42' };

package/dist/providers/openai.js

@@ -30,10 +30,16 @@ export function isOpenAIAvailable(provider) {
 const LANGFUSE_APP_NAME = 'skimpyclaw';
 function recordOpenAIUsage(params) {
     const usage = params.usage;
-    const inputTokens = typeof usage?.prompt_tokens === 'number' ? usage.prompt_tokens : 0;
-    const outputTokens = typeof usage?.completion_tokens === 'number' ? usage.completion_tokens : 0;
-    if (inputTokens === 0 && outputTokens === 0)
-        return;
+    let inputTokens = typeof usage?.prompt_tokens === 'number'
+        ? usage.prompt_tokens
+        : (typeof usage?.input_tokens === 'number' ? usage.input_tokens : 0);
+    let outputTokens = typeof usage?.completion_tokens === 'number'
+        ? usage.completion_tokens
+        : (typeof usage?.output_tokens === 'number' ? usage.output_tokens : 0);
+    // Some OpenAI-compatible providers only return total_tokens.
+    if (inputTokens === 0 && outputTokens === 0 && typeof usage?.total_tokens === 'number') {
+        inputTokens = usage.total_tokens;
+    }
     const cost = toCostDetails(params.model, usage);
     recordUsage(buildUsageRecord({
         model: params.model,
@@ -61,6 +67,11 @@ export async function chatOpenAI(params, provider) {
     }
     const { messages, options, config } = params;
     const modelId = stripProvider(options.model, openaiClients);
+    const providerBaseURL = config.models.providers[provider]?.baseURL || '';
+    const isKimiLike = providerBaseURL.includes('kimi.com') || providerBaseURL.includes('moonshot.ai');
+    const kimiRequestExtras = isKimiLike
+        ? { extra_body: { interleaved: { field: 'reasoning_content' } } }
+        : {};
     const openaiMessages = messages.map(m => ({
         role: m.role,
         content: toOpenAIContent(m.content),
@@ -80,6 +91,7 @@ export async function chatOpenAI(params, provider) {
             messages: openaiMessages,
             max_tokens: options.maxTokens || 4096,
             temperature: options.temperature,
+            ...kimiRequestExtras,
         });
         let content = response.choices[0]?.message?.content || '';
         // Strip <think>...</think> reasoning blocks (e.g. MiniMax M2.x)
@@ -119,6 +131,9 @@ export async function chatWithToolsOpenAI(params, provider) {
     // Inject Kimi $web_search builtin tool when using Moonshot/Kimi provider
     const providerBaseURL = config.models.providers[provider]?.baseURL || '';
     const requiresReasoningContent = providerBaseURL.includes('kimi.com') || providerBaseURL.includes('moonshot.ai');
+    const kimiRequestExtras = requiresReasoningContent
+        ? { extra_body: { interleaved: { field: 'reasoning_content' } } }
+        : {};
     if (providerBaseURL.includes('kimi.com') || providerBaseURL.includes('moonshot.ai')) {
         openaiTools.push({ type: 'builtin_function', function: { name: '$web_search' } });
         console.log('[agent:openai-tools] Injected Kimi $web_search builtin tool');
@@ -157,6 +172,7 @@ export async function chatWithToolsOpenAI(params, provider) {
                 tools: openaiTools,
                 max_tokens: options.maxTokens || 4096,
                 temperature: options.temperature,
+                ...kimiRequestExtras,
             });
             recordOpenAIUsage({
                 model: modelId,
@@ -171,16 +187,8 @@ export async function chatWithToolsOpenAI(params, provider) {
                 costDetails: toCostDetails(modelId, completion.usage),
             });
             genObs?.end();
-            // Guard: track token usage
-            const tokenResult = guard.recordTokens(completion.usage?.prompt_tokens ?? 0, completion.usage?.completion_tokens ?? 0);
-            if (tokenResult.warning)
-                console.warn(`[agent:openai-tools:guard] ${tokenResult.warning}`);
-            if (tokenResult.exceeded) {
-                return {
-                    response: `[Stopped: ${tokenResult.warning}]`,
-                    toolCalls: toolLog,
-                };
-            }
+            // Guard: track token usage (stats only, no enforcement)
+            guard.recordTokens(completion.usage?.prompt_tokens ?? 0, completion.usage?.completion_tokens ?? 0);
         }
         catch (err) {
             const errorMessage = err instanceof Error ? err.message : String(err);
@@ -224,14 +232,21 @@ export async function chatWithToolsOpenAI(params, provider) {
         // Kimi requires reasoning_content when thinking mode is enabled.
         const assistantToolCallMessage = {
             role: 'assistant',
-            content: message.content ?? '',
+            content: message.content ?? null,
             tool_calls: message.tool_calls,
         };
-        if (message.reasoning_content !== undefined) {
-            assistantToolCallMessage.reasoning_content = message.reasoning_content;
+        const rawReasoning = message.reasoning_content
+            ?? message.additional_kwargs?.reasoning_content
+            ?? message.reasoning?.content;
+        if (rawReasoning !== undefined && rawReasoning !== null) {
+            assistantToolCallMessage.reasoning_content = Array.isArray(rawReasoning)
+                ? rawReasoning.join('\n')
+                : String(rawReasoning);
         }
         else if (requiresReasoningContent) {
-            assistantToolCallMessage.reasoning_content = '';
+            // Some Kimi responses omit reasoning_content despite thinking mode.
+            // Send a placeholder to satisfy strict tool-call replay validation.
+            assistantToolCallMessage.reasoning_content = ' ';
         }
         apiMessages.push(assistantToolCallMessage);
         // Execute each tool call

package/dist/providers/tool-guard.d.ts

@@ -15,11 +15,8 @@ export declare class ToolCallGuard {
     recordResult(result: string): {
         nudge?: string;
     };
-    /** Record token usage. Returns exceeded flag if over budget. */
-    recordTokens(inputTokens: number, outputTokens: number): {
-        exceeded: boolean;
-        warning?: string;
-    };
+    /** Record token usage for stats tracking. */
+    recordTokens(inputTokens: number, outputTokens: number): void;
     /** Reset guard state (for testing or between turns). */
     reset(): void;
     /** Get current stats. */

package/dist/providers/tool-guard.js

@@ -1,17 +1,17 @@
-// ToolCallGuard — Spin detection, no-progress detection, token budget
+// ToolCallGuard — Spin detection, no-progress detection
 import { createHash } from 'crypto';
 const SPIN_WARN_THRESHOLD = 3;
 const SPIN_BLOCK_THRESHOLD = 5;
 const NO_PROGRESS_THRESHOLD = 5;
-const DEFAULT_MAX_TURN_TOKENS = 200_000;
 export class ToolCallGuard {
     callHistory = [];
     resultHashes = [];
     totalInputTokens = 0;
     totalOutputTokens = 0;
+    // Kept for future use — not currently enforced
     maxTurnTokens;
     constructor(maxTurnTokens) {
-        this.maxTurnTokens = maxTurnTokens ?? DEFAULT_MAX_TURN_TOKENS;
+        this.maxTurnTokens = maxTurnTokens;
     }
     hash(data) {
         return createHash('md5').update(data).digest('hex').slice(0, 16);
@@ -52,25 +52,10 @@ export class ToolCallGuard {
         }
         return {};
     }
-    /** Record token usage. Returns exceeded flag if over budget. */
+    /** Record token usage for stats tracking. */
     recordTokens(inputTokens, outputTokens) {
         this.totalInputTokens += inputTokens;
         this.totalOutputTokens += outputTokens;
-        const total = this.totalInputTokens + this.totalOutputTokens;
-        if (total >= this.maxTurnTokens) {
-            return {
-                exceeded: true,
-                warning: `Token budget exceeded: ${total} tokens used (limit: ${this.maxTurnTokens})`
-            };
-        }
-        // Warn at 80%
-        if (total >= this.maxTurnTokens * 0.8) {
-            return {
-                exceeded: false,
-                warning: `Token budget warning: ${total}/${this.maxTurnTokens} tokens used (${Math.round(total / this.maxTurnTokens * 100)}%)`
-            };
-        }
-        return { exceeded: false };
     }
     /** Reset guard state (for testing or between turns). */
     reset() {

package/dist/setup.js

@@ -284,7 +284,7 @@ function buildDefaultModel(providers) {
     if (providers.has('kimi-api'))
         return 'kimi/kimi-for-coding';
     if (providers.has('minimax-api'))
-        return 'minimax/MiniMax-M2.1';
+        return 'minimax/MiniMax-M2.5';
     return 'openai/gpt-4o';
 }
 function buildAliases(providers) {
@@ -307,7 +307,7 @@ function buildAliases(providers) {
         aliases.codex = 'codex/gpt-5.3-codex';
     }
     if (providers.has('minimax-api')) {
-        aliases.minimax = 'minimax/MiniMax-M2.1';
+        aliases.minimax = 'minimax/MiniMax-M2.5';
     }
     if (providers.has('kimi-api')) {
         aliases.kimi = 'kimi/kimi-for-coding';
@@ -398,7 +398,7 @@ export function buildSetupConfig(input) {
         },
         heartbeat: {
             intervalMs: 1800000,
-            prompt: 'Read HEARTBEAT.md. Follow it strictly. If nothing needs attention, reply HEARTBEAT_OK.',
+            prompt: 'Read ~/.skimpyclaw/agents/main/HEARTBEAT.md. Follow it strictly. If nothing needs attention, reply HEARTBEAT_OK.',
             tools: {
                 enabled: true,
                 allowedPaths: [
@@ -510,7 +510,7 @@ async function validateProviderAuth(providers, secrets) {
                     'content-type': 'application/json',
                     'anthropic-version': '2023-06-01',
                 },
-                body: JSON.stringify({ model: 'MiniMax-M2.1', max_tokens: 8, messages: [{ role: 'user', content: 'ping' }] }),
+                body: JSON.stringify({ model: 'MiniMax-M2.5', max_tokens: 8, messages: [{ role: 'user', content: 'ping' }] }),
             });
             checks.push({ name: 'MiniMax API', ok: res.ok, detail: res.ok ? 'auth ok' : `HTTP ${res.status}` });
         }

package/dist/voice.js

@@ -187,11 +187,19 @@ function getSTTProvider(config) {
     if (!providers || Object.keys(providers).length === 0) {
         return null;
     }
-    const providerName = config.defaultProvider || Object.keys(providers)[0];
-    const provider = providers[providerName];
-    if (!provider)
-        return null;
-    return { name: providerName, provider };
+    const isApiBackedSttProvider = (provider) => Boolean(provider && (provider.stt || provider.apiKey));
+    if (config.defaultProvider) {
+        const preferred = providers[config.defaultProvider];
+        if (isApiBackedSttProvider(preferred)) {
+            return { name: config.defaultProvider, provider: preferred };
+        }
+    }
+    for (const [name, provider] of Object.entries(providers)) {
+        if (isApiBackedSttProvider(provider)) {
+            return { name, provider };
+        }
+    }
+    return null;
 }
 /**
  * Resolve the API key, supporting ${ENV_VAR} syntax.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skimpyclaw",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Lightweight personal AI assistant with Telegram and Discord integration",
   "type": "module",
   "main": "dist/index.js",