@pasko70/pibo 2.5.1 → 3.0.0

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

@@ -165,17 +165,14 @@ function secondsToIso(seconds) {
     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 userMessageText(item) {
+    if (item.type !== "userMessage" || !Array.isArray(item.content))
+        return undefined;
+    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;
 }
 function threadLeafId(thread) {
     return thread.turns.at(-1)?.id ?? null;
@@ -204,23 +201,32 @@ export function codexThreadInfo(runtimeInstanceId, thread) {
         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 };
+function codexThreadForkTargets(thread) {
+    return thread.turns.flatMap((turn, index) => {
+        const userMessage = turn.items.find((item) => item.type === "userMessage");
+        if (!userMessage)
+            return [];
+        return [{
+                entryId: userMessage.id,
+                text: userMessageText(userMessage) ?? `Codex turn ${turn.id}`,
+                ...(index > 0 ? { previousTurnId: thread.turns[index - 1].id } : {}),
+            }];
     });
 }
+export function codexThreadForkCandidates(thread) {
+    return codexThreadForkTargets(thread).map(({ entryId, text }) => ({ entryId, text }));
+}
 export class CodexNativeThreadController {
     client;
     currentThread;
     currentConfiguration;
-    resourceSelection;
+    inheritedSelection;
     knownThreads = new Map();
-    constructor(client, currentThread, currentConfiguration, resourceSelection) {
+    constructor(client, currentThread, currentConfiguration, inheritedSelection) {
         this.client = client;
         this.currentThread = currentThread;
         this.currentConfiguration = currentConfiguration;
-        this.resourceSelection = resourceSelection;
+        this.inheritedSelection = inheritedSelection;
         this.knownThreads.set(currentThread.id, structuredClone(currentThread));
     }
     static async start(client, workspace, selection = {}) {
@@ -230,13 +236,18 @@ export class CodexNativeThreadController {
             ...(selection.model ? { model: selection.model } : {}),
             ...(selection.serviceTier !== undefined ? { serviceTier: selection.serviceTier } : {}),
             ...(selection.personality !== undefined ? { personality: selection.personality } : {}),
+            ...(selection.approvalPolicy ? { approvalPolicy: selection.approvalPolicy } : {}),
+            ...(selection.sandbox ? { sandbox: selection.sandbox } : {}),
             ...(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.approvalPolicy ? { approvalPolicy: selection.approvalPolicy } : {}),
+            ...(selection.sandbox ? { sandbox: selection.sandbox } : {}),
             ...(selection.config ? { config: structuredClone(selection.config) } : {}),
             ...(selection.developerInstructions ? { developerInstructions: selection.developerInstructions } : {}),
+            ...(selection.personality !== undefined ? { personality: selection.personality } : {}),
         });
     }
     static async resume(client, threadId, workspace, selection = {}) {
@@ -247,6 +258,8 @@ export class CodexNativeThreadController {
                 ...(selection.model ? { model: selection.model } : {}),
                 ...(selection.serviceTier !== undefined ? { serviceTier: selection.serviceTier } : {}),
                 ...(selection.personality !== undefined ? { personality: selection.personality } : {}),
+                ...(selection.approvalPolicy ? { approvalPolicy: selection.approvalPolicy } : {}),
+                ...(selection.sandbox ? { sandbox: selection.sandbox } : {}),
                 ...(selection.config ? { config: selection.config } : {}),
                 ...(selection.developerInstructions ? { developerInstructions: selection.developerInstructions } : {}),
             });
@@ -255,8 +268,11 @@ export class CodexNativeThreadController {
             if (thread.id !== threadId)
                 throw new CodexNativeThreadProtocolError("Codex resumed a different thread than requested.");
             return new CodexNativeThreadController(client, thread, selected.configuration, {
+                ...(selection.approvalPolicy ? { approvalPolicy: selection.approvalPolicy } : {}),
+                ...(selection.sandbox ? { sandbox: selection.sandbox } : {}),
                 ...(selection.config ? { config: structuredClone(selection.config) } : {}),
                 ...(selection.developerInstructions ? { developerInstructions: selection.developerInstructions } : {}),
+                ...(selection.personality !== undefined ? { personality: selection.personality } : {}),
             });
         }
         catch (error) {
@@ -337,15 +353,29 @@ export class CodexNativeThreadController {
             .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 fork(runtimeInstanceId, workspace, entryId, validateThread) {
+        if (!entryId.trim())
+            throw new Error("Codex thread fork requires a native user-message id.");
+        const target = codexThreadForkTargets(this.currentThread).find((candidate) => candidate.entryId === entryId);
+        if (target) {
+            if (!target.previousTurnId) {
+                return this.branchBeforeFirstTurn(runtimeInstanceId, workspace, target);
+            }
+            return await this.forkAt(runtimeInstanceId, workspace, target.previousTurnId, validateThread, target);
+        }
+        const legacyTurn = this.currentThread.turns.find((turn) => turn.id === entryId);
+        if (!legacyTurn)
+            throw new Error(`Codex fork target "${entryId}" was not found.`);
+        const legacyText = legacyTurn.items.map(userMessageText).find((text) => text?.trim());
+        return await this.forkAt(runtimeInstanceId, workspace, entryId, validateThread, {
+            entryId,
+            text: legacyText ?? `Codex turn ${entryId}`,
+        });
     }
     async clone(runtimeInstanceId, workspace, validateThread) {
         return await this.forkAt(runtimeInstanceId, workspace, undefined, validateThread);
     }
-    async forkAt(runtimeInstanceId, workspace, lastTurnId, validateThread) {
+    async forkAt(runtimeInstanceId, workspace, lastTurnId, validateThread, selectedTarget) {
         const previousThread = this.currentThread;
         const previous = codexThreadSnapshot(runtimeInstanceId, previousThread);
         const params = {
@@ -353,9 +383,11 @@ export class CodexNativeThreadController {
             ...(lastTurnId ? { lastTurnId } : {}),
             cwd: workspace,
             ephemeral: false,
-            ...(this.resourceSelection.config ? { config: structuredClone(this.resourceSelection.config) } : {}),
-            ...(this.resourceSelection.developerInstructions
-                ? { developerInstructions: this.resourceSelection.developerInstructions }
+            ...(this.inheritedSelection.approvalPolicy ? { approvalPolicy: this.inheritedSelection.approvalPolicy } : {}),
+            ...(this.inheritedSelection.sandbox ? { sandbox: this.inheritedSelection.sandbox } : {}),
+            ...(this.inheritedSelection.config ? { config: structuredClone(this.inheritedSelection.config) } : {}),
+            ...(this.inheritedSelection.developerInstructions
+                ? { developerInstructions: this.inheritedSelection.developerInstructions }
                 : {}),
         };
         try {
@@ -366,9 +398,6 @@ export class CodexNativeThreadController {
                 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;
@@ -377,12 +406,27 @@ export class CodexNativeThreadController {
                 previous,
                 current: codexThreadSnapshot(runtimeInstanceId, forked),
                 cancelled: false,
-                ...(selectedText ? { selectedText } : {}),
-                ...(lastTurnId ? { summaryEntryId: lastTurnId } : {}),
+                ...(selectedTarget?.text ? { selectedText: selectedTarget.text } : {}),
+                ...(selectedTarget ? { summaryEntryId: selectedTarget.entryId } : {}),
             };
         }
         catch (error) {
             return normalizeThreadError(error, previousThread.id);
         }
     }
+    branchBeforeFirstTurn(runtimeInstanceId, workspace, target) {
+        const previousThread = this.currentThread;
+        return {
+            previous: codexThreadSnapshot(runtimeInstanceId, previousThread),
+            current: {
+                adapterId: CODEX_NATIVE_ADAPTER_ID,
+                runtimeInstanceId,
+                cwd: workspace,
+                leafId: null,
+            },
+            cancelled: false,
+            selectedText: target.text,
+            summaryEntryId: target.entryId,
+        };
+    }
 }

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

@@ -291,6 +291,9 @@ export class CodexNativeTurnController {
             model: modelOptions.model,
             effort: modelOptions.effort,
             serviceTier: modelOptions.serviceTier,
+            approvalPolicy: modelOptions.approvalPolicy,
+            sandboxPolicy: modelOptions.sandboxPolicy,
+            ...(modelOptions.collaborationMode ? { collaborationMode: modelOptions.collaborationMode } : {}),
             ...(modelOptions.summary !== undefined ? { summary: modelOptions.summary } : {}),
             ...(modelOptions.personality !== undefined ? { personality: modelOptions.personality } : {}),
         };
@@ -316,6 +319,33 @@ export class CodexNativeTurnController {
             throw error;
         }
     }
+    replayTerminalTurn(turn) {
+        if (this.disposed)
+            throw new Error("Codex native turn controller is disposed.");
+        if (this.pending)
+            throw new Error("Codex native session already has an active turn.");
+        if (turn.status === "inProgress") {
+            throw new CodexNativeTurnProtocolError("Codex cannot replay a non-terminal native turn.");
+        }
+        const replay = newPendingTurn();
+        this.assignTurnId(replay, turn.id);
+        replay.started = true;
+        for (const item of turn.items)
+            this.completeItem(replay, item);
+        this.finishIncompleteItems(replay, turn.status);
+        if (turn.status === "failed") {
+            const message = errorMessage(turn.error);
+            this.emit({
+                type: "turn_failed",
+                message,
+                details: providerErrorDetails(turn.error, message, false),
+                turnId: turn.id,
+            });
+        }
+        else {
+            this.emit({ type: "turn_completed", status: turn.status, turnId: turn.id });
+        }
+    }
     async compact() {
         if (this.disposed)
             throw new Error("Codex native turn controller is disposed.");

package/dist/agent-runtimes/history-proof.js

@@ -0,0 +1,8 @@
+import { isCodexNativeBuiltInHistoryReconciliationProof } from "./codex-native/adapter.js";
+import { isOmpBuiltInHistoryReconciliationProof } from "./omp/adapter.js";
+import { isPiBuiltInHistoryReconciliationProof } from "./pi/adapter.js";
+export function isBuiltInHistoryReconciliationProof(proof) {
+    return proof !== undefined && (isPiBuiltInHistoryReconciliationProof(proof)
+        || isOmpBuiltInHistoryReconciliationProof(proof)
+        || isCodexNativeBuiltInHistoryReconciliationProof(proof));
+}

package/dist/agent-runtimes/omp/adapter.js

@@ -6,6 +6,7 @@ import { OmpRpcClient, OmpRpcResponseError } from "./client.js";
 import { defaultOmpRuntimeConfig, OMP_RUNTIME_CONFIG_SCHEMA, parseOmpRuntimeConfig } from "./config.js";
 import { OmpHostToolBridge } from "./host-tools.js";
 import { emptyOmpHistoryPage, inspectOmpHistory, readOmpHistory } from "./history.js";
+import { historyReconciliationDigest, } from "../../agent-runtime/history.js";
 import { OMP_MODEL_OPTIONS_SCHEMA, OMP_MODEL_PROVIDER_ID, OMP_REASONING_VALUES, parseOmpReasoning, readOmpModelCatalog, setOmpModel, } from "./models.js";
 import { buildOmpProcessEnvironment, diagnoseOmpRuntime, disposeOmpSessionPaths, prepareOmpSessionPaths, resetOmpNativeSession, resolveOmpCommand, } from "./process.js";
 import { OmpResourceDelivery } from "./resource-delivery.js";
@@ -14,6 +15,32 @@ import { OmpRpcTurnController } from "./turn.js";
 export { OMP_ADAPTER_ID } from "./thread.js";
 export const OMP_RUNTIME_PROTOCOL_NAME = "omp-rpc";
 export const OMP_RUNTIME_SUPPORTED_RANGE = "2";
+const ompCompleteHistoryProofs = new WeakMap();
+const ompRpcRequestImplementation = OmpRpcClient.prototype.request;
+const ompBuiltInHistoryClients = new WeakMap();
+const ompBuiltInAdapterHistoryClients = new WeakMap();
+function bindOmpCompleteHistoryProof(page) {
+    const claim = page.reconciliationProof;
+    if (!claim?.complete)
+        return page;
+    const entries = Object.freeze([...claim.entries]);
+    const fullScope = Object.freeze({ entryCount: entries.length, digest: historyReconciliationDigest(entries) });
+    const proof = Object.freeze({
+        complete: true,
+        ...(claim.scopeId ? { scopeId: claim.scopeId } : {}),
+        fullScope,
+        entries,
+    });
+    ompCompleteHistoryProofs.set(proof, { ...(claim.scopeId ? { scopeId: claim.scopeId } : {}), fullScope });
+    return { ...page, reconciliationProof: proof };
+}
+export function isOmpBuiltInHistoryReconciliationProof(proof) {
+    const bound = ompCompleteHistoryProofs.get(proof);
+    return proof.complete
+        && bound !== undefined
+        && proof.scopeId === bound.scopeId
+        && proof.fullScope === bound.fullScope;
+}
 function ompCapabilities() {
     return {
         lifecycle: {
@@ -179,6 +206,7 @@ export class OmpSession {
     thread;
     hostTools;
     resourceDelivery;
+    forkCandidatesRequest;
     constructor(runtimeInstanceId, bundle, config, emitWarning, adapter) {
         this.runtimeInstanceId = runtimeInstanceId;
         this.bundle = bundle;
@@ -197,12 +225,11 @@ export class OmpSession {
         this.controls = {
             getCurrentSession: () => this.thread.getSessionSnapshot(this.runtimeInstanceId),
             listSessions: () => this.thread.listSessions(this.runtimeInstanceId),
-            getForkCandidates: () => this.forkCandidates(),
+            getForkCandidates: () => this.getForkCandidates(),
             forkSession: async (entryId) => await this.runIdleOperation(async () => {
-                const previous = this.thread.getSessionSnapshot(this.runtimeInstanceId);
                 const result = await this.thread.forkSession(this.runtimeInstanceId, entryId);
                 this.updateBinding();
-                return { previous, current: result.current, cancelled: result.cancelled };
+                return result;
             }),
             getReasoning: () => parseOmpReasoning(undefined),
             setReasoning: (value) => {
@@ -245,9 +272,6 @@ export class OmpSession {
             adapterId: OMP_ADAPTER_ID,
         };
     }
-    forkCandidates() {
-        return this.thread.cachedForkCandidates();
-    }
     async setOmpModel(provider, modelId) {
         const info = await setOmpModel(this.client, provider, modelId);
         return info;
@@ -315,7 +339,7 @@ export class OmpSession {
             listener(event);
     }
     async prompt(input) {
-        this.assertActive();
+        this.assertIdle();
         this.operationInFlight = true;
         try {
             await this.turn.prompt(input.text);
@@ -369,6 +393,19 @@ export class OmpSession {
         if (this.disposed)
             throw new Error("OMP session is disposed.");
     }
+    async getForkCandidates() {
+        if (this.forkCandidatesRequest)
+            return await this.forkCandidatesRequest;
+        const request = this.runIdleOperation(async () => await this.thread.loadForkCandidates(this.runtimeInstanceId));
+        this.forkCandidatesRequest = request;
+        try {
+            return await request;
+        }
+        finally {
+            if (this.forkCandidatesRequest === request)
+                this.forkCandidatesRequest = undefined;
+        }
+    }
     async runIdleOperation(operation) {
         this.assertIdle();
         this.operationInFlight = true;
@@ -380,7 +417,7 @@ export class OmpSession {
         }
     }
 }
-export class OmpAgentRuntimeAdapter {
+class OmpAgentRuntimeAdapter {
     instanceId;
     descriptor;
     config;
@@ -473,6 +510,10 @@ export class OmpAgentRuntimeAdapter {
         const session = new OmpSession(this.instanceId, bundle, this.parsed, (m) => {
             // Warning surfaced via session events is delivered by the turn controller.
         }, this);
+        const historyClient = Object.freeze({
+            request: ((...args) => Reflect.apply(ompRpcRequestImplementation, client, args)),
+        });
+        ompBuiltInHistoryClients.set(session, { owner: this, client: historyClient });
         session.setPiboSessionId(input.piboSession.id);
         // Wire host tools after session construction so the executor is available.
         const portableTools = input.services?.portableTools;
@@ -521,8 +562,6 @@ export class OmpAgentRuntimeAdapter {
                     // (bindNativeSessionId below still sets the binding.)
                 }
             }
-            // Prime fork candidates (get_branch_messages) for the sync SPI.
-            void threads.loadForkCandidates(this.instanceId);
         }
         catch (error) {
             await client.dispose();
@@ -537,11 +576,18 @@ export class OmpAgentRuntimeAdapter {
     }
     /** Record the live session so adapter-level reads can route to it. */
     attachLiveSession(session) {
+        const history = ompBuiltInHistoryClients.get(session);
+        if (!history || history.owner !== this) {
+            throw new AgentRuntimeUnavailableError(this.instanceId, "OMP history requires a session created by this built-in adapter instance.");
+        }
         this.live = session;
+        ompBuiltInAdapterHistoryClients.set(this, history.client);
     }
     detachLiveSession(session) {
-        if (this.live === session)
-            this.live = undefined;
+        if (this.live !== session)
+            return;
+        this.live = undefined;
+        ompBuiltInAdapterHistoryClients.delete(this);
     }
     async listModels() {
         if (this.live) {
@@ -579,8 +625,9 @@ export class OmpAgentRuntimeAdapter {
         return inspectOmpHistory(input, this.instanceId);
     }
     async readHistory(input) {
-        if (this.live) {
-            return await readOmpHistory(this.live.getClient(), input, this.instanceId, input.binding);
+        const historyClient = ompBuiltInAdapterHistoryClients.get(this);
+        if (historyClient) {
+            return bindOmpCompleteHistoryProof(await readOmpHistory(historyClient, input, this.instanceId, input.binding));
         }
         return emptyOmpHistoryPage(this.instanceId);
     }