@pasko70/pibo 1.16.6 → 2.0.0

package/dist/agent-runtimes/codex-native/thread.js

@@ -0,0 +1,388 @@
+import { CodexAppServerRpcResponseError, } from "./client.js";
+import { redactCodexNativeSensitiveText } from "./redaction.js";
+export const CODEX_NATIVE_ADAPTER_ID = "codex-native";
+const THREAD_LIST_LIMIT = 100;
+const THREAD_LIST_SOURCE_KINDS = [
+    "cli",
+    "vscode",
+    "exec",
+    "appServer",
+    "subAgent",
+    "subAgentReview",
+    "subAgentCompact",
+    "subAgentThreadSpawn",
+    "subAgentOther",
+    "unknown",
+];
+const THREAD_MISSING_PATTERN = /\b(?:thread(?:\s+\S+)?\s+(?:not found|not loaded)|no rollout found for (?:thread|conversation) id|failed to resolve rollout path[^\r\n]{0,2048}(?:file does not exist|no such file or directory))\b/i;
+const TURN_STATUSES = new Set(["completed", "interrupted", "failed", "inProgress"]);
+const THREAD_STATUS_TYPES = new Set(["notLoaded", "idle", "systemError", "active"]);
+export class CodexNativeThreadMissingError extends Error {
+    threadId;
+    constructor(threadId) {
+        super("The bound Codex thread is not available in this configured runtime instance.");
+        this.threadId = threadId;
+        this.name = "CodexNativeThreadMissingError";
+    }
+}
+export class CodexNativeThreadProtocolError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CodexNativeThreadProtocolError";
+    }
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function finiteInteger(value, label) {
+    if (!Number.isSafeInteger(value))
+        throw new CodexNativeThreadProtocolError(`Codex ${label} is invalid.`);
+    return Number(value);
+}
+function optionalInteger(value, label) {
+    if (value === undefined || value === null)
+        return value;
+    return finiteInteger(value, label);
+}
+function requiredString(value, label) {
+    if (typeof value !== "string" || !value.trim())
+        throw new CodexNativeThreadProtocolError(`Codex ${label} is missing.`);
+    return value;
+}
+function optionalString(value, label) {
+    if (value === undefined || value === null)
+        return value;
+    if (typeof value !== "string")
+        throw new CodexNativeThreadProtocolError(`Codex ${label} is invalid.`);
+    return value;
+}
+export function validateCodexAppServerThreadStatus(value) {
+    if (!isRecord(value) || typeof value.type !== "string" || !THREAD_STATUS_TYPES.has(value.type)) {
+        throw new CodexNativeThreadProtocolError("Codex thread status is invalid.");
+    }
+    if (value.type === "active") {
+        if (!Array.isArray(value.activeFlags) || value.activeFlags.some((flag) => typeof flag !== "string")) {
+            throw new CodexNativeThreadProtocolError("Codex active thread flags are invalid.");
+        }
+        return { type: "active", activeFlags: [...value.activeFlags] };
+    }
+    return { type: value.type };
+}
+export function validateCodexAppServerThreadItem(value) {
+    if (!isRecord(value))
+        throw new CodexNativeThreadProtocolError("Codex thread item is invalid.");
+    const id = requiredString(value.id, "thread item id");
+    const type = requiredString(value.type, "thread item type");
+    return structuredClone({ ...value, id, type });
+}
+export function validateCodexAppServerTurn(value) {
+    if (!isRecord(value))
+        throw new CodexNativeThreadProtocolError("Codex turn is invalid.");
+    const id = requiredString(value.id, "turn id");
+    if (typeof value.status !== "string" || !TURN_STATUSES.has(value.status)) {
+        throw new CodexNativeThreadProtocolError("Codex turn status is invalid.");
+    }
+    if (!Array.isArray(value.items))
+        throw new CodexNativeThreadProtocolError("Codex turn items are invalid.");
+    const itemsView = optionalString(value.itemsView, "turn items view");
+    if (itemsView !== undefined && itemsView !== null && !["notLoaded", "summary", "full"].includes(itemsView)) {
+        throw new CodexNativeThreadProtocolError("Codex turn items view is invalid.");
+    }
+    return {
+        id,
+        status: value.status,
+        items: value.items.map(validateCodexAppServerThreadItem),
+        ...(itemsView ? { itemsView: itemsView } : {}),
+        ...((value.startedAt !== undefined) ? { startedAt: optionalInteger(value.startedAt, "turn start timestamp") } : {}),
+        ...((value.completedAt !== undefined) ? { completedAt: optionalInteger(value.completedAt, "turn completion timestamp") } : {}),
+        ...((value.durationMs !== undefined) ? { durationMs: optionalInteger(value.durationMs, "turn duration") } : {}),
+        ...(value.error !== undefined ? { error: structuredClone(value.error) } : {}),
+    };
+}
+export function validateCodexAppServerThread(value) {
+    if (!isRecord(value))
+        throw new CodexNativeThreadProtocolError("Codex thread response is invalid.");
+    if (!Array.isArray(value.turns))
+        throw new CodexNativeThreadProtocolError("Codex thread turns are invalid.");
+    return {
+        id: requiredString(value.id, "thread id"),
+        preview: typeof value.preview === "string" ? value.preview : "",
+        modelProvider: requiredString(value.modelProvider, "thread model provider"),
+        createdAt: finiteInteger(value.createdAt, "thread creation timestamp"),
+        updatedAt: finiteInteger(value.updatedAt, "thread update timestamp"),
+        ...((value.recencyAt !== undefined) ? { recencyAt: optionalInteger(value.recencyAt, "thread recency timestamp") } : {}),
+        cwd: requiredString(value.cwd, "thread workspace"),
+        cliVersion: requiredString(value.cliVersion, "thread CLI version"),
+        source: structuredClone(value.source),
+        ...(value.threadSource !== undefined ? { threadSource: structuredClone(value.threadSource) } : {}),
+        status: validateCodexAppServerThreadStatus(value.status),
+        ephemeral: value.ephemeral === true,
+        turns: value.turns.map(validateCodexAppServerTurn),
+        sessionId: requiredString(value.sessionId, "thread session id"),
+        ...((value.name !== undefined) ? { name: optionalString(value.name, "thread name") } : {}),
+        ...((value.forkedFromId !== undefined) ? { forkedFromId: optionalString(value.forkedFromId, "fork source id") } : {}),
+        ...((value.parentThreadId !== undefined) ? { parentThreadId: optionalString(value.parentThreadId, "parent thread id") } : {}),
+        ...((value.path !== undefined) ? { path: optionalString(value.path, "thread path") } : {}),
+    };
+}
+function threadFromResponse(value, operation) {
+    if (!isRecord(value) || !Object.hasOwn(value, "thread")) {
+        throw new CodexNativeThreadProtocolError(`Codex ${operation} response is missing its thread.`);
+    }
+    return validateCodexAppServerThread(value.thread);
+}
+function threadSessionFromResponse(value, operation) {
+    const record = isRecord(value) ? value : undefined;
+    const thread = threadFromResponse(value, operation);
+    if (!record)
+        throw new CodexNativeThreadProtocolError(`Codex ${operation} response is invalid.`);
+    const reasoningEffort = optionalString(record.reasoningEffort, `${operation} reasoning effort`);
+    const serviceTier = optionalString(record.serviceTier, `${operation} service tier`);
+    return {
+        thread,
+        configuration: {
+            model: requiredString(record.model, `${operation} model`),
+            modelProvider: requiredString(record.modelProvider, `${operation} model provider`),
+            ...(reasoningEffort !== undefined ? { reasoningEffort } : {}),
+            ...(serviceTier !== undefined ? { serviceTier } : {}),
+        },
+    };
+}
+export function isCodexNativeThreadMissingError(error) {
+    return error instanceof CodexNativeThreadMissingError
+        || (error instanceof CodexAppServerRpcResponseError
+            && error.rpcCode === -32600
+            && THREAD_MISSING_PATTERN.test(error.message));
+}
+function normalizeThreadError(error, threadId) {
+    if (isCodexNativeThreadMissingError(error))
+        throw new CodexNativeThreadMissingError(threadId);
+    throw error;
+}
+function secondsToIso(seconds) {
+    if (!Number.isSafeInteger(seconds))
+        return undefined;
+    const date = new Date(Number(seconds) * 1_000);
+    return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+}
+function itemText(item) {
+    if (item.type === "agentMessage" && typeof item.text === "string")
+        return redactCodexNativeSensitiveText(item.text);
+    if (item.type === "userMessage" && Array.isArray(item.content)) {
+        const text = item.content
+            .filter((part) => isRecord(part) && part.type === "text" && typeof part.text === "string")
+            .map((part) => redactCodexNativeSensitiveText(part.text))
+            .join("\n");
+        return text || undefined;
+    }
+    return undefined;
+}
+function threadLeafId(thread) {
+    return thread.turns.at(-1)?.id ?? null;
+}
+export function codexThreadSnapshot(runtimeInstanceId, thread) {
+    return {
+        adapterId: CODEX_NATIVE_ADAPTER_ID,
+        runtimeInstanceId,
+        nativeSessionId: thread.id,
+        locator: { kind: "adapter-resolved" },
+        leafId: threadLeafId(thread),
+        cwd: thread.cwd,
+        name: thread.name ? redactCodexNativeSensitiveText(thread.name) : undefined,
+        metadata: {
+            cliVersion: thread.cliVersion,
+            modelProvider: thread.modelProvider,
+            status: thread.status.type,
+        },
+    };
+}
+export function codexThreadInfo(runtimeInstanceId, thread) {
+    return {
+        ...codexThreadSnapshot(runtimeInstanceId, thread),
+        createdAt: secondsToIso(thread.createdAt),
+        updatedAt: secondsToIso(thread.updatedAt),
+        firstMessage: thread.preview ? redactCodexNativeSensitiveText(thread.preview) : undefined,
+    };
+}
+export function codexThreadForkCandidates(thread) {
+    return thread.turns.map((turn) => {
+        const text = [...turn.items].reverse().map(itemText).find((candidate) => candidate?.trim()) ?? `Codex turn ${turn.id}`;
+        return { entryId: turn.id, text };
+    });
+}
+export class CodexNativeThreadController {
+    client;
+    currentThread;
+    currentConfiguration;
+    resourceSelection;
+    knownThreads = new Map();
+    constructor(client, currentThread, currentConfiguration, resourceSelection) {
+        this.client = client;
+        this.currentThread = currentThread;
+        this.currentConfiguration = currentConfiguration;
+        this.resourceSelection = resourceSelection;
+        this.knownThreads.set(currentThread.id, structuredClone(currentThread));
+    }
+    static async start(client, workspace, selection = {}) {
+        const response = await client.request("thread/start", {
+            cwd: workspace,
+            ephemeral: false,
+            ...(selection.model ? { model: selection.model } : {}),
+            ...(selection.serviceTier !== undefined ? { serviceTier: selection.serviceTier } : {}),
+            ...(selection.personality !== undefined ? { personality: selection.personality } : {}),
+            ...(selection.config ? { config: selection.config } : {}),
+            ...(selection.developerInstructions ? { developerInstructions: selection.developerInstructions } : {}),
+        });
+        const selected = threadSessionFromResponse(response, "thread/start");
+        return new CodexNativeThreadController(client, selected.thread, selected.configuration, {
+            ...(selection.config ? { config: structuredClone(selection.config) } : {}),
+            ...(selection.developerInstructions ? { developerInstructions: selection.developerInstructions } : {}),
+        });
+    }
+    static async resume(client, threadId, workspace, selection = {}) {
+        try {
+            const response = await client.request("thread/resume", {
+                threadId,
+                cwd: workspace,
+                ...(selection.model ? { model: selection.model } : {}),
+                ...(selection.serviceTier !== undefined ? { serviceTier: selection.serviceTier } : {}),
+                ...(selection.personality !== undefined ? { personality: selection.personality } : {}),
+                ...(selection.config ? { config: selection.config } : {}),
+                ...(selection.developerInstructions ? { developerInstructions: selection.developerInstructions } : {}),
+            });
+            const selected = threadSessionFromResponse(response, "thread/resume");
+            const thread = selected.thread;
+            if (thread.id !== threadId)
+                throw new CodexNativeThreadProtocolError("Codex resumed a different thread than requested.");
+            return new CodexNativeThreadController(client, thread, selected.configuration, {
+                ...(selection.config ? { config: structuredClone(selection.config) } : {}),
+                ...(selection.developerInstructions ? { developerInstructions: selection.developerInstructions } : {}),
+            });
+        }
+        catch (error) {
+            return normalizeThreadError(error, threadId);
+        }
+    }
+    static async read(client, threadId, includeTurns) {
+        try {
+            const response = await client.request("thread/read", { threadId, includeTurns });
+            const thread = threadFromResponse(response, "thread/read");
+            if (thread.id !== threadId)
+                throw new CodexNativeThreadProtocolError("Codex read a different thread than requested.");
+            return thread;
+        }
+        catch (error) {
+            return normalizeThreadError(error, threadId);
+        }
+    }
+    get thread() {
+        return structuredClone(this.currentThread);
+    }
+    get configuration() {
+        return structuredClone(this.currentConfiguration);
+    }
+    getSnapshot(runtimeInstanceId) {
+        return codexThreadSnapshot(runtimeInstanceId, this.currentThread);
+    }
+    getForkCandidates() {
+        return codexThreadForkCandidates(this.currentThread);
+    }
+    setStatus(status) {
+        this.currentThread = { ...this.currentThread, status: structuredClone(status) };
+        this.knownThreads.set(this.currentThread.id, structuredClone(this.currentThread));
+    }
+    recordTurn(turn) {
+        const turns = this.currentThread.turns.map((entry) => structuredClone(entry));
+        const existingIndex = turns.findIndex((entry) => entry.id === turn.id);
+        if (existingIndex >= 0)
+            turns[existingIndex] = structuredClone(turn);
+        else
+            turns.push(structuredClone(turn));
+        const terminal = turn.status !== "inProgress";
+        const updatedAt = Math.max(this.currentThread.updatedAt, turn.completedAt ?? turn.startedAt ?? Math.floor(Date.now() / 1_000));
+        this.currentThread = {
+            ...this.currentThread,
+            turns,
+            updatedAt,
+            recencyAt: updatedAt,
+            status: terminal ? { type: "idle" } : { type: "active", activeFlags: [] },
+        };
+        this.knownThreads.set(this.currentThread.id, structuredClone(this.currentThread));
+    }
+    async list(runtimeInstanceId, workspace) {
+        const params = {
+            cwd: workspace,
+            limit: THREAD_LIST_LIMIT,
+            sortKey: "updated_at",
+            sortDirection: "desc",
+            archived: false,
+            sourceKinds: THREAD_LIST_SOURCE_KINDS,
+        };
+        const response = await this.client.request("thread/list", params);
+        if (!isRecord(response) || !Array.isArray(response.data)) {
+            throw new CodexNativeThreadProtocolError("Codex thread/list response is invalid.");
+        }
+        const threads = new Map();
+        for (const value of response.data) {
+            const thread = validateCodexAppServerThread(value);
+            threads.set(thread.id, thread);
+            this.knownThreads.set(thread.id, structuredClone(thread));
+        }
+        for (const thread of this.knownThreads.values()) {
+            if (thread.cwd === workspace && !threads.has(thread.id)) {
+                threads.set(thread.id, structuredClone(thread));
+            }
+        }
+        return [...threads.values()]
+            .sort((left, right) => right.updatedAt - left.updatedAt || right.createdAt - left.createdAt)
+            .map((thread) => codexThreadInfo(runtimeInstanceId, thread));
+    }
+    async fork(runtimeInstanceId, workspace, lastTurnId, validateThread) {
+        if (!lastTurnId.trim())
+            throw new Error("Codex thread fork requires a native turn id.");
+        return await this.forkAt(runtimeInstanceId, workspace, lastTurnId, validateThread);
+    }
+    async clone(runtimeInstanceId, workspace, validateThread) {
+        return await this.forkAt(runtimeInstanceId, workspace, undefined, validateThread);
+    }
+    async forkAt(runtimeInstanceId, workspace, lastTurnId, validateThread) {
+        const previousThread = this.currentThread;
+        const previous = codexThreadSnapshot(runtimeInstanceId, previousThread);
+        const params = {
+            threadId: previousThread.id,
+            ...(lastTurnId ? { lastTurnId } : {}),
+            cwd: workspace,
+            ephemeral: false,
+            ...(this.resourceSelection.config ? { config: structuredClone(this.resourceSelection.config) } : {}),
+            ...(this.resourceSelection.developerInstructions
+                ? { developerInstructions: this.resourceSelection.developerInstructions }
+                : {}),
+        };
+        try {
+            const response = await this.client.request("thread/fork", params);
+            const selected = threadSessionFromResponse(response, "thread/fork");
+            const forked = selected.thread;
+            if (forked.id === previousThread.id) {
+                throw new CodexNativeThreadProtocolError("Codex thread/fork returned the source thread id.");
+            }
+            await validateThread?.(forked.id);
+            const selectedText = lastTurnId
+                ? codexThreadForkCandidates(previousThread).find((candidate) => candidate.entryId === lastTurnId)?.text
+                : undefined;
+            this.knownThreads.set(previousThread.id, structuredClone(previousThread));
+            this.knownThreads.set(forked.id, structuredClone(forked));
+            this.currentThread = forked;
+            this.currentConfiguration = selected.configuration;
+            return {
+                previous,
+                current: codexThreadSnapshot(runtimeInstanceId, forked),
+                cancelled: false,
+                ...(selectedText ? { selectedText } : {}),
+                ...(lastTurnId ? { summaryEntryId: lastTurnId } : {}),
+            };
+        }
+        catch (error) {
+            return normalizeThreadError(error, previousThread.id);
+        }
+    }
+}