export type CodexDynamicToolSpec = CodexDynamicToolFunctionSpec | CodexDynamicToolNamespaceSpec;

export type CodexLegacyDynamicToolFunctionSpec = JsonObject & {

name: string;

description: string;

inputSchema: JsonValue;

deferLoading?: boolean;

namespace?: string;

};

export type CodexThreadStartDynamicToolSpec =

| CodexDynamicToolSpec

| CodexLegacyDynamicToolFunctionSpec;

export function flattenCodexDynamicToolFunctions(

tools: readonly CodexDynamicToolSpec[] | undefined,

): CodexDynamicToolFunctionSpec[] {

approvalsReviewer?: string | null;

sandbox?: string;

serviceTier?: CodexServiceTier | null;

dynamicTools?: CodexDynamicToolSpec[] | null;

dynamicTools?: CodexThreadStartDynamicToolSpec[] | null;

developerInstructions?: string;

experimentalRawEvents?: boolean;

environments?: CodexTurnEnvironmentParams[] | null;

vi.restoreAllMocks();

});

it("passes prepared executable dynamic tool schemas through thread start unchanged", async () => {

it("passes prepared executable dynamic tool schemas through legacy thread start specs", async () => {

const sessionFile = path.join(tempDir, "session.jsonl");

const workspaceDir = path.join(tempDir, "workspace");

const parameterFreeTool = createParameterFreeTool("message");

throw new Error(`expected thread/start request, got ${method}`);

}

const startPayload = payload as CodexThreadStartParams | undefined;

expect(startPayload?.dynamicTools).toStrictEqual([dynamicTool]);

expect(startPayload?.dynamicTools).toStrictEqual([

{

name: dynamicTool.name,

description: dynamicTool.description,

inputSchema: dynamicTool.inputSchema,

},

]);

expect(startPayload?.cwd).toBe(workspaceDir);

expect(startPayload?.model).toBe("gpt-5.4");

expect(startPayload?.modelProvider).toBeUndefined();

expect(request.mock.calls.map(([method]) => method)).toEqual(["thread/start", "thread/resume"]);

});

it("sends legacy flat dynamic tools on thread start", async () => {

const sessionFile = path.join(tempDir, "session.jsonl");

const workspaceDir = path.join(tempDir, "workspace");

const params = createParams(sessionFile, workspaceDir);

const appServer = createThreadLifecycleAppServerOptions();

const request = vi.fn(async (method: string, _requestParams?: unknown) => {

if (method === "thread/start") {

return threadStartResult("thread-flat-tools");

}

throw new Error(`unexpected method: ${method}`);

});

await startOrResumeThread({

client: { request } as never,

params,

cwd: workspaceDir,

dynamicTools: [

createMessageDynamicTool("Send a message."),

createDeferredNamedDynamicTool("web_search"),

],

appServer,

});

const startParams = request.mock.calls.find(([method]) => method === "thread/start")?.[1] as

| { dynamicTools?: unknown[] }

| undefined;

expect(startParams?.dynamicTools).toEqual([

expect.objectContaining({

name: "message",

description: "Send a message.",

}),

expect.objectContaining({

name: "web_search",

namespace: "openclaw",

deferLoading: true,

}),

]);

expect(startParams?.dynamicTools?.[0]).not.toHaveProperty("type");

expect(startParams?.dynamicTools?.[1]).not.toHaveProperty("type");

});

it("keeps the bound local provider when recoverable resume failure starts a fresh thread", async () => {

const sessionFile = path.join(tempDir, "session.jsonl");

const workspaceDir = path.join(tempDir, "workspace");

import {

flattenCodexDynamicToolFunctions,

isJsonObject,

type CodexDynamicToolFunctionSpec,

type CodexDynamicToolSpec,

type CodexLegacyDynamicToolFunctionSpec,

type CodexSandboxPolicy,

type CodexThreadResumeParams,

type CodexThreadStartParams,

developerInstructions:

options.developerInstructions ??

buildDeveloperInstructions(params, { dynamicTools: options.dynamicTools }),

dynamicTools: options.dynamicTools,

dynamicTools: toCodexThreadStartDynamicTools(options.dynamicTools),

experimentalRawEvents: true,

persistExtendedHistory: true,

};

}

function toCodexThreadStartDynamicTools(

dynamicTools: readonly CodexDynamicToolSpec[],

): CodexLegacyDynamicToolFunctionSpec[] {

// Managed stable Codex still accepts the legacy flat start payload. Keep

// OpenClaw namespaces internally, but omit `type` on the wire so Codex does

// not reject a mixed canonical/legacy shape before thread creation.

return dynamicTools.flatMap((tool) =>

tool.type === "namespace"

? tool.tools.map((child) => toCodexLegacyDynamicTool(child, tool.name))

: [toCodexLegacyDynamicTool(tool)],

);

}

function toCodexLegacyDynamicTool(

tool: CodexDynamicToolFunctionSpec,

namespace?: string,

): CodexLegacyDynamicToolFunctionSpec {

const { type: _type, ...legacyTool } = tool;

return namespace ? { ...legacyTool, namespace } : legacyTool;

}

export function buildThreadResumeParams(

params: EmbeddedRunAttemptParams,

options: {

#!/usr/bin/env bash

# Installs OpenClaw from a prepared package tarball, installs @openclaw/codex

# from a registry/git/tarball spec, and verifies a live Codex app-server turn.

set -euo pipefail

set -Eeuo pipefail

SCRIPT_ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"

TRUSTED_HARNESS_DIR="${OPENCLAW_LIVE_DOCKER_TRUSTED_HARNESS_DIR:-$SCRIPT_ROOT_DIR}"

"${CODEX_PLUGIN_MOUNT[@]}" \

"${PROFILE_MOUNT[@]}" \

-i "$IMAGE_NAME" bash -s >"$run_log" 2>&1 <<'EOF'; then

set -euo pipefail

set -Eeuo pipefail

source scripts/lib/openclaw-e2e-instance.sh

openclaw_e2e_eval_test_state_from_b64 "${OPENCLAW_TEST_STATE_SCRIPT_B64:?missing OPENCLAW_TEST_STATE_SCRIPT_B64}"

if [ -f "$profile_path" ] && [ -r "$profile_path" ]; then

set +e +u

source "$profile_path"

set -euo pipefail

set -Eeuo pipefail

break

fi

done

local message="$3"

local out="$4"

local err="$5"

local status

echo "${label}_prompt: $message"

openclaw agent --local \

if openclaw agent --local \

--agent main \

--session-id "$SESSION_ID" \

--model "$MODEL_REF" \

--message "$message" \

--thinking low \

--timeout 420 \

--json >"$out" 2>"$err" </dev/null

print_agent_reply "$out" "$marker" "${label}_reply"

--json >"$out" 2>"$err" </dev/null; then

status=0

else

status=$?

fi

echo "${label}_agent_status: $status stdout_bytes=$(wc -c <"$out" 2>/dev/null || printf 0) stderr_bytes=$(wc -c <"$err" 2>/dev/null || printf 0)"

if [ "$status" -ne 0 ]; then

dump_debug_logs "$status"

exit "$status"

fi

if ! print_agent_reply "$out" "$marker" "${label}_reply"; then

dump_debug_logs 1

exit 1

fi

}

echo "TRANSCRIPT_BEGIN"

const bindingPath = `${entry.sessionFile}.codex-app-server.json`;

const binding = readJson(bindingPath);

if (binding.schemaVersion !== 1 || typeof binding.threadId !== "string") {

if (![1, 2].includes(binding.schemaVersion) || typeof binding.threadId !== "string") {

throw new Error(`invalid Codex app-server binding: ${JSON.stringify(binding)}`);

}

if (binding.model !== modelRef.split("/").slice(1).join("/")) {