gestalt-mobile 0.35.4 → 0.36.0

package/dist/server/server/features/sessions/list-models/endpoint.js

@@ -0,0 +1,16 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { z } from 'zod';
+const paramsSchema = z.object({ provider: z.enum(['codex', 'kimi']) });
+/** Resolves the selected provider's current model catalog for new-session setup. */
+export function registerListSessionModels(app, models) {
+    app.post('/api/session-models/:provider', async (request, reply) => {
+        const parsed = paramsSchema.safeParse(request.params);
+        if (!parsed.success)
+            return reply.code(400).send({ code: 'PROVIDER_INVALID' });
+        return { models: await models.list(parsed.data.provider) };
+    });
+}

package/dist/server/server/features/sessions/list-recent-threads/endpoint.js

@@ -7,18 +7,23 @@ import { buildResumeCommand } from '../application/resume-command.js';
 export function registerListRecentThreads(app, deps) {
     app.get('/api/sessions/recent-threads', async () => {
         const threads = await deps.list();
-        return threads.map(({ id, cwd, recencyAt }) => {
-            const metadata = deps.metadata?.(id);
+        return threads.map(({ id, cwd, recencyAt, provider }) => {
+            const metadata = deps.metadata?.(id, provider ?? 'codex');
             return {
                 id,
                 cwd,
                 recencyAt,
+                ...(provider ? { provider } : {}),
                 ...(metadata?.model === undefined ? {} : { model: metadata.model }),
                 ...(metadata?.skillProfile === undefined ? {} : { skillProfile: metadata.skillProfile }),
                 ...(metadata?.orgPlanFilename === undefined
                     ? {}
                     : { orgPlanFilename: metadata.orgPlanFilename }),
-                resumeCommand: buildResumeCommand({ threadId: id, workspacePath: cwd }),
+                // The CLI resume command is codex-specific; kimi threads open in the
+                // relay without one.
+                ...(provider === 'kimi'
+                    ? {}
+                    : { resumeCommand: buildResumeCommand({ threadId: id, workspacePath: cwd }) }),
             };
         });
     });

package/dist/server/server/features/sessions/list-sessions/endpoint.js

@@ -24,7 +24,7 @@ export function registerListSessions(app, deps) {
                 pendingAttention: Boolean(session.pendingInteractions?.length),
                 observedAt: new Date().toISOString(),
             }),
-            resumeCommand: session.threadId ? buildResumeCommand(session) : null,
+            resumeCommand: session.threadId && session.provider !== 'kimi' ? buildResumeCommand(session) : null,
         };
     }));
 }

package/dist/server/server/features/sessions/model/relay-session.js

