@stevezhou/sisu 0.1.10 → 0.2.0

package/dist/pager/model.js

@@ -9,8 +9,13 @@ exports.appendText = appendText;
 exports.applyKey = applyKey;
 exports.SLASH_COMMANDS = [
     { name: '/login', hint: 'Sign in with the browser' },
+    { name: '/logout', hint: 'Sign out of this terminal' },
     { name: '/new', hint: 'Start a new conversation (alias: /clear)' },
     { name: '/resume', hint: 'Resume a conversation (alias: /history)' },
+    { name: '/model', hint: 'Switch model (alias: /m)' },
+    { name: '/models', hint: 'List models available to your account' },
+    { name: '/copy', hint: 'Copy the last assistant reply' },
+    { name: '/export', hint: 'Write this conversation to a markdown file' },
     { name: '/status', hint: 'Show session status' },
     { name: '/ls', hint: 'List local workspace files' },
     { name: '/training', hint: 'Training mode' },
@@ -23,6 +28,7 @@ const SLASH_ALIASES = {
     '/clear': '/new',
     '/history': '/resume',
     '/exit': '/quit',
+    '/m': '/model',
 };
 let nextEntryId = 1;
 function entryId() {
@@ -38,6 +44,9 @@ function createPagerState() {
         slashOpen: false,
         conversationId: '',
         slashIndex: 0,
+        draftIndex: 0,
+        historyIndex: -1,
+        stashDraft: '',
     };
 }
 function clampSelected(entries, selected) {
@@ -59,11 +68,40 @@ function clampSlashIndex(draft, slashIndex) {
         return 0;
     return slashIndex;
 }
-function withDraft(state, draft, slashOpen) {
+function draftChars(draft) {
+    return Array.from(draft);
+}
+function clampDraftIndex(draft, index) {
+    const n = draftChars(draft).length;
+    if (index < 0)
+        return 0;
+    if (index > n)
+        return n;
+    return index;
+}
+function insertAt(draft, index, value) {
+    const chars = draftChars(draft);
+    const at = clampDraftIndex(draft, index);
+    chars.splice(at, 0, ...Array.from(value));
+    return { draft: chars.join(''), draftIndex: at + Array.from(value).length };
+}
+function deleteBefore(draft, index) {
+    const chars = draftChars(draft);
+    const at = clampDraftIndex(draft, index);
+    if (at <= 0)
+        return { draft, draftIndex: 0 };
+    chars.splice(at - 1, 1);
+    return { draft: chars.join(''), draftIndex: at - 1 };
+}
+function userPrompts(state) {
+    return state.entries.filter((entry) => entry.kind === 'user').map((entry) => entry.text);
+}
+function withDraft(state, draft, slashOpen, draftIndex) {
     const open = slashOpen ?? (draft.startsWith('/') ? state.slashOpen || draft === '/' : false);
     return {
         ...state,
         draft,
+        draftIndex: clampDraftIndex(draft, draftIndex ?? draftChars(draft).length),
         slashOpen: open && draft.startsWith('/'),
         slashIndex: open && draft.startsWith('/') ? clampSlashIndex(draft, state.slashIndex) : 0,
     };
@@ -140,29 +178,57 @@ function appendText(state, text) {
     const seeded = startAssistant(state);
     return appendText(seeded, text);
 }
+function applyHistory(state, delta) {
+    const prompts = userPrompts(state);
+    if (prompts.length === 0) {
+        if (state.draft === '' && state.entries.length > 0) {
+            const selected = clampSelected(state.entries, state.selected + delta);
+            return { ...state, selected };
+        }
+        return state;
+    }
+    let historyIndex = state.historyIndex;
+    let stashDraft = state.stashDraft;
+    if (historyIndex < 0) {
+        if (delta > 0)
+            return state;
+        stashDraft = state.draft;
+        historyIndex = prompts.length - 1;
+    }
+    else {
+        historyIndex += delta;
+    }
+    if (historyIndex < 0)
+        historyIndex = 0;
+    if (historyIndex >= prompts.length) {
+        return withDraft({ ...state, historyIndex: -1, stashDraft: '' }, stashDraft, stashDraft.startsWith('/'));
+    }
+    const draft = prompts[historyIndex];
+    return withDraft({ ...state, historyIndex, stashDraft }, draft, draft.startsWith('/'));
+}
 function applyKey(state, key) {
     switch (key.type) {
         case 'char': {
-            const draft = state.draft + key.value;
+            const next = insertAt(state.draft, state.draftIndex, key.value);
             if (key.value === '/' && state.draft === '') {
-                return { ...state, draft: '/', slashOpen: true, slashIndex: 0 };
+                return { ...state, draft: '/', draftIndex: 1, slashOpen: true, slashIndex: 0, historyIndex: -1 };
             }
-            if (state.slashOpen || draft.startsWith('/')) {
-                return withDraft(state, draft, draft.startsWith('/'));
+            if (state.slashOpen || next.draft.startsWith('/')) {
+                return withDraft({ ...state, historyIndex: -1 }, next.draft, next.draft.startsWith('/'), next.draftIndex);
             }
-            return { ...state, draft };
+            return { ...state, draft: next.draft, draftIndex: next.draftIndex, historyIndex: -1 };
         }
         case 'backspace': {
             if (!state.draft)
                 return state;
-            const draft = state.draft.slice(0, -1);
+            const next = deleteBefore(state.draft, state.draftIndex);
             if (state.slashOpen) {
-                if (!draft.startsWith('/')) {
-                    return { ...state, draft, slashOpen: false, slashIndex: 0 };
+                if (!next.draft.startsWith('/')) {
+                    return { ...state, draft: next.draft, draftIndex: next.draftIndex, slashOpen: false, slashIndex: 0 };
                 }
-                return withDraft(state, draft, true);
+                return withDraft(state, next.draft, true, next.draftIndex);
             }
-            return { ...state, draft };
+            return { ...state, draft: next.draft, draftIndex: next.draftIndex };
         }
         case 'escape': {
             if (state.slashOpen) {
@@ -171,13 +237,20 @@ function applyKey(state, key) {
             return state;
         }
         case 'enter': {
-            // Command execution is owned by the app layer; model only retains draft.
-            return state;
+            return { ...state, historyIndex: -1, stashDraft: '' };
         }
-        case 'left':
+        case 'left': {
+            if (state.draft) {
+                return { ...state, draftIndex: clampDraftIndex(state.draft, state.draftIndex - 1) };
+            }
             return setEntryFold(state, true);
-        case 'right':
+        }
+        case 'right': {
+            if (state.draft) {
+                return { ...state, draftIndex: clampDraftIndex(state.draft, state.draftIndex + 1) };
+            }
             return setEntryFold(state, false);
+        }
         case 'up': {
             if (state.slashOpen) {
                 const items = filterSlash(state.draft);
@@ -186,11 +259,7 @@ function applyKey(state, key) {
                 const slashIndex = (state.slashIndex - 1 + items.length) % items.length;
                 return { ...state, slashIndex };
             }
-            if (state.draft === '' && state.entries.length > 0) {
-                const selected = clampSelected(state.entries, state.selected - 1);
-                return { ...state, selected };
-            }
-            return state;
+            return applyHistory(state, -1);
         }
         case 'down': {
             if (state.slashOpen) {
@@ -200,11 +269,17 @@ function applyKey(state, key) {
                 const slashIndex = (state.slashIndex + 1) % items.length;
                 return { ...state, slashIndex };
             }
-            if (state.draft === '' && state.entries.length > 0) {
-                const selected = clampSelected(state.entries, state.selected + 1);
-                return { ...state, selected };
-            }
-            return state;
+            return applyHistory(state, 1);
+        }
+        case 'pageup': {
+            if (state.entries.length === 0)
+                return state;
+            return { ...state, selected: clampSelected(state.entries, state.selected - 8) };
+        }
+        case 'pagedown': {
+            if (state.entries.length === 0)
+                return state;
+            return { ...state, selected: clampSelected(state.entries, state.selected + 8) };
         }
         default:
             return state;

package/dist/runtime/adapter.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toProviderMessages = toProviderMessages;
+exports.completeUrl = completeUrl;
+exports.openaiCompatUrl = openaiCompatUrl;
+exports.buildCompleteRequest = buildCompleteRequest;
+exports.isServerSideAgentPayload = isServerSideAgentPayload;
+exports.parseCompleteSse = parseCompleteSse;
+exports.parseOpenAiChatCompletion = parseOpenAiChatCompletion;
+exports.createSisuCloudModel = createSisuCloudModel;
+const client_1 = require("../client");
+const http_1 = require("../http");
+const sse_1 = require("../sse");
+const suite_1 = require("./suite");
+/** OpenAI/Poe wire: assistant.tool_calls is {id,type,function:{name,arguments:string}}. */
+function toProviderMessages(messages) {
+    return messages.map((row) => {
+        const out = { role: row.role, content: row.content };
+        if (row.tool_call_id)
+            out.tool_call_id = row.tool_call_id;
+        if (row.name)
+            out.name = row.name;
+        if (row.tool_calls?.length) {
+            out.tool_calls = row.tool_calls.map((call) => ({
+                id: call.id,
+                type: 'function',
+                function: {
+                    name: call.name,
+                    arguments: JSON.stringify(call.arguments || {}),
+                },
+            }));
+        }
+        return out;
+    });
+}
+function completeUrl(apiBase) {
+    return `${apiBase.replace(/\/+$/, '')}${suite_1.COMPLETE_PATH}`;
+}
+function openaiCompatUrl(apiBase) {
+    return `${apiBase.replace(/\/+$/, '')}${suite_1.OPENAI_COMPAT_PATH}`;
+}
+function buildCompleteRequest(request, options = {}) {
+    const stamp = (0, client_1.clientStamp)(options.client || 'cli');
+    return {
+        model: request.model,
+        messages: toProviderMessages(request.messages),
+        tools: request.tools,
+        stream: true,
+        client: stamp.client,
+        client_version: stamp.client_version,
+        client_request_id: stamp.client_request_id,
+    };
+}
+function isServerSideAgentPayload(body) {
+    if (!body || typeof body !== 'object')
+        return false;
+    const row = body;
+    return row.task_category === 'coding' && typeof row.message === 'string' && !Array.isArray(row.messages);
+}
+function asToolCall(raw, index) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const row = raw;
+    const fn = row.function && typeof row.function === 'object' ? row.function : row;
+    const name = String(fn.name || row.name || '');
+    if (!name)
+        return null;
+    let args = {};
+    const rawArgs = fn.arguments ?? row.arguments ?? row.input;
+    if (typeof rawArgs === 'string') {
+        try {
+            args = JSON.parse(rawArgs);
+        }
+        catch {
+            args = { raw: rawArgs };
+        }
+    }
+    else if (rawArgs && typeof rawArgs === 'object') {
+        args = rawArgs;
+    }
+    return { id: String(row.id || `call_${index}`), name, arguments: args };
+}
+function parseCompleteSse(buffer) {
+    const parsed = (0, sse_1.consumeSse)(buffer.endsWith('\n\n') ? buffer : `${buffer}\n\n`);
+    let text = '';
+    const tool_calls = [];
+    for (const event of parsed.events) {
+        if (event.type === 'error') {
+            throw new Error(typeof event.data === 'string' ? event.data : 'stream error');
+        }
+        if (event.name === 'tool_call') {
+            const mapped = asToolCall(event.data, tool_calls.length);
+            if (mapped)
+                tool_calls.push(mapped);
+            continue;
+        }
+        if (event.name === 'delta' || event.type === 'text' || event.name === 'text') {
+            const chunk = (0, sse_1.sseEventText)(event);
+            if (chunk)
+                text += chunk;
+        }
+        if (event.data && typeof event.data === 'object') {
+            const row = event.data;
+            if (Array.isArray(row.tool_calls)) {
+                row.tool_calls.forEach((item, index) => {
+                    const mapped = asToolCall(item, tool_calls.length + index);
+                    if (mapped)
+                        tool_calls.push(mapped);
+                });
+            }
+            if (typeof row.content === 'string')
+                text += row.content;
+        }
+    }
+    return { text, tool_calls };
+}
+function parseOpenAiChatCompletion(body) {
+    const row = body && typeof body === 'object' ? body : {};
+    const choices = Array.isArray(row.choices) ? row.choices : [];
+    const first = choices[0] && typeof choices[0] === 'object' ? choices[0] : {};
+    const message = first.message && typeof first.message === 'object' ? first.message : first;
+    const text = typeof message.content === 'string' ? message.content : '';
+    const rawCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+    const tool_calls = rawCalls
+        .map((item, index) => asToolCall(item, index))
+        .filter((item) => Boolean(item));
+    return { text, tool_calls };
+}
+function createSisuCloudModel(http, options) {
+    return {
+        async complete(request) {
+            const payload = buildCompleteRequest(request, { client: options.client });
+            if (isServerSideAgentPayload(payload)) {
+                throw new Error('refusing server-side /api/chat/send agent payload');
+            }
+            const sent = await http(completeUrl(options.apiBase), {
+                method: 'POST',
+                headers: (0, http_1.authHeaders)(options.token),
+                body: JSON.stringify(payload),
+            });
+            if (!sent.ok) {
+                const body = await sent.json().catch(() => ({}));
+                throw new Error((0, http_1.errorDetail)(body, `complete failed (${sent.status})`));
+            }
+            const stream = sent.stream;
+            if (stream) {
+                let buffer = '';
+                for await (const chunk of stream())
+                    buffer += chunk;
+                return parseCompleteSse(buffer);
+            }
+            const raw = await sent.text();
+            if (raw.trim().startsWith('{')) {
+                try {
+                    return parseOpenAiChatCompletion(JSON.parse(raw));
+                }
+                catch {
+                    // fall through to SSE
+                }
+            }
+            return parseCompleteSse(raw);
+        },
+    };
+}

package/dist/runtime/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.launchGrokBuildHeadless = exports.findGrokBuildBinary = exports.execLocalTurn = exports.createLocalRuntimeTransport = exports.resolveWorkspaceRoot = exports.localToolDefinitions = exports.dispatchLocalTool = exports.runLocalTurn = exports.createScriptedModel = exports.createLaunchStubModel = exports.collectLocalTurn = exports.toProviderMessages = exports.parseOpenAiChatCompletion = exports.parseCompleteSse = exports.isServerSideAgentPayload = exports.createSisuCloudModel = exports.completeUrl = exports.buildCompleteRequest = exports.PRODUCT_NAME = exports.PRODUCT_BIN = exports.grokBuildSuitePresent = exports.grokBuildRoot = exports.grokBuildPath = exports.assertGrokBuildSuite = void 0;
+var suite_1 = require("./suite");
+Object.defineProperty(exports, "assertGrokBuildSuite", { enumerable: true, get: function () { return suite_1.assertGrokBuildSuite; } });
+Object.defineProperty(exports, "grokBuildPath", { enumerable: true, get: function () { return suite_1.grokBuildPath; } });
+Object.defineProperty(exports, "grokBuildRoot", { enumerable: true, get: function () { return suite_1.grokBuildRoot; } });
+Object.defineProperty(exports, "grokBuildSuitePresent", { enumerable: true, get: function () { return suite_1.grokBuildSuitePresent; } });
+Object.defineProperty(exports, "PRODUCT_BIN", { enumerable: true, get: function () { return suite_1.PRODUCT_BIN; } });
+Object.defineProperty(exports, "PRODUCT_NAME", { enumerable: true, get: function () { return suite_1.PRODUCT_NAME; } });
+var adapter_1 = require("./adapter");
+Object.defineProperty(exports, "buildCompleteRequest", { enumerable: true, get: function () { return adapter_1.buildCompleteRequest; } });
+Object.defineProperty(exports, "completeUrl", { enumerable: true, get: function () { return adapter_1.completeUrl; } });
+Object.defineProperty(exports, "createSisuCloudModel", { enumerable: true, get: function () { return adapter_1.createSisuCloudModel; } });
+Object.defineProperty(exports, "isServerSideAgentPayload", { enumerable: true, get: function () { return adapter_1.isServerSideAgentPayload; } });
+Object.defineProperty(exports, "parseCompleteSse", { enumerable: true, get: function () { return adapter_1.parseCompleteSse; } });
+Object.defineProperty(exports, "parseOpenAiChatCompletion", { enumerable: true, get: function () { return adapter_1.parseOpenAiChatCompletion; } });
+Object.defineProperty(exports, "toProviderMessages", { enumerable: true, get: function () { return adapter_1.toProviderMessages; } });
+var loop_1 = require("./loop");
+Object.defineProperty(exports, "collectLocalTurn", { enumerable: true, get: function () { return loop_1.collectLocalTurn; } });
+Object.defineProperty(exports, "createLaunchStubModel", { enumerable: true, get: function () { return loop_1.createLaunchStubModel; } });
+Object.defineProperty(exports, "createScriptedModel", { enumerable: true, get: function () { return loop_1.createScriptedModel; } });
+Object.defineProperty(exports, "runLocalTurn", { enumerable: true, get: function () { return loop_1.runLocalTurn; } });
+var tools_1 = require("./tools");
+Object.defineProperty(exports, "dispatchLocalTool", { enumerable: true, get: function () { return tools_1.dispatchLocalTool; } });
+Object.defineProperty(exports, "localToolDefinitions", { enumerable: true, get: function () { return tools_1.localToolDefinitions; } });
+Object.defineProperty(exports, "resolveWorkspaceRoot", { enumerable: true, get: function () { return tools_1.resolveWorkspaceRoot; } });
+var transport_1 = require("./transport");
+Object.defineProperty(exports, "createLocalRuntimeTransport", { enumerable: true, get: function () { return transport_1.createLocalRuntimeTransport; } });
+Object.defineProperty(exports, "execLocalTurn", { enumerable: true, get: function () { return transport_1.execLocalTurn; } });
+var launch_1 = require("./launch");
+Object.defineProperty(exports, "findGrokBuildBinary", { enumerable: true, get: function () { return launch_1.findGrokBuildBinary; } });
+Object.defineProperty(exports, "launchGrokBuildHeadless", { enumerable: true, get: function () { return launch_1.launchGrokBuildHeadless; } });

package/dist/runtime/launch.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grokBuildBinaryCandidates = grokBuildBinaryCandidates;
+exports.findGrokBuildBinary = findGrokBuildBinary;
+exports.sisuRuntimeApiBase = sisuRuntimeApiBase;
+exports.writeSisuGrokConfig = writeSisuGrokConfig;
+exports.sisuGrokBuildEnv = sisuGrokBuildEnv;
+exports.launchGrokBuildHeadless = launchGrokBuildHeadless;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const store_1 = require("../store");
+const suite_1 = require("./suite");
+const adapter_1 = require("./adapter");
+function grokBuildBinaryCandidates() {
+    const env = (process.env.SISU_GROK_BIN || '').trim();
+    const root = (0, suite_1.grokBuildRoot)();
+    const packaged = path_1.default.resolve(__dirname, '..', 'bin', 'xai-grok-pager');
+    return [
+        env,
+        packaged,
+        path_1.default.join(root, 'target', 'release', 'xai-grok-pager'),
+        path_1.default.join(root, 'target', 'debug', 'xai-grok-pager'),
+        path_1.default.join(root, 'target', 'release', 'sisu-agent'),
+    ].filter(Boolean);
+}
+function findGrokBuildBinary() {
+    for (const candidate of grokBuildBinaryCandidates()) {
+        if (candidate && fs_1.default.existsSync(candidate) && fs_1.default.statSync(candidate).isFile())
+            return candidate;
+    }
+    return null;
+}
+function sisuRuntimeApiBase(apiBase) {
+    return (0, adapter_1.openaiCompatUrl)(apiBase).replace(/\/chat\/completions$/, '');
+}
+function writeSisuGrokConfig() {
+    const auth = (0, store_1.readAuth)();
+    const home = (0, store_1.getSisuHome)();
+    fs_1.default.mkdirSync(home, { recursive: true, mode: 0o700 });
+    const file = path_1.default.join(home, 'config.toml');
+    const runtimeBase = sisuRuntimeApiBase(auth?.api_base || process.env.SISU_API_BASE || 'https://www.sisu.chat');
+    const body = [
+        '# sisu-managed grok-build config — SiSu auth + models + quota',
+        '[endpoints]',
+        `xai_api_base_url = "${runtimeBase}"`,
+        '',
+    ].join('\n');
+    const existing = fs_1.default.existsSync(file) ? fs_1.default.readFileSync(file, 'utf8') : '';
+    if (!existing || existing.includes('sisu-managed grok-build')) {
+        fs_1.default.writeFileSync(file, `${body}\n`, { encoding: 'utf8', mode: 0o600 });
+    }
+    return file;
+}
+function sisuGrokBuildEnv() {
+    const auth = (0, store_1.readAuth)();
+    const home = (0, store_1.getSisuHome)();
+    const runtimeBase = auth ? sisuRuntimeApiBase(auth.api_base) : '';
+    return {
+        ...process.env,
+        GROK_HOME: process.env.GROK_HOME || home,
+        SISU_HOME: home,
+        GROK_TELEMETRY_ENABLED: process.env.GROK_TELEMETRY_ENABLED || '0',
+        XAI_API_KEY: process.env.XAI_API_KEY || auth?.token || '',
+        SISU_API_BASE: auth?.api_base || process.env.SISU_API_BASE || 'https://www.sisu.chat',
+        ...(runtimeBase
+            ? {
+                GROK_XAI_API_BASE_URL: runtimeBase,
+                XAI_API_BASE_URL: runtimeBase,
+            }
+            : {}),
+    };
+}
+function launchGrokBuildHeadless(prompt, cwd) {
+    const binary = findGrokBuildBinary();
+    if (!binary) {
+        return { status: 127, stdout: '', stderr: 'grok-build binary not built', binary: null };
+    }
+    const result = (0, child_process_1.spawnSync)(binary, ['-p', prompt], {
+        cwd,
+        encoding: 'utf8',
+        env: sisuGrokBuildEnv(),
+        timeout: 30_000,
+    });
+    return {
+        status: result.status ?? 1,
+        stdout: result.stdout || '',
+        stderr: result.stderr || result.error?.message || '',
+        binary,
+    };
+}

package/dist/runtime/loop.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLocalTurn = runLocalTurn;
+exports.collectLocalTurn = collectLocalTurn;
+exports.createLaunchStubModel = createLaunchStubModel;
+exports.createScriptedModel = createScriptedModel;
+const crypto_1 = require("crypto");
+const tools_1 = require("./tools");
+const DEFAULT_MAX_ROUNDS = 8;
+async function* runLocalTurn(options) {
+    const prompt = options.prompt.trim();
+    if (!prompt)
+        throw new Error('prompt is required');
+    const cwd = (0, tools_1.resolveWorkspaceRoot)(options.cwd);
+    const conversationId = options.conversationId || (0, crypto_1.randomUUID)();
+    yield { type: 'bound', text: conversationId };
+    const messages = [...(options.messages || []), { role: 'user', content: prompt }];
+    const tools = (0, tools_1.localToolDefinitions)();
+    const toolResults = [];
+    const requests = [];
+    let text = '';
+    const maxRounds = options.maxRounds ?? DEFAULT_MAX_ROUNDS;
+    for (let round = 0; round < maxRounds; round += 1) {
+        const request = { model: options.model, messages: messages.map((row) => ({ ...row })), tools };
+        requests.push(request);
+        const completion = await options.client.complete(request);
+        if (completion.text) {
+            text += completion.text;
+            yield { type: 'text', text: completion.text };
+        }
+        if (!completion.tool_calls.length) {
+            return { conversationId, text, toolResults, requests };
+        }
+        messages.push({
+            role: 'assistant',
+            content: completion.text || '',
+            tool_calls: completion.tool_calls,
+        });
+        for (const call of completion.tool_calls) {
+            const result = (0, tools_1.dispatchLocalTool)(cwd, {
+                ...call,
+                id: call.id || (0, crypto_1.randomUUID)(),
+                arguments: call.arguments || {},
+            });
+            toolResults.push(result);
+            yield { type: 'tool', text: `${result.name} · ${result.ok ? 'ok' : 'error'} · ${result.content}` };
+            messages.push({
+                role: 'tool',
+                name: result.name,
+                tool_call_id: result.id,
+                content: result.content,
+            });
+        }
+    }
+    yield { type: 'status', text: `stopped after ${maxRounds} tool rounds` };
+    return { conversationId, text, toolResults, requests };
+}
+async function collectLocalTurn(options) {
+    const gen = runLocalTurn(options);
+    let step = await gen.next();
+    while (!step.done)
+        step = await gen.next();
+    return step.value;
+}
+function createLaunchStubModel() {
+    let step = 0;
+    return {
+        async complete(request) {
+            step += 1;
+            if (step === 1) {
+                return {
+                    text: '',
+                    tool_calls: [{ id: 'stub-read', name: 'read_file', arguments: { target_file: 'hello.txt' } }],
+                };
+            }
+            const lastTool = [...request.messages].reverse().find((row) => row.role === 'tool');
+            return { text: `local tool result:\n${lastTool?.content || ''}`, tool_calls: [] };
+        },
+    };
+}
+function createScriptedModel(script) {
+    const remaining = [...script];
+    return {
+        async complete() {
+            const next = remaining.shift();
+            if (!next)
+                return { text: '', tool_calls: [] };
+            return { text: next.text || '', tool_calls: next.tool_calls || [] };
+        },
+    };
+}

package/dist/runtime/models.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchModelCatalog = fetchModelCatalog;
+exports.resolveCatalogModel = resolveCatalogModel;
+exports.resolveRuntimeModel = resolveRuntimeModel;
+const http_1 = require("../http");
+const store_1 = require("../store");
+function normalizeModelKey(value) {
+    return value.toLowerCase().replace(/[-_.\s]/g, '');
+}
+async function fetchModelCatalog(http = http_1.defaultHttp) {
+    const auth = (0, store_1.requireAuth)();
+    const response = await http(`${auth.api_base}/api/chat/models`, { headers: (0, http_1.authHeaders)(auth.token) });
+    const body = await response.json().catch(() => ({}));
+    if (!response.ok)
+        throw new Error((0, http_1.errorDetail)(body, `models failed (${response.status})`));
+    const rows = Array.isArray(body?.models) ? body.models : [];
+    const models = rows
+        .map((row) => {
+        const name = String(row?.name || '').trim();
+        if (!name)
+            return null;
+        return { name, label: String(row.display_name || row.label || name) };
+    })
+        .filter((row) => Boolean(row));
+    return { models, defaultModel: String(body?.default_model || '') };
+}
+function resolveCatalogModel(query, models) {
+    const needle = normalizeModelKey(query);
+    if (!needle)
+        return undefined;
+    return (models.find((row) => normalizeModelKey(row.name) === needle) ||
+        models.find((row) => normalizeModelKey(row.label) === needle) ||
+        models.find((row) => normalizeModelKey(row.name).includes(needle) || normalizeModelKey(row.label).includes(needle)));
+}
+async function resolveRuntimeModel(http, options = {}) {
+    if (options.stub)
+        return (options.explicit || '').trim() || 'stub';
+    const wanted = (options.explicit || '').trim();
+    const { models, defaultModel } = await fetchModelCatalog(http);
+    if (wanted) {
+        const match = resolveCatalogModel(wanted, models);
+        if (!match)
+            throw new Error(`unknown model ${wanted}`);
+        (0, store_1.writeSession)({ ...(0, store_1.readSession)(), last_model: match.name });
+        return match.name;
+    }
+    const last = ((0, store_1.readSession)().last_model || '').trim();
+    if (last && models.some((row) => row.name === last))
+        return last;
+    const name = defaultModel || models[0]?.name || '';
+    if (!name)
+        throw new Error('no SiSu model available');
+    (0, store_1.writeSession)({ ...(0, store_1.readSession)(), last_model: name });
+    return name;
+}