@full-self-developing/fsd 1.0.0

package/extensions/openai/speech-provider.ts

@@ -0,0 +1,347 @@
+import { normalizeResolvedSecretInputString } from "openclaw/plugin-sdk/secret-input";
+import type {
+  SpeechDirectiveTokenParseContext,
+  SpeechProviderConfig,
+  SpeechProviderOverrides,
+  SpeechProviderPlugin,
+} from "openclaw/plugin-sdk/speech";
+import {
+  normalizeLowercaseStringOrEmpty,
+  normalizeOptionalLowercaseString,
+} from "openclaw/plugin-sdk/string-coerce-runtime";
+import {
+  asFiniteNumber,
+  asObjectRecord,
+  resolveOpenAIProviderConfigRecord,
+  trimToUndefined,
+} from "./realtime-provider-shared.js";
+import {
+  DEFAULT_OPENAI_BASE_URL,
+  isValidOpenAIModel,
+  isValidOpenAIVoice,
+  normalizeOpenAITtsBaseUrl,
+  OPENAI_TTS_MODELS,
+  OPENAI_TTS_VOICES,
+  openaiTTS,
+} from "./tts.js";
+
+const OPENAI_SPEECH_RESPONSE_FORMATS = ["mp3", "opus", "wav"] as const;
+
+type OpenAiSpeechResponseFormat = (typeof OPENAI_SPEECH_RESPONSE_FORMATS)[number];
+
+type OpenAITtsProviderConfig = {
+  apiKey?: string;
+  baseUrl: string;
+  model: string;
+  voice: string;
+  speed?: number;
+  instructions?: string;
+  responseFormat?: OpenAiSpeechResponseFormat;
+  extraBody?: Record<string, unknown>;
+};
+
+type OpenAITtsProviderOverrides = {
+  model?: string;
+  voice?: string;
+  speed?: number;
+};
+
+function normalizeOpenAISpeechResponseFormat(
+  value: unknown,
+): OpenAiSpeechResponseFormat | undefined {
+  const next = normalizeOptionalLowercaseString(value);
+  if (!next) {
+    return undefined;
+  }
+  if (
+    OPENAI_SPEECH_RESPONSE_FORMATS.includes(next as (typeof OPENAI_SPEECH_RESPONSE_FORMATS)[number])
+  ) {
+    return next as OpenAiSpeechResponseFormat;
+  }
+  throw new Error(`Invalid OpenAI speech responseFormat: ${next}`);
+}
+
+function isGroqSpeechBaseUrl(baseUrl: string): boolean {
+  try {
+    const hostname = normalizeLowercaseStringOrEmpty(new URL(baseUrl).hostname);
+    return hostname === "groq.com" || hostname.endsWith(".groq.com");
+  } catch {
+    return false;
+  }
+}
+
+function resolveSpeechResponseFormat(
+  baseUrl: string,
+  target: "audio-file" | "voice-note" | "telephony",
+  configuredFormat?: OpenAiSpeechResponseFormat,
+): OpenAiSpeechResponseFormat {
+  if (configuredFormat) {
+    return configuredFormat;
+  }
+  if (isGroqSpeechBaseUrl(baseUrl)) {
+    return "wav";
+  }
+  return target === "voice-note" ? "opus" : "mp3";
+}
+
+function responseFormatToFileExtension(
+  format: OpenAiSpeechResponseFormat,
+): ".mp3" | ".opus" | ".wav" {
+  switch (format) {
+    case "opus":
+      return ".opus";
+    case "wav":
+      return ".wav";
+    default:
+      return ".mp3";
+  }
+}
+
+function readExtraBody(value: unknown): Record<string, unknown> | undefined {
+  const body = asObjectRecord(value);
+  if (!body || Object.keys(body).length === 0) {
+    return undefined;
+  }
+  return body;
+}
+
+function normalizeOpenAIProviderConfig(
+  rawConfig: Record<string, unknown>,
+): OpenAITtsProviderConfig {
+  const raw = resolveOpenAIProviderConfigRecord(rawConfig);
+  const extraBody = readExtraBody(raw?.extraBody) ?? readExtraBody(raw?.extra_body);
+  return {
+    apiKey: normalizeResolvedSecretInputString({
+      value: raw?.apiKey,
+      path: "messages.tts.providers.openai.apiKey",
+    }),
+    baseUrl: normalizeOpenAITtsBaseUrl(
+      trimToUndefined(raw?.baseUrl) ??
+        trimToUndefined(process.env.OPENAI_TTS_BASE_URL) ??
+        DEFAULT_OPENAI_BASE_URL,
+    ),
+    model: trimToUndefined(raw?.model) ?? "gpt-4o-mini-tts",
+    voice: trimToUndefined(raw?.voice) ?? "coral",
+    speed: asFiniteNumber(raw?.speed),
+    instructions: trimToUndefined(raw?.instructions),
+    responseFormat: normalizeOpenAISpeechResponseFormat(raw?.responseFormat),
+    extraBody,
+  };
+}
+
+function readOpenAIProviderConfig(config: SpeechProviderConfig): OpenAITtsProviderConfig {
+  const normalized = normalizeOpenAIProviderConfig({});
+  return {
+    apiKey: trimToUndefined(config.apiKey) ?? normalized.apiKey,
+    baseUrl: trimToUndefined(config.baseUrl) ?? normalized.baseUrl,
+    model: trimToUndefined(config.model) ?? normalized.model,
+    voice: trimToUndefined(config.voice) ?? normalized.voice,
+    speed: asFiniteNumber(config.speed) ?? normalized.speed,
+    instructions: trimToUndefined(config.instructions) ?? normalized.instructions,
+    responseFormat:
+      normalizeOpenAISpeechResponseFormat(config.responseFormat) ?? normalized.responseFormat,
+    extraBody: readExtraBody(config.extraBody) ?? readExtraBody(config.extra_body),
+  };
+}
+
+function readOpenAIOverrides(
+  overrides: SpeechProviderOverrides | undefined,
+): OpenAITtsProviderOverrides {
+  if (!overrides) {
+    return {};
+  }
+  return {
+    model: trimToUndefined(overrides.model),
+    voice: trimToUndefined(overrides.voice),
+    speed: asFiniteNumber(overrides.speed),
+  };
+}
+
+function renderOpenAITtsPersonaInstructions(req: {
+  label?: string;
+  prompt?: {
+    profile?: string;
+    scene?: string;
+    sampleContext?: string;
+    style?: string;
+    accent?: string;
+    pacing?: string;
+    constraints?: string[];
+  };
+}): string | undefined {
+  const prompt = req.prompt;
+  if (!prompt) {
+    return undefined;
+  }
+  const lines = [
+    req.label ? `Persona: ${req.label}` : undefined,
+    prompt.profile ? `Profile: ${prompt.profile}` : undefined,
+    prompt.scene ? `Scene: ${prompt.scene}` : undefined,
+    prompt.style ? `Style: ${prompt.style}` : undefined,
+    prompt.accent ? `Accent: ${prompt.accent}` : undefined,
+    prompt.pacing ? `Pacing: ${prompt.pacing}` : undefined,
+    prompt.sampleContext ? `Sample context: ${prompt.sampleContext}` : undefined,
+    ...(prompt.constraints ?? []).map((constraint) => `Constraint: ${constraint}`),
+  ]
+    .map((line) => trimToUndefined(line))
+    .filter((line): line is string => Boolean(line));
+  return lines.length > 0 ? lines.join("\n") : undefined;
+}
+
+function parseDirectiveToken(ctx: SpeechDirectiveTokenParseContext): {
+  handled: boolean;
+  overrides?: SpeechProviderOverrides;
+  warnings?: string[];
+} {
+  const baseUrl = trimToUndefined(asObjectRecord(ctx.providerConfig)?.baseUrl);
+  switch (ctx.key) {
+    case "voice":
+    case "openai_voice":
+    case "openaivoice":
+      if (!ctx.policy.allowVoice) {
+        return { handled: true };
+      }
+      if (!isValidOpenAIVoice(ctx.value, baseUrl)) {
+        return { handled: true, warnings: [`invalid OpenAI voice "${ctx.value}"`] };
+      }
+      return { handled: true, overrides: { voice: ctx.value } };
+    case "model":
+    case "openai_model":
+    case "openaimodel":
+      if (!ctx.policy.allowModelId) {
+        return { handled: true };
+      }
+      if (!isValidOpenAIModel(ctx.value, baseUrl)) {
+        return { handled: false };
+      }
+      return { handled: true, overrides: { model: ctx.value } };
+    default:
+      return { handled: false };
+  }
+}
+
+export function buildOpenAISpeechProvider(): SpeechProviderPlugin {
+  return {
+    id: "openai",
+    label: "OpenAI",
+    autoSelectOrder: 10,
+    models: OPENAI_TTS_MODELS,
+    voices: OPENAI_TTS_VOICES,
+    resolveConfig: ({ rawConfig }) => normalizeOpenAIProviderConfig(rawConfig),
+    parseDirectiveToken,
+    resolveTalkConfig: ({ baseTtsConfig, talkProviderConfig }) => {
+      const base = normalizeOpenAIProviderConfig(baseTtsConfig);
+      const responseFormat = normalizeOpenAISpeechResponseFormat(talkProviderConfig.responseFormat);
+      return {
+        ...base,
+        ...(talkProviderConfig.apiKey === undefined
+          ? {}
+          : {
+              apiKey: normalizeResolvedSecretInputString({
+                value: talkProviderConfig.apiKey,
+                path: "talk.providers.openai.apiKey",
+              }),
+            }),
+        ...(trimToUndefined(talkProviderConfig.baseUrl) == null
+          ? {}
+          : { baseUrl: trimToUndefined(talkProviderConfig.baseUrl) }),
+        ...(trimToUndefined(talkProviderConfig.modelId) == null
+          ? {}
+          : { model: trimToUndefined(talkProviderConfig.modelId) }),
+        ...(trimToUndefined(talkProviderConfig.voiceId) == null
+          ? {}
+          : { voice: trimToUndefined(talkProviderConfig.voiceId) }),
+        ...(asFiniteNumber(talkProviderConfig.speed) == null
+          ? {}
+          : { speed: asFiniteNumber(talkProviderConfig.speed) }),
+        ...(trimToUndefined(talkProviderConfig.instructions) == null
+          ? {}
+          : { instructions: trimToUndefined(talkProviderConfig.instructions) }),
+        ...(responseFormat == null ? {} : { responseFormat }),
+      };
+    },
+    resolveTalkOverrides: ({ params }) => ({
+      ...(trimToUndefined(params.voiceId) == null
+        ? {}
+        : { voice: trimToUndefined(params.voiceId) }),
+      ...(trimToUndefined(params.modelId) == null
+        ? {}
+        : { model: trimToUndefined(params.modelId) }),
+      ...(asFiniteNumber(params.speed) == null ? {} : { speed: asFiniteNumber(params.speed) }),
+    }),
+    listVoices: async () => OPENAI_TTS_VOICES.map((voice) => ({ id: voice, name: voice })),
+    isConfigured: ({ providerConfig }) =>
+      Boolean(readOpenAIProviderConfig(providerConfig).apiKey || process.env.OPENAI_API_KEY),
+    prepareSynthesis: (ctx) => {
+      const config = readOpenAIProviderConfig(ctx.providerConfig);
+      if (config.instructions) {
+        return undefined;
+      }
+      const instructions = renderOpenAITtsPersonaInstructions({
+        label: ctx.persona?.label ?? ctx.persona?.id,
+        prompt: ctx.persona?.prompt,
+      });
+      return instructions
+        ? {
+            providerConfig: {
+              instructions,
+            },
+          }
+        : undefined;
+    },
+    synthesize: async (req) => {
+      const config = readOpenAIProviderConfig(req.providerConfig);
+      const overrides = readOpenAIOverrides(req.providerOverrides);
+      const apiKey = config.apiKey || process.env.OPENAI_API_KEY;
+      if (!apiKey) {
+        throw new Error("OpenAI API key missing");
+      }
+      const responseFormat = resolveSpeechResponseFormat(
+        config.baseUrl,
+        req.target,
+        config.responseFormat,
+      );
+      const audioBuffer = await openaiTTS({
+        text: req.text,
+        apiKey,
+        baseUrl: config.baseUrl,
+        model: overrides.model ?? config.model,
+        voice: overrides.voice ?? config.voice,
+        speed: overrides.speed ?? config.speed,
+        instructions: config.instructions,
+        responseFormat,
+        extraBody: config.extraBody,
+        timeoutMs: req.timeoutMs,
+      });
+      return {
+        audioBuffer,
+        outputFormat: responseFormat,
+        fileExtension: responseFormatToFileExtension(responseFormat),
+        voiceCompatible: req.target === "voice-note" && responseFormat === "opus",
+      };
+    },
+    synthesizeTelephony: async (req) => {
+      const config = readOpenAIProviderConfig(req.providerConfig);
+      const overrides = readOpenAIOverrides(req.providerOverrides);
+      const apiKey = config.apiKey || process.env.OPENAI_API_KEY;
+      if (!apiKey) {
+        throw new Error("OpenAI API key missing");
+      }
+      const outputFormat = "pcm";
+      const sampleRate = 24_000;
+      const audioBuffer = await openaiTTS({
+        text: req.text,
+        apiKey,
+        baseUrl: config.baseUrl,
+        model: overrides.model ?? config.model,
+        voice: overrides.voice ?? config.voice,
+        speed: overrides.speed ?? config.speed,
+        instructions: config.instructions,
+        responseFormat: outputFormat,
+        extraBody: config.extraBody,
+        timeoutMs: req.timeoutMs,
+      });
+      return { audioBuffer, outputFormat, sampleRate };
+    },
+  };
+}

