gestalt-mobile 0.35.4 → 0.36.0

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

@@ -0,0 +1,196 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+/**
+ * Maps kimi web session events onto the relay's provider-neutral event types.
+ * The relay's turn lifecycle is prompt-based (`prompt.completed`/`aborted`),
+ * because a gestalt turn id is the kimi prompt id; `turn.started` exists only
+ * to bind kimi per-agent turn numbers to prompt ids. Unknown future event
+ * types deliberately become `null`, mirroring the codex normalizer.
+ */
+export function normalizeKimiEvent(sessionId, sequence, occurredAt, event, context = {
+    resolveTurnId: () => null,
+    isChildAgent: () => false,
+}) {
+    const payload = record(event.payload);
+    if (!payload || typeof payload.type !== 'string')
+        return null;
+    switch (payload.type) {
+        case 'assistant.delta': {
+            const agentId = safeId(payload.agentId);
+            const turnNumber = safeTurn(payload.turnId);
+            const delta = bounded(payload.delta, 64_000);
+            if (!agentId || turnNumber === null || delta === null)
+                return null;
+            if (context.isChildAgent(agentId))
+                return null;
+            const turnId = context.resolveTurnId(agentId, turnNumber) ?? `kimi:${agentId}:${turnNumber}`;
+            return {
+                sessionId,
+                sequence,
+                occurredAt,
+                type: 'agentMessageDelta',
+                payload: { text: delta, itemId: `kimi:${agentId}:${turnNumber}`, turnId },
+            };
+        }
+        case 'tool.call.started': {
+            const toolCallId = safeId(payload.toolCallId);
+            const agentId = safeId(payload.agentId) ?? 'main';
+            const turnNumber = safeTurn(payload.turnId);
+            if (!toolCallId || turnNumber === null)
+                return null;
+            const display = record(payload.display);
+            const kind = typeof display?.kind === 'string' ? display.kind : 'generic';
+            const name = safeId(payload.name);
+            const description = bounded(payload.description, 500);
+            const detail = (typeof display?.command === 'string' ? bounded(display.command, 500) : null) ??
+                (typeof display?.path === 'string' ? bounded(display.path, 500) : null) ??
+                description ??
+                name ??
+                kind;
+            const label = kind === 'command' || kind === 'bash'
+                ? 'Command'
+                : kind === 'file_io'
+                    ? 'File'
+                    : `Tool · ${name ?? kind}`;
+            const owner = ownership(agentId, turnNumber, context);
+            return {
+                sessionId,
+                sequence,
+                occurredAt,
+                type: 'activity.updated',
+                payload: { id: toolCallId, label, detail, ...owner },
+            };
+        }
+        case 'tool.result': {
+            const toolCallId = safeId(payload.toolCallId);
+            const agentId = safeId(payload.agentId) ?? 'main';
+            const turnNumber = safeTurn(payload.turnId);
+            if (!toolCallId || turnNumber === null)
+                return null;
+            const isError = payload.isError === true;
+            const owner = ownership(agentId, turnNumber, context);
+            return {
+                sessionId,
+                sequence,
+                occurredAt,
+                type: 'activity.updated',
+                payload: {
+                    id: toolCallId,
+                    label: isError ? 'Tool error' : 'Tool result',
+                    detail: bounded(safeJson(payload.output), 400) ?? (isError ? 'failed' : 'done'),
+                    ...owner,
+                },
+            };
+        }
+        case 'subagent.spawned': {
+            const subagentId = safeId(payload.subagentId);
+            if (!subagentId)
+                return null;
+            const name = bounded(payload.subagentName, 128);
+            const description = bounded(payload.description, 300);
+            return {
+                sessionId,
+                sequence,
+                occurredAt,
+                type: 'activity.updated',
+                payload: {
+                    id: subagentId,
+                    label: 'Subagent',
+                    detail: [name, description].filter(Boolean).join(' · '),
+                    ...(context.activeTurnId ? { turnId: context.activeTurnId } : {}),
+                },
+            };
+        }
+        case 'subagent.completed':
+        case 'subagent.failed': {
+            const subagentId = safeId(payload.subagentId);
+            if (!subagentId)
+                return null;
+            const failed = payload.type === 'subagent.failed';
+            return {
+                sessionId,
+                sequence,
+                occurredAt,
+                type: 'activity.updated',
+                payload: {
+                    id: subagentId,
+                    label: failed ? 'Subagent failed' : 'Subagent completed',
+                    detail: bounded(payload.resultSummary, 500) ?? '',
+                    ...(context.activeTurnId ? { turnId: context.activeTurnId } : {}),
+                },
+            };
+        }
+        case 'prompt.completed': {
+            const agentId = safeId(payload.agentId);
+            const promptId = safeId(payload.promptId);
+            if (!agentId || !promptId || context.isChildAgent(agentId))
+                return null;
+            return {
+                sessionId,
+                sequence,
+                occurredAt,
+                type: 'turnCompleted',
+                payload: {
+                    turn: {
+                        id: promptId,
+                        ...(typeof payload.reason === 'string' ? { status: bounded(payload.reason, 64) } : {}),
+                    },
+                },
+            };
+        }
+        case 'prompt.aborted': {
+            const agentId = safeId(payload.agentId);
+            const promptId = safeId(payload.promptId);
+            if (!agentId || !promptId || context.isChildAgent(agentId))
+                return null;
+            return {
+                sessionId,
+                sequence,
+                occurredAt,
+                type: 'turnInterrupted',
+                payload: { turn: { id: promptId } },
+            };
+        }
+        default:
+            return null;
+    }
+}
+function ownership(agentId, turnNumber, context) {
+    if (context.isChildAgent(agentId)) {
+        return {
+            ...(context.activeTurnId ? { turnId: context.activeTurnId } : {}),
+            actorTurnId: `${agentId}:${turnNumber}`,
+        };
+    }
+    const turnId = context.resolveTurnId(agentId, turnNumber);
+    return turnId ? { turnId } : context.activeTurnId ? { turnId: context.activeTurnId } : {};
+}
+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;
+}
+function bounded(value, max) {
+    return typeof value === 'string' ? value.slice(0, max) : null;
+}
+function safeJson(value) {
+    if (value === undefined || value === null)
+        return null;
+    if (typeof value === 'string')
+        return value.slice(0, 400);
+    try {
+        return JSON.stringify(value).slice(0, 400);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/server/server/platform/kimi/kimi-recent-session-lister.js

@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+const LIST_PATH = '/api/v2/sessions?page_size=50&sort=meta.updated_at_desc';
+const LIST_TIMEOUT_MS = 5_000;
+/**
+ * Lists recent kimi web sessions across every running gestalt-owned server,
+ * for parity with the codex recent-thread lister. Each skill profile owns an
+ * isolated `kimi web` process and state directory, so a profile's sessions
+ * only exist on that profile's server; only already-running servers are
+ * queried, never spawned just to list. kimi timestamps arrive as epoch
+ * seconds (or, defensively, epoch millis), normalized to seconds.
+ */
+export function createKimiRecentSessionLister(deps) {
+    return {
+        async list() {
+            if (!deps.available || !deps.servers)
+                return [];
+            const listings = await Promise.all(deps.servers.list().map(listFromServer));
+            return listings.flat().sort((a, b) => (b.recencyAt ?? 0) - (a.recencyAt ?? 0));
+        },
+    };
+}
+async function listFromServer(handle) {
+    try {
+        const data = (await withTimeout(handle.client.get(LIST_PATH), LIST_TIMEOUT_MS, 'kimi session list timed out'));
+        const items = Array.isArray(data.items) ? data.items : [];
+        return items.flatMap((item) => {
+            if (!item || typeof item !== 'object')
+                return [];
+            const workspace = item.workspace;
+            const cwd = workspace && typeof workspace === 'object'
+                ? workspace.cwd
+                : undefined;
+            if (typeof item.id !== 'string' || typeof cwd !== 'string' || !cwd.startsWith('/'))
+                return [];
+            const updatedAt = item.meta && typeof item.meta === 'object'
+                ? item.meta.updated_at
+                : undefined;
+            return [
+                {
+                    id: item.id,
+                    cwd,
+                    profile: handle.profileKey,
+                    recencyAt: toEpochSeconds(updatedAt),
+                    provider: 'kimi',
+                },
+            ];
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function toEpochSeconds(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return null;
+    // Epoch millis are roughly 1e12+ today; seconds stay below 1e11 for decades.
+    return value > 1e11 ? Math.floor(value / 1000) : Math.floor(value);
+}
+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-server-request.js

@@ -0,0 +1,143 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+function safeId(value) {
+    return typeof value === 'string' && value.length > 0 && value.length <= 256 ? value : undefined;
+}
+function bounded(value, max = 1_000) {
+    if (typeof value !== 'string')
+        return '';
+    return value.slice(0, max);
+}
+function displayText(display) {
+    if (!display || typeof display !== 'object')
+        return '';
+    const record = display;
+    for (const key of ['command', 'path', 'detail', 'description', 'text']) {
+        if (typeof record[key] === 'string')
+            return bounded(record[key], 500);
+    }
+    try {
+        return bounded(JSON.stringify(display), 500);
+    }
+    catch {
+        return '';
+    }
+}
+/** Command-shaped approvals steer to commandExecution; file mutations to fileChange. */
+export function approvalToServerRequest(id, item) {
+    const approvalId = safeId(item.approval_id);
+    if (!approvalId)
+        return null;
+    const toolName = (item.tool_name ?? '').toLowerCase();
+    const fileLike = /file|write|edit|patch|str_replace|apply|notebook/.test(toolName);
+    const detail = displayText(item.tool_input_display);
+    return {
+        id,
+        method: fileLike ? 'item/fileChange/requestApproval' : 'item/commandExecution/requestApproval',
+        params: {
+            itemId: approvalId,
+            ...(item.tool_name ? { toolName: bounded(item.tool_name, 128) } : {}),
+            ...(item.action ? { reason: bounded(item.action, 256) } : {}),
+            ...(detail ? { [fileLike ? 'changes' : 'command']: detail } : {}),
+        },
+    };
+}
+export function questionToServerRequest(id, item) {
+    const questionId = safeId(item.question_id);
+    if (!questionId)
+        return null;
+    const questions = (item.questions ?? []).flatMap((question) => {
+        if (!safeId(question.id) || typeof question.question !== 'string')
+            return [];
+        return [
+            {
+                id: question.id,
+                question: bounded(question.question, 1_000),
+                ...(question.header ? { header: bounded(question.header, 200) } : {}),
+                ...(question.body ? { body: bounded(question.body, 2_000) } : {}),
+                ...(question.options && question.options.length
+                    ? {
+                        options: question.options.flatMap((option) => safeId(option.id) && typeof option.label === 'string'
+                            ? [
+                                {
+                                    id: option.id,
+                                    label: bounded(option.label, 200),
+                                    ...(option.description
+                                        ? { description: bounded(option.description, 500) }
+                                        : {}),
+                                },
+                            ]
+                            : []),
+                    }
+                    : {}),
+            },
+        ];
+    });
+    return {
+        id,
+        method: 'item/tool/requestUserInput',
+        params: { questions },
+    };
+}
+/** Translates a relay approval decision into a kimi approval decision. */
+export function kimiApprovalDecision(value) {
+    if (value === 'accept' || value === 'acceptForSession')
+        return 'approved';
+    if (value === 'decline')
+        return 'rejected';
+    if (value === 'cancel')
+        return 'cancelled';
+    return null;
+}
+/**
+ * Translates a relay userInput response (`{answers: {<qid>: {answers: string[]}}}`)
+ * into kimi's question answers map. An answer matching an option id or label
+ * becomes a single choice; anything else becomes free text.
+ */
+export function kimiQuestionAnswers(item, value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const answers = value.answers;
+    if (!answers || typeof answers !== 'object' || Array.isArray(answers))
+        return null;
+    const result = {};
+    for (const [questionId, rawAnswer] of Object.entries(answers)) {
+        const reply = rawAnswer && typeof rawAnswer === 'object' ? rawAnswer : {};
+        const texts = Array.isArray(reply.answers)
+            ? reply.answers.filter((entry) => typeof entry === 'string')
+            : [];
+        if (!texts.length) {
+            result[questionId] = { kind: 'skipped' };
+            continue;
+        }
+        const question = (item.questions ?? []).find((candidate) => candidate.id === questionId);
+        const option = question?.options?.find((candidate) => candidate.id === texts[0] || candidate.label === texts[0]);
+        result[questionId] = option
+            ? { kind: 'single', option_id: option.id }
+            : { kind: 'other', text: texts.join('\n').slice(0, 4_000) };
+    }
+    return Object.keys(result).length ? result : null;
+}
+export function decodeApprovalItems(data) {
+    const items = data?.items;
+    if (!Array.isArray(items))
+        return [];
+    return items.filter((item) => {
+        if (!item || typeof item !== 'object')
+            return false;
+        return safeId(item.approval_id) !== undefined;
+    });
+}
+export function decodeQuestionItems(data) {
+    const items = data?.items;
+    if (!Array.isArray(items))
+        return [];
+    return items.filter((item) => {
+        if (!item || typeof item !== 'object')
+            return false;
+        return safeId(item.question_id) !== undefined;
+    });
+}