gestalt-mobile 0.35.4 → 0.36.0

package/dist/server/server/platform/kimi/kimi-share-dir.js

@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { mkdirSync, symlinkSync, existsSync, statSync, copyFileSync, rmSync, lstatSync, } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { normalizeSkillProfileName } from '../../features/skills/model/skill-profile.js';
+/**
+ * Base directory holding gestalt-owned kimi web state:
+ * `<home>/.codex-gestalt/gestalt-mobile/kimi/<profileKey>/`.
+ */
+export function kimiStateBase(homeDirectory) {
+    return join(resolve(homeDirectory), '.codex-gestalt', 'gestalt-mobile', 'kimi');
+}
+const AUTH_LINKS = ['credentials', 'oauth', 'device_id', 'region'];
+/**
+ * Builds one isolated share dir per skill-profile key. Auth material is
+ * symlinked from the user's real `~/.kimi-code` home so every gestalt-owned
+ * kimi web instance shares the user's login; `config.toml` is copied (never
+ * symlinked) so gestalt can patch it without mutating user configuration.
+ */
+export function prepareKimiShareDir(input) {
+    const profileKey = normalizeSkillProfileName(input.profileKey);
+    const profileDir = join(input.stateBase, profileKey);
+    const shareDir = join(profileDir, 'share');
+    const skillsDir = join(profileDir, 'skills');
+    mkdirSync(shareDir, { recursive: true, mode: 0o700 });
+    mkdirSync(skillsDir, { recursive: true, mode: 0o700 });
+    for (const name of AUTH_LINKS) {
+        const source = join(input.sourceShareDir, name);
+        if (!existsSync(source))
+            continue;
+        const link = join(shareDir, name);
+        removeIfPresent(link);
+        symlinkSync(source, link);
+    }
+    copyConfig(sourceConfig(input.sourceShareDir), join(shareDir, 'config.toml'));
+    return { shareDir, skillsDir, profileDir };
+}
+function sourceConfig(sourceShareDir) {
+    const candidate = join(sourceShareDir, 'config.toml');
+    return existsSync(candidate) ? candidate : null;
+}
+/** Refreshes the copied config when the user's own config is newer. */
+function copyConfig(source, destination) {
+    if (!source) {
+        rmSync(destination, { force: true });
+        return;
+    }
+    if (existsSync(destination) && statSync(destination).mtimeMs >= statSync(source).mtimeMs) {
+        return;
+    }
+    copyFileSync(source, destination);
+}
+/** Removes a path if it exists, following lstat so broken symlinks count too. */
+function removeIfPresent(path) {
+    try {
+        lstatSync(path);
+    }
+    catch {
+        return;
+    }
+    rmSync(path, { recursive: true, force: true });
+}

package/dist/server/server/platform/kimi/kimi-skill-catalog.js