package/extensions/openai/test-api.ts

@@ -0,0 +1,9 @@
+export { buildOpenAIImageGenerationProvider } from "./image-generation-provider.js";
+export {
+  openaiCodexMediaUnderstandingProvider,
+  openaiMediaUnderstandingProvider,
+} from "./media-understanding-provider.js";
+export { buildOpenAIRealtimeTranscriptionProvider } from "./realtime-transcription-provider.js";
+export { buildOpenAIRealtimeVoiceProvider } from "./realtime-voice-provider.js";
+export { buildOpenAISpeechProvider } from "./speech-provider.js";
+export { buildOpenAIVideoGenerationProvider } from "./video-generation-provider.js";

package/extensions/openai/test-support/provider-catalog.contract-test-support.ts

@@ -0,0 +1,134 @@
+import {
+  registerProviderPlugin,
+  requireRegisteredProvider,
+} from "openclaw/plugin-sdk/plugin-test-runtime";
+import {
+  expectAugmentedCodexCatalog,
+  expectedOpenaiPluginCodexCatalogEntriesWithGpt55,
+  expectCodexMissingAuthHint,
+  importProviderRuntimeCatalogModule,
+  loadBundledPluginPublicSurface,
+} from "openclaw/plugin-sdk/provider-test-contracts";
+import type { ProviderPlugin } from "openclaw/plugin-sdk/provider-test-contracts";
+import { beforeEach, describe, it, vi } from "vitest";
+
+const PROVIDER_CATALOG_CONTRACT_TIMEOUT_MS = 300_000;
+
+type ResolvePluginProviders = (params?: { onlyPluginIds?: string[] }) => ProviderPlugin[];
+type ResolveOwningPluginIdsForProvider = (params: { provider: string }) => string[] | undefined;
+type ResolveCatalogHookProviderPluginIds = (params: unknown) => string[];
+
+const resolvePluginProvidersMock = vi.hoisted(() => vi.fn<ResolvePluginProviders>(() => []));
+const resolveOwningPluginIdsForProviderMock = vi.hoisted(() =>
+  vi.fn<ResolveOwningPluginIdsForProvider>(() => undefined),
+);
+const resolveCatalogHookProviderPluginIdsMock = vi.hoisted(() =>
+  vi.fn<ResolveCatalogHookProviderPluginIds>((_) => [] as string[]),
+);
+
+vi.mock("openclaw/plugin-sdk/provider-catalog-runtime", async () => {
+  const actual = await vi.importActual<
+    typeof import("openclaw/plugin-sdk/provider-catalog-runtime")
+  >("openclaw/plugin-sdk/provider-catalog-runtime");
+  const resolveCatalogHookProviders = (params: unknown) =>
+    resolvePluginProvidersMock({
+      onlyPluginIds: resolveCatalogHookProviderPluginIdsMock(params),
+    });
+  return {
+    ...actual,
+    augmentModelCatalogWithProviderPlugins: async (params: {
+      context: Parameters<NonNullable<ProviderPlugin["augmentModelCatalog"]>>[0];
+    }) => {
+      const supplemental = [];
+      for (const provider of resolveCatalogHookProviders(params)) {
+        const entries = await provider.augmentModelCatalog?.(params.context);
+        if (entries?.length) {
+          supplemental.push(...entries);
+        }
+      }
+      return supplemental;
+    },
+    resolveOwningPluginIdsForProvider: (params: unknown) =>
+      resolveOwningPluginIdsForProviderMock(params as never),
+    resolveCatalogHookProviderPluginIds: (params: unknown) =>
+      resolveCatalogHookProviderPluginIdsMock(params as never),
+    isPluginProvidersLoadInFlight: () => false,
+    resolvePluginProviders: (params: unknown) => resolvePluginProvidersMock(params as never),
+  };
+});
+
+export function describeOpenAIProviderCatalogContract() {
+  const contractDepsPromise = (async () => {
+    vi.resetModules();
+    const openaiPlugin = await loadBundledPluginPublicSurface<{
+      default: Parameters<typeof registerProviderPlugin>[0]["plugin"];
+    }>({
+      pluginId: "openai",
+      artifactBasename: "index.js",
+    });
+    const openaiProviders = (
+      await registerProviderPlugin({
+        plugin: openaiPlugin.default,
+        id: "openai",
+        name: "OpenAI",
+      })
+    ).providers;
+    const openaiProvider = requireRegisteredProvider(openaiProviders, "openai", "provider");
+    const { augmentModelCatalogWithProviderPlugins } = await importProviderRuntimeCatalogModule();
+    return {
+      augmentModelCatalogWithProviderPlugins,
+      openaiProviders,
+      openaiProvider,
+    };
+  })();
+
+  describe(
+    "openai provider catalog contract",
+    { timeout: PROVIDER_CATALOG_CONTRACT_TIMEOUT_MS },
+    () => {
+      beforeEach(async () => {
+        const { openaiProviders } = await contractDepsPromise;
+
+        resolvePluginProvidersMock.mockReset();
+        resolvePluginProvidersMock.mockImplementation((params?: { onlyPluginIds?: string[] }) => {
+          const onlyPluginIds = params?.onlyPluginIds;
+          if (!onlyPluginIds || onlyPluginIds.length === 0) {
+            return openaiProviders;
+          }
+          return onlyPluginIds.includes("openai") ? openaiProviders : [];
+        });
+
+        resolveOwningPluginIdsForProviderMock.mockReset();
+        resolveOwningPluginIdsForProviderMock.mockImplementation((params) => {
+          switch (params.provider) {
+            case "azure-openai-responses":
+            case "openai":
+            case "openai-codex":
+              return ["openai"];
+            default:
+              return undefined;
+          }
+        });
+
+        resolveCatalogHookProviderPluginIdsMock.mockReset();
+        resolveCatalogHookProviderPluginIdsMock.mockReturnValue(["openai"]);
+      });
+
+      it("keeps codex-only missing-auth hints wired through the provider runtime", async () => {
+        const { openaiProvider } = await contractDepsPromise;
+        expectCodexMissingAuthHint(
+          (params) => openaiProvider.buildMissingAuthMessage?.(params.context) ?? undefined,
+          "openai/gpt-*",
+        );
+      });
+
+      it("keeps bundled model augmentation wired through the provider runtime", async () => {
+        const { augmentModelCatalogWithProviderPlugins } = await contractDepsPromise;
+        await expectAugmentedCodexCatalog(
+          augmentModelCatalogWithProviderPlugins,
+          expectedOpenaiPluginCodexCatalogEntriesWithGpt55,
+        );
+      });
+    },
+  );
+}

