@openclaw/codex 2026.5.2 → 2026.5.3-beta.2

package/src/app-server/models.ts

@@ -1,168 +0,0 @@
-import type { CodexAppServerClient } from "./client.js";
-import type { CodexAppServerStartOptions } from "./config.js";
-import type { v2 } from "./protocol-generated/typescript/index.js";
-import { readCodexModelListResponse } from "./protocol-validators.js";
-
-export type CodexAppServerModel = {
-  id: string;
-  model: string;
-  displayName?: string;
-  description?: string;
-  hidden?: boolean;
-  isDefault?: boolean;
-  inputModalities: string[];
-  supportedReasoningEfforts: string[];
-  defaultReasoningEffort?: string;
-};
-
-export type CodexAppServerModelListResult = {
-  models: CodexAppServerModel[];
-  nextCursor?: string;
-  truncated?: boolean;
-};
-
-export type CodexAppServerListModelsOptions = {
-  limit?: number;
-  cursor?: string;
-  includeHidden?: boolean;
-  timeoutMs?: number;
-  startOptions?: CodexAppServerStartOptions;
-  authProfileId?: string;
-  agentDir?: string;
-  sharedClient?: boolean;
-};
-
-export async function listCodexAppServerModels(
-  options: CodexAppServerListModelsOptions = {},
-): Promise<CodexAppServerModelListResult> {
-  return await withCodexAppServerModelClient(options, async ({ client, timeoutMs }) =>
-    requestModelListPage(client, { ...options, timeoutMs }),
-  );
-}
-
-export async function listAllCodexAppServerModels(
-  options: CodexAppServerListModelsOptions & { maxPages?: number } = {},
-): Promise<CodexAppServerModelListResult> {
-  const maxPages = normalizeMaxPages(options.maxPages);
-  return await withCodexAppServerModelClient(options, async ({ client, timeoutMs }) => {
-    const models: CodexAppServerModel[] = [];
-    let cursor = options.cursor;
-    let nextCursor: string | undefined;
-    for (let page = 0; page < maxPages; page += 1) {
-      const result = await requestModelListPage(client, {
-        ...options,
-        timeoutMs,
-        cursor,
-      });
-      models.push(...result.models);
-      nextCursor = result.nextCursor;
-      if (!nextCursor) {
-        return { models };
-      }
-      cursor = nextCursor;
-    }
-    return { models, nextCursor, truncated: true };
-  });
-}
-
-async function withCodexAppServerModelClient<T>(
-  options: CodexAppServerListModelsOptions,
-  run: (params: { client: CodexAppServerClient; timeoutMs: number }) => Promise<T>,
-): Promise<T> {
-  const timeoutMs = options.timeoutMs ?? 2500;
-  const useSharedClient = options.sharedClient !== false;
-  const { createIsolatedCodexAppServerClient, getSharedCodexAppServerClient } =
-    await import("./shared-client.js");
-  const client = useSharedClient
-    ? await getSharedCodexAppServerClient({
-        startOptions: options.startOptions,
-        timeoutMs,
-        authProfileId: options.authProfileId,
-        agentDir: options.agentDir,
-      })
-    : await createIsolatedCodexAppServerClient({
-        startOptions: options.startOptions,
-        timeoutMs,
-        authProfileId: options.authProfileId,
-        agentDir: options.agentDir,
-      });
-  try {
-    return await run({ client, timeoutMs });
-  } finally {
-    if (!useSharedClient) {
-      client.close();
-    }
-  }
-}
-
-async function requestModelListPage(
-  client: CodexAppServerClient,
-  options: CodexAppServerListModelsOptions & { timeoutMs: number },
-): Promise<CodexAppServerModelListResult> {
-  const response = await client.request(
-    "model/list",
-    {
-      limit: options.limit ?? null,
-      cursor: options.cursor ?? null,
-      includeHidden: options.includeHidden ?? null,
-    },
-    { timeoutMs: options.timeoutMs },
-  );
-  return readModelListResult(response);
-}
-
-export function readModelListResult(value: unknown): CodexAppServerModelListResult {
-  const response = readCodexModelListResponse(value);
-  if (!response) {
-    return { models: [] };
-  }
-  const models = response.data
-    .map((entry) => readCodexModel(entry))
-    .filter((entry): entry is CodexAppServerModel => entry !== undefined);
-  const nextCursor = response.nextCursor ?? undefined;
-  return { models, ...(nextCursor ? { nextCursor } : {}) };
-}
-
-function readCodexModel(value: v2.Model): CodexAppServerModel | undefined {
-  const id = readNonEmptyString(value.id);
-  const model = readNonEmptyString(value.model) ?? id;
-  if (!id || !model) {
-    return undefined;
-  }
-  return {
-    id,
-    model,
-    ...(readNonEmptyString(value.displayName)
-      ? { displayName: readNonEmptyString(value.displayName) }
-      : {}),
-    ...(readNonEmptyString(value.description)
-      ? { description: readNonEmptyString(value.description) }
-      : {}),
-    hidden: value.hidden,
-    isDefault: value.isDefault,
-    inputModalities: value.inputModalities,
-    supportedReasoningEfforts: readReasoningEfforts(value.supportedReasoningEfforts),
-    ...(readNonEmptyString(value.defaultReasoningEffort)
-      ? { defaultReasoningEffort: readNonEmptyString(value.defaultReasoningEffort) }
-      : {}),
-  };
-}
-
-function readReasoningEfforts(value: v2.ReasoningEffortOption[]): string[] {
-  const efforts = value
-    .map((entry) => readNonEmptyString(entry.reasoningEffort))
-    .filter((entry): entry is string => entry !== undefined);
-  return [...new Set(efforts)];
-}
-
-function readNonEmptyString(value: unknown): string | undefined {
-  if (typeof value !== "string") {
-    return undefined;
-  }
-  const trimmed = value.trim();
-  return trimmed || undefined;
-}
-
-function normalizeMaxPages(value: unknown): number {
-  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : 20;
-}