@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { isAbsolute, resolve } from 'node:path';
+import { availableSkillSchema, } from '../../features/skills/model/skill-profile.js';
+const DISCOVERY_TIMEOUT_MS = 5_000;
+/**
+ * Discovers kimi skills through a gestalt-owned kimi web server. The gestalt
+ * workspace path is matched against kimi's own workspace registry (`root`),
+ * then kimi's workspace-scoped skill list is mapped onto the provider-neutral
+ * catalog contract. kimi reports discovered skills only, so every entry is
+ * advertised as enabled; per-profile availability is gestalt-side state that
+ * materialization enforces when the profile's server starts.
+ */
+export class KimiSkillCatalog {
+    servers;
+    available;
+    constructor(servers, available) {
+        this.servers = servers;
+        this.available = available;
+    }
+    async list(workspace) {
+        if (!this.available || !this.servers)
+            return { skills: [], errors: [] };
+        try {
+            const handle = await this.servers.ensure('default', []);
+            const canonicalWorkspace = resolve(workspace);
+            const workspaces = (await withTimeout(handle.client.get('/api/v1/workspaces'), DISCOVERY_TIMEOUT_MS, 'kimi workspace list timed out'));
+            const entries = Array.isArray(workspaces.items) ? workspaces.items : [];
+            const entry = entries.find((candidate) => !!candidate &&
+                typeof candidate === 'object' &&
+                candidate.root === canonicalWorkspace);
+            if (!entry || typeof entry.id !== 'string' || !entry.id)
+                return {
+                    skills: [],
+                    errors: [{ message: 'Kimi has no registered workspace for this path yet.' }],
+                };
+            const data = (await withTimeout(handle.client.get(`/api/v1/workspaces/${entry.id}/skills`), DISCOVERY_TIMEOUT_MS, 'kimi skill list timed out'));
+            const wireSkills = Array.isArray(data.skills) ? data.skills : [];
+            const skills = [];
+            const errors = [];
+            for (const wire of wireSkills) {
+                const skill = wire;
+                if (!skill || typeof skill !== 'object' || typeof skill.name !== 'string')
+                    continue;
+                // The shared catalog contract canonicalizes skill paths as absolute
+                // filesystem paths (profile snapshots and overrides resolve against
+                // them). kimi built-ins report no path and cannot be materialized per
+                // profile, so they are omitted rather than advertised with a
+                // non-filesystem fallback that would fail validation downstream.
+                if (typeof skill.path !== 'string' || !isAbsolute(skill.path))
+                    continue;
+                const parsed = availableSkillSchema.safeParse({
+                    name: skill.name,
+                    path: skill.path,
+                    enabled: true,
+                    ...(typeof skill.description === 'string' ? { description: skill.description } : {}),
+                    ...(typeof skill.source === 'string' ? { scope: `kimi:${skill.source}` } : {}),
+                });
+                if (parsed.success)
+                    skills.push(parsed.data);
+                else
+                    errors.push({ message: `Invalid Kimi skill metadata for "${skill.name}".` });
+            }
+            return { skills, errors };
+        }
+        catch {
+            return { skills: [], errors: [{ message: 'Kimi skill discovery failed.' }] };
+        }
+    }
+}
+function withTimeout(promise, timeoutMs, message) {
+    return Promise.race([
+        promise,
+        new Promise((_resolve, reject) => setTimeout(() => reject(new Error(message)), timeoutMs).unref()),
+    ]);
+}

package/dist/server/server/platform/kimi/kimi-skills-materializer.js

@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { mkdirSync, readdirSync, rmSync, symlinkSync } from 'node:fs';
+import { basename, isAbsolute, join } from 'node:path';
+/**
+ * Materializes a kimi skills directory from a gestalt skill selection: one
+ * symlink per enabled entry, named by the entry's basename. kimi discovers
+ * both directory skills (a folder holding `SKILL.md`) and flat `.md` skills
+ * in an `extra_skill_dirs` entry, so linking the canonical path as-is
+ * preserves either shape.
+ *
+ * Note: `extra_skill_dirs` only *adds* directories on top of kimi's automatic
+ * user/project discovery — unlike codex's `skills.config` override, kimi web
+ * offers no way to hide auto-discovered skills. A profile therefore narrows
+ * availability by adding, never by removing.
+ */
+export function materializeKimiSkillsDir(skillsDir, selection) {
+    rmSync(skillsDir, { recursive: true, force: true });
+    mkdirSync(skillsDir, { recursive: true, mode: 0o700 });
+    const linked = [];
+    const skipped = [];
+    const taken = new Set(readdirSync(skillsDir));
+    for (const entry of selection) {
+        if (!entry.enabled)
+            continue;
+        if (!isAbsolute(entry.path))
+            continue;
+        const name = basename(entry.path);
+        if (taken.has(name)) {
+            skipped.push(entry.path);
+            continue;
+        }
+        symlinkSync(entry.path, join(skillsDir, name));
+        taken.add(name);
+        linked.push(entry.path);
+    }
+    return { skillsDir, linked, skipped };
+}

