@stevezhou/sisu 0.1.11 → 0.2.1

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,96 @@
+"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');
+    const npmInstalled = path_1.default.join((0, store_1.getSisuHome)(), 'bin', process.platform === 'win32' ? 'xai-grok-pager.exe' : 'xai-grok-pager');
+    return [
+        env,
+        npmInstalled,
+        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;
+}

package/dist/runtime/sessions.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLocalSession = createLocalSession;
+exports.loadLocalSession = loadLocalSession;
+exports.saveLocalSession = saveLocalSession;
+exports.listLocalSessions = listLocalSessions;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = require("crypto");
+const store_1 = require("../store");
+function sessionsDir() {
+    return path_1.default.join((0, store_1.getSisuHome)(), 'sessions');
+}
+function sessionFile(id) {
+    return path_1.default.join(sessionsDir(), `${id}.json`);
+}
+function createLocalSession(title, cwd, model) {
+    const session = {
+        id: (0, crypto_1.randomUUID)(),
+        title: title.slice(0, 80) || 'session',
+        cwd,
+        model,
+        messages: [],
+        updatedAt: new Date().toISOString(),
+    };
+    saveLocalSession(session);
+    return session;
+}
+function loadLocalSession(id) {
+    try {
+        return JSON.parse(fs_1.default.readFileSync(sessionFile(id), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function saveLocalSession(session) {
+    fs_1.default.mkdirSync(sessionsDir(), { recursive: true, mode: 0o700 });
+    const file = sessionFile(session.id);
+    fs_1.default.writeFileSync(file, JSON.stringify({ ...session, updatedAt: new Date().toISOString() }, null, 2) + '\n', {
+        encoding: 'utf8',
+        mode: 0o600,
+    });
+}
+function listLocalSessions() {
+    const dir = sessionsDir();
+    if (!fs_1.default.existsSync(dir))
+        return [];
+    return fs_1.default
+        .readdirSync(dir)
+        .filter((name) => name.endsWith('.json'))
+        .map((name) => {
+        try {
+            return JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, name), 'utf8'));
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((row) => Boolean(row))
+        .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}

package/dist/runtime/suite.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPENAI_COMPAT_PATH = exports.COMPLETE_PATH = exports.PRODUCT_BIN = exports.PRODUCT_NAME = exports.GROK_BUILD_SURFACE = void 0;
+exports.grokBuildRoot = grokBuildRoot;
+exports.grokBuildPath = grokBuildPath;
+exports.grokBuildSuitePresent = grokBuildSuitePresent;
+exports.assertGrokBuildSuite = assertGrokBuildSuite;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/** Absolute path to the vendored grok-build first-party tree. */
+function grokBuildRoot() {
+    return path_1.default.resolve(__dirname, '..', '..', 'vendor', 'grok-build');
+}
+exports.GROK_BUILD_SURFACE = {
+    agent: 'crates/codegen/xai-grok-agent',
+    tools: 'crates/codegen/xai-grok-tools',
+    pager: 'crates/codegen/xai-grok-pager',
+    hooks: 'crates/codegen/xai-grok-hooks',
+    mcp: 'crates/codegen/xai-grok-mcp',
+    plugins: 'crates/codegen/xai-grok-plugin-marketplace',
+    subagents: 'crates/codegen/xai-grok-subagent-resolution',
+    skills: 'crates/codegen/xai-grok-tools/src/implementations/skills',
+};
+function grokBuildPath(surface) {
+    const root = grokBuildRoot();
+    if (surface === 'license')
+        return path_1.default.join(root, 'LICENSE');
+    if (surface === 'notice')
+        return path_1.default.join(root, 'NOTICE');
+    if (surface === 'thirdParty')
+        return path_1.default.join(root, 'THIRD-PARTY-NOTICES');
+    return path_1.default.join(root, exports.GROK_BUILD_SURFACE[surface]);
+}
+function grokBuildSuitePresent() {
+    const keys = [
+        'agent',
+        'tools',
+        'pager',
+        'hooks',
+        'mcp',
+        'plugins',
+        'subagents',
+        'skills',
+        'license',
+        'notice',
+    ];
+    return keys.map((surface) => {
+        const file = grokBuildPath(surface);
+        return { surface, path: file, ok: fs_1.default.existsSync(file) };
+    });
+}
+function assertGrokBuildSuite() {
+    const missing = grokBuildSuitePresent().filter((row) => !row.ok);
+    if (missing.length) {
+        throw new Error(`grok-build suite missing: ${missing.map((row) => row.surface).join(', ')}`);
+    }
+}
+exports.PRODUCT_NAME = 'SiSu';
+exports.PRODUCT_BIN = 'sisu';
+exports.COMPLETE_PATH = '/api/runtime/complete';
+exports.OPENAI_COMPAT_PATH = '/api/runtime/v1/chat/completions';