Support Venice Kimi model completions

Author: trilltino

LLM.md

@@ -52,6 +52,18 @@ All live in the repo-root **`.env`** (gitignored - never committed). `.env.examp
 Default models (override with `LLM_MODEL`): Venice `llama-3.3-70b` — OpenAI `gpt-4o-mini` — Anthropic
 `claude-haiku-4-5-20251001`.
 
+Venice code/reasoning models such as `kimi-k2-7-code` work too:
+
+```ini
+LLM_PROVIDER=venice
+VENICE_API_KEY=...
+LLM_MODEL=kimi-k2-7-code
+```
+
+Kimi may spend a small completion budget on internal reasoning before emitting `message.content`, so
+the runtime automatically raises too-low Venice/Kimi `maxTokens` requests to `1024`. Other providers
+and non-Kimi Venice models keep the caller's requested budget.
+
 ## Set it up — copy/paste
 
 **Venice AI — the kit's LLM (recommended, free credits):**

packages/agent-runtime/src/llm/complete.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, afterEach, vi } from 'vitest'
-import { pickProvider, parseJsonReply, complete } from './complete.js'
+import { pickProvider, parseJsonReply, complete, effectiveMaxTokens } from './complete.js'
 
 const env = { ...process.env }
 afterEach(() => {
@@ -60,6 +60,29 @@ describe('complete model resolution', () => {
     }
     expect(sentModel).toBe('claude-haiku-4-5-20251001') // not "" (which Anthropic 400s)
   })
+
+  it('raises too-small Venice Kimi budgets so reasoning models can emit content', async () => {
+    process.env.LLM_PROVIDER = 'venice'
+    process.env.VENICE_API_KEY = 'k'
+    process.env.LLM_MODEL = 'kimi-k2-7-code'
+    let sentMaxTokens = 0
+    const realFetch = global.fetch
+    global.fetch = vi.fn(async (_url: unknown, init?: { body?: string }) => {
+      sentMaxTokens = JSON.parse(init?.body ?? '{}').max_tokens
+      return { ok: true, json: async () => ({ choices: [{ message: { content: '{"ok":true}' } }] }) }
+    }) as unknown as typeof fetch
+    try {
+      await complete({ system: 's', user: 'u', maxTokens: 120 })
+    } finally {
+      global.fetch = realFetch
+    }
+    expect(sentMaxTokens).toBe(1024)
+  })
+
+  it('leaves non-Kimi token budgets alone', () => {
+    expect(effectiveMaxTokens('venice', 'llama-3.3-70b', 120)).toBe(120)
+    expect(effectiveMaxTokens('openai', 'kimi-k2-7-code', 120)).toBe(120)
+  })
 })
 
 describe('parseJsonReply', () => {

packages/agent-runtime/src/llm/complete.ts

@@ -2,8 +2,8 @@
  * LLM pillar — one provider-agnostic `complete()` call.
  *
  * SDK-free (`fetch`-based) so the runtime stays dependency-light. Provider is chosen by env, so the
- * whole market flips from Anthropic (dev default) to the sponsored OpenAI key with `LLM_PROVIDER=openai`
- * (or to Venice AI with `LLM_PROVIDER=venice`) and no code change. Callers ask for a single JSON-shaped
+ * whole market flips to Venice AI with `LLM_PROVIDER=venice` (or OpenAI/Anthropic) and no code change.
+ * Callers ask for a single JSON-shaped
  * answer and enforce their own guards on it — the model proposes, code disposes.
  *
  * To add a provider in code: extend `LlmProvider`, add a `DEFAULT_MODEL` entry, teach `pickProvider()`
@@ -27,6 +27,18 @@ const DEFAULT_MODEL: Record<LlmProvider, string> = {
   venice: 'llama-3.3-70b',
 }
 
+const KIMI_MIN_COMPLETION_TOKENS = 1024
+
+/**
+ * Venice-hosted Kimi code models can spend small budgets on internal reasoning before emitting
+ * `message.content`. Keep caller limits for other models, but give Kimi enough room to finish JSON.
+ */
+export function effectiveMaxTokens(provider: LlmProvider, model: string, requested: number): number {
+  return provider === 'venice' && /kimi/i.test(model) && requested < KIMI_MIN_COMPLETION_TOKENS
+    ? KIMI_MIN_COMPLETION_TOKENS
+    : requested
+}
+
 export interface CompleteOpts {
   system: string
   user: string
@@ -43,9 +55,10 @@ export async function complete(opts: CompleteOpts): Promise<string> {
   const provider = pickProvider()
   // `||` not `??`: coral manifests default unset options to "" — an empty LLM_MODEL must not win.
   const model = opts.model || process.env.LLM_MODEL || DEFAULT_MODEL[provider]
-  const maxTokens = opts.maxTokens ?? 512
+  const requestedMaxTokens = opts.maxTokens ?? 512
+  const maxTokens = effectiveMaxTokens(provider, model, requestedMaxTokens)
   const trace = process.env.TRACE === '1'
-  if (trace) console.error(`[llm] provider=${provider} model=${model}`)
+  if (trace) console.error(`[llm] provider=${provider} model=${model} maxTokens=${maxTokens}`)
 
   const text = provider === 'openai'
     ? await completeOpenAI(opts, model, maxTokens)