package/dist/server/server/platform/kimi/kimi-web-client.js

@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { KimiWebError } from './kimi-errors.js';
+/**
+ * Minimal REST client for the local kimi web Server API (`kimi web`).
+ * Every response is a uniform envelope where the business outcome lives in
+ * `code` — HTTP status alone never reports success or failure.
+ */
+export class KimiWebClient {
+    baseUrl;
+    token;
+    fetchImpl;
+    timeoutMs;
+    constructor(baseUrl, token, fetchImpl = fetch, timeoutMs = 10_000) {
+        this.baseUrl = baseUrl;
+        this.token = token;
+        this.fetchImpl = fetchImpl;
+        this.timeoutMs = timeoutMs;
+    }
+    get(path) {
+        return this.request('GET', path);
+    }
+    post(path, body) {
+        return this.request('POST', path, body);
+    }
+    delete(path) {
+        return this.request('DELETE', path);
+    }
+    async request(method, path, body) {
+        let response;
+        try {
+            response = await this.fetchImpl(this.baseUrl + path, {
+                method,
+                headers: {
+                    authorization: `Bearer ${this.token}`,
+                    ...(body === undefined ? {} : { 'content-type': 'application/json' }),
+                },
+                ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+                signal: AbortSignal.timeout(this.timeoutMs),
+            });
+        }
+        catch (error) {
+            throw new KimiWebError(-1, error instanceof Error ? error.message : String(error));
+        }
+        let envelope;
+        try {
+            envelope = (await response.json());
+        }
+        catch {
+            throw new KimiWebError(-1, `kimi web returned an unreadable response (HTTP ${response.status})`);
+        }
+        if (typeof envelope.code !== 'number') {
+            throw new KimiWebError(-1, `kimi web returned a malformed envelope (HTTP ${response.status})`);
+        }
+        if (envelope.code !== 0) {
+            throw new KimiWebError(envelope.code, envelope.msg ?? 'kimi web request failed', envelope.request_id);
+        }
+        return envelope.data;
+    }
+}

package/dist/server/server/platform/kimi/kimi-web-server-manager.js

