pikiloom 0.4.41 → 0.4.42

package/dist/bot/command-ui.js

@@ -2,6 +2,7 @@ import { normalizeAgent } from './bot.js';
 import { getDriverCapabilities } from '../agent/driver.js';
 import { getSessionStatusForChat } from './session-status.js';
 import { getAgentsListData, getModelsListData, getSessionsPageData, getSkillsListData, summarizeSessionRun, modelMatchesSelection, resolveSkillPrompt, } from './commands.js';
+import { accountAgentSupported, listAccounts, getAccount, getActiveAccountId, setActiveAccount, warmAccountUsages, accountUsageSummary, } from '../agent/accounts.js';
 function chunkRows(items, columns) {
     const rows = [];
     const size = Math.max(1, columns);
@@ -28,6 +29,8 @@ export function encodeCommandAction(action) {
             return `sess:${action.sessionId}`;
         case 'agent.switch':
             return `ag:${action.agent}`;
+        case 'agent.account.set':
+            return `agacc:${action.agent}:${action.accountId ?? ''}`;
         case 'model.switch':
             return `mod:${action.modelId}`;
         case 'effort.set':
@@ -63,6 +66,18 @@ export function decodeCommandAction(data) {
             return null;
         return { kind: 'session.switch', sessionId };
     }
+    if (data.startsWith('agacc:')) {
+        const rest = data.slice(6);
+        const sep = rest.indexOf(':');
+        if (sep < 0)
+            return null;
+        try {
+            return { kind: 'agent.account.set', agent: normalizeAgent(rest.slice(0, sep)), accountId: rest.slice(sep + 1) || null };
+        }
+        catch {
+            return null;
+        }
+    }
     if (data.startsWith('ag:')) {
         try {
             return { kind: 'agent.switch', agent: normalizeAgent(data.slice(3)) };
@@ -194,15 +209,43 @@ export function buildAgentsCommandView(bot, chatId) {
         };
     });
     const current = installed.find(a => a.isCurrent);
+    // For the current agent, if it has local accounts (claude), surface them so the user can
+    // switch the active account right here — labelled with 👤 and each account's live usage.
+    const accountRows = [];
+    const accountItems = [];
+    const curAgent = data.currentAgent;
+    if (accountAgentSupported(curAgent)) {
+        const accs = listAccounts(curAgent);
+        if (accs.length) {
+            warmAccountUsages(curAgent);
+            const activeAccId = getActiveAccountId(curAgent);
+            const entry = (label, accountId, summary) => {
+                const isActive = accountId === activeAccId;
+                accountRows.push([{
+                        label: summary ? `👤 ${label} · ${summary}` : `👤 ${label}`,
+                        action: { kind: 'agent.account.set', agent: curAgent, accountId },
+                        state: isActive ? 'current' : 'default',
+                        primary: isActive,
+                    }]);
+                accountItems.push({ label: `👤 ${label}`, detail: summary, state: isActive ? 'current' : 'default' });
+            };
+            for (const acc of accs)
+                entry(acc.label, acc.id, accountUsageSummary(curAgent, acc.id));
+            entry('Default login', null, null);
+        }
+    }
+    const helperText = actions.length
+        ? (accountRows.length ? 'Tap an agent to switch · 👤 = account' : 'Tap an agent to switch.')
+        : undefined;
     return {
         kind: 'agents',
         title: 'Agents',
         detail: current ? current.label : undefined,
         metaLines: current ? [`Current: ${current.label}`] : [],
-        items,
+        items: [...items, ...accountItems],
         emptyText: actions.length ? undefined : 'No installed agents.',
-        helperText: actions.length ? 'Tap an agent to switch.' : undefined,
-        rows: actions.map(action => [action]),
+        helperText,
+        rows: [...actions.map(action => [action]), ...accountRows],
     };
 }
 const modelsDrafts = new Map();
@@ -434,9 +477,18 @@ export async function executeCommandAction(bot, chatId, action, opts = {}) {
         }
         case 'agent.switch': {
             const chat = bot.chat(chatId);
-            if (chat.agent === action.agent)
+            const hasAccounts = accountAgentSupported(action.agent) && listAccounts(action.agent).length > 0;
+            if (chat.agent === action.agent) {
+                // Already current: reopen the menu (now showing accounts) if it has any, else no-op.
+                if (hasAccounts)
+                    return { kind: 'view', view: buildAgentsCommandView(bot, chatId), callbackText: '' };
                 return { kind: 'noop', message: `Already using ${action.agent}` };
+            }
             bot.switchAgentForChat(chatId, action.agent);
+            // For an account-capable agent, drop the user straight into its account picker.
+            if (hasAccounts) {
+                return { kind: 'view', view: buildAgentsCommandView(bot, chatId), callbackText: `Switched to ${action.agent}` };
+            }
             const resumed = bot.selectedSession(chatId);
             return {
                 kind: 'notice',
@@ -453,6 +505,19 @@ export async function executeCommandAction(bot, chatId, action, opts = {}) {
                     : null,
             };
         }
+        case 'agent.account.set': {
+            if (!accountAgentSupported(action.agent))
+                return { kind: 'noop', message: `${action.agent} has no accounts` };
+            try {
+                setActiveAccount(action.agent, action.accountId);
+            }
+            catch (e) {
+                return { kind: 'noop', message: e?.message || 'Switch failed' };
+            }
+            warmAccountUsages(action.agent);
+            const label = action.accountId ? (getAccount(action.agent, action.accountId)?.label ?? action.accountId) : 'Default login';
+            return { kind: 'view', view: buildAgentsCommandView(bot, chatId), callbackText: `Account → ${label}` };
+        }
         case 'model.switch': {
             const chat = bot.chat(chatId);
             const currentModel = bot.modelForAgent(chat.agent);

package/dist/cli/kernel-app.js

@@ -19,13 +19,14 @@ const DEMO_MODELS = {
     claude: [{ id: 'claude-opus-4-8', label: 'Opus 4.8', providerName: 'anthropic', contextWindow: 200000 }],
     codex: [{ id: 'gpt-5.5-codex', label: 'GPT-5.5 Codex', providerName: 'openai', contextWindow: 400000 }],
     gemini: [{ id: 'gemini-2.5-pro', label: 'Gemini 2.5 Pro', providerName: 'google', contextWindow: 1000000 }],
+    opencode: [{ id: 'claude-sonnet-4-6', label: 'OpenCode · Sonnet 4.6 (ACP)', providerName: 'opencode', contextWindow: 200000 }],
     echo: [{ id: 'echo-1', label: 'Echo (hermetic)', providerName: 'local', contextWindow: 8192 }],
 };
 export async function runKernelApp(argv) {
     const i = argv.indexOf('--dashboard-port');
     const port = (i >= 0 && parseInt(argv[i + 1], 10)) || 3940;
     const k = await loadKernel();
-    const { createLoom, ClaudeDriver, CodexDriver, GeminiDriver, HermesDriver, EchoDriver, WebSurface } = k;
+    const { createLoom, ClaudeDriver, CodexDriver, GeminiDriver, HermesDriver, AcpDriver, EchoDriver, WebSurface } = k;
     // Load providers/profiles so the active BYOK/豆包 bindings are visible to the resolver.
     try {
         applyUserConfig(loadUserConfig(), undefined, { overwrite: true, clearMissing: true });
@@ -100,7 +101,8 @@ export async function runKernelApp(argv) {
     const surfaces = [web];
     const loom = createLoom({
         appNamespace: 'pikiloom-kernel',
-        drivers: [new EchoDriver(), new ClaudeDriver(), new CodexDriver(), new GeminiDriver(), new HermesDriver()],
+        // OpenCode (and any other ACP CLI) plugs in via the generic AcpDriver — same registry as the natives.
+        drivers: [new EchoDriver(), new ClaudeDriver(), new CodexDriver(), new GeminiDriver(), new HermesDriver(), new AcpDriver({ id: 'opencode', command: 'opencode', args: ['acp'] })],
         defaultAgent: 'claude',
         surfaces,
         catalog,

package/dist/dashboard/routes/accounts.js

@@ -0,0 +1,113 @@
+import { Hono } from 'hono';
+import { allDriverIds } from '../../agent/index.js';
+import { accountAgentSupported, listAccounts, getAccount, addAccount, updateAccount, removeAccount, getActiveAccountId, setActiveAccount, probeAccountUsage, MAX_ACCOUNTS_PER_AGENT, } from '../../agent/accounts.js';
+const app = new Hono();
+function agentError(agent) {
+    if (!allDriverIds().includes(agent))
+        return { status: 400, msg: `Unknown agent: ${agent}` };
+    if (!accountAgentSupported(agent))
+        return { status: 400, msg: `Agent ${agent} does not support multiple accounts` };
+    return null;
+}
+// Never returns the token — only the display name, usage, and active flag.
+async function publicAccount(agent, rec, activeId) {
+    return {
+        id: rec.id,
+        label: rec.label,
+        createdAt: rec.createdAt,
+        lastUsedAt: rec.lastUsedAt ?? null,
+        active: rec.id === activeId,
+        usage: await probeAccountUsage(agent, rec.id),
+    };
+}
+app.get('/api/agents/:agent/accounts', async (c) => {
+    const agent = c.req.param('agent');
+    if (!allDriverIds().includes(agent))
+        return c.json({ ok: false, error: `Unknown agent: ${agent}` }, 400);
+    if (!accountAgentSupported(agent)) {
+        return c.json({ ok: true, agent, supported: false, accounts: [], activeAccountId: null, max: MAX_ACCOUNTS_PER_AGENT });
+    }
+    const activeId = getActiveAccountId(agent);
+    const accounts = await Promise.all(listAccounts(agent).map(r => publicAccount(agent, r, activeId)));
+    return c.json({ ok: true, agent, supported: true, accounts, activeAccountId: activeId, max: MAX_ACCOUNTS_PER_AGENT });
+});
+app.post('/api/agents/:agent/accounts', async (c) => {
+    const agent = c.req.param('agent');
+    const err = agentError(agent);
+    if (err)
+        return c.json({ ok: false, error: err.msg }, err.status);
+    let body = {};
+    try {
+        body = await c.req.json();
+    }
+    catch {
+        body = {};
+    }
+    try {
+        const rec = await addAccount(agent, String(body.label || ''), String(body.token || ''));
+        return c.json({ ok: true, account: await publicAccount(agent, rec, getActiveAccountId(agent)) });
+    }
+    catch (e) {
+        return c.json({ ok: false, error: e?.message || String(e) }, 400);
+    }
+});
+app.patch('/api/agents/:agent/accounts/:id', async (c) => {
+    const agent = c.req.param('agent');
+    const id = c.req.param('id');
+    const err = agentError(agent);
+    if (err)
+        return c.json({ ok: false, error: err.msg }, err.status);
+    if (!getAccount(agent, id))
+        return c.json({ ok: false, error: 'Account not found' }, 404);
+    let body = {};
+    try {
+        body = await c.req.json();
+    }
+    catch {
+        body = {};
+    }
+    try {
+        const rec = await updateAccount(agent, id, {
+            label: typeof body.label === 'string' ? body.label : undefined,
+            token: typeof body.token === 'string' && body.token.trim() ? body.token : undefined,
+        });
+        return c.json({ ok: true, account: await publicAccount(agent, rec, getActiveAccountId(agent)) });
+    }
+    catch (e) {
+        return c.json({ ok: false, error: e?.message || String(e) }, 400);
+    }
+});
+app.delete('/api/agents/:agent/accounts/:id', async (c) => {
+    const agent = c.req.param('agent');
+    const id = c.req.param('id');
+    const err = agentError(agent);
+    if (err)
+        return c.json({ ok: false, error: err.msg }, err.status);
+    if (!(await removeAccount(agent, id)))
+        return c.json({ ok: false, error: 'Account not found' }, 404);
+    return c.json({ ok: true });
+});
+app.post('/api/agents/:agent/active-account', async (c) => {
+    const agent = c.req.param('agent');
+    const err = agentError(agent);
+    if (err)
+        return c.json({ ok: false, error: err.msg }, err.status);
+    let body = {};
+    try {
+        body = await c.req.json();
+    }
+    catch {
+        body = {};
+    }
+    const accountId = body.accountId === null ? null : (typeof body.accountId === 'string' ? body.accountId : undefined);
+    if (accountId === undefined)
+        return c.json({ ok: false, error: 'accountId (string|null) is required' }, 400);
+    try {
+        setActiveAccount(agent, accountId);
+        return c.json({ ok: true, agent, activeAccountId: accountId });
+    }
+    catch (e) {
+        return c.json({ ok: false, error: e?.message || String(e) }, 400);
+    }
+});
+export default app;

package/dist/dashboard/server.js

@@ -13,6 +13,7 @@ import extensionRoutes from './routes/extensions.js';
 import cliRoutes from './routes/cli.js';
 import modelsRoutes from './routes/models.js';
 import localModelsRoutes from './routes/local-models.js';
+import accountsRoutes from './routes/accounts.js';
 import { runtime } from './runtime.js';
 import { registerProcessRuntime } from '../core/process-control.js';
 import { mountPikichannel } from '../pikichannel/server.js';
@@ -30,6 +31,7 @@ export async function startDashboard(opts = {}) {
     app.route('/', cliRoutes);
     app.route('/', modelsRoutes);
     app.route('/', localModelsRoutes);
+    app.route('/', accountsRoutes);
     let pikichannel = null;
     try {
         pikichannel = await mountPikichannel(app);

package/dist/model/responses-bridge.js

@@ -137,7 +137,33 @@ async function handleResponses(req, res, upstreamBase, body) {
     const tools = new Map();
     let usage = null;
     const finalItems = [];
+    // Reasoning ("thinking") from chat-only providers arrives as delta.reasoning_content
+    // (DeepSeek / 豆包) or delta.reasoning (GLM / OpenRouter). Translate it to the Responses
+    // reasoning-summary stream so codex surfaces item/reasoning/summaryTextDelta live; without
+    // this the entire thinking phase is silent and the answer looks like it appears all at once.
+    let reasoningOpen = false, reasoningDone = false, reasoningId = '', reasoningIndex = 0, reasoningText = '';
+    const openReasoning = () => {
+        if (reasoningOpen || reasoningDone)
+            return;
+        reasoningOpen = true;
+        reasoningId = genId('rs');
+        reasoningIndex = nextIndex++;
+        emit('response.output_item.added', { output_index: reasoningIndex, item: { id: reasoningId, type: 'reasoning', summary: [] } });
+        emit('response.reasoning_summary_part.added', { item_id: reasoningId, output_index: reasoningIndex, summary_index: 0, part: { type: 'summary_text', text: '' } });
+    };
+    const closeReasoning = () => {
+        if (!reasoningOpen)
+            return;
+        reasoningOpen = false;
+        reasoningDone = true;
+        emit('response.reasoning_summary_text.done', { item_id: reasoningId, output_index: reasoningIndex, summary_index: 0, text: reasoningText });
+        emit('response.reasoning_summary_part.done', { item_id: reasoningId, output_index: reasoningIndex, summary_index: 0, part: { type: 'summary_text', text: reasoningText } });
+        const item = { id: reasoningId, type: 'reasoning', summary: reasoningText ? [{ type: 'summary_text', text: reasoningText }] : [] };
+        emit('response.output_item.done', { output_index: reasoningIndex, item });
+        finalItems.push(item);
+    };
     const openMsg = () => {
+        closeReasoning(); // a reasoning item must finish before the message item opens (ordered output)
         if (msgOpen)
             return;
         msgOpen = true;
@@ -178,12 +204,22 @@ async function handleResponses(req, res, upstreamBase, body) {
                 if (!choice)
                     continue;
                 const delta = choice.delta || {};
+                const reasoningChunk = typeof delta.reasoning_content === 'string' ? delta.reasoning_content
+                    : typeof delta.reasoning === 'string' ? delta.reasoning : '';
+                if (reasoningChunk && !msgOpen && tools.size === 0) {
+                    openReasoning();
+                    if (reasoningOpen) {
+                        reasoningText += reasoningChunk;
+                        emit('response.reasoning_summary_text.delta', { item_id: reasoningId, output_index: reasoningIndex, summary_index: 0, delta: reasoningChunk });
+                    }
+                }
                 if (typeof delta.content === 'string' && delta.content) {
                     openMsg();
                     msgText += delta.content;
                     emit('response.output_text.delta', { item_id: msgId, output_index: msgIndex, content_index: 0, delta: delta.content });
                 }
                 if (Array.isArray(delta.tool_calls)) {
+                    closeReasoning(); // tool calls follow the thinking phase; close the reasoning item first
                     for (const tc of delta.tool_calls) {
                         const idx = typeof tc.index === 'number' ? tc.index : 0;
                         let st = tools.get(idx);
@@ -213,6 +249,7 @@ async function handleResponses(req, res, upstreamBase, body) {
     catch (e) {
         warn(`stream read error: ${e?.message || e}`);
     }
+    closeReasoning(); // reasoning-only turn (no content/tools followed): finish the reasoning item
     if (msgOpen) {
         emit('response.output_text.done', { item_id: msgId, output_index: msgIndex, content_index: 0, text: msgText });
         const item = { id: msgId, type: 'message', role: 'assistant', content: [{ type: 'output_text', text: msgText }] };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pikiloom",
-  "version": "0.4.41",
+  "version": "0.4.42",
   "description": "Put the world's smartest AI agents in your pocket. Command local Claude & Gemini via IM. | 让最好用的 IM 变成你电脑上的顶级 Agent 控制台",
   "type": "module",
   "bin": {

package/packages/kernel/dist/accounts.d.ts

@@ -0,0 +1,6 @@
+/** Whether this agent's local accounts are switched by injecting a token. */
+export declare function accountTokenSupported(agent: string): boolean;
+/** The env-var name that overrides this agent's subscription identity, or null. */
+export declare function accountTokenEnvVar(agent: string): string | null;
+/** Env to merge at spawn so the agent runs under the given account token. */
+export declare function accountTokenEnv(agent: string, token: string): Record<string, string>;

package/packages/kernel/dist/accounts.js

@@ -0,0 +1,29 @@
+// Multi-account capability (token form): switch between several local subscription accounts
+// of a coding-agent CLI by injecting a long-lived auth token at spawn time. The CLI keeps
+// using its normal single config home (~/.claude etc.) — only the *identity* changes.
+//
+//   claude / claude-tui -> CLAUDE_CODE_OAUTH_TOKEN=<token from `claude setup-token`>
+//
+// This replaces the earlier per-account config-directory approach: on macOS claude stores
+// its credential in one shared OS-keychain item (not per CLAUDE_CONFIG_DIR), so the token is
+// what actually isolates an account. codex has no equivalent token, so it is not supported
+// here yet (single account only).
+//
+// Dependency-free (no imports) so any @pikiloom/kernel consumer inherits account switching.
+const ACCOUNT_TOKEN_ENV = {
+    claude: 'CLAUDE_CODE_OAUTH_TOKEN',
+    'claude-tui': 'CLAUDE_CODE_OAUTH_TOKEN',
+};
+/** Whether this agent's local accounts are switched by injecting a token. */
+export function accountTokenSupported(agent) {
+    return Object.prototype.hasOwnProperty.call(ACCOUNT_TOKEN_ENV, agent);
+}
+/** The env-var name that overrides this agent's subscription identity, or null. */
+export function accountTokenEnvVar(agent) {
+    return ACCOUNT_TOKEN_ENV[agent] ?? null;
+}
+/** Env to merge at spawn so the agent runs under the given account token. */
+export function accountTokenEnv(agent, token) {
+    const key = accountTokenEnvVar(agent);
+    return key && token ? { [key]: token } : {};
+}

package/packages/kernel/dist/drivers/acp.d.ts

@@ -0,0 +1,24 @@
+import type { AgentDriver, AgentTurnInput, DriverContext, DriverResult, DriverEvent, McpServerSpec } from '../contracts/driver.js';
+export interface AcpDriverConfig {
+    id: string;
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    fsAccess?: boolean;
+    permissionFallback?: 'allow' | 'reject' | 'cancel';
+    protocolVersion?: number;
+    promptTimeoutMs?: number;
+    capabilities?: AgentDriver['capabilities'];
+}
+export declare function toAcpMcpServers(servers?: McpServerSpec[]): any[];
+export declare function buildAcpPromptBlocks(prompt: string, attachments: string[]): any[];
+export declare function applyAcpUpdate(update: any, s: any, tools: Set<string>, emit: (e: DriverEvent) => void): void;
+export declare class AcpDriver implements AgentDriver {
+    readonly id: string;
+    readonly capabilities: NonNullable<AgentDriver['capabilities']>;
+    protected readonly cfg: Required<Omit<AcpDriverConfig, 'capabilities' | 'env'>> & Pick<AcpDriverConfig, 'env' | 'capabilities'>;
+    constructor(config: AcpDriverConfig);
+    run(input: AgentTurnInput, ctx: DriverContext): Promise<DriverResult>;
+    private resolvePermission;
+    private startupError;
+}