@full-self-developing/fsd 1.0.0

package/extensions/codex/test-api.ts

@@ -0,0 +1,95 @@
+import type {
+  AnyAgentTool,
+  EmbeddedRunAttemptParams,
+} from "openclaw/plugin-sdk/agent-harness-runtime";
+import {
+  type CodexAppServerRuntimeOptions,
+  resolveCodexAppServerRuntimeOptions,
+} from "./src/app-server/config.js";
+import type { CodexPluginConfig } from "./src/app-server/config.js";
+import { filterCodexDynamicTools } from "./src/app-server/dynamic-tool-profile.js";
+import { createCodexDynamicToolBridge } from "./src/app-server/dynamic-tools.js";
+import type { CodexDynamicToolSpec, JsonObject } from "./src/app-server/protocol.js";
+import {
+  buildDeveloperInstructions,
+  buildThreadResumeParams,
+  buildThreadStartParams,
+  buildTurnStartParams,
+} from "./src/app-server/thread-lifecycle.js";
+
+type CodexHarnessPromptSnapshot = {
+  developerInstructions: string;
+  threadStartParams: ReturnType<typeof buildThreadStartParams>;
+  threadResumeParams: ReturnType<typeof buildThreadResumeParams>;
+  turnStartParams: ReturnType<typeof buildTurnStartParams>;
+};
+
+export function resolveCodexPromptSnapshotAppServerOptions(
+  pluginConfig?: unknown,
+): CodexAppServerRuntimeOptions {
+  return resolveCodexAppServerRuntimeOptions({
+    pluginConfig,
+    env: {},
+    requirementsToml: null,
+  });
+}
+
+export function buildCodexHarnessPromptSnapshot(params: {
+  attempt: EmbeddedRunAttemptParams;
+  cwd: string;
+  threadId: string;
+  dynamicTools: CodexDynamicToolSpec[];
+  appServer: CodexAppServerRuntimeOptions;
+  config?: JsonObject;
+  promptText?: string;
+  developerInstructionAdditions?: string;
+  heartbeatCollaborationInstructions?: string;
+}): CodexHarnessPromptSnapshot {
+  const developerInstructions = joinPresentSections(
+    buildDeveloperInstructions(params.attempt, {
+      dynamicTools: params.dynamicTools,
+    }),
+    params.developerInstructionAdditions,
+  );
+  return {
+    developerInstructions,
+    threadStartParams: buildThreadStartParams(params.attempt, {
+      cwd: params.cwd,
+      dynamicTools: params.dynamicTools,
+      appServer: params.appServer,
+      developerInstructions,
+      config: params.config,
+    }),
+    threadResumeParams: buildThreadResumeParams(params.attempt, {
+      threadId: params.threadId,
+      appServer: params.appServer,
+      developerInstructions,
+      config: params.config,
+    }),
+    turnStartParams: buildTurnStartParams(params.attempt, {
+      threadId: params.threadId,
+      cwd: params.cwd,
+      appServer: params.appServer,
+      promptText: params.promptText,
+      heartbeatCollaborationInstructions: params.heartbeatCollaborationInstructions,
+    }),
+  };
+}
+
+function joinPresentSections(...sections: Array<string | undefined>): string {
+  return sections.filter((section): section is string => Boolean(section?.trim())).join("\n\n");
+}
+
+export function createCodexDynamicToolSpecsForPromptSnapshot(params: {
+  tools: AnyAgentTool[];
+  pluginConfig?: Pick<CodexPluginConfig, "codexDynamicToolsLoading" | "codexDynamicToolsExclude">;
+  directToolNames?: Iterable<string>;
+}): CodexDynamicToolSpec[] {
+  const filteredTools = filterCodexDynamicTools(params.tools, params.pluginConfig ?? {});
+  return createCodexDynamicToolBridge({
+    tools: filteredTools,
+    signal: new AbortController().signal,
+    loading: params.pluginConfig?.codexDynamicToolsLoading ?? "searchable",
+    directToolNames: params.directToolNames,
+  }).specs;
+}

package/extensions/codex/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../tsconfig.package-boundary.base.json",
+  "compilerOptions": {
+    "rootDir": "."
+  },
+  "include": ["./*.ts", "./src/**/*.ts"],
+  "exclude": [
+    "./**/*.test.ts",
+    "./dist/**",
+    "./node_modules/**",
+    "./src/test-support/**",
+    "./src/**/*test-helpers.ts",
+    "./src/**/*test-harness.ts",
+    "./src/**/*test-support.ts"
+  ]
+}