package/extensions/openai/thinking-policy.ts

@@ -0,0 +1,55 @@
+import type { ProviderThinkingProfile } from "openclaw/plugin-sdk/plugin-entry";
+
+const OPENAI_THINKING_BASE_LEVELS = [
+  { id: "off" },
+  { id: "minimal" },
+  { id: "low" },
+  { id: "medium" },
+  { id: "high" },
+] as const satisfies ProviderThinkingProfile["levels"];
+
+const OPENAI_XHIGH_MODEL_IDS = [
+  "gpt-5.5",
+  "gpt-5.5-pro",
+  "gpt-5.4",
+  "gpt-5.4-pro",
+  "gpt-5.4-mini",
+  "gpt-5.4-nano",
+  "gpt-5.2",
+] as const;
+
+const OPENAI_CODEX_XHIGH_MODEL_IDS = ["gpt-5.5", "gpt-5.5-pro", "gpt-5.4", "gpt-5.4-pro"] as const;
+
+function normalizeModelId(value: string): string {
+  return value.trim().toLowerCase();
+}
+
+function matchesExactOrPrefix(id: string, values: readonly string[]): boolean {
+  const normalizedId = normalizeModelId(id);
+  return values.some((value) => {
+    const normalizedValue = normalizeModelId(value);
+    return normalizedId === normalizedValue || normalizedId.startsWith(normalizedValue);
+  });
+}
+
+function buildOpenAIThinkingProfile(params: {
+  modelId: string;
+  xhighModelIds: readonly string[];
+}): ProviderThinkingProfile {
+  return {
+    levels: [
+      ...OPENAI_THINKING_BASE_LEVELS,
+      ...(matchesExactOrPrefix(params.modelId, params.xhighModelIds)
+        ? [{ id: "xhigh" as const }]
+        : []),
+    ],
+  };
+}
+
+export function resolveOpenAIThinkingProfile(modelId: string): ProviderThinkingProfile {
+  return buildOpenAIThinkingProfile({ modelId, xhighModelIds: OPENAI_XHIGH_MODEL_IDS });
+}
+
+export function resolveOpenAICodexThinkingProfile(modelId: string): ProviderThinkingProfile {
+  return buildOpenAIThinkingProfile({ modelId, xhighModelIds: OPENAI_CODEX_XHIGH_MODEL_IDS });
+}

