@cartanova/qgrid-cli 2.9.5 → 2.9.7

package/bundle/src/utils/providers/anthropic/anthropic-constants.test.ts

@@ -33,6 +33,7 @@ describe("Anthropic 1M context policy", () => {
     expect(supports1MContext("claude-fable-5-1")).toBe(true);
     expect(supports1MContext("claude-fable-5")).toBe(true);
     expect(supports1MContext("claude-opus-5")).toBe(true);
+    expect(supports1MContext("claude-opus-5-5")).toBe(true);
     expect(supports1MContext("claude-sonnet-5")).toBe(true);
     expect(supports1MContext("claude-sonnet-4-6")).toBe(true);
     expect(supports1MContext("claude-opus-4-6")).toBe(true);
@@ -48,6 +49,7 @@ describe("Anthropic 1M context policy", () => {
     expect(needsCli1mSuffix("claude-fable-5-1")).toBe(false);
     expect(needsCli1mSuffix("claude-fable-5")).toBe(false);
     expect(needsCli1mSuffix("claude-opus-5")).toBe(false);
+    expect(needsCli1mSuffix("claude-opus-5-5")).toBe(false);
     expect(needsCli1mSuffix("claude-sonnet-5")).toBe(false);
     expect(needsCli1mSuffix("claude-sonnet-4-6")).toBe(true);
     expect(needsCli1mSuffix("claude-opus-4-6")).toBe(true);
@@ -78,13 +80,15 @@ describe("Anthropic 1M context policy", () => {
 });
 
 describe("Anthropic thinking policy", () => {
-  it("Fable 5/5.1 과 Opus 5 는 adaptive thinking 을 보존한다", () => {
+  it("Fable 5/5.1, Opus 5, Opus 5.5 는 adaptive thinking 을 보존한다", () => {
     expect(usesAdaptiveThinking("claude-fable-5-1")).toBe(true);
     expect(usesAdaptiveThinking("anthropic/claude-fable-5-1")).toBe(true);
     expect(usesAdaptiveThinking("claude-fable-5")).toBe(true);
     expect(usesAdaptiveThinking("anthropic/claude-fable-5")).toBe(true);
     expect(usesAdaptiveThinking("claude-opus-5")).toBe(true);
     expect(usesAdaptiveThinking("anthropic/claude-opus-5")).toBe(true);
+    expect(usesAdaptiveThinking("claude-opus-5-5")).toBe(true);
+    expect(usesAdaptiveThinking("anthropic/claude-opus-5-5[1m]")).toBe(true);
     expect(usesAdaptiveThinking("claude-sonnet-5")).toBe(false);
     expect(usesAdaptiveThinking("claude-opus-4-8")).toBe(false);
   });

package/bundle/src/utils/providers/anthropic/anthropic-constants.ts

@@ -48,6 +48,7 @@ const ONE_MILLION_CONTEXT_MODELS = new Set([
   "claude-fable-5-1",
   "claude-fable-5",
   "claude-opus-5",
+  "claude-opus-5-5",
   "claude-sonnet-5",
   "claude-sonnet-4-6",
   "claude-opus-4-6",
@@ -55,11 +56,17 @@ const ONE_MILLION_CONTEXT_MODELS = new Set([
 ]);
 
 const CLI_ONE_MILLION_SUFFIX_MODELS = new Set(["claude-sonnet-4-6", "claude-opus-4-6"]);
-// Fable 5/5.1 은 adaptive thinking 이 유일한 모드다(CLI 카탈로그 `rejects_disabled_thinking`). Opus 5 는
+// Fable 5/5.1 과 Opus 5.5 는 adaptive thinking 이 유일한 모드다(Fable: CLI 카탈로그 `rejects_disabled_thinking`,
+// Opus 5.5: 공식 사양 "can't be turned off", 2026-09-22 출시). Opus 5 는
 // disabled 를 high 이하에서 지원하지만, 공식 기본값·권장 동작인 adaptive thinking 을 유지한다. qgrid
 // 기본 effort=low 가 비용/지연 제어를 맡으며, 이 정책은 disabled+xhigh/max 400 오류와 disabled 시
 // tool/XML 출력 오염도 피한다.
-const ADAPTIVE_THINKING_MODELS = new Set(["claude-fable-5-1", "claude-fable-5", "claude-opus-5"]);
+const ADAPTIVE_THINKING_MODELS = new Set([
+  "claude-fable-5-1",
+  "claude-fable-5",
+  "claude-opus-5",
+  "claude-opus-5-5",
+]);
 
 // Fable 계열: 구독 플랜에서 usage credits 가 필요한 최상위 티어. 구독 usage API 의
 // `seven_day_overage_included` 버킷은 이 계열에만 적용되므로 quota threshold 판정이 참조한다.

package/bundle/src/utils/providers/common/effort.test.ts

@@ -23,6 +23,8 @@ describe("resolveOpenAIEffort", () => {
     expect(resolveOpenAIEffort("gpt-5.6-terra", "max")).toBe("max");
     expect(resolveOpenAIEffort("gpt-5.6-terra", "ultra")).toBe("ultra");
     expect(resolveOpenAIEffort("gpt-5.6-luna", "max")).toBe("max");
+    expect(resolveOpenAIEffort("gpt-6-sol", "ultra")).toBe("ultra");
+    expect(resolveOpenAIEffort("gpt-6-luna", "max")).toBe("max");
   });
 
   it("공개 API 어휘(none/minimal)와 다른 provider 어휘, 오타는 조용히 미지정으로 바꾼다", () => {
@@ -36,6 +38,7 @@ describe("resolveOpenAIEffort", () => {
     expect(resolveOpenAIEffort("gpt-5.5", "max")).toBeUndefined();
     expect(resolveOpenAIEffort("gpt-5.4", "ultra")).toBeUndefined();
     expect(resolveOpenAIEffort("gpt-5.6-luna", "ultra")).toBeUndefined();
+    expect(resolveOpenAIEffort("gpt-6-luna", "ultra")).toBeUndefined();
     expect(resolveOpenAIEffort("gpt-5.3-codex-spark", "xhigh")).toBe("xhigh");
   });
 

package/bundle/src/utils/providers/common/model-cost.test.ts

@@ -13,6 +13,8 @@ describe("calculateCostUsd", () => {
   });
   it.each([
     ["gpt-6-astra", 10, 50, 1, 12.5],
+    ["gpt-6-sol", 2, 10, 0.2, 2.5],
+    ["gpt-6-luna", 0.1, 0.5, 0.01, 0.125],
     ["gpt-5.6-sol", 4, 20, 0.4, 5],
     ["gpt-5.6-terra", 2, 12, 0.2, 2.5],
     ["gpt-5.6-luna", 0.2, 1.2, 0.02, 0.25],
@@ -54,6 +56,8 @@ describe("calculateCostUsd", () => {
     ["claude-opus-4-7", 5, 25, 0.5, 10],
     ["claude-opus-4-8", 5, 25, 0.5, 10],
     ["claude-opus-5", 5, 25, 0.5, 10],
+    // Opus 5.5 는 cache read 만 0.05x 특례($0.20), cache write 배율은 표준(5m $5 / 1h $8).
+    ["claude-opus-5-5", 4, 20, 0.2, 8],
     ["claude-sonnet-5", 2, 10, 0.2, 4],
   ])(
     "%s official Anthropic rates for 5m/1h cache writes",
@@ -92,6 +96,8 @@ describe("calculateCostUsd", () => {
 
   it.each([
     ["gpt-6-astra", 10, 50, 1, 12.5, 5.6125],
+    ["gpt-6-sol", 2, 10, 0.2, 2.5, 1.1225],
+    ["gpt-6-luna", 0.1, 0.5, 0.01, 0.125, 0.056125],
     ["gpt-5.6-sol", 4, 20, 0.4, 5, 2.245],
     ["gpt-5.6-terra", 2, 12, 0.2, 2.5, 1.3225],
     ["gpt-5.6-luna", 0.2, 1.2, 0.02, 0.25, 0.13225],
@@ -118,6 +124,8 @@ describe("calculateCostUsd", () => {
 
   it.each([
     ["gpt-6-astra", 2.475],
+    ["gpt-6-sol", 0.495],
+    ["gpt-6-luna", 0.02475],
     ["gpt-5.6-sol", 0.99],
     ["gpt-5.6-terra", 0.498],
     ["gpt-5.6-luna", 0.0498],
@@ -133,6 +141,8 @@ describe("calculateCostUsd", () => {
 
   it.each([
     ["gpt-6-astra", 2.725],
+    ["gpt-6-sol", 0.545],
+    ["gpt-6-luna", 0.02725],
     ["gpt-5.6-sol", 1.09],
     ["gpt-5.6-terra", 0.548],
     ["gpt-5.6-luna", 0.0548],
@@ -204,6 +214,18 @@ describe("calculateCostUsd", () => {
     expect(calculateCostUsd("claude-fable-5-1", usage)).toBeCloseTo(5.7625, 10);
   });
 
+  it("Opus 5.5 는 $4/$20 에 cache read 0.05x($0.20), 1h cache write $8 을 적용한다", () => {
+    // uncached 30K*$4 + output 10K*$20 + cache read 50K*$0.20 + 1h write 20K*$8 = 0.12+0.2+0.01+0.16
+    expect(
+      calculateCostUsd("anthropic/claude-opus-5-5", {
+        inputTokens: 100_000,
+        outputTokens: 10_000,
+        cachedInputTokens: 50_000,
+        cacheCreationInputTokens1h: 20_000,
+      }),
+    ).toBeCloseTo(0.49, 10);
+  });
+
   it("Fable 의 5분/1시간 cache write 단가도 구분한다", () => {
     expect(
       calculateCostUsd("claude-fable-5", {

package/bundle/src/utils/providers/common/model-cost.ts

@@ -34,7 +34,7 @@ export interface ModelCosts {
 
 // ── OpenAI ─────────────────────────────────────────────────────────
 //
-// Standard pricing verified 2026-09-07: https://developers.openai.com/api/docs/pricing
+// Standard pricing verified 2026-09-23 (기존 모델 단가 변동 없음): https://developers.openai.com/api/docs/pricing
 // 신모델 출시마다 단가가 바뀌므로(5.2→5.4→5.5) 모델 추가 시 반드시 공식 페이지 재확인해야함
 
 // GPT-5.4에서 처음 도입된 long-context 할증 (5.2/5.3-codex는 해당 없음, 5.4-mini/nano는 공식 표에서 long-context 단가 없음)
@@ -65,6 +65,26 @@ const OPENAI_COSTS: Record<string, OpenAIModelSpec> = {
     cacheCreationInputTokens: 12.5,
     longContext: LONG_CONTEXT_272K,
   },
+  // GPT-6 Sol, Luna (2026-09-22 출시): Standard API pricing verified 2026-09-23. GPT-5.6 Sol/Luna 의 절반 단가.
+  // Codex 카탈로그(2026-09-23)는 Sol 에 ultra, Luna 에 max 까지 허용하고 기본 effort 는 둘 다 medium 이다.
+  // @see https://developers.openai.com/api/docs/models/gpt-6-sol
+  // @see https://developers.openai.com/api/docs/models/gpt-6-luna
+  "gpt-6-sol": {
+    maxEffort: "ultra",
+    inputTokens: 2,
+    outputTokens: 10,
+    cachedInputTokens: 0.2,
+    cacheCreationInputTokens: 2.5,
+    longContext: LONG_CONTEXT_272K,
+  },
+  "gpt-6-luna": {
+    maxEffort: "max",
+    inputTokens: 0.1,
+    outputTokens: 0.5,
+    cachedInputTokens: 0.01,
+    cacheCreationInputTokens: 0.125,
+    longContext: LONG_CONTEXT_272K,
+  },
   // GPT-5.6 Sol, Terra, Luna. cache write 단가는 외부 logger/manual usage 입력을 위해
   // 유지한다. 현재 OpenAI 응답 usage 에 cache write 토큰 필드가 없으면 비용은 0으로 계산된다.
   // @see https://developers.openai.com/api/docs/models/gpt-5.6-sol
@@ -140,7 +160,7 @@ function anthropicCosts(
   };
 }
 
-// 가격 출처: https://platform.claude.com/docs/en/about-claude/pricing (2026-09-02 확인)
+// 가격 출처: https://platform.claude.com/docs/en/about-claude/pricing (2026-09-23 확인, 기존 모델 단가 변동 없음)
 const ANTHROPIC_COSTS: Record<string, ModelCosts> = {
   // Fable 5.1 (2026-09-01 출시): input/output 은 Fable 5 와 같고 cache read 만 0.025x($0.25) 특례.
   // @see https://platform.claude.com/docs/en/models/fable-5-1/overview
@@ -162,6 +182,9 @@ const ANTHROPIC_COSTS: Record<string, ModelCosts> = {
   "claude-opus-4-7": anthropicCosts(5, 25),
   "claude-opus-4-8": anthropicCosts(5, 25),
   "claude-opus-5": anthropicCosts(5, 25),
+  // Opus 5.5 (2026-09-22 출시): $4/$20. cache read 는 0.05x($0.20) 특례, cache write 는 표준 배율($5/$8).
+  // @see https://platform.claude.com/docs/en/models/opus-5-5/overview
+  "claude-opus-5-5": anthropicCosts(4, 20, { cachedInputTokens: 0.2 }),
   // Sonnet 5 의 introductory $2/$10 이 정식 단가로 확정됐다. 2026-09-01 에 예정됐던 $3/$15 인상은
   // 취소됐으므로 날짜 분기 없이 고정 단가로 계산한다.
   "claude-sonnet-5": anthropicCosts(2, 10),

package/bundle/src/utils/providers/common/provider-dispatcher.ts

@@ -7,6 +7,7 @@
 import {
   type ImageGenerationMetadata,
   type ImageGenerationOptions,
+  type QgridContent,
 } from "../../../application/qgrid/qgrid.types";
 import { type JsonValue, type TokenUsageBreakdown, type UserInput } from "./provider-types";
 
@@ -28,7 +29,8 @@ export interface ReuseThreadCoord {
 // provider-무관 이미지 결과. OpenAI 경로에서만 채워지며, 상위(qgrid.dispatcher)가
 // content 파트로 전파한다. Anthropic 경로는 이 필드를 채우지 않는다.
 export interface GeneratedImage {
-  data: string; // base64 PNG
+  data: string; // base64 image
+  mediaType?: Extract<QgridContent, { type: "image" }>["mediaType"];
   revisedPrompt: string | null;
   generation?: ImageGenerationMetadata;
 }

package/bundle/src/utils/providers/openai/openai-backend-protocol.test.ts

@@ -8,6 +8,29 @@ import {
 } from "./openai-backend-protocol";
 
 describe("OpenAI Codex backend protocol", () => {
+  it("uses returned bytes rather than a mismatched format label", () => {
+    expect(normalizeOpenAIEvent({ type: "response.output_item.done", item: {
+      type: "image_generation_call", result: "UklGRgAAAABXRUJQ", output_format: "png",
+    } })).toMatchObject({ mimeType: "image/webp" });
+  });
+
+  it("detects JPEG when the format label is absent", () => {
+    expect(normalizeOpenAIEvent({ type: "response.output_item.done", item: {
+      type: "image_generation_call", result: "/9j/",
+    } })).toMatchObject({ mimeType: "image/jpeg" });
+  });
+
+  it.each([
+    ["png", "iVBORw0KGgo=", "image/png"],
+    ["jpeg", "/9j/", "image/jpeg"],
+    ["webp", "UklGRgAAAABXRUJQ", "image/webp"],
+  ])("preserves %s output MIME type", (format, result, mimeType) => {
+    expect(normalizeOpenAIEvent({
+      type: "response.output_item.done",
+      item: { type: "image_generation_call", result, output_format: format },
+    })).toMatchObject({ type: "image", mimeType });
+  });
+
   it("preserves raw history and pins Responses controls", () => {
     const history = [{ type: "message", role: "user", content: [{ type: "input_text", text: "hi" }] }];
     const request = buildOpenAIResponsesRequest({

package/bundle/src/utils/providers/openai/openai-backend-protocol.ts

@@ -175,7 +175,7 @@ export type OpenAINormalizedEvent =
       type: "image";
       id?: string;
       base64: string;
-      mimeType: "image/png";
+      mimeType: "image/png" | "image/jpeg" | "image/webp";
       revisedPrompt?: string;
       generation?: ImageGenerationMetadata;
     }
@@ -209,6 +209,23 @@ function usageFrom(value: unknown): OpenAIUsage | undefined {
   };
 }
 
+export function imageMimeType(
+  base64: string,
+  outputFormat?: unknown,
+): "image/png" | "image/jpeg" | "image/webp" {
+  // Inspect only the header, without decoding a potentially large image twice.
+  const header = Buffer.from(base64.slice(0, 24), "base64");
+  if (header.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])))
+    return "image/png";
+  if (header[0] === 255 && header[1] === 216 && header[2] === 255) return "image/jpeg";
+  if (header.toString("ascii", 0, 4) === "RIFF" && header.toString("ascii", 8, 12) === "WEBP")
+    return "image/webp";
+  if (outputFormat === "jpeg") return "image/jpeg";
+  if (outputFormat === "webp") return "image/webp";
+  if (outputFormat === undefined || outputFormat === "png") return "image/png";
+  throw new OpenAIProtocolError(`Unsupported image output format: ${String(outputFormat)}`);
+}
+
 export function normalizeOpenAIEvent(raw: unknown): OpenAINormalizedEvent | undefined {
   if (!raw || typeof raw !== "object") return undefined;
   const event = raw as Record<string, unknown>;
@@ -231,7 +248,7 @@ export function normalizeOpenAIEvent(raw: unknown): OpenAINormalizedEvent | unde
         type: "image",
         ...(typeof item.id === "string" ? { id: item.id } : {}),
         base64: item.result,
-        mimeType: "image/png",
+        mimeType: imageMimeType(item.result, item.output_format),
         ...(typeof item.revised_prompt === "string"
           ? { revisedPrompt: item.revised_prompt }
           : typeof item.revisedPrompt === "string"

package/bundle/src/utils/providers/openai/openai-dispatcher.test.ts

@@ -51,6 +51,25 @@ async function tickTimer(): Promise<void> {
 }
 
 describe("OpenAIDispatcher direct runtime", () => {
+  it.each(["png", "jpeg", "webp"] as const)("forwards %s format and preserves returned MIME", async (outputFormat) => {
+    const args = QueryInput.parse({ prompt: "draw", imageGeneration: true, imageGenerationOptions: { outputFormat } });
+    let body: ReturnType<typeof buildOpenAIResponsesRequest> | undefined;
+    const d = dispatcher((options) => {
+      body = buildOpenAIResponsesRequest(options);
+      return events({ type: "image", base64: "data", mimeType: `image/${outputFormat}` }, { type: "completed", responseId: "r" });
+    });
+    await d.onTokenAdded(1, "one", credentials);
+    const result = await d.generate(request({ imageGeneration: args.imageGeneration, imageGenerationOptions: args.imageGenerationOptions }));
+    expect(body?.tools).toEqual([{ type: "image_generation", output_format: outputFormat }]);
+    expect(result.images).toMatchObject([{ mediaType: `image/${outputFormat}` }]);
+  });
+
+  it("rejects unsupported output formats and non-PNG transparent requests", () => {
+    for (const imageGenerationOptions of [{ outputFormat: "gif" }, { outputFormat: "webp", background: "transparent" }, { outputFormat: "jpeg", background: "transparent" }]) {
+      expect(QueryInput.safeParse({ prompt: "draw", imageGeneration: true, imageGenerationOptions }).success).toBe(false);
+    }
+  });
+
   beforeEach(() => { refreshMock.mockReset(); });
 
   it("refreshes a quota 401 once, shares the recovery, and uses the new credentials", async () => {
@@ -565,6 +584,9 @@ describe("effort 어휘 해석 (Codex 카탈로그 기준)", () => {
 
   it("모델이 지원하는 값은 그대로 보내고, 상한 초과·공개 API 어휘는 reasoning 에서 빼 백엔드 기본값을 쓴다", async () => {
     await expect(mappedEffortFor("gpt-6-astra", "ultra")).resolves.toBe("ultra");
+    await expect(mappedEffortFor("gpt-6-sol", "ultra")).resolves.toBe("ultra");
+    await expect(mappedEffortFor("gpt-6-luna", "max")).resolves.toBe("max");
+    await expect(mappedEffortFor("gpt-6-luna", "ultra")).resolves.toBeUndefined();
     await expect(mappedEffortFor("gpt-5.6-terra", "ultra")).resolves.toBe("ultra");
     await expect(mappedEffortFor("gpt-5.5", "xhigh")).resolves.toBe("xhigh");
     await expect(mappedEffortFor("gpt-5.5", "max")).resolves.toBeUndefined();

package/bundle/src/utils/providers/openai/openai-dispatcher.ts

@@ -112,6 +112,7 @@ function asReasoning(req: GenerateRequest): OpenAIResponsesOptions["reasoning"]
 }
 
 function requestOptions(req: GenerateRequest): OpenAIResponsesOptions {
+  const { outputFormat, ...imageControls } = req.imageGenerationOptions ?? {};
   return {
     model: req.model ?? "",
     ...(req.systemPrompt ? { instructions: req.systemPrompt } : {}),
@@ -124,7 +125,14 @@ function requestOptions(req: GenerateRequest): OpenAIResponsesOptions {
     ...(req.promptCacheKey ? { promptCacheKey: req.promptCacheKey } : {}),
     ...(req.outputSchema ? { outputSchema: { schema: req.outputSchema as JsonValue } } : {}),
     ...(req.imageGeneration
-      ? { imageGeneration: req.imageGenerationOptions ? { ...req.imageGenerationOptions } : true }
+      ? {
+          imageGeneration: req.imageGenerationOptions
+            ? {
+                ...imageControls,
+                ...(outputFormat ? { output_format: outputFormat } : {}),
+              }
+            : true,
+        }
       : {}),
   };
 }
@@ -320,6 +328,7 @@ export class OpenAIDispatcher implements ProviderDispatcher {
           imageAttempted = true;
           images.push({
             data: event.base64,
+            mediaType: event.mimeType,
             revisedPrompt: event.revisedPrompt ?? null,
             ...(event.generation ? { generation: event.generation } : {}),
           });

package/bundle/src/utils/providers/openai/openai-image-generation.test.ts

@@ -31,6 +31,23 @@ async function run(fetchImpl: typeof fetch, overrides = {}) {
 }
 
 describe("standalone transparent images", () => {
+  it("rejects non-PNG formats before a network request", async () => {
+    const fetchMock = vi.fn<typeof fetch>();
+    await expect(run(fetchMock, { imageGeneration: { background: "transparent", output_format: "webp" } })).rejects.toThrow("only supports PNG");
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it("preserves a previous JPEG image MIME when switching to transparent editing", async () => {
+    const fetchMock = vi.fn<typeof fetch>(async () => Response.json(result()));
+    await run(fetchMock, { history: [
+      { type: "image_generation_call", result: "/9j/", output_format: "jpeg" },
+      { role: "user", content: "Remove the background" },
+    ] });
+    const [url, init] = fetchMock.mock.calls[0]!;
+    expect(url).toContain("/images/edits");
+    expect(JSON.parse(String(init?.body)).images).toEqual([{ image_url: "data:image/jpeg;base64,/9j/" }]);
+  });
+
   it("uses the Images endpoint and preserves actual metadata without charging a driver", async () => {
     const fetchMock = vi.fn<typeof fetch>(async () => Response.json(result()));
     const events = await run(fetchMock);

package/bundle/src/utils/providers/openai/openai-image-generation.ts

@@ -4,6 +4,7 @@ import { z } from "zod";
 import { ImageGenerationMetadata } from "../../../application/qgrid/qgrid.types";
 import {
   CHATGPT_CODEX_RESPONSES_URL,
+  imageMimeType,
   OpenAIProtocolError,
   type OpenAINormalizedEvent,
   type OpenAIResponsesOptions,
@@ -26,13 +27,18 @@ export function buildStandaloneImageRequest(options: OpenAIResponsesOptions) {
       "Standalone images require an explicit transparent background request",
     );
   }
+  if (controls.output_format && controls.output_format !== "png") {
+    throw new OpenAIProtocolError("Transparent image generation only supports PNG output");
+  }
   const text: string[] = [];
   const images: Array<{ image_url: string }> = [];
   if (options.instructions) text.push(`System instructions:\n${options.instructions}`);
   for (const item of options.history) {
     if (item.type === "reasoning") continue;
     if (item.type === "image_generation_call" && typeof item.result === "string") {
-      images.push({ image_url: `data:image/png;base64,${item.result}` });
+      images.push({
+        image_url: `data:${imageMimeType(item.result, item.output_format)};base64,${item.result}`,
+      });
       continue;
     }
     if (item.type !== "message" && typeof item.role !== "string") {