package/extensions/comfy/comfy.live.test.ts

@@ -0,0 +1,128 @@
+import { resolveDefaultAgentDir } from "openclaw/plugin-sdk/agent-runtime";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/config-contracts";
+import { createTestPluginApi } from "openclaw/plugin-sdk/plugin-test-api";
+import { getRuntimeConfig } from "openclaw/plugin-sdk/runtime-config-snapshot";
+import { isLiveTestEnabled } from "openclaw/plugin-sdk/test-env";
+import { beforeAll, describe, expect, it } from "vitest";
+import plugin from "./index.js";
+import { getComfyConfig, isComfyCapabilityConfigured } from "./workflow-runtime.js";
+
+const LIVE =
+  isLiveTestEnabled(["COMFY_LIVE_TEST"]) && (process.env.COMFY_LIVE_TEST ?? "").trim() === "1";
+const describeLive = LIVE ? describe : describe.skip;
+
+type RegisteredMusicProvider = {
+  id: string;
+  generateMusic: Function;
+  isConfigured?: Function;
+};
+
+function withPluginsEnabled<T>(cfg: T): T {
+  if (!cfg || typeof cfg !== "object") {
+    return cfg;
+  }
+  const record = cfg as Record<string, unknown>;
+  return {
+    ...record,
+    plugins: {
+      ...(record.plugins && typeof record.plugins === "object" ? record.plugins : {}),
+      enabled: true,
+    },
+  } as T;
+}
+
+function requireProvider<T extends { id: string }>(providers: T[], id: string): T {
+  const provider = providers.find((entry) => entry.id === id);
+  if (!provider) {
+    throw new Error(`expected ${id} provider to be registered`);
+  }
+  return provider;
+}
+
+describeLive("comfy live", () => {
+  let cfg = {} as OpenClawConfig;
+  let agentDir = "";
+  const imageProviders: Array<{ id: string; generateImage: Function; isConfigured?: Function }> =
+    [];
+  const musicProviders: RegisteredMusicProvider[] = [];
+  const videoProviders: Array<{ id: string; generateVideo: Function; isConfigured?: Function }> =
+    [];
+
+  beforeAll(async () => {
+    cfg = withPluginsEnabled(getRuntimeConfig());
+    agentDir = resolveDefaultAgentDir(cfg as never);
+    plugin.register(
+      createTestPluginApi({
+        config: cfg as never,
+        registerImageGenerationProvider(provider) {
+          imageProviders.push(provider as never);
+        },
+        registerMusicGenerationProvider(provider) {
+          musicProviders.push(provider as never);
+        },
+        registerVideoGenerationProvider(provider) {
+          videoProviders.push(provider as never);
+        },
+      }),
+    );
+  });
+
+  it.skipIf(!isComfyCapabilityConfigured({ cfg: cfg as never, agentDir, capability: "image" }))(
+    "runs an image workflow",
+    async () => {
+      const provider = requireProvider(imageProviders, "comfy");
+      const result = await provider.generateImage({
+        provider: "comfy",
+        model: "workflow",
+        prompt: "A tiny orange lobster icon on a clean background.",
+        cfg: cfg as never,
+        agentDir,
+      });
+      expect(result.images.length).toBeGreaterThan(0);
+      expect(result.images[0]?.mimeType.startsWith("image/")).toBe(true);
+      expect(result.images[0]?.buffer.byteLength).toBeGreaterThan(128);
+    },
+    120_000,
+  );
+
+  it.skipIf(!isComfyCapabilityConfigured({ cfg: cfg as never, agentDir, capability: "video" }))(
+    "runs a video workflow",
+    async () => {
+      const provider = requireProvider(videoProviders, "comfy");
+      const result = await provider.generateVideo({
+        provider: "comfy",
+        model: "workflow",
+        prompt: "A tiny paper lobster gently waving, cinematic motion.",
+        cfg: cfg as never,
+        agentDir,
+      });
+      expect(result.videos.length).toBeGreaterThan(0);
+      expect(result.videos[0]?.mimeType.startsWith("video/")).toBe(true);
+      expect(result.videos[0]?.buffer.byteLength).toBeGreaterThan(512);
+    },
+    180_000,
+  );
+
+  it.skipIf(!isComfyCapabilityConfigured({ cfg: cfg as never, agentDir, capability: "music" }))(
+    "runs a music workflow",
+    async () => {
+      const provider = requireProvider(musicProviders, "comfy");
+      const result = await provider.generateMusic({
+        provider: "comfy",
+        model: "workflow",
+        prompt: "A gentle ambient synth loop with warm analog pads.",
+        cfg: cfg as never,
+        agentDir,
+      });
+      expect(result.tracks.length).toBeGreaterThan(0);
+      expect(result.tracks[0]?.mimeType.startsWith("audio/")).toBe(true);
+      expect(result.tracks[0]?.buffer.byteLength).toBeGreaterThan(512);
+    },
+    180_000,
+  );
+
+  it("documents the effective comfy config shape for live debugging", () => {
+    const comfyConfig = getComfyConfig(cfg as never);
+    expect(typeof comfyConfig).toBe("object");
+  });
+});