@@ -0,0 +1,215 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { spawn } from 'node:child_process';
+import { createServer } from 'node:net';
+import { KimiWebClient } from './kimi-web-client.js';
+import { boundMessage } from './kimi-errors.js';
+import { prepareKimiShareDir } from './kimi-share-dir.js';
+import { materializeKimiSkillsDir } from './kimi-skills-materializer.js';
+const READINESS_TIMEOUT_MS = 15_000;
+const READINESS_POLL_MS = 100;
+const LOG_TAIL_BYTES = 4 * 1024;
+const BASE_PORT = 58627;
+/**
+ * Owns one gestalt-dedicated `kimi web` process per skill profile. Each
+ * process gets an isolated `KIMI_SHARE_DIR` (auth material symlinked from the
+ * user's real kimi home) whose copied `config.toml` gestalt patches with the
+ * profile's materialized skills directory via `POST /api/v1/config`.
+ */
+export class KimiWebServerManager {
+    input;
+    servers = new Map();
+    ensureInFlight = new Map();
+    constructor(input) {
+        this.input = input;
+    }
+    /** Returns the running (or freshly started) server for a profile key. */
+    async ensure(profileKey, selection) {
+        const fingerprint = JSON.stringify(selection);
+        const existing = this.servers.get(profileKey);
+        if (existing && !existing.exited && existing.fingerprint === fingerprint) {
+            return existing.handle;
+        }
+        // Serialize starts per profile key: without this, concurrent callers can
+        // both observe no server, spawn two children, and leave the first handle
+        // pointing at a process stopAll() no longer tracks.
+        const pending = this.ensureInFlight.get(profileKey);
+        if (pending) {
+            await pending.then(() => { }, () => { });
+            return this.ensure(profileKey, selection);
+        }
+        const start = (async () => {
+            const current = this.servers.get(profileKey);
+            if (current)
+                await this.stop(profileKey);
+            return this.spawn(profileKey, fingerprint, selection);
+        })();
+        this.ensureInFlight.set(profileKey, start);
+        try {
+            return await start;
+        }
+        finally {
+            if (this.ensureInFlight.get(profileKey) === start)
+                this.ensureInFlight.delete(profileKey);
+        }
+    }
+    get(profileKey) {
+        const server = this.servers.get(profileKey);
+        return server && !server.exited ? server.handle : null;
+    }
+    /** Returns handles for every currently running profile server, unsorted. */
+    list() {
+        return [...this.servers.values()]
+            .filter((server) => !server.exited)
+            .map((server) => server.handle);
+    }
+    onServerExit(profileKey, listener) {
+        const server = this.servers.get(profileKey);
+        if (!server)
+            return () => { };
+        server.exitListeners.add(listener);
+        return () => server.exitListeners.delete(listener);
+    }
+    async stop(profileKey) {
+        const server = this.servers.get(profileKey);
+        if (!server)
+            return;
+        this.servers.delete(profileKey);
+        if (!server.exited) {
+            server.child.kill('SIGTERM');
+            await waitForExit(server.child, 3_000);
+        }
+        for (const listener of server.exitListeners)
+            listener();
+    }
+    async stopAll() {
+        await Promise.all([...this.servers.keys()].map((key) => this.stop(key)));
+    }
+    async spawn(profileKey, fingerprint, selection) {
+        const { shareDir, skillsDir } = prepareKimiShareDir({
+            stateBase: this.input.stateBase,
+            profileKey,
+            sourceShareDir: this.input.sourceShareDir,
+        });
+        materializeKimiSkillsDir(skillsDir, selection);
+        const port = await pickFreePort(this.input.startPort ?? BASE_PORT);
+        const baseUrl = `http://127.0.0.1:${port}`;
+        const child = (this.input.spawnImpl ?? spawn)(this.input.command ?? 'kimi', ['web', '--no-open', '--port', String(port)], {
+            cwd: shareDir,
+            env: kimiChildEnvironment({ KIMI_SHARE_DIR: shareDir }),
+            shell: false,
+            stdio: 'pipe',
+        });
+        const server = {
+            profileKey,
+            fingerprint,
+            child,
+            handle: {
+                profileKey,
+                baseUrl,
+                token: '',
+                shareDir,
+                skillsDir,
+                client: new KimiWebClient(baseUrl, '', this.input.fetchImpl),
+            },
+            exitListeners: new Set(),
+            exited: false,
+            logTail: '',
+        };
+        this.servers.set(profileKey, server);
+        try {
+            server.handle.token = await waitForServerReady(server);
+            server.handle.client = new KimiWebClient(baseUrl, server.handle.token, this.input.fetchImpl);
+            // Publish the profile's materialized skills dir to this isolated server.
+            await server.handle.client.post('/api/v1/config', { extra_skill_dirs: [skillsDir] });
+        }
+        catch (error) {
+            await this.stop(profileKey);
+            throw error;
+        }
+        child.once('exit', () => {
+            server.exited = true;
+            if (this.servers.get(profileKey) === server)
+                this.servers.delete(profileKey);
+            for (const listener of server.exitListeners)
+                listener();
+        });
+        return server.handle;
+    }
+}
+/** Prevents relay state from leaking into kimi web children, and pins KIMI_SHARE_DIR. */
+export function kimiChildEnvironment(overrides) {
+    const inherited = { ...process.env };
+    delete inherited.GESTALT_MOBILE_ORG_PLAN_STATUS_FILE;
+    delete inherited.GESTALT_MOBILE_ORG_PLAN_STATUS_DIRECTORY;
+    delete inherited.GESTALT_MOBILE_ORG_PLAN_MEASUREMENT_URL;
+    delete inherited.GESTALT_MOBILE_ORG_PLAN_MEASUREMENT_TOKEN;
+    delete inherited.KIMI_SHARE_DIR;
+    return { ...inherited, ...overrides };
+}
+async function pickFreePort(preferred) {
+    const probe = createServer();
+    try {
+        await new Promise((resolve) => probe.listen(0, '127.0.0.1', resolve));
+        const address = probe.address();
+        if (address && typeof address === 'object')
+            return address.port;
+    }
+    finally {
+        await new Promise((resolve) => probe.close(() => resolve()));
+    }
+    return preferred;
+}
+/** Watches the child until its token is printed and `/api/v1/meta` answers. */
+async function waitForServerReady(server) {
+    const tokenPromise = new Promise((resolve, reject) => {
+        server.child.stdout.on('data', (chunk) => {
+            server.logTail = (server.logTail + chunk.toString('utf8')).slice(-LOG_TAIL_BYTES);
+            const match = /^Token:\s+(\S+)\s*$/m.exec(server.logTail);
+            if (match)
+                resolve(match[1]);
+        });
+        server.child.once('exit', (code) => {
+            reject(new Error(`kimi web exited before becoming ready (code ${code ?? 'signal'}): ${boundMessage(server.logTail).slice(-200)}`));
+        });
+    });
+    const timeout = setTimeout(() => {
+        server.child.kill('SIGTERM');
+    }, READINESS_TIMEOUT_MS);
+    try {
+        const token = await tokenPromise;
+        const client = new KimiWebClient(server.handle.baseUrl, token);
+        const deadline = Date.now() + READINESS_TIMEOUT_MS;
+        for (;;) {
+            try {
+                await client.get('/api/v1/meta');
+                return token;
+            }
+            catch (error) {
+                if (Date.now() > deadline)
+                    throw error;
+                await delay(READINESS_POLL_MS);
+            }
+        }
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function waitForExit(child, timeoutMs) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, timeoutMs);
+        child.once('exit', () => {
+            clearTimeout(timer);
+            resolve();
+        });
+    });
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/server/server/platform/kimi/kimi-ws-client.js

