@openclaw/codex 2026.5.2-beta.2 → 2026.5.3-beta.1

package/src/app-server/protocol.ts

@@ -1,110 +0,0 @@
-import type {
-  ClientRequest as GeneratedClientRequest,
-  InitializeParams as GeneratedInitializeParams,
-  InitializeResponse as GeneratedInitializeResponse,
-  ServiceTier as GeneratedServiceTier,
-  v2,
-} from "./protocol-generated/typescript/index.js";
-import type { JsonValue as GeneratedJsonValue } from "./protocol-generated/typescript/serde_json/JsonValue.js";
-
-export type JsonValue = GeneratedJsonValue;
-export type JsonObject = { [key: string]: JsonValue };
-export type CodexServiceTier = GeneratedServiceTier;
-
-export type CodexAppServerRequestMethod = GeneratedClientRequest["method"];
-export type CodexAppServerRequestParams<M extends CodexAppServerRequestMethod> =
-  M extends keyof CodexAppServerRequestParamsOverride
-    ? CodexAppServerRequestParamsOverride[M]
-    : Extract<GeneratedClientRequest, { method: M }>["params"];
-
-export type CodexAppServerRequestResult<M extends CodexAppServerRequestMethod> =
-  M extends keyof CodexAppServerRequestResultMap
-    ? CodexAppServerRequestResultMap[M]
-    : JsonValue | undefined;
-
-export type RpcRequest = {
-  id?: number | string;
-  method: string;
-  params?: JsonValue;
-};
-
-export type RpcResponse = {
-  id: number | string;
-  result?: JsonValue;
-  error?: {
-    code?: number;
-    message: string;
-    data?: JsonValue;
-  };
-};
-
-export type RpcMessage = RpcRequest | RpcResponse;
-
-export type CodexInitializeParams = GeneratedInitializeParams;
-
-export type CodexInitializeResponse = GeneratedInitializeResponse;
-
-export type CodexUserInput = v2.UserInput;
-
-export type CodexDynamicToolSpec = v2.DynamicToolSpec;
-
-export type CodexThreadStartParams = v2.ThreadStartParams & {
-  dynamicTools?: CodexDynamicToolSpec[] | null;
-};
-
-export type CodexThreadResumeParams = v2.ThreadResumeParams;
-
-export type CodexThreadStartResponse = v2.ThreadStartResponse;
-
-export type CodexThreadResumeResponse = v2.ThreadResumeResponse;
-
-export type CodexTurnStartParams = v2.TurnStartParams;
-
-export type CodexSandboxPolicy = v2.SandboxPolicy;
-
-export type CodexTurnStartResponse = v2.TurnStartResponse;
-
-export type CodexTurn = v2.Turn;
-
-export type CodexThreadItem = v2.ThreadItem;
-
-export type CodexServerNotification = {
-  method: string;
-  params?: JsonValue;
-};
-
-export type CodexDynamicToolCallParams = v2.DynamicToolCallParams;
-
-export type CodexDynamicToolCallResponse = v2.DynamicToolCallResponse;
-
-export type CodexDynamicToolCallOutputContentItem = v2.DynamicToolCallOutputContentItem;
-
-type CodexAppServerRequestParamsOverride = {
-  "thread/start": CodexThreadStartParams;
-};
-
-type CodexAppServerRequestResultMap = {
-  initialize: CodexInitializeResponse;
-  "account/rateLimits/read": v2.GetAccountRateLimitsResponse;
-  "account/read": v2.GetAccountResponse;
-  "feedback/upload": v2.FeedbackUploadResponse;
-  "mcpServerStatus/list": v2.ListMcpServerStatusResponse;
-  "model/list": v2.ModelListResponse;
-  "review/start": v2.ReviewStartResponse;
-  "skills/list": v2.SkillsListResponse;
-  "thread/compact/start": v2.ThreadCompactStartResponse;
-  "thread/list": v2.ThreadListResponse;
-  "thread/resume": CodexThreadResumeResponse;
-  "thread/start": CodexThreadStartResponse;
-  "turn/interrupt": v2.TurnInterruptResponse;
-  "turn/start": CodexTurnStartResponse;
-  "turn/steer": v2.TurnSteerResponse;
-};
-
-export function isJsonObject(value: JsonValue | undefined): value is JsonObject {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-
-export function isRpcResponse(message: RpcMessage): message is RpcResponse {
-  return "id" in message && !("method" in message);
-}

package/src/app-server/request.ts

@@ -1,45 +0,0 @@
-import type { CodexAppServerStartOptions } from "./config.js";
-import type {
-  CodexAppServerRequestMethod,
-  CodexAppServerRequestParams,
-  CodexAppServerRequestResult,
-  JsonValue,
-} from "./protocol.js";
-import { getSharedCodexAppServerClient } from "./shared-client.js";
-import { withTimeout } from "./timeout.js";
-
-export async function requestCodexAppServerJson<M extends CodexAppServerRequestMethod>(params: {
-  method: M;
-  requestParams: CodexAppServerRequestParams<M>;
-  timeoutMs?: number;
-  startOptions?: CodexAppServerStartOptions;
-  authProfileId?: string;
-}): Promise<CodexAppServerRequestResult<M>>;
-export async function requestCodexAppServerJson<T = JsonValue | undefined>(params: {
-  method: string;
-  requestParams?: unknown;
-  timeoutMs?: number;
-  startOptions?: CodexAppServerStartOptions;
-  authProfileId?: string;
-}): Promise<T>;
-export async function requestCodexAppServerJson<T = JsonValue | undefined>(params: {
-  method: string;
-  requestParams?: unknown;
-  timeoutMs?: number;
-  startOptions?: CodexAppServerStartOptions;
-  authProfileId?: string;
-}): Promise<T> {
-  const timeoutMs = params.timeoutMs ?? 60_000;
-  return await withTimeout(
-    (async () => {
-      const client = await getSharedCodexAppServerClient({
-        startOptions: params.startOptions,
-        timeoutMs,
-        authProfileId: params.authProfileId,
-      });
-      return await client.request<T>(params.method, params.requestParams, { timeoutMs });
-    })(),
-    timeoutMs,
-    `codex app-server ${params.method} timed out`,
-  );
-}

package/src/app-server/run-attempt.context-engine.test.ts

@@ -1,423 +0,0 @@
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import type { AgentMessage } from "@mariozechner/pi-agent-core";
-import { SessionManager } from "@mariozechner/pi-coding-agent";
-import type { EmbeddedRunAttemptParams } from "openclaw/plugin-sdk/agent-harness";
-import {
-  embeddedAgentLog,
-  type HarnessContextEngine as ContextEngine,
-} from "openclaw/plugin-sdk/agent-harness-runtime";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import type { CodexServerNotification } from "./protocol.js";
-import { runCodexAppServerAttempt, __testing } from "./run-attempt.js";
-import { createCodexTestModel } from "./test-support.js";
-
-let tempDir: string;
-
-function createParams(sessionFile: string, workspaceDir: string): EmbeddedRunAttemptParams {
-  return {
-    prompt: "hello",
-    sessionId: "session-1",
-    sessionKey: "agent:main:session-1",
-    sessionFile,
-    workspaceDir,
-    runId: "run-1",
-    provider: "codex",
-    modelId: "gpt-5.4-codex",
-    model: createCodexTestModel("codex"),
-    thinkLevel: "medium",
-    disableTools: true,
-    timeoutMs: 5_000,
-    authStorage: {} as never,
-    authProfileStore: { version: 1, profiles: {} },
-    modelRegistry: {} as never,
-  } as EmbeddedRunAttemptParams;
-}
-
-function assistantMessage(text: string, timestamp: number): AgentMessage {
-  return {
-    role: "assistant",
-    content: [{ type: "text", text }],
-    api: "openai-codex-responses",
-    provider: "openai-codex",
-    model: "gpt-5.4-codex",
-    usage: {
-      input: 0,
-      output: 0,
-      cacheRead: 0,
-      cacheWrite: 0,
-      totalTokens: 0,
-      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-    },
-    stopReason: "stop",
-    timestamp,
-  };
-}
-
-function userMessage(text: string, timestamp: number): AgentMessage {
-  return {
-    role: "user",
-    content: [{ type: "text", text }],
-    timestamp,
-  } as AgentMessage;
-}
-
-function threadStartResult(threadId = "thread-1") {
-  return {
-    thread: {
-      id: threadId,
-      forkedFromId: null,
-      preview: "",
-      ephemeral: false,
-      modelProvider: "openai",
-      createdAt: 1,
-      updatedAt: 1,
-      status: { type: "idle" },
-      path: null,
-      cwd: tempDir || "/tmp/openclaw-codex-test",
-      cliVersion: "0.125.0",
-      source: "unknown",
-      agentNickname: null,
-      agentRole: null,
-      gitInfo: null,
-      name: null,
-      turns: [],
-    },
-    model: "gpt-5.4-codex",
-    modelProvider: "openai",
-    serviceTier: null,
-    cwd: tempDir || "/tmp/openclaw-codex-test",
-    instructionSources: [],
-    approvalPolicy: "never",
-    approvalsReviewer: "user",
-    sandbox: { type: "dangerFullAccess" },
-    permissionProfile: null,
-    reasoningEffort: null,
-  };
-}
-
-function turnStartResult(turnId = "turn-1", status = "inProgress") {
-  return {
-    turn: {
-      id: turnId,
-      status,
-      items: [],
-      error: null,
-      startedAt: null,
-      completedAt: null,
-      durationMs: null,
-    },
-  };
-}
-
-function createStartedThreadHarness(
-  requestImpl: (method: string, params: unknown) => Promise<unknown> = async () => undefined,
-) {
-  const requests: Array<{ method: string; params: unknown }> = [];
-  let notify: (notification: CodexServerNotification) => Promise<void> = async () => undefined;
-  const request = vi.fn(async (method: string, params?: unknown) => {
-    requests.push({ method, params });
-    const override = await requestImpl(method, params);
-    if (override !== undefined) {
-      return override;
-    }
-    if (method === "thread/start") {
-      return threadStartResult();
-    }
-    if (method === "turn/start") {
-      return turnStartResult();
-    }
-    return {};
-  });
-
-  __testing.setCodexAppServerClientFactoryForTests(
-    async () =>
-      ({
-        request,
-        addNotificationHandler: (handler: typeof notify) => {
-          notify = handler;
-          return () => undefined;
-        },
-        addRequestHandler: () => () => undefined,
-      }) as never,
-  );
-
-  return {
-    requests,
-    async waitForMethod(method: string) {
-      await vi.waitFor(() => expect(requests.some((entry) => entry.method === method)).toBe(true), {
-        interval: 1,
-      });
-    },
-    async notify(notification: CodexServerNotification) {
-      await notify(notification);
-    },
-    async completeTurn(status: "completed" | "failed" = "completed") {
-      await notify({
-        method: "turn/completed",
-        params: {
-          threadId: "thread-1",
-          turnId: "turn-1",
-          turn: {
-            id: "turn-1",
-            status,
-            ...(status === "failed" ? { error: { message: "codex failed" } } : {}),
-            items: [{ type: "agentMessage", id: "msg-1", text: "final answer" }],
-          },
-        },
-      });
-    },
-  };
-}
-
-function createContextEngine(overrides: Partial<ContextEngine> = {}): ContextEngine {
-  const engine: ContextEngine = {
-    info: {
-      id: "lossless-claw",
-      name: "Lossless Claw",
-      ownsCompaction: true,
-    },
-    bootstrap: vi.fn(async () => ({ bootstrapped: true })),
-    assemble: vi.fn(async ({ messages, prompt }) => ({
-      messages: [...messages, userMessage(prompt ?? "", 10)],
-      estimatedTokens: 42,
-      systemPromptAddition: "context-engine system",
-    })),
-    ingest: vi.fn(async () => ({ ingested: true })),
-    maintain: vi.fn(async () => ({ changed: false, bytesFreed: 0, rewrittenEntries: 0 })),
-    compact: vi.fn(async () => ({
-      ok: true,
-      compacted: true,
-      result: { summary: "summary", firstKeptEntryId: "entry-1", tokensBefore: 10 },
-    })),
-    ...overrides,
-  };
-  return engine;
-}
-
-describe("runCodexAppServerAttempt context-engine lifecycle", () => {
-  beforeEach(async () => {
-    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-codex-context-engine-"));
-  });
-
-  afterEach(async () => {
-    __testing.resetCodexAppServerClientFactoryForTests();
-    vi.restoreAllMocks();
-    await fs.rm(tempDir, { recursive: true, force: true });
-  });
-
-  it("bootstraps and assembles non-legacy context before the Codex turn starts", async () => {
-    const sessionFile = path.join(tempDir, "session.jsonl");
-    const workspaceDir = path.join(tempDir, "workspace");
-    SessionManager.open(sessionFile).appendMessage(
-      assistantMessage("existing context", Date.now()) as never,
-    );
-    const openSpy = vi.spyOn(SessionManager, "open");
-    const contextEngine = createContextEngine();
-    const harness = createStartedThreadHarness();
-    const params = createParams(sessionFile, workspaceDir);
-    params.contextEngine = contextEngine;
-    params.contextTokenBudget = 321;
-    params.config = { memory: { citations: "on" } } as EmbeddedRunAttemptParams["config"];
-
-    const run = runCodexAppServerAttempt(params);
-    await harness.waitForMethod("turn/start");
-
-    expect(contextEngine.bootstrap).toHaveBeenCalledWith(
-      expect.objectContaining({
-        sessionId: "session-1",
-        sessionKey: "agent:main:session-1",
-        sessionFile,
-      }),
-    );
-    expect(contextEngine.assemble).toHaveBeenCalledWith(
-      expect.objectContaining({
-        sessionId: "session-1",
-        sessionKey: "agent:main:session-1",
-        tokenBudget: 321,
-        citationsMode: "on",
-        model: "gpt-5.4-codex",
-        prompt: "hello",
-        messages: [expect.objectContaining({ role: "assistant" })],
-        availableTools: new Set(),
-      }),
-    );
-    expect(harness.requests).toEqual(
-      expect.arrayContaining([
-        {
-          method: "thread/start",
-          params: expect.objectContaining({
-            developerInstructions: expect.stringContaining("context-engine system"),
-          }),
-        },
-        {
-          method: "turn/start",
-          params: expect.objectContaining({
-            input: expect.arrayContaining([
-              expect.objectContaining({
-                type: "text",
-                text: expect.stringContaining("OpenClaw assembled context for this turn:"),
-              }),
-            ]),
-          }),
-        },
-      ]),
-    );
-
-    await harness.completeTurn();
-    await run;
-    expect(openSpy).not.toHaveBeenCalled();
-  });
-
-  it("calls afterTurn with the mirrored transcript and runs turn maintenance", async () => {
-    const sessionFile = path.join(tempDir, "session.jsonl");
-    const workspaceDir = path.join(tempDir, "workspace");
-    const afterTurn = vi.fn(
-      async (_params: Parameters<NonNullable<ContextEngine["afterTurn"]>>[0]) => undefined,
-    );
-    const maintain = vi.fn(async () => ({ changed: false, bytesFreed: 0, rewrittenEntries: 0 }));
-    const contextEngine = createContextEngine({ afterTurn, maintain, bootstrap: undefined });
-    const harness = createStartedThreadHarness();
-    const params = createParams(sessionFile, workspaceDir);
-    params.contextEngine = contextEngine;
-    params.contextTokenBudget = 111;
-
-    const run = runCodexAppServerAttempt(params);
-    await harness.waitForMethod("turn/start");
-    await harness.completeTurn();
-    await run;
-
-    expect(afterTurn).toHaveBeenCalledTimes(1);
-    const afterTurnCall = afterTurn.mock.calls.at(0)?.[0];
-    expect(afterTurnCall).toMatchObject({
-      sessionId: "session-1",
-      sessionKey: "agent:main:session-1",
-      prePromptMessageCount: 0,
-      tokenBudget: 111,
-    });
-    expect(afterTurnCall?.messages).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ role: "user" }),
-        expect.objectContaining({ role: "assistant" }),
-      ]),
-    );
-    expect(maintain).toHaveBeenCalledTimes(1);
-  });
-
-  it("reloads mirrored history after bootstrap mutates the session transcript", async () => {
-    const sessionFile = path.join(tempDir, "session.jsonl");
-    const workspaceDir = path.join(tempDir, "workspace");
-    SessionManager.open(sessionFile).appendMessage(
-      assistantMessage("existing context", Date.now()) as never,
-    );
-    const afterTurn = vi.fn(
-      async (_params: Parameters<NonNullable<ContextEngine["afterTurn"]>>[0]) => undefined,
-    );
-    const bootstrap = vi.fn(
-      async ({ sessionFile: file }: Parameters<NonNullable<ContextEngine["bootstrap"]>>[0]) => {
-        SessionManager.open(file).appendMessage(
-          assistantMessage("bootstrap context", Date.now() + 1) as never,
-        );
-        return { bootstrapped: true };
-      },
-    );
-    const contextEngine = createContextEngine({
-      bootstrap,
-      afterTurn,
-      maintain: undefined,
-    });
-    const harness = createStartedThreadHarness();
-    const params = createParams(sessionFile, workspaceDir);
-    params.contextEngine = contextEngine;
-
-    const run = runCodexAppServerAttempt(params);
-    await harness.waitForMethod("turn/start");
-    await harness.completeTurn();
-    await run;
-
-    expect(contextEngine.assemble).toHaveBeenCalledWith(
-      expect.objectContaining({
-        messages: [
-          expect.objectContaining({ role: "assistant" }),
-          expect.objectContaining({ role: "assistant" }),
-        ],
-      }),
-    );
-    expect(afterTurn).toHaveBeenCalledWith(
-      expect.objectContaining({
-        prePromptMessageCount: 2,
-      }),
-    );
-    const turnStart = harness.requests.find((request) => request.method === "turn/start");
-    expect(turnStart?.params).toEqual(
-      expect.objectContaining({
-        input: expect.arrayContaining([
-          expect.objectContaining({
-            type: "text",
-            text: expect.stringContaining("bootstrap context"),
-          }),
-        ]),
-      }),
-    );
-  });
-
-  it("logs assemble failures as a formatted message instead of the raw error object", async () => {
-    const sessionFile = path.join(tempDir, "session.jsonl");
-    const workspaceDir = path.join(tempDir, "workspace");
-    const rawError = new Error("Authorization: Bearer sk-abcdefghijklmnopqrstuv");
-    const contextEngine = createContextEngine({
-      assemble: vi.fn(async () => {
-        throw rawError;
-      }),
-      bootstrap: undefined,
-    });
-    const warn = vi.spyOn(embeddedAgentLog, "warn").mockImplementation(() => undefined);
-    const harness = createStartedThreadHarness();
-    const params = createParams(sessionFile, workspaceDir);
-    params.contextEngine = contextEngine;
-
-    const run = runCodexAppServerAttempt(params);
-    await harness.waitForMethod("turn/start");
-    await harness.completeTurn();
-    await run;
-
-    expect(warn).toHaveBeenCalledWith(
-      "context engine assemble failed; using Codex baseline prompt",
-      {
-        error: expect.any(String),
-      },
-    );
-    const warning = warn.mock.calls.find(
-      ([message]) => message === "context engine assemble failed; using Codex baseline prompt",
-    );
-    expect(warning?.[1]).not.toEqual({ error: rawError });
-    expect(String((warning?.[1] as { error?: unknown } | undefined)?.error)).not.toContain(
-      "sk-abcdefghijklmnopqrstuv",
-    );
-  });
-
-  it("falls back to ingestBatch and skips turn maintenance on prompt failure", async () => {
-    const sessionFile = path.join(tempDir, "session.jsonl");
-    const workspaceDir = path.join(tempDir, "workspace");
-    const ingestBatch = vi.fn(async () => ({ ingestedCount: 2 }));
-    const maintain = vi.fn(async () => ({ changed: false, bytesFreed: 0, rewrittenEntries: 0 }));
-    const contextEngine = createContextEngine({
-      afterTurn: undefined,
-      ingestBatch,
-      maintain,
-      bootstrap: undefined,
-    });
-    const harness = createStartedThreadHarness();
-    const params = createParams(sessionFile, workspaceDir);
-    params.contextEngine = contextEngine;
-
-    const run = runCodexAppServerAttempt(params);
-    await harness.waitForMethod("turn/start");
-    await harness.completeTurn("failed");
-    await run;
-
-    expect(ingestBatch).toHaveBeenCalledTimes(1);
-    expect(maintain).not.toHaveBeenCalled();
-  });
-});