@@ -51,6 +51,7 @@ export class RelaySession {
             id: sessionId(input.id),
             workspaceId: workspaceId(input.workspaceId),
             workspacePath: workspacePath(input.workspacePath),
+            provider: input.provider,
             profile: profileName(input.profile),
             ...(input.model === undefined ? {} : { model: input.model }),
             ...(input.branch === undefined ? {} : { branch: input.branch }),
@@ -72,6 +73,7 @@ export class RelaySession {
             id: sessionId(input.id),
             workspaceId: workspaceId(input.workspaceId),
             workspacePath: workspacePath(input.workspacePath),
+            provider: input.provider,
             profile: profileName(input.profile),
             ...(input.executionPolicy === undefined
                 ? {}

package/dist/server/server/features/sessions/promote-recent-thread/endpoint.js

@@ -8,13 +8,17 @@ import { RecentThreadHistoryUnavailable } from './use-case.js';
 const requestSchema = z.object({
     threadId: z.string().min(1),
     cwd: z.string().startsWith('/'),
+    // Requests written before provider support remain Codex-compatible.
+    provider: z.enum(['codex', 'kimi']).optional().default('codex'),
 });
 export function registerPromoteRecentThread(app, deps) {
     app.post('/api/sessions/recent-threads/open', { bodyLimit: 8 * 1024 }, async (request, reply) => {
         const parsed = requestSchema.safeParse(request.body);
         if (!parsed.success)
             return reply.code(400).send({ code: 'INVALID_RECENT_THREAD' });
-        const thread = (await deps.list()).find((candidate) => candidate.id === parsed.data.threadId && candidate.cwd === parsed.data.cwd);
+        const thread = (await deps.list()).find((candidate) => candidate.id === parsed.data.threadId &&
+            candidate.cwd === parsed.data.cwd &&
+            (candidate.provider ?? 'codex') === parsed.data.provider);
         if (!thread)
             return reply.code(404).send({ code: 'RECENT_THREAD_NOT_FOUND' });
         try {
@@ -27,7 +31,7 @@ export function registerPromoteRecentThread(app, deps) {
                     ? 'RECENT_THREAD_HISTORY_UNAVAILABLE'
                     : 'RECENT_THREAD_OPEN_FAILED',
                 detail: historyUnavailable
-                    ? 'The selected thread history is currently unavailable. Retry after Codex is available.'
+                    ? 'The selected thread history is currently unavailable. Retry after its provider is available.'
                     : 'The selected thread could not be opened. Retry shortly.',
             });
         }

package/dist/server/server/features/sessions/promote-recent-thread/use-case.js

@@ -11,7 +11,8 @@ export class RecentThreadHistoryUnavailable extends Error {
 }
 const inFlightPromotions = new Map();
 export async function promoteRecentThread(thread, deps) {
-    const key = `${thread.profile}:${thread.cwd}:${thread.id}`;
+    const provider = thread.provider ?? 'codex';
+    const key = `${provider}:${thread.profile}:${thread.cwd}:${thread.id}`;
     const ongoing = inFlightPromotions.get(key);
     if (ongoing)
         return ongoing;
@@ -26,7 +27,10 @@ export async function promoteRecentThread(thread, deps) {
     }
 }
 async function promote(thread, deps) {
-    const existing = deps.list().find((session) => session.threadId === thread.id);
+    const provider = thread.provider ?? 'codex';
+    const existing = deps
+        .list()
+        .find((session) => session.threadId === thread.id && (session.provider ?? 'codex') === provider);
     if (existing) {
         const executionPolicy = existing.executionPolicy
             ? undefined
@@ -51,6 +55,7 @@ async function promote(thread, deps) {
             id: deps.createId(),
             workspaceId: thread.cwd,
             workspacePath: thread.cwd,
+            provider,
             profile: thread.profile,
             threadId: thread.id,
             ...(executionPolicy === undefined ? {} : { executionPolicy }),

package/dist/server/server/features/sessions/register-routes.js

@@ -17,6 +17,7 @@ import { registerReleaseSession } from './release-session/endpoint.js';
 import { registerRestoreSession } from './restore-session/endpoint.js';
 import { registerRespondInteraction } from './respond-interaction/endpoint.js';
 import { registerSelectModel } from './select-model/endpoint.js';
+import { registerListSessionModels } from './list-models/endpoint.js';
 import { registerSessionEvents } from './session-events/endpoint.js';
 import { registerStartSession } from './start-session/endpoint.js';
 import { registerStartTurn } from './start-turn/endpoint.js';
@@ -27,8 +28,10 @@ export function registerSessionRoutes(app, deps) {
     if (deps.recentThreads) {
         registerListRecentThreads(app, {
             ...deps.recentThreads,
-            metadata: (threadId) => {
-                const session = sessions?.list?.().find((candidate) => candidate.threadId === threadId);
+            metadata: (threadId, provider) => {
+                const session = sessions
+                    ?.list?.()
+                    .find((candidate) => candidate.threadId === threadId && (candidate.provider ?? 'codex') === provider);
                 if (!session)
                     return null;
                 return {
@@ -44,6 +47,8 @@ export function registerSessionRoutes(app, deps) {
         });
     }
     if (sessions) {
+        if (sessions.sessionModels)
+            registerListSessionModels(app, sessions.sessionModels);
         registerStartSession(app, {
             ...sessions,
             reportFailure: (operation, error) => deps.logger.error(`${operation} failed: ${safeErrorLabel(error)}`),
@@ -84,7 +89,7 @@ export function registerSessionRoutes(app, deps) {
         if (sessions.models)
             registerSelectModel(app, {
                 find: sessions.find,
-                models: () => sessions.models.list(),
+                models: (provider) => sessions.models.list(provider),
                 now: sessions.now,
                 save: sessions.save,
             });

package/dist/server/server/features/sessions/respond-interaction/endpoint.js

@@ -18,7 +18,7 @@ export function registerRespondInteraction(app, deps) {
             return reply.code(409).send({ code: 'INTERACTION_NOT_PENDING' });
         if (deps.validate && !deps.validate(id, requestId, value))
             return reply.code(400).send({ code: 'INTERACTION_RESPONSE_INVALID' });
-        const delivery = deps.reply(id, requestId, value);
+        const delivery = await deps.reply(id, requestId, value);
         if (delivery === false || delivery === 'unavailable')
             return reply.code(409).send({ code: 'INTERACTION_DELIVERY_UNAVAILABLE' });
         if (delivery === 'cleared') {

package/dist/server/server/features/sessions/select-model/endpoint.js

@@ -12,7 +12,7 @@ export function registerSelectModel(app, deps) {
         const model = request.body.model;
         if (typeof model !== 'string')
             return reply.code(400).send({ code: 'MODEL_REQUIRED' });
-        if (!(await deps.models()).includes(model))
+        if (!(await deps.models(session.provider)).includes(model))
             return reply.code(400).send({ code: 'MODEL_UNAVAILABLE' });
         if (session.state !== 'ready')
             return reply.code(409).send({ code: 'SESSION_NOT_READY' });

package/dist/server/server/features/sessions/start-session/request.js

@@ -6,6 +6,7 @@
 import { z } from 'zod';
 const schema = z.object({
     workspaceId: z.string().min(1),
+    provider: z.enum(['codex', 'kimi']),
     profile: z.string().min(1),
     skillProfile: z.string().trim().min(1).optional(),
     model: z

package/dist/server/server/features/sessions/start-session/use-case.js

@@ -8,15 +8,28 @@ import { DEFAULT_SESSION_MODEL } from '../application/start-settings.js';
 import { reconcileSkillSelectionSnapshot, } from '../../skills/model/skill-profile.js';
 import { SkillProfileError } from '../../skills/model/errors.js';
 export async function startSession(input, deps) {
-    const model = input.model ?? DEFAULT_SESSION_MODEL;
+    // Codex launcher profiles select the app-server skill directory. Kimi owns
+    // its isolated profile lifecycle, so it must not require a Codex launcher
+    // profile before its own catalog/runtime can be selected.
     const [workspace] = await Promise.all([
         deps.workspaces.resolve(input.workspaceId),
-        deps.profiles.require(input.profile),
+        ...(input.provider === 'codex' ? [deps.profiles.require(input.profile)] : []),
     ]);
-    if (deps.models) {
-        const models = await deps.models.list();
+    let model = input.model;
+    const modelCatalog = deps.sessionModels ?? deps.models;
+    if (modelCatalog) {
+        const models = await modelCatalog.list(input.provider);
+        // An omitted model resolves to the provider's own default: the relay-wide
+        // default when that provider serves it, otherwise the provider's first
+        // available model, so a kimi request never inherits the codex default.
+        model ??= models.includes(DEFAULT_SESSION_MODEL)
+            ? DEFAULT_SESSION_MODEL
+            : (models[0] ?? DEFAULT_SESSION_MODEL);
         if (!models.includes(model))
-            throw new Error('CODEX_MODEL_UNAVAILABLE');
+            throw new Error(input.provider === 'codex' ? 'CODEX_MODEL_UNAVAILABLE' : 'KIMI_MODEL_UNAVAILABLE');
+    }
+    else {
+        model ??= DEFAULT_SESSION_MODEL;
     }
     const selectedProfile = input.skillProfile
         ? await deps.skillProfiles.readGlobalProfile(input.skillProfile)
@@ -25,7 +38,7 @@ export async function startSession(input, deps) {
         throw new SkillProfileError('UNKNOWN_SKILL_PROFILE', 'The selected skill profile does not exist.');
     const [projectProfile, catalog] = await Promise.all([
         deps.skillProfiles.readWorkspaceDefault(workspace.realPath),
-        deps.skillCatalog(input.profile).list(workspace.realPath),
+        deps.skillCatalog(input.provider, input.profile).list(workspace.realPath),
     ]);
     const sourceProfile = selectedProfile ?? projectProfile;
     const reconciledSkills = reconcileSkillSelectionSnapshot(catalog.skills, sourceProfile?.skills);
@@ -46,6 +59,7 @@ export async function startSession(input, deps) {
         id: deps.createId(),
         workspaceId: workspace.id,
         workspacePath: workspace.realPath,
+        provider: input.provider,
         profile: input.profile,
         model,
         ...(branch ? { branch } : {}),
@@ -57,7 +71,7 @@ export async function startSession(input, deps) {
     deps.save(session);
     if (!deps.activate)
         return session;
-    const active = await deps.activate(session, {});
+    const active = await deps.activate(session, { provider: session.provider });
     deps.save(active);
     return active;
 }

package/dist/server/server/features/skills/list-available/endpoint.js

@@ -11,6 +11,7 @@ const querySchema = z
     .object({
     workspaceId: z.string().min(1),
     profile: z.string().min(1),
+    provider: z.enum(['codex', 'kimi']).optional(),
     refresh: z.enum(['true']).optional(),
 })
     .strict();
@@ -28,10 +29,11 @@ export function registerListAvailableSkills(app, deps) {
                 deps.workspaces.resolve(parsed.data.workspaceId),
                 deps.profiles.require(parsed.data.profile),
             ]);
+            const provider = parsed.data.provider ?? 'codex';
             const [discovered, project] = await Promise.all([
                 parsed.data.refresh
-                    ? deps.catalog.refresh(profile.name, workspace.realPath)
-                    : deps.catalog.list(profile.name, workspace.realPath),
+                    ? deps.catalog.refresh(provider, profile.name, workspace.realPath)
+                    : deps.catalog.list(provider, profile.name, workspace.realPath),
                 deps.selections.readWorkspaceDefault(workspace.realPath),
             ]);
             const skills = applySkillSelectionSnapshot(discovered.skills, project?.skills);

package/dist/server/server/platform/catalog/provider-model-catalog.js

@@ -0,0 +1,15 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+/** Routes each provider's model query to that provider's own catalog adapter. */
+export class ProviderModelCatalog {
+    catalogs;
+    constructor(catalogs) {
+        this.catalogs = catalogs;
+    }
+    list(provider) {
+        return this.catalogs[provider].list();
+    }
+}

package/dist/server/server/platform/kimi/kimi-activity-facts.js

@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+/**
+ * Decodes bounded activity evidence from kimi web events. Turn lifecycle is
+ * prompt-based; `agent.status.updated` supplies context usage and
+ * awaiting-human transitions (kimi 2.0.2 has no dedicated interaction events —
+ * pending approvals/questions arrive through status changes plus REST lists).
+ */
+export function decodeKimiActivityFacts(sessionId, occurredAt, event, context) {
+    const payload = record(event.payload);
+    if (!payload || typeof payload.type !== 'string')
+        return [];
+    switch (payload.type) {
+        case 'turn.started': {
+            const agentId = safeId(payload.agentId);
+            const turnNumber = safeTurn(payload.turnId);
+            if (!agentId || turnNumber === null)
+                return [];
+            const turnId = context.resolveTurnId(agentId, turnNumber);
+            return [
+                {
+                    sessionId,
+                    occurredAt,
+                    kind: 'turnStarted',
+                    ...(event.session_id ? { threadId: event.session_id } : {}),
+                    ...(turnId ? { turnId } : {}),
+                    ...(context.isChildAgent(agentId) ? { childThreadId: agentId } : {}),
+                },
+            ];
+        }
+        case 'prompt.completed':
+        case 'prompt.aborted': {
+            const agentId = safeId(payload.agentId);
+            const promptId = safeId(payload.promptId);
+            if (!agentId || !promptId || context.isChildAgent(agentId))
+                return [];
+            return [
+                {
+                    sessionId,
+                    occurredAt,
+                    kind: 'turnCompleted',
+                    ...(event.session_id ? { threadId: event.session_id } : {}),
+                    turnId: promptId,
+                },
+            ];
+        }
+        case 'agent.status.updated': {
+            const status = typeof payload.status === 'string' ? payload.status : null;
+            const facts = [];
+            const usage = typeof payload.contextUsage === 'number' ? payload.contextUsage : null;
+            if (usage !== null && usage >= 0) {
+                facts.push({
+                    sessionId,
+                    occurredAt,
+                    kind: 'contextUsage',
+                    ...(event.session_id ? { threadId: event.session_id } : {}),
+                    contextUsedPercent: usage <= 1 ? Math.round(usage * 100) : Math.min(100, Math.round(usage)),
+                });
+            }
+            if (status === 'awaiting_approval' || status === 'awaiting_question') {
+                facts.push({
+                    sessionId,
+                    occurredAt,
+                    kind: 'interactionPending',
+                    ...(event.session_id ? { threadId: event.session_id } : {}),
+                    attentionReason: status === 'awaiting_approval' ? 'permissionRequired' : 'materialAmbiguity',
+                });
+            }
+            return facts;
+        }
+        default:
+            return [];
+    }
+}
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+function safeId(value) {
+    return typeof value === 'string' && value.length > 0 && value.length <= 256 ? value : null;
+}
+function safeTurn(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}

package/dist/server/server/platform/kimi/kimi-errors.js

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+/**
+ * Error surfaced by the kimi web client. `code` is the protocol business code
+ * (0 means success on the wire, so a thrown error always has code !== 0);
+ * HTTP-level failures are normalized to code -1 with the transport message.
+ */
+export class KimiWebError extends Error {
+    code;
+    requestId;
+    constructor(code, message, requestId) {
+        super(boundMessage(message));
+        this.code = code;
+        this.requestId = requestId;
+        this.name = 'KimiWebError';
+    }
+}
+export function isKimiWebError(error) {
+    return error instanceof KimiWebError;
+}
+/** Caps and redacts wire messages before they enter logs or client payloads. */
+export function boundMessage(message) {
+    return message
+        .replace(/((?:authorization|token|api[_ -]?key|password)\s*[:=]\s*)\S+/gi, '$1[REDACTED]')
+        .replace(/(authentication failed:\s*).*/i, '$1[REDACTED]')
+        .slice(0, 256);
+}

package/dist/server/server/platform/kimi/kimi-model-catalog.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
+ */
+const MODELS_TIMEOUT_MS = 5_000;
+/**
+ * Lists kimi model aliases from a running gestalt-owned kimi web server
+ * (`GET /api/v1/models`) when a Kimi profile server is already running.
+ * Discovery is deliberately read-only: bootstrap must not spawn or wait for
+ * Kimi on behalf of an otherwise ordinary Codex client. Explicit Kimi session
+ * activation owns server startup; any discovery failure degrades to an empty
+ * list, matching the catalog contract.
+ */
+export class KimiModelCatalog {
+    servers;
+    available;
+    constructor(servers, available) {
+        this.servers = servers;
+        this.available = available;
+    }
+    async list() {
+        if (!this.available || !this.servers)
+            return [];
+        try {
+            const handle = this.servers.list()[0];
+            if (!handle)
+                return [];
+            return await this.read(handle);
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Explicit Kimi session setup may start its isolated default server. */
+    async listForSession() {
+        if (!this.available || !this.servers)
+            return [];
+        try {
+            return await this.read(await this.servers.ensure('default', []));
+        }
+        catch {
+            return [];
+        }
+    }
+    async read(handle) {
+        const data = await withTimeout(handle.client.get('/api/v1/models'), MODELS_TIMEOUT_MS, 'kimi model list timed out');
+        const items = Array.isArray(data?.items)
+            ? data.items
+            : [];
+        return [
+            ...new Set(items.flatMap((item) => typeof item.model === 'string' && item.model.length > 0 && item.model.length <= 128
+                ? [item.model]
+                : [])),
+        ].sort();
+    }
+}
+function withTimeout(promise, timeoutMs, message) {
+    return Promise.race([
+        promise,
+        new Promise((_resolve, reject) => setTimeout(() => reject(new Error(message)), timeoutMs).unref()),
+    ]);
+}