package/extensions/comfy/image-generation-provider.test.ts

@@ -0,0 +1,457 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  setComfyFetchGuardForTesting,
+  buildComfyImageGenerationProvider,
+} from "./image-generation-provider.js";
+import {
+  buildComfyConfig,
+  buildLegacyComfyConfig,
+  mockComfyCloudJobResponses,
+  mockComfyProviderApiKey,
+  parseComfyJsonBody,
+} from "./test-helpers.js";
+
+const { fetchWithSsrFGuardMock } = vi.hoisted(() => ({
+  fetchWithSsrFGuardMock: vi.fn(),
+}));
+
+type FetchGuardRequest = {
+  url?: unknown;
+  auditContext?: unknown;
+  init?: {
+    method?: unknown;
+    headers?: HeadersInit;
+    body?: BodyInit | null;
+  };
+};
+
+function fetchRequest(call: number): FetchGuardRequest {
+  const request = fetchWithSsrFGuardMock.mock.calls[call - 1]?.[0] as FetchGuardRequest | undefined;
+  if (!request) {
+    throw new Error(`expected Comfy fetch call ${call}`);
+  }
+  return request;
+}
+
+function parseJsonBody(call: number): Record<string, unknown> {
+  return parseComfyJsonBody(fetchWithSsrFGuardMock, call);
+}
+
+describe("comfy image-generation provider", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    setComfyFetchGuardForTesting(null);
+    vi.unstubAllEnvs();
+    vi.restoreAllMocks();
+  });
+
+  it("treats local comfy workflows as configured without an API key", () => {
+    const provider = buildComfyImageGenerationProvider();
+    expect(
+      provider.isConfigured?.({
+        cfg: buildComfyConfig({
+          workflow: {
+            "6": { inputs: { text: "" } },
+          },
+          promptNodeId: "6",
+        }),
+      }),
+    ).toBe(true);
+  });
+
+  it("falls back to legacy models.providers comfy config when plugin config is absent", () => {
+    const provider = buildComfyImageGenerationProvider();
+    expect(
+      provider.isConfigured?.({
+        cfg: buildLegacyComfyConfig({
+          workflow: {
+            "6": { inputs: { text: "" } },
+          },
+          promptNodeId: "6",
+        }),
+      }),
+    ).toBe(true);
+  });
+
+  it("treats cloud comfy workflows as configured with a plugin config API key", () => {
+    const provider = buildComfyImageGenerationProvider();
+    expect(
+      provider.isConfigured?.({
+        cfg: buildComfyConfig({
+          mode: "cloud",
+          apiKey: "comfy-test-key",
+          image: {
+            workflow: {
+              "6": { inputs: { text: "" } },
+            },
+            promptNodeId: "6",
+          },
+        }),
+      }),
+    ).toBe(true);
+  });
+
+  it("treats cloud comfy workflows as configured with a plugin config env SecretRef", () => {
+    vi.stubEnv("COMFY_TEST_API_KEY", "comfy-secret-ref-key");
+    const provider = buildComfyImageGenerationProvider();
+    expect(
+      provider.isConfigured?.({
+        cfg: buildComfyConfig({
+          mode: "cloud",
+          apiKey: { source: "env", provider: "default", id: "COMFY_TEST_API_KEY" },
+          image: {
+            workflow: {
+              "6": { inputs: { text: "" } },
+            },
+            promptNodeId: "6",
+          },
+        }),
+      }),
+    ).toBe(true);
+  });
+
+  it("submits a local workflow, waits for history, and downloads images", async () => {
+    setComfyFetchGuardForTesting(fetchWithSsrFGuardMock);
+    fetchWithSsrFGuardMock
+      .mockResolvedValueOnce({
+        response: new Response(JSON.stringify({ prompt_id: "local-prompt-1" }), {
+          status: 200,
+          headers: { "content-type": "application/json" },
+        }),
+        release: vi.fn(async () => {}),
+      })
+      .mockResolvedValueOnce({
+        response: new Response(
+          JSON.stringify({
+            "local-prompt-1": {
+              outputs: {
+                "9": {
+                  images: [{ filename: "generated.png", subfolder: "", type: "output" }],
+                },
+              },
+            },
+          }),
+          {
+            status: 200,
+            headers: { "content-type": "application/json" },
+          },
+        ),
+        release: vi.fn(async () => {}),
+      })
+      .mockResolvedValueOnce({
+        response: new Response(Buffer.from("png-data"), {
+          status: 200,
+          headers: { "content-type": "image/png" },
+        }),
+        release: vi.fn(async () => {}),
+      });
+
+    const provider = buildComfyImageGenerationProvider();
+    const result = await provider.generateImage({
+      provider: "comfy",
+      model: "workflow",
+      prompt: "draw a lobster",
+      cfg: buildComfyConfig({
+        workflow: {
+          "6": { inputs: { text: "" } },
+          "9": { inputs: {} },
+        },
+        promptNodeId: "6",
+        outputNodeId: "9",
+      }),
+    });
+
+    const submitRequest = fetchRequest(1);
+    expect(submitRequest.url).toBe("http://127.0.0.1:8188/prompt");
+    expect(submitRequest.auditContext).toBe("comfy-image-generate");
+    expect(parseJsonBody(1)).toEqual({
+      prompt: {
+        "6": { inputs: { text: "draw a lobster" } },
+        "9": { inputs: {} },
+      },
+    });
+    const historyRequest = fetchRequest(2);
+    expect(historyRequest.url).toBe("http://127.0.0.1:8188/history/local-prompt-1");
+    expect(historyRequest.auditContext).toBe("comfy-history");
+    const downloadRequest = fetchRequest(3);
+    expect(downloadRequest.url).toBe(
+      "http://127.0.0.1:8188/view?filename=generated.png&subfolder=&type=output",
+    );
+    expect(downloadRequest.auditContext).toBe("comfy-image-download");
+    expect(result).toEqual({
+      images: [
+        {
+          buffer: Buffer.from("png-data"),
+          mimeType: "image/png",
+          fileName: "generated.png",
+          metadata: {
+            nodeId: "9",
+            promptId: "local-prompt-1",
+          },
+        },
+      ],
+      model: "workflow",
+      metadata: {
+        promptId: "local-prompt-1",
+        outputNodeIds: ["9"],
+      },
+    });
+  });
+
+  it("reports malformed local workflow submit JSON as a provider error", async () => {
+    setComfyFetchGuardForTesting(fetchWithSsrFGuardMock);
+    const release = vi.fn(async () => {});
+    fetchWithSsrFGuardMock.mockResolvedValueOnce({
+      response: new Response("{ nope", {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      }),
+      release,
+    });
+
+    const provider = buildComfyImageGenerationProvider();
+    await expect(
+      provider.generateImage({
+        provider: "comfy",
+        model: "workflow",
+        prompt: "draw a lobster",
+        cfg: buildComfyConfig({
+          workflow: {
+            "6": { inputs: { text: "" } },
+            "9": { inputs: {} },
+          },
+          promptNodeId: "6",
+          outputNodeId: "9",
+        }),
+      }),
+    ).rejects.toThrow("Comfy workflow submit failed: malformed JSON response");
+    expect(release).toHaveBeenCalledTimes(1);
+  });
+
+  it("uploads reference images for local edit workflows", async () => {
+    setComfyFetchGuardForTesting(fetchWithSsrFGuardMock);
+    fetchWithSsrFGuardMock
+      .mockResolvedValueOnce({
+        response: new Response(JSON.stringify({ name: "upload.png" }), {
+          status: 200,
+          headers: { "content-type": "application/json" },
+        }),
+        release: vi.fn(async () => {}),
+      })
+      .mockResolvedValueOnce({
+        response: new Response(JSON.stringify({ prompt_id: "local-edit-1" }), {
+          status: 200,
+          headers: { "content-type": "application/json" },
+        }),
+        release: vi.fn(async () => {}),
+      })
+      .mockResolvedValueOnce({
+        response: new Response(
+          JSON.stringify({
+            "local-edit-1": {
+              outputs: {
+                "9": {
+                  images: [{ filename: "edited.png", subfolder: "", type: "output" }],
+                },
+              },
+            },
+          }),
+          {
+            status: 200,
+            headers: { "content-type": "application/json" },
+          },
+        ),
+        release: vi.fn(async () => {}),
+      })
+      .mockResolvedValueOnce({
+        response: new Response(Buffer.from("edited-data"), {
+          status: 200,
+          headers: { "content-type": "image/png" },
+        }),
+        release: vi.fn(async () => {}),
+      });
+
+    const provider = buildComfyImageGenerationProvider();
+    await provider.generateImage({
+      provider: "comfy",
+      model: "workflow",
+      prompt: "turn this into a poster",
+      cfg: buildComfyConfig({
+        workflow: {
+          "6": { inputs: { text: "" } },
+          "7": { inputs: { image: "" } },
+          "9": { inputs: {} },
+        },
+        promptNodeId: "6",
+        inputImageNodeId: "7",
+        outputNodeId: "9",
+      }),
+      inputImages: [
+        {
+          buffer: Buffer.from("source"),
+          mimeType: "image/png",
+          fileName: "source.png",
+        },
+      ],
+    });
+
+    const uploadRequest = fetchRequest(1);
+    expect(uploadRequest?.url).toBe("http://127.0.0.1:8188/upload/image");
+    expect(uploadRequest?.auditContext).toBe("comfy-image-upload");
+    expect(uploadRequest?.init?.method).toBe("POST");
+    const uploadForm = uploadRequest?.init?.body;
+    if (!(uploadForm instanceof FormData)) {
+      throw new Error("expected Comfy upload request body to be FormData");
+    }
+    expect(uploadForm.get("type")).toBe("input");
+    expect(uploadForm.get("overwrite")).toBe("true");
+
+    expect(parseJsonBody(2)).toEqual({
+      prompt: {
+        "6": { inputs: { text: "turn this into a poster" } },
+        "7": { inputs: { image: "upload.png" } },
+        "9": { inputs: {} },
+      },
+    });
+  });
+
+  it("uses cloud endpoints, auth headers, and partner-node extra_data", async () => {
+    mockComfyProviderApiKey();
+    setComfyFetchGuardForTesting(fetchWithSsrFGuardMock);
+    mockComfyCloudJobResponses(fetchWithSsrFGuardMock, {
+      body: Buffer.from("cloud-data"),
+      contentType: "image/png",
+      filename: "cloud.png",
+      outputKind: "images",
+      promptId: "cloud-job-1",
+      redirectLocation: "https://cdn.example.com/cloud.png",
+    });
+
+    const provider = buildComfyImageGenerationProvider();
+    const result = await provider.generateImage({
+      provider: "comfy",
+      model: "workflow",
+      prompt: "cloud workflow prompt",
+      cfg: buildComfyConfig({
+        mode: "cloud",
+        workflow: {
+          "6": { inputs: { text: "" } },
+          "9": { inputs: {} },
+        },
+        promptNodeId: "6",
+        outputNodeId: "9",
+      }),
+    });
+
+    const submitRequest = fetchRequest(1);
+    expect(submitRequest?.url).toBe("https://cloud.comfy.org/api/prompt");
+    expect(submitRequest?.auditContext).toBe("comfy-image-generate");
+    const submitHeaders = new Headers(submitRequest?.init?.headers);
+    expect(submitHeaders.get("x-api-key")).toBe("comfy-test-key");
+    expect(parseJsonBody(1)).toEqual({
+      prompt: {
+        "6": { inputs: { text: "cloud workflow prompt" } },
+        "9": { inputs: {} },
+      },
+      extra_data: {
+        api_key_comfy_org: "comfy-test-key",
+      },
+    });
+
+    const statusRequest = fetchRequest(2);
+    expect(statusRequest.url).toBe("https://cloud.comfy.org/api/job/cloud-job-1/status");
+    expect(statusRequest.auditContext).toBe("comfy-status");
+    const historyRequest = fetchRequest(3);
+    expect(historyRequest.url).toBe("https://cloud.comfy.org/api/history_v2/cloud-job-1");
+    expect(historyRequest.auditContext).toBe("comfy-history");
+    const viewRequest = fetchRequest(4);
+    expect(viewRequest.url).toBe(
+      "https://cloud.comfy.org/api/view?filename=cloud.png&subfolder=&type=output",
+    );
+    expect(viewRequest.auditContext).toBe("comfy-image-download");
+    const cdnRequest = fetchRequest(5);
+    expect(cdnRequest.url).toBe("https://cdn.example.com/cloud.png");
+    expect(cdnRequest.auditContext).toBe("comfy-image-download");
+    expect(result.metadata).toEqual({
+      promptId: "cloud-job-1",
+      outputNodeIds: ["9"],
+    });
+  });
+
+  it("uses plugin config env SecretRef auth for cloud workflows", async () => {
+    vi.stubEnv("COMFY_TEST_API_KEY", "comfy-secret-ref-key");
+    setComfyFetchGuardForTesting(fetchWithSsrFGuardMock);
+    mockComfyCloudJobResponses(fetchWithSsrFGuardMock, {
+      body: Buffer.from("cloud-data"),
+      contentType: "image/png",
+      filename: "cloud.png",
+      outputKind: "images",
+      promptId: "cloud-secret-ref-1",
+      redirectLocation: "https://cdn.example.com/cloud.png",
+    });
+
+    const provider = buildComfyImageGenerationProvider();
+    await provider.generateImage({
+      provider: "comfy",
+      model: "workflow",
+      prompt: "cloud workflow prompt",
+      cfg: buildComfyConfig({
+        mode: "cloud",
+        apiKey: { source: "env", provider: "default", id: "COMFY_TEST_API_KEY" },
+        workflow: {
+          "6": { inputs: { text: "" } },
+          "9": { inputs: {} },
+        },
+        promptNodeId: "6",
+        outputNodeId: "9",
+      }),
+    });
+
+    const submitRequest = fetchRequest(1);
+    const submitHeaders = new Headers(submitRequest?.init?.headers);
+    expect(submitHeaders.get("x-api-key")).toBe("comfy-secret-ref-key");
+    const requestBody = parseJsonBody(1);
+    const extraData = requestBody.extra_data as { api_key_comfy_org?: unknown } | undefined;
+    expect(extraData?.api_key_comfy_org).toBe("comfy-secret-ref-key");
+  });
+
+  it("uses provider auth fallback for cloud workflows without plugin config API keys", async () => {
+    vi.stubEnv("COMFY_API_KEY", "stale-env-key");
+    mockComfyProviderApiKey("profile-key");
+    setComfyFetchGuardForTesting(fetchWithSsrFGuardMock);
+    mockComfyCloudJobResponses(fetchWithSsrFGuardMock, {
+      body: Buffer.from("cloud-data"),
+      contentType: "image/png",
+      filename: "cloud.png",
+      outputKind: "images",
+      promptId: "cloud-profile-1",
+      redirectLocation: "https://cdn.example.com/cloud.png",
+    });
+
+    const provider = buildComfyImageGenerationProvider();
+    await provider.generateImage({
+      provider: "comfy",
+      model: "workflow",
+      prompt: "cloud workflow prompt",
+      cfg: buildComfyConfig({
+        mode: "cloud",
+        workflow: {
+          "6": { inputs: { text: "" } },
+          "9": { inputs: {} },
+        },
+        promptNodeId: "6",
+        outputNodeId: "9",
+      }),
+    });
+
+    const submitRequest = fetchRequest(1);
+    const submitHeaders = new Headers(submitRequest?.init?.headers);
+    expect(submitHeaders.get("x-api-key")).toBe("profile-key");
+    const requestBody = parseJsonBody(1);
+    const extraData = requestBody.extra_data as { api_key_comfy_org?: unknown } | undefined;
+    expect(extraData?.api_key_comfy_org).toBe("profile-key");
+  });
+});