kimaki 0.26.0 → 0.28.0

package/src/xai-auth-plugin.ts

@@ -1,3 +1,4 @@
+// LEGACY rotation, superseded by @subrouter/opencode. See oauth-rotation-shared.ts.
 /**
  * xAI OAuth rotation plugin for OpenCode.
  *

package/src/xai-auth-state.ts

@@ -1,3 +1,4 @@
+// LEGACY rotation, superseded by @subrouter/opencode. See oauth-rotation-shared.ts.
 /**
  * xAI OAuth account store and rotation.
  * Mirrors openai-auth-state.ts but for xAI/Grok OAuth accounts.

package/dist/message-finish-field.e2e.test.js

@@ -1,169 +0,0 @@
-// E2e test verifying that the opencode server populates the `finish` field
-// on assistant messages. This field is critical for kimaki's footer logic:
-// isAssistantMessageNaturalCompletion checks `message.finish !== 'tool-calls'`
-// to suppress footers on intermediate tool-call steps.
-// When `finish` is missing/null, every completed assistant message gets a
-// spurious footer, breaking multi-step tool chains (16 test failures).
-//
-// Direct SDK test — no Discord layer needed since this is a server-level bug.
-import fs from 'node:fs';
-import path from 'node:path';
-import url from 'node:url';
-import { test, expect, beforeAll, afterAll } from 'vitest';
-import { buildDeterministicOpencodeConfig, } from 'opencode-deterministic-provider';
-import { setDataDir } from './config.js';
-import { initializeOpencodeForDirectory, stopOpencodeServer } from './opencode.js';
-import { cleanupTestSessions, initTestGitRepo } from './test-utils.js';
-const ROOT = path.resolve(process.cwd(), 'tmp', 'finish-field-e2e');
-function createRunDirectories() {
-    fs.mkdirSync(ROOT, { recursive: true });
-    const dataDir = fs.mkdtempSync(path.join(ROOT, 'data-'));
-    const projectDirectory = path.join(ROOT, 'project');
-    fs.mkdirSync(projectDirectory, { recursive: true });
-    initTestGitRepo(projectDirectory);
-    return { dataDir, projectDirectory };
-}
-function createMatchers() {
-    // Tool-call step: finish="tool-calls"
-    const toolCallMatcher = {
-        id: 'finish-tool-call',
-        priority: 20,
-        when: {
-            lastMessageRole: 'user',
-            latestUserTextIncludes: 'FINISH_FIELD_TOOLCALL',
-        },
-        then: {
-            parts: [
-                { type: 'stream-start', warnings: [] },
-                { type: 'text-start', id: 'ft' },
-                { type: 'text-delta', id: 'ft', delta: 'calling tool' },
-                { type: 'text-end', id: 'ft' },
-                {
-                    type: 'tool-call',
-                    toolCallId: 'finish-bash',
-                    toolName: 'bash',
-                    input: JSON.stringify({ command: 'echo ok', description: 'test' }),
-                },
-                {
-                    type: 'finish',
-                    finishReason: 'tool-calls',
-                    usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
-                },
-            ],
-        },
-    };
-    // Follow-up after tool result: finish="stop"
-    const followupMatcher = {
-        id: 'finish-followup',
-        priority: 21,
-        when: {
-            lastMessageRole: 'tool',
-            latestUserTextIncludes: 'FINISH_FIELD_TOOLCALL',
-        },
-        then: {
-            parts: [
-                { type: 'stream-start', warnings: [] },
-                { type: 'text-start', id: 'ff' },
-                { type: 'text-delta', id: 'ff', delta: 'tool done' },
-                { type: 'text-end', id: 'ff' },
-                {
-                    type: 'finish',
-                    finishReason: 'stop',
-                    usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
-                },
-            ],
-        },
-    };
-    return [toolCallMatcher, followupMatcher];
-}
-let client;
-let directories;
-let testStartTime;
-beforeAll(async () => {
-    testStartTime = Date.now();
-    directories = createRunDirectories();
-    setDataDir(directories.dataDir);
-    const providerNpm = url
-        .pathToFileURL(path.resolve(process.cwd(), '..', 'opencode-deterministic-provider', 'src', 'index.ts'))
-        .toString();
-    const opencodeConfig = buildDeterministicOpencodeConfig({
-        providerName: 'deterministic-provider',
-        providerNpm,
-        model: 'deterministic-v2',
-        smallModel: 'deterministic-v2',
-        settings: { strict: false, matchers: createMatchers() },
-    });
-    fs.writeFileSync(path.join(directories.projectDirectory, 'opencode.json'), JSON.stringify(opencodeConfig, null, 2));
-    const getClient = await initializeOpencodeForDirectory(directories.projectDirectory);
-    if (getClient instanceof Error) {
-        throw getClient;
-    }
-    client = getClient();
-}, 20_000);
-afterAll(async () => {
-    await cleanupTestSessions({
-        projectDirectory: directories.projectDirectory,
-        testStartTime,
-    });
-    await stopOpencodeServer();
-}, 5_000);
-test('tool-call step has finish="tool-calls", follow-up has finish="stop"', async () => {
-    const session = await client.session.create({
-        directory: directories.projectDirectory,
-        title: 'finish-field-test',
-    });
-    const sessionID = session.data.id;
-    await client.session.promptAsync({
-        sessionID,
-        directory: directories.projectDirectory,
-        parts: [{ type: 'text', text: 'FINISH_FIELD_TOOLCALL' }],
-    });
-    // Poll until we have 2 completed assistant messages (tool-call + follow-up)
-    const maxWait = 8_000;
-    const pollStart = Date.now();
-    let completedAssistants = [];
-    while (Date.now() - pollStart < maxWait) {
-        const msgs = await client.session.messages({
-            sessionID,
-            directory: directories.projectDirectory,
-        });
-        completedAssistants = (msgs.data || [])
-            .filter((m) => {
-            return m.info.role === 'assistant' && m.info.time.completed;
-        })
-            .map((m) => {
-            return {
-                finish: m.info.finish ?? null,
-                partTypes: m.parts.map((p) => { return p.type; }),
-            };
-        });
-        if (completedAssistants.length >= 2) {
-            break;
-        }
-        await new Promise((resolve) => { setTimeout(resolve, 100); });
-    }
-    // Snapshot completed assistant messages — finish should NOT be null
-    expect(completedAssistants).toMatchInlineSnapshot(`
-    [
-      {
-        "finish": "tool-calls",
-        "partTypes": [
-          "step-start",
-          "text",
-          "tool",
-          "step-finish",
-        ],
-      },
-      {
-        "finish": "stop",
-        "partTypes": [
-          "step-start",
-          "text",
-          "step-finish",
-        ],
-      },
-    ]
-  `);
-    const finishes = completedAssistants.map((m) => { return m.finish; });
-    expect(finishes).toEqual(['tool-calls', 'stop']);
-}, 5_000);

package/dist/subagent-rate-limit-plugin.js

@@ -1,184 +0,0 @@
-// OpenCode plugin that aborts task-created subagent sessions after rate limits.
-import { appendToastSessionMarker, createPluginLogger, formatPluginErrorWithStack, setPluginLogFilePath, } from './plugin-logger.js';
-import { createPluginClient } from './plugin-opencode-client.js';
-import { initSentry, notifyError } from './sentry.js';
-const logger = createPluginLogger('SUBMODEL');
-const RATE_LIMIT_TEXT_PATTERNS = [
-    'rate_limit',
-    'rate limit',
-    'resource exhausted',
-    'retry after',
-    'too many requests',
-    'quota exceeded',
-    'balance exhausted',
-    'spending-limit',
-    'run out of credits',
-];
-function isRateLimitText(text) {
-    if (!text) {
-        return false;
-    }
-    const haystack = text.toLowerCase();
-    return RATE_LIMIT_TEXT_PATTERNS.some((pattern) => {
-        return haystack.includes(pattern);
-    });
-}
-function getTaskChildSession(event) {
-    if (event.type !== 'message.part.updated') {
-        return undefined;
-    }
-    const part = event.properties.part;
-    if (part.type !== 'tool' || part.tool !== 'task' || part.state.status === 'pending') {
-        return undefined;
-    }
-    const childSessionId = part.state.metadata?.sessionId;
-    if (typeof childSessionId !== 'string' || childSessionId.length === 0) {
-        return undefined;
-    }
-    const subagentType = part.state.input?.subagent_type;
-    return {
-        childSessionId,
-        subagentType: typeof subagentType === 'string' ? subagentType : undefined,
-    };
-}
-function getEventSessionId(event) {
-    if (event.type === 'session.status' || event.type === 'session.idle') {
-        return event.properties.sessionID;
-    }
-    if (event.type === 'session.error') {
-        return event.properties.sessionID;
-    }
-    if (event.type === 'message.updated') {
-        return event.properties.info.sessionID;
-    }
-    if (event.type === 'message.part.updated') {
-        return event.properties.part.sessionID;
-    }
-    if (event.type === 'session.created'
-        || event.type === 'session.updated'
-        || event.type === 'session.deleted') {
-        return event.properties.info.id;
-    }
-    return undefined;
-}
-function extractRateLimitReason(event) {
-    if (event.type === 'session.status' && event.properties.status.type === 'retry') {
-        return isRateLimitText(event.properties.status.message)
-            ? event.properties.status.message
-            : undefined;
-    }
-    if (event.type === 'message.part.updated' && event.properties.part.type === 'retry') {
-        const retryError = event.properties.part.error;
-        if (retryError.data.statusCode === 429 || retryError.data.statusCode === 402) {
-            return retryError.data.message;
-        }
-        if (isRateLimitText(retryError.data.responseBody)) {
-            return retryError.data.responseBody;
-        }
-        return isRateLimitText(retryError.data.message)
-            ? retryError.data.message
-            : undefined;
-    }
-    const apiError = (() => {
-        if (event.type === 'session.error' && event.properties.error?.name === 'APIError') {
-            return event.properties.error.data;
-        }
-        if (event.type === 'message.updated'
-            && event.properties.info.role === 'assistant'
-            && event.properties.info.error?.name === 'APIError') {
-            return event.properties.info.error.data;
-        }
-        return undefined;
-    })();
-    if (!apiError) {
-        return undefined;
-    }
-    if (apiError.statusCode === 429 || apiError.statusCode === 402) {
-        return apiError.message;
-    }
-    // xAI returns 403 with spending-limit or run out of credits text.
-    // Only treat 403 as a usage limit if the body matches specific patterns,
-    // not all 403s (which can be auth errors handled elsewhere).
-    if (apiError.statusCode === 403) {
-        const errorText = [apiError.message, apiError.responseBody].filter(Boolean).join(' ');
-        if (isRateLimitText(errorText))
-            return apiError.message;
-    }
-    if (isRateLimitText(apiError.responseBody)) {
-        return apiError.responseBody;
-    }
-    return isRateLimitText(apiError.message) ? apiError.message : undefined;
-}
-export const subagentRateLimitPlugin = async ({ serverUrl, directory }) => {
-    initSentry();
-    const dataDir = process.env.KIMAKI_DATA_DIR;
-    if (dataDir) {
-        setPluginLogFilePath(dataDir);
-    }
-    // Build our own v2 client. The plugin-provided ctx.client (v1) does not
-    // reliably make REST calls (session.abort silently no-ops) from inside the
-    // plugin process. See plugin-opencode-client.ts.
-    const client = createPluginClient({ serverUrl, directory });
-    logger.bindClient(client);
-    const subagentSessions = new Map();
-    return {
-        event: async ({ event }) => {
-            const taskChild = getTaskChildSession(event);
-            if (taskChild) {
-                const existing = subagentSessions.get(taskChild.childSessionId);
-                if (existing) {
-                    if (taskChild.subagentType) {
-                        existing.subagentType = taskChild.subagentType;
-                    }
-                }
-                else {
-                    subagentSessions.set(taskChild.childSessionId, {
-                        subagentType: taskChild.subagentType,
-                        aborting: false,
-                    });
-                }
-            }
-            const eventSessionId = getEventSessionId(event);
-            if (!eventSessionId) {
-                return;
-            }
-            if (event.type === 'session.deleted' || event.type === 'session.idle') {
-                subagentSessions.delete(eventSessionId);
-                return;
-            }
-            const rateLimitReason = extractRateLimitReason(event);
-            if (!rateLimitReason) {
-                return;
-            }
-            const subagent = subagentSessions.get(eventSessionId);
-            if (!subagent || subagent.aborting) {
-                return;
-            }
-            subagent.aborting = true;
-            const abortResult = await (async () => {
-                await client.session.abort({ sessionID: eventSessionId, directory });
-                await client.tui.showToast({
-                    message: appendToastSessionMarker({
-                        message: `Aborting ${subagent.subagentType || 'subagent'} after rate limit so the parent task can recover: ${rateLimitReason}`,
-                        sessionId: eventSessionId,
-                    }),
-                    variant: 'info',
-                }).catch(() => {
-                    return;
-                });
-                logger.info(`Aborted subagent ${eventSessionId} after rate limit`);
-            })()
-                .catch((error) => {
-                return new Error('Subagent rate-limit abort failed', {
-                    cause: error,
-                });
-            });
-            subagentSessions.delete(eventSessionId);
-            if (!(abortResult instanceof Error)) {
-                return;
-            }
-            logger.warn(`[subagent-rate-limit-plugin] ${formatPluginErrorWithStack(abortResult)}`);
-            void notifyError(abortResult, 'subagent rate-limit plugin abort failed');
-        },
-    };
-};

package/src/message-finish-field.e2e.test.ts

@@ -1,196 +0,0 @@
-// E2e test verifying that the opencode server populates the `finish` field
-// on assistant messages. This field is critical for kimaki's footer logic:
-// isAssistantMessageNaturalCompletion checks `message.finish !== 'tool-calls'`
-// to suppress footers on intermediate tool-call steps.
-// When `finish` is missing/null, every completed assistant message gets a
-// spurious footer, breaking multi-step tool chains (16 test failures).
-//
-// Direct SDK test — no Discord layer needed since this is a server-level bug.
-
-import fs from 'node:fs'
-import path from 'node:path'
-import url from 'node:url'
-import { test, expect, beforeAll, afterAll } from 'vitest'
-import type { OpencodeClient } from '@opencode-ai/sdk/v2'
-import {
-  buildDeterministicOpencodeConfig,
-  type DeterministicMatcher,
-} from 'opencode-deterministic-provider'
-import { setDataDir } from './config.js'
-import { initializeOpencodeForDirectory, stopOpencodeServer } from './opencode.js'
-import { cleanupTestSessions, initTestGitRepo } from './test-utils.js'
-
-const ROOT = path.resolve(process.cwd(), 'tmp', 'finish-field-e2e')
-
-function createRunDirectories() {
-  fs.mkdirSync(ROOT, { recursive: true })
-  const dataDir = fs.mkdtempSync(path.join(ROOT, 'data-'))
-  const projectDirectory = path.join(ROOT, 'project')
-  fs.mkdirSync(projectDirectory, { recursive: true })
-  initTestGitRepo(projectDirectory)
-  return { dataDir, projectDirectory }
-}
-
-function createMatchers(): DeterministicMatcher[] {
-  // Tool-call step: finish="tool-calls"
-  const toolCallMatcher: DeterministicMatcher = {
-    id: 'finish-tool-call',
-    priority: 20,
-    when: {
-      lastMessageRole: 'user',
-      latestUserTextIncludes: 'FINISH_FIELD_TOOLCALL',
-    },
-    then: {
-      parts: [
-        { type: 'stream-start', warnings: [] },
-        { type: 'text-start', id: 'ft' },
-        { type: 'text-delta', id: 'ft', delta: 'calling tool' },
-        { type: 'text-end', id: 'ft' },
-        {
-          type: 'tool-call',
-          toolCallId: 'finish-bash',
-          toolName: 'bash',
-          input: JSON.stringify({ command: 'echo ok', description: 'test' }),
-        },
-        {
-          type: 'finish',
-          finishReason: 'tool-calls',
-          usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
-        },
-      ],
-    },
-  }
-
-  // Follow-up after tool result: finish="stop"
-  const followupMatcher: DeterministicMatcher = {
-    id: 'finish-followup',
-    priority: 21,
-    when: {
-      lastMessageRole: 'tool',
-      latestUserTextIncludes: 'FINISH_FIELD_TOOLCALL',
-    },
-    then: {
-      parts: [
-        { type: 'stream-start', warnings: [] },
-        { type: 'text-start', id: 'ff' },
-        { type: 'text-delta', id: 'ff', delta: 'tool done' },
-        { type: 'text-end', id: 'ff' },
-        {
-          type: 'finish',
-          finishReason: 'stop',
-          usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
-        },
-      ],
-    },
-  }
-
-  return [toolCallMatcher, followupMatcher]
-}
-
-let client: OpencodeClient
-let directories: ReturnType<typeof createRunDirectories>
-let testStartTime: number
-
-beforeAll(async () => {
-  testStartTime = Date.now()
-  directories = createRunDirectories()
-  setDataDir(directories.dataDir)
-
-  const providerNpm = url
-    .pathToFileURL(
-      path.resolve(process.cwd(), '..', 'opencode-deterministic-provider', 'src', 'index.ts'),
-    )
-    .toString()
-
-  const opencodeConfig = buildDeterministicOpencodeConfig({
-    providerName: 'deterministic-provider',
-    providerNpm,
-    model: 'deterministic-v2',
-    smallModel: 'deterministic-v2',
-    settings: { strict: false, matchers: createMatchers() },
-  })
-  fs.writeFileSync(
-    path.join(directories.projectDirectory, 'opencode.json'),
-    JSON.stringify(opencodeConfig, null, 2),
-  )
-
-  const getClient = await initializeOpencodeForDirectory(directories.projectDirectory)
-  if (getClient instanceof Error) {
-    throw getClient
-  }
-  client = getClient()
-}, 20_000)
-
-afterAll(async () => {
-  await cleanupTestSessions({
-    projectDirectory: directories.projectDirectory,
-    testStartTime,
-  })
-  await stopOpencodeServer()
-}, 5_000)
-
-test('tool-call step has finish="tool-calls", follow-up has finish="stop"', async () => {
-  const session = await client.session.create({
-    directory: directories.projectDirectory,
-    title: 'finish-field-test',
-  })
-  const sessionID = session.data!.id
-
-  await client.session.promptAsync({
-    sessionID,
-    directory: directories.projectDirectory,
-    parts: [{ type: 'text', text: 'FINISH_FIELD_TOOLCALL' }],
-  })
-
-  // Poll until we have 2 completed assistant messages (tool-call + follow-up)
-  const maxWait = 8_000
-  const pollStart = Date.now()
-  let completedAssistants: Array<{ finish: string | null; partTypes: string[] }> = []
-
-  while (Date.now() - pollStart < maxWait) {
-    const msgs = await client.session.messages({
-      sessionID,
-      directory: directories.projectDirectory,
-    })
-    completedAssistants = (msgs.data || [])
-      .filter((m) => {
-        return m.info.role === 'assistant' && m.info.time.completed
-      })
-      .map((m) => {
-        return {
-          finish: (m.info as Record<string, unknown>).finish as string | null ?? null,
-          partTypes: m.parts.map((p) => { return p.type }),
-        }
-      })
-    if (completedAssistants.length >= 2) {
-      break
-    }
-    await new Promise((resolve) => { setTimeout(resolve, 100) })
-  }
-
-  // Snapshot completed assistant messages — finish should NOT be null
-  expect(completedAssistants).toMatchInlineSnapshot(`
-    [
-      {
-        "finish": "tool-calls",
-        "partTypes": [
-          "step-start",
-          "text",
-          "tool",
-          "step-finish",
-        ],
-      },
-      {
-        "finish": "stop",
-        "partTypes": [
-          "step-start",
-          "text",
-          "step-finish",
-        ],
-      },
-    ]
-  `)
-
-  const finishes = completedAssistants.map((m) => { return m.finish })
-  expect(finishes).toEqual(['tool-calls', 'stop'])
-}, 5_000)