// Verifies OpenAI Responses replay preserves reasoning and response item ids.

import type { AssistantMessage, Model, ToolResultMessage } from "openclaw/plugin-sdk/llm";

import { stream } from "openclaw/plugin-sdk/llm";

import { Type } from "typebox";

}>;

replayResponsesItemIds?: boolean;

}) {

// Abort after payload capture so tests inspect serialization without network I/O.

const controller = new AbortController();

controller.abort();

let payload: Record<string, unknown> | undefined;

});

it("does not replay a signed assistant message id after its reasoning item was pruned", async () => {

// Signed message ids are only safe to replay when their preceding reasoning item survived.

expect(

resolveReplayableResponsesMessageId({

replayResponsesItemIds: true,

// Verifies OpenAI model selections route between OpenClaw and Codex runtimes.

import { describe, expect, it } from "vitest";

import type { OpenClawConfig } from "../config/types.openclaw.js";

import {

});

it("does not force Codex for custom OpenAI-compatible base URLs", () => {

// A custom baseUrl means the provider key is only OpenAI-compatible, not official OpenAI.

const config = {

models: {

providers: {

});

it("keeps explicit OpenClaw plus Codex auth profile under the unified OpenAI provider", () => {

// OpenAI auth now stays canonical even when the runtime is not Codex.

expect(

listOpenAIAuthProfileProvidersForAgentRuntime({

provider: "openai",

// Verifies session thinking levels reach OpenAI and Codex Responses transports.

import { Agent, type StreamFn } from "openclaw/plugin-sdk/agent-core";

import {

createAssistantMessageEventStream,

model: ResponsesModel,

capturedOptions: SimpleStreamOptions[],

): StreamFn {

// Captures Agent -> stream options while returning a complete assistant event.

return (_model, _context, options) => {

capturedOptions.push({ ...options });

const stream = createAssistantMessageEventStream();

) => ReturnType<StreamFn>;

options: SimpleStreamOptions;

}): Promise<Record<string, unknown>> {

// Stop at onPayload so transport serialization can be asserted without HTTP.

const payloadPromise = new Promise<Record<string, unknown>>((resolve, reject) => {

const timeout = setTimeout(

() => reject(new Error(`provider payload callback was not invoked for ${params.model.api}`)),

// Verifies OpenAI strict tool schema normalization and cache behavior.

import { beforeEach, describe, expect, it } from "vitest";

import {

clearOpenAIToolSchemaCacheForTest,

});

it("does not close permissive nested object schemas implicitly", () => {

// Nested permissive objects stay incompatible unless callers make them strict.

const schema = {

type: "object",

properties: {

});

it("reuses normalized strict schemas for stable tool schema objects", () => {

// Cache keys include unsupported-keyword policy, not just object identity.

const schema = {

type: "object",

properties: {

// Verifies OpenAI-compatible streaming payloads, failures, and transport wrapping.

import { createServer } from "node:http";

import type { Api, Model } from "openclaw/plugin-sdk/llm";

import { describe, expect, it, vi } from "vitest";

}

function neverYieldsStream(): AsyncIterable<unknown> {

// Simulates an HTTP stream that opened but never delivered the first SSE event.

return {

[Symbol.asyncIterator]() {

return {

}

function expectRecordFields(record: unknown, expected: Record<string, unknown>) {

// Shared assertion helper for parsed transport payload/event records.

if (!record || typeof record !== "object") {

throw new Error("Expected record");

}

});

it("observes detail-less Responses failures without leaking request ids", async () => {

// Observation should preserve hashes/metadata shape while dropping raw request ids.

const model = createAzureResponsesModel();

const event = {

type: "response.failed",

// Verifies OpenClaw gateway tool schema, restart signaling, and config mutations.

import fs from "node:fs/promises";

import os from "node:os";

import path from "node:path";

}));

function requireGatewayTool(agentSessionKey?: string) {

// Tests run with restart enabled so schema and execution paths are visible.

return createGatewayTool({

...(agentSessionKey ? { agentSessionKey } : {}),

config: { commands: { restart: true } },

});

}

function collectActionValues(schema: unknown, values: Set<string>): void {

// Tool schemas can expose actions through const, enum, or anyOf variants.

if (!schema || typeof schema !== "object") {

return;

}

raw: string;

sessionKey: string;

}) {

// Config writes must include the base hash from a preceding config.get read.

expect(params.callGatewayTool.mock.calls.some(([method]) => method === "config.get")).toBe(true);

const call = params.callGatewayTool.mock.calls.find(([method]) => method === params.action);

if (!call) {