package/extensions/openai/transport-policy.test.ts

@@ -0,0 +1,128 @@
+import type { ProviderRuntimeModel } from "openclaw/plugin-sdk/plugin-entry";
+import { describe, expect, it } from "vitest";
+import {
+  resolveOpenAITransportTurnState,
+  resolveOpenAIWebSocketSessionPolicy,
+} from "./transport-policy.js";
+
+describe("openai transport policy", () => {
+  const nativeModel = {
+    id: "gpt-5.4",
+    name: "GPT-5.4",
+    api: "openai-responses",
+    provider: "openai",
+    baseUrl: "https://api.openai.com/v1",
+    reasoning: true,
+    input: ["text"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 200000,
+    maxTokens: 8192,
+  } satisfies ProviderRuntimeModel;
+
+  const proxyModel = {
+    ...nativeModel,
+    id: "proxy-model",
+    name: "Proxy Model",
+    baseUrl: "https://proxy.example.com/v1",
+  } satisfies ProviderRuntimeModel;
+
+  it("builds native turn state for direct OpenAI routes", () => {
+    const state = resolveOpenAITransportTurnState({
+      provider: "openai",
+      modelId: nativeModel.id,
+      model: nativeModel,
+      sessionId: "session-123",
+      turnId: "turn-123",
+      attempt: 2,
+      transport: "websocket",
+    });
+    expect(state?.headers?.["x-client-request-id"]).toBe("session-123");
+    expect(state?.headers?.["x-openclaw-session-id"]).toBe("session-123");
+    expect(state?.headers?.["x-openclaw-turn-id"]).toBe("turn-123");
+    expect(state?.headers?.["x-openclaw-turn-attempt"]).toBe("2");
+    expect(state?.metadata?.openclaw_session_id).toBe("session-123");
+    expect(state?.metadata?.openclaw_turn_id).toBe("turn-123");
+    expect(state?.metadata?.openclaw_turn_attempt).toBe("2");
+    expect(state?.metadata?.openclaw_transport).toBe("websocket");
+  });
+
+  it("skips turn state for proxy-like OpenAI routes", () => {
+    expect(
+      resolveOpenAITransportTurnState({
+        provider: "openai",
+        modelId: proxyModel.id,
+        model: proxyModel,
+        sessionId: "session-123",
+        turnId: "turn-123",
+        attempt: 1,
+        transport: "stream",
+      }),
+    ).toBeUndefined();
+  });
+
+  it("keeps Codex request identity session-scoped while adding turn metadata", () => {
+    const state = resolveOpenAITransportTurnState({
+      provider: "openai-codex",
+      modelId: "gpt-5.4",
+      model: {
+        ...nativeModel,
+        provider: "openai-codex",
+        api: "openai-codex-responses",
+        baseUrl: "https://chatgpt.com/backend-api",
+      },
+      sessionId: "session-123",
+      turnId: "turn-123",
+      attempt: 2,
+      transport: "stream",
+    });
+    expect(state?.headers?.["x-client-request-id"]).toBe("session-123");
+    expect(state?.headers?.["x-openclaw-session-id"]).toBe("session-123");
+    expect(state?.headers?.["x-openclaw-turn-id"]).toBe("turn-123");
+    expect(state?.headers?.["x-openclaw-turn-attempt"]).toBe("2");
+  });
+
+  it("returns websocket session headers and cooldown for native routes", () => {
+    const policy = resolveOpenAIWebSocketSessionPolicy({
+      provider: "openai",
+      modelId: nativeModel.id,
+      model: nativeModel,
+      sessionId: "session-123",
+    });
+    expect(policy?.headers?.["x-client-request-id"]).toBe("session-123");
+    expect(policy?.headers?.["x-openclaw-session-id"]).toBe("session-123");
+    expect(policy?.degradeCooldownMs).toBe(60_000);
+  });
+
+  it("treats Azure routes as native OpenAI-family transports", () => {
+    const policy = resolveOpenAIWebSocketSessionPolicy({
+      provider: "azure-openai-responses",
+      modelId: "gpt-5.4",
+      model: {
+        ...nativeModel,
+        provider: "azure-openai-responses",
+        baseUrl: "https://demo.openai.azure.com/openai/v1",
+      },
+      sessionId: "session-123",
+    });
+    expect(policy?.headers?.["x-client-request-id"]).toBe("session-123");
+    expect(policy?.headers?.["x-openclaw-session-id"]).toBe("session-123");
+    expect(policy?.degradeCooldownMs).toBe(60_000);
+  });
+
+  it("treats ChatGPT Codex backend routes as native OpenAI-family transports", () => {
+    const policy = resolveOpenAIWebSocketSessionPolicy({
+      provider: "openai-codex",
+      modelId: "gpt-5.4",
+      model: {
+        ...nativeModel,
+        provider: "openai-codex",
+        api: "openai-codex-responses",
+        baseUrl: "https://chatgpt.com/backend-api",
+      },
+      sessionId: "session-123",
+    });
+    expect(policy?.headers?.["x-client-request-id"]).toBe("session-123");
+    expect(policy?.headers?.["x-openclaw-session-id"]).toBe("session-123");
+    expect(policy?.degradeCooldownMs).toBe(60_000);
+  });
+});