@@ -0,0 +1,154 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import WebSocket from 'ws';
+import { boundMessage } from './kimi-errors.js';
+/**
+ * WebSocket client for the kimi web Server API. Client frames carry a
+ * monotonically increasing id and are acknowledged with `{type:'ack'}`;
+ * every other frame is an event whose top-level `type` is the event type
+ * (`assistant.delta`, `turn.started`, ...). Durable missed events are
+ * replayed by the server when `subscribe` carries per-session cursors.
+ */
+export class KimiWsClient {
+    baseUrl;
+    token;
+    socket = null;
+    sequence = 0;
+    pending = new Map();
+    eventListeners = new Set();
+    closeListeners = new Set();
+    connectResolve = null;
+    connectReject = null;
+    constructor(baseUrl, token) {
+        this.baseUrl = baseUrl;
+        this.token = token;
+    }
+    connect() {
+        if (this.socket)
+            return Promise.resolve();
+        const wsBase = this.baseUrl.replace(/^http/, 'ws');
+        const socket = new WebSocket(`${wsBase}/api/v1/ws`, [`kimi-code.bearer.${this.token}`]);
+        this.socket = socket;
+        socket.on('message', (data) => this.onMessage(data));
+        socket.on('close', () => this.onSocketClosed());
+        socket.on('error', () => {
+            /* surface errors through connect() or the pending acks only */
+        });
+        return new Promise((resolve, reject) => {
+            this.connectResolve = resolve;
+            this.connectReject = reject;
+            socket.once('open', () => {
+                this.send({ type: 'client_hello', payload: { client_id: 'gestalt-mobile' } });
+            });
+            // `server_hello` resolves connect(); guard against a silent hang.
+            setTimeout(() => {
+                if (this.connectReject) {
+                    const reject = this.connectReject;
+                    this.connectReject = null;
+                    reject(new Error('timed out waiting for kimi web server_hello'));
+                }
+            }, 10_000).unref();
+        });
+    }
+    onEvent(listener) {
+        this.eventListeners.add(listener);
+        return () => this.eventListeners.delete(listener);
+    }
+    onClose(listener) {
+        this.closeListeners.add(listener);
+        return () => this.closeListeners.delete(listener);
+    }
+    subscribe(sessionIds, cursors) {
+        return this.request('subscribe', { session_ids: sessionIds, ...(cursors ? { cursors } : {}) });
+    }
+    unsubscribe(sessionIds) {
+        return this.request('unsubscribe', { session_ids: sessionIds });
+    }
+    abort(sessionId, promptId) {
+        return this.request('abort', { session_id: sessionId, prompt_id: promptId });
+    }
+    close() {
+        const socket = this.socket;
+        this.socket = null;
+        if (socket && socket.readyState === WebSocket.OPEN)
+            socket.close();
+        this.failPending(new Error('kimi web socket closed'));
+    }
+    request(type, payload) {
+        const socket = this.socket;
+        if (!socket || socket.readyState !== WebSocket.OPEN) {
+            return Promise.reject(new Error(`kimi web socket is not open (frame ${type})`));
+        }
+        const id = `g${++this.sequence}`;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            this.send({ type, id, payload });
+        });
+    }
+    send(frame) {
+        this.socket?.send(JSON.stringify(frame));
+    }
+    onMessage(data) {
+        let frame;
+        try {
+            frame = JSON.parse(String(data));
+        }
+        catch {
+            return;
+        }
+        if (frame.type === 'server_hello') {
+            const resolve = this.connectResolve;
+            this.connectResolve = null;
+            this.connectReject = null;
+            resolve?.();
+            return;
+        }
+        if (frame.type === 'ack') {
+            const id = typeof frame.id === 'string' ? frame.id : undefined;
+            const pending = id ? this.pending.get(id) : undefined;
+            if (pending) {
+                this.pending.delete(id);
+                const ack = {
+                    type: 'ack',
+                    id,
+                    code: typeof frame.code === 'number' ? frame.code : -1,
+                    ...(typeof frame.msg === 'string' ? { msg: boundMessage(frame.msg) } : {}),
+                };
+                pending.resolve(ack);
+            }
+            return;
+        }
+        // Event frames carry the event type at the top level (for example
+        // `{type:'assistant.delta', payload:{delta}}`). The gestalt event
+        // contract keeps the type inside the payload, so it is folded in here;
+        // any non-hello, non-ack frame is an event.
+        if (typeof frame.type === 'string') {
+            const payload = frame.payload && typeof frame.payload === 'object' ? frame.payload : {};
+            const event = {
+                ...frame,
+                payload: { ...payload, type: frame.type },
+            };
+            for (const listener of this.eventListeners)
+                listener(event);
+        }
+    }
+    onSocketClosed() {
+        this.socket = null;
+        const reject = this.connectReject;
+        this.connectReject = null;
+        this.connectResolve = null;
+        reject?.(new Error('kimi web socket closed before server_hello'));
+        this.failPending(new Error('kimi web socket closed'));
+        for (const listener of this.closeListeners)
+            listener();
+    }
+    failPending(reason) {
+        const pending = [...this.pending.values()];
+        this.pending.clear();
+        for (const entry of pending)
+            entry.reject(reason);
+    }
+}