package/src/app-server/native-hook-relay.test.ts

@@ -1,143 +0,0 @@
-import type { NativeHookRelayRegistrationHandle } from "openclaw/plugin-sdk/agent-harness-runtime";
-import { describe, expect, it } from "vitest";
-import {
-  buildCodexNativeHookRelayConfig,
-  buildCodexNativeHookRelayDisabledConfig,
-} from "./native-hook-relay.js";
-
-describe("Codex native hook relay config", () => {
-  it("builds deterministic Codex config overrides with command hooks", () => {
-    const config = buildCodexNativeHookRelayConfig({
-      relay: createRelay(),
-      hookTimeoutSec: 7,
-    });
-
-    expect(config).toEqual({
-      "features.codex_hooks": true,
-      "hooks.PreToolUse": [
-        {
-          matcher: null,
-          hooks: [
-            {
-              type: "command",
-              command:
-                "openclaw hooks relay --provider codex --relay-id relay-1 --event pre_tool_use",
-              timeout: 7,
-              async: false,
-              statusMessage: "OpenClaw native hook relay",
-            },
-          ],
-        },
-      ],
-      "hooks.PostToolUse": [
-        {
-          matcher: null,
-          hooks: [
-            {
-              type: "command",
-              command:
-                "openclaw hooks relay --provider codex --relay-id relay-1 --event post_tool_use",
-              timeout: 7,
-              async: false,
-              statusMessage: "OpenClaw native hook relay",
-            },
-          ],
-        },
-      ],
-      "hooks.PermissionRequest": [
-        {
-          matcher: null,
-          hooks: [
-            {
-              type: "command",
-              command:
-                "openclaw hooks relay --provider codex --relay-id relay-1 --event permission_request",
-              timeout: 7,
-              async: false,
-              statusMessage: "OpenClaw native hook relay",
-            },
-          ],
-        },
-      ],
-      "hooks.Stop": [
-        {
-          matcher: null,
-          hooks: [
-            {
-              type: "command",
-              command:
-                "openclaw hooks relay --provider codex --relay-id relay-1 --event before_agent_finalize",
-              timeout: 7,
-              async: false,
-              statusMessage: "OpenClaw native hook relay",
-            },
-          ],
-        },
-      ],
-    });
-    expect(JSON.stringify(config)).not.toContain("timeoutSec");
-    expect(config).not.toHaveProperty("hooks.SessionStart");
-    expect(config).not.toHaveProperty("hooks.UserPromptSubmit");
-  });
-
-  it("includes only requested hook events", () => {
-    expect(
-      buildCodexNativeHookRelayConfig({
-        relay: createRelay(),
-        events: ["permission_request"],
-      }),
-    ).toEqual({
-      "features.codex_hooks": true,
-      "hooks.PermissionRequest": [
-        {
-          matcher: null,
-          hooks: [
-            {
-              type: "command",
-              command:
-                "openclaw hooks relay --provider codex --relay-id relay-1 --event permission_request",
-              timeout: 5,
-              async: false,
-              statusMessage: "OpenClaw native hook relay",
-            },
-          ],
-        },
-      ],
-    });
-  });
-
-  it("leaves matchers open so Codex MCP tool names reach the relay", () => {
-    const config = buildCodexNativeHookRelayConfig({
-      relay: createRelay(),
-      events: ["pre_tool_use", "post_tool_use"],
-    });
-
-    expect(config["hooks.PreToolUse"]).toEqual([expect.objectContaining({ matcher: null })]);
-    expect(config["hooks.PostToolUse"]).toEqual([expect.objectContaining({ matcher: null })]);
-  });
-
-  it("builds deterministic clearing config when the relay is disabled", () => {
-    expect(buildCodexNativeHookRelayDisabledConfig()).toEqual({
-      "features.codex_hooks": false,
-      "hooks.PreToolUse": [],
-      "hooks.PostToolUse": [],
-      "hooks.PermissionRequest": [],
-      "hooks.Stop": [],
-    });
-  });
-});
-
-function createRelay(): NativeHookRelayRegistrationHandle {
-  return {
-    relayId: "relay-1",
-    provider: "codex",
-    sessionId: "session-1",
-    sessionKey: "agent:main:session-1",
-    runId: "run-1",
-    allowedEvents: ["pre_tool_use", "post_tool_use", "permission_request", "before_agent_finalize"],
-    expiresAtMs: Date.now() + 1000,
-    commandForEvent: (event) =>
-      `openclaw hooks relay --provider codex --relay-id relay-1 --event ${event}`,
-    unregister: () => undefined,
-  };
-}