package/dist/server/server/platform/persistence/migrate.js

@@ -22,6 +22,8 @@ export function migrate(database) {
         database.exec('ALTER TABLE relay_sessions ADD COLUMN sandbox TEXT');
     if (!columns.some((column) => column.name === 'approval_policy'))
         database.exec('ALTER TABLE relay_sessions ADD COLUMN approval_policy TEXT');
+    if (!columns.some((column) => column.name === 'provider'))
+        database.exec("ALTER TABLE relay_sessions ADD COLUMN provider TEXT NOT NULL DEFAULT 'codex'");
     const autopilotColumns = database
         .prepare('PRAGMA table_info(autopilot_sessions)')
         .all();

package/dist/server/server/platform/persistence/sqlite-session-repository.js

@@ -11,8 +11,8 @@ export class SqliteSessionRepository {
     }
     save(session) {
         this.db
-            .prepare('INSERT INTO relay_sessions (id,workspace_id,workspace_path,profile,model,branch,sandbox,approval_policy,thread_id,state,desired_state,active_turn_id,protocol_version,attention_tool_capability,failure_count,effective_skill_selection_json,last_org_plan_json,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET workspace_id=excluded.workspace_id,workspace_path=excluded.workspace_path,profile=excluded.profile,model=excluded.model,branch=excluded.branch,sandbox=excluded.sandbox,approval_policy=excluded.approval_policy,thread_id=excluded.thread_id,state=excluded.state,desired_state=excluded.desired_state,active_turn_id=excluded.active_turn_id,protocol_version=excluded.protocol_version,attention_tool_capability=excluded.attention_tool_capability,failure_count=excluded.failure_count,effective_skill_selection_json=excluded.effective_skill_selection_json,last_org_plan_json=excluded.last_org_plan_json,updated_at=excluded.updated_at')
-            .run(session.id, session.workspaceId, session.workspacePath, session.profile, session.model ?? null, session.branch ?? null, session.executionPolicy?.sandbox ?? null, session.executionPolicy?.approvalPolicy ?? null, session.threadId, session.state, session.desiredState, session.activeTurnId, session.protocolVersion, session.attentionToolCapability ?? null, session.failureCount, session.effectiveSkillSelection === undefined
+            .prepare('INSERT INTO relay_sessions (id,workspace_id,workspace_path,provider,profile,model,branch,sandbox,approval_policy,thread_id,state,desired_state,active_turn_id,protocol_version,attention_tool_capability,failure_count,effective_skill_selection_json,last_org_plan_json,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET workspace_id=excluded.workspace_id,workspace_path=excluded.workspace_path,provider=excluded.provider,profile=excluded.profile,model=excluded.model,branch=excluded.branch,sandbox=excluded.sandbox,approval_policy=excluded.approval_policy,thread_id=excluded.thread_id,state=excluded.state,desired_state=excluded.desired_state,active_turn_id=excluded.active_turn_id,protocol_version=excluded.protocol_version,attention_tool_capability=excluded.attention_tool_capability,failure_count=excluded.failure_count,effective_skill_selection_json=excluded.effective_skill_selection_json,last_org_plan_json=excluded.last_org_plan_json,updated_at=excluded.updated_at')
+            .run(session.id, session.workspaceId, session.workspacePath, session.provider, session.profile, session.model ?? null, session.branch ?? null, session.executionPolicy?.sandbox ?? null, session.executionPolicy?.approvalPolicy ?? null, session.threadId, session.state, session.desiredState, session.activeTurnId, session.protocolVersion, session.attentionToolCapability ?? null, session.failureCount, session.effectiveSkillSelection === undefined
             ? null
             : JSON.stringify(session.effectiveSkillSelection), session.lastOrgPlan === undefined ? null : JSON.stringify(session.lastOrgPlan), session.createdAt, session.updatedAt);
     }
@@ -45,6 +45,7 @@ function map(row) {
         id: row.id,
         workspaceId: row.workspace_id,
         workspacePath: row.workspace_path,
+        provider: row.provider === 'kimi' ? 'kimi' : 'codex',
         profile: row.profile,
         ...(row.model === null ? {} : { model: row.model }),
         ...(row.branch === null ? {} : { branch: row.branch }),

package/dist/server/shared/contracts/llm-provider.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export const llmProviders = ['codex', 'kimi'];