package/src/app-server/native-hook-relay.ts

@@ -1,64 +0,0 @@
-import type {
-  NativeHookRelayEvent,
-  NativeHookRelayRegistrationHandle,
-} from "openclaw/plugin-sdk/agent-harness-runtime";
-import type { JsonObject, JsonValue } from "./protocol.js";
-
-export const CODEX_NATIVE_HOOK_RELAY_EVENTS: readonly NativeHookRelayEvent[] = [
-  "pre_tool_use",
-  "post_tool_use",
-  "permission_request",
-  "before_agent_finalize",
-] as const;
-
-type CodexHookEventName = "PreToolUse" | "PostToolUse" | "PermissionRequest" | "Stop";
-
-const CODEX_HOOK_EVENT_BY_NATIVE_EVENT: Record<NativeHookRelayEvent, CodexHookEventName> = {
-  pre_tool_use: "PreToolUse",
-  post_tool_use: "PostToolUse",
-  permission_request: "PermissionRequest",
-  before_agent_finalize: "Stop",
-};
-
-export function buildCodexNativeHookRelayConfig(params: {
-  relay: NativeHookRelayRegistrationHandle;
-  events?: readonly NativeHookRelayEvent[];
-  hookTimeoutSec?: number;
-}): JsonObject {
-  const events = params.events?.length ? params.events : CODEX_NATIVE_HOOK_RELAY_EVENTS;
-  const config: JsonObject = {
-    "features.codex_hooks": true,
-  };
-  for (const event of events) {
-    const codexEvent = CODEX_HOOK_EVENT_BY_NATIVE_EVENT[event];
-    config[`hooks.${codexEvent}`] = [
-      {
-        matcher: null,
-        hooks: [
-          {
-            type: "command",
-            command: params.relay.commandForEvent(event),
-            timeout: normalizeHookTimeoutSec(params.hookTimeoutSec),
-            async: false,
-            statusMessage: "OpenClaw native hook relay",
-          },
-        ],
-      },
-    ] satisfies JsonValue;
-  }
-  return config;
-}
-
-export function buildCodexNativeHookRelayDisabledConfig(): JsonObject {
-  return {
-    "features.codex_hooks": false,
-    "hooks.PreToolUse": [],
-    "hooks.PostToolUse": [],
-    "hooks.PermissionRequest": [],
-    "hooks.Stop": [],
-  };
-}
-
-function normalizeHookTimeoutSec(value: number | undefined): number {
-  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.ceil(value) : 5;
-}