@cartanova/qgrid-ai-sdk 2.10.5 → 2.10.6

package/README.ko.md

@@ -2,7 +2,7 @@
 
 [English](./README.md) · **한국어**
 
-AI SDK v6 custom `LanguageModelV3` provider for [qgrid](https://github.com/cartanova-ai/Qgrid).
+AI SDK v6 custom `LanguageModelV3` / `ImageModelV3` provider for [qgrid](https://github.com/cartanova-ai/Qgrid).
 
 **기존 AI SDK 코드 변경 없이, `model` 한 줄만 바꾸면 구독 토큰 풀링(토큰 N개 × concurrent permit) + request log 대시보드를 사용할 수 있습니다.**
 
@@ -211,8 +211,6 @@ const { text } = await generateText({
 | `reasoningSummary` | `"auto"` \| `"concise"` \| `"detailed"` \| `"none"` | OpenAI 전용 | 추론 요약 출력 방식 |
 | `serviceTier` | `string` | OpenAI 전용 | OpenAI/codex service tier |
 | `timeoutMs` | 양의 정수, 최대 `1_800_000` | Anthropic 전용 | 서버의 Claude Code 프로세스 제한시간(ms). SDK의 non-stream HTTP 제한은 이 값보다 60초 길게 설정. 기본값은 240초 |
-| `imageGeneration` | `boolean` | OpenAI 전용, non-stream | codex 내장 `image_generation` tool 활성화 ([아래](#image-generation) 참조) |
-| `imageGenerationOptions` | `{ quality?, size?, background? }` | OpenAI 전용 | 이미지 생성 옵션. `background: "transparent"`는 전용 경로 사용. 실제 크기·품질은 응답 metadata 확인 ([아래](#image-generation)). |
 | `fallbackModels` | `string[]` | deprecated | 호환용으로만 남긴 무시되는 필드. 사용하면 unsupported-option 경고를 반환하므로 호출부에서 제거하세요. Claude Code의 Fable refusal fallback과 무관 |
 
 ```typescript
@@ -270,52 +268,68 @@ const { text } = await generateText({
 
 ### Image Generation
 
-OpenAI/codex 경로 전용, `generateText` 전용입니다. 요청별로 이미지 생성을 활성화하고 결과를 AI SDK `files`로 받습니다. 투명 배경은 Codex 전용 Images 경로를, 그 외에는 내장 `image_generation` 도구를 사용합니다.
+이미지 생성과 참조 이미지 편집에는 표준 `generateImage`와 `qgrid.image()`를 사용합니다.
+구독 토큰으로 Codex Images 엔드포인트를 직접 호출하므로 Astra/Luna 같은 채팅 모델을
+선택하지 않습니다. 서버와 SDK를 이 인터페이스를 지원하는 버전으로 함께 업데이트하세요.
+
+`openai/gpt-image-2`는 Codex 구독 경로의 요청 식별자이며 실제 이미지 모델 버전을 2.0으로
+고정한다는 뜻은 아닙니다. OpenAI는 Codex에 Images 2.5를 제공한다고 발표했지만, 구독
+엔드포인트에서 Flare/Sunburst 선택을 보장할 방법은 확인되지 않았습니다. 응답에 모델이
+없을 때 메타데이터의 모델명도 요청 식별자를 사용하므로 실제 버전의 증거로 해석하지 마세요.
 
 ```typescript
-const result = await generateText({
-  model: qgrid("openai/gpt-5.6-terra"),
-  prompt: "우주를 나는 고래 일러스트",
+import { generateImage } from "ai";
+import { qgrid, type QgridImageProviderOptions } from "@cartanova/qgrid-ai-sdk";
+
+const { image, usage, providerMetadata } = await generateImage({
+  model: qgrid.image("openai/gpt-image-2", { projectName: "deti" }),
+  prompt: "세로형 포스터를 만들어줘",
   providerOptions: {
-    qgrid: {
-      imageGeneration: true,
-      imageGenerationOptions: { quality: "medium", size: "1536x1024" },
-    },
+    qgrid: { background: "opaque" } satisfies QgridImageProviderOptions,
   },
 });
 
-const image = result.files[0]; // mediaType: "image/png", base64
+image.uint8Array; // 실제 반환된 PNG bytes
+usage.inputTokens; // 이미지 모델 입력 토큰 (채팅 모델 usage가 아님)
+providerMetadata.qgrid?.images[0]; // requestLogId, generation: 생성 조건과 세부 usage
 ```
 
-레퍼런스 이미지는 일반 AI SDK multimodal message part로 전달할 수 있습니다:
+프로젝트 전체에는 `QGRID_PROJECT_NAME=deti` 설정을 권장합니다. 모델 설정에는 기존과 같이
+`serverUrl`과 `projectName`을 사용할 수 있습니다. `providerOptions.qgrid`에는 `quality`,
+`background`, `outputFormat: "png"`, `tokenName`, `logger`를 중첩 없이 전달합니다.
+표준 `size`는 provider options가 아닌 `generateImage` 최상위에 전달합니다.
+
+참조 이미지 편집도 표준 입력으로 전달합니다. `images`의 각 항목에는 `Buffer`,
+`Uint8Array`, base64 이미지 데이터 또는 HTTPS URL 문자열을 넣습니다. 참조가 있으면
+`/images/edits`, 없으면 `/images/generations`를 호출합니다. 큰 참조 사진은 압축하거나
+리사이즈해서 전달하세요. 과도하게 큰 인라인 이미지 입력은 전송 전에 거부합니다.
 
 ```typescript
-const result = await generateText({
-  model: qgrid("openai/gpt-5.6-terra"),
-  messages: [
-    {
-      role: "user",
-      content: [
-        { type: "text", text: "이 이미지를 스타일 레퍼런스로 사용해서 포스터를 만들어줘" },
-        { type: "file", mediaType: "image/png", data: referenceImageBase64 },
-      ],
-    },
-  ],
-  providerOptions: { qgrid: { imageGeneration: true } },
+const { image } = await generateImage({
+  model: qgrid.image("openai/gpt-image-2"),
+  prompt: { text: "이 캐릭터를 유지해서 포스터를 만들어줘", images: [referenceImageBytes] },
 });
 ```
 
-- `streamText`에서는 거부됩니다 (non-stream 전용).
-- 이미지 생성 요청은 provider 대화 상태를 보관하지 않고 전체 input을 직접 전송합니다.
-- 레퍼런스 이미지는 JSON data URL로 전송됩니다. 큰 사진은 압축하거나 리사이즈해서 전달하세요. 과도하게 큰 base64 입력은 SDK가 거부하며, 사진에는 WebP/JPEG를 권장합니다.
-- 일반 Responses 이미지 비용은 알 수 없어 `image_cost_usd: null`로 기록합니다. 요청한 크기·품질이나 텍스트 모델 사용량을 이미지 비용으로 간주하지 않습니다. 출력 metadata가 없는 기존 응답만 세 가지 표준 크기의 공개 가격표 추정을 유지하며, 임의 크기와 `auto`는 추정하지 않습니다.
-- `imageGenerationOptions.background`는 `"auto" | "opaque" | "transparent"`를 지원합니다. `"transparent"` 요청만 기존 ChatGPT 구독 토큰으로 Codex 전용 `images/generations` 또는 `images/edits` 경로를 사용합니다. 나머지는 기존 Responses 도구 경로를 유지합니다. 투명 경로는 텍스트 모델 없이 `gpt-image-2`를 직접 실행하며, tools·structured output은 지원하지 않습니다. 레퍼런스는 최대 5장입니다. 불투명·완전 빈 이미지·손상된 PNG는 오류로 처리하고, 별도 배경 제거로 대체하지 않습니다.
-- 두 경로 모두 `result.providerMetadata.qgrid.imageGeneration` 배열로 출력 정보를 제공합니다. `contentIndex`, `route`와 선택적인 `model`, `size`, `quality`, `background`, 이미지 `usage`가 포함됩니다. 경로는 `codex-responses` 또는 `codex-images`이며, 일반 경로에서 보고되지 않은 이미지 모델은 비워 둡니다. `result.content` 파일 파트에도 metadata가 있지만 `result.files[]`에는 없습니다. PNG 크기는 실제 바이트에서 읽고, JPEG/WebP는 백엔드가 보고한 출력 크기를 사용합니다. qgrid는 리사이즈하지 않습니다.
-- `imageGenerationOptions.size`는 `"auto"` 또는 `"1152x2560"` 같은 양의 정수 `가로x세로` 힌트를 받습니다. 정확한 출력 크기를 보장하지 않으므로 생략하거나 `auto`를 사용하고, 원하는 비율은 프롬프트에 적으세요. 2026-10-13 실호출에서 두 구독 경로 모두 크기 옵션을 무시했고, 9:20 요청은 `841x1870`, 4K 세로 요청은 `941x1672`, 4:1 요청은 3:1로 반환됐습니다. 약 157만 픽셀이라는 관측값은 모든 계정의 고정 상한이 아닙니다. 공개 Images API의 16배수·4K 규칙도 구독 경로의 보장 사양이 아닙니다. 확장된 크기 힌트와 일반 이미지 metadata를 사용하려면 서버와 SDK를 함께 업데이트하세요.
-- 투명 경로는 텍스트 모델을 실행하지 않아 일반 토큰 usage·비용이 0입니다. 이미지 usage는 별도로 보존하고, `image_cost_usd`는 보고된 토큰과 공개 API 단가로 추정합니다. 알려진 text/image input은 구분하고 불명확한 input은 보수적으로 계산하며, 캐시 할인은 반영하지 않습니다. 구독 청구액을 뜻하지 않습니다.
-- 이미지 도구 로그는 `requestedOptions`와 `observedGeneration`을 구분합니다. 관측 정보가 없고 가격표에 있는 크기의 기존 응답만 `pricingAssumption`을 유지합니다. 그 기본값 `1536x1024`/`medium`은 실제 출력 설정을 뜻하지 않습니다.
-
-투명 생성은 위 `imageGenerationOptions`에 `background: "transparent"`를 추가하고, 프롬프트에도 피사체 밖의 투명 배경을 명시하세요. 크로마키·배경색 지시는 제거해야 합니다. 이 기능이 포함된 서버와 SDK가 모두 필요하며, 저장 시 PNG 알파를 유지하세요. 정확한 최종 크기는 소비 앱의 명시적인 crop/resize 정책으로 처리합니다.
+- PNG/JPEG/WebP 참조 이미지는 요청당 최대 5개이고, 출력은 PNG입니다. 마스크 편집과 JPEG/WebP 출력은 지원하지 않습니다.
+- `n`은 AI SDK가 한 장씩 여러 호출로 나눕니다. 요청당 한 장 제한을 `maxImagesPerCall`로 우회할 수는 없습니다.
+- `size`와 `quality`는 힌트이며 구독 백엔드가 자동 결정할 수 있습니다. 실제 조건은 메타데이터에서 확인하세요. `aspectRatio`와 `seed`는 적용되지 않으며 AI SDK 경고를 반환합니다. 원하는 비율은 프롬프트로 전달하세요.
+- `usage`는 이미지 응답의 토큰 사용량입니다. 세부 입력 분류는 `providerMetadata.qgrid.images[]`에 보존합니다. 서버는 이 usage로 API 가격 기준 추정 비용을 기록하고, usage가 없으면 이미지당 가격 추정을 사용합니다. 별도 채팅 비용은 없습니다.
+- `logger: false`는 요청 로그만 비활성화합니다. 취소는 표준 `abortSignal`을 사용합니다.
+
+투명 출력은 `background: "transparent"`를 중첩 없이 전달하고 프롬프트에도 투명 배경을
+명시하세요. 크로마키·배경색 지시는 제거하고, 저장 시 PNG 알파를 유지하세요. 불투명·완전
+빈 이미지·손상된 PNG는 오류로 처리합니다. qgrid는 배경 제거 또는 리사이즈를 하지 않으며,
+정확한 최종 크기는 소비 앱의 명시적인 crop/resize 정책으로 처리합니다.
+
+`generateText`와 `streamText`는 이미지 생성 옵션이 없는 대화 모델 인터페이스입니다.
+일반적인 이미지 인식도 지원하지 않아 image part는 경고와 함께 무시됩니다. 이미지 생성·편집이
+목적이면 `generateImage`의 참조 입력을 사용하세요. 대시보드 `qgrid_chat`은 내부 이미지
+도구를 기본으로 등록합니다. 채팅 모델이 생성 여부를 판단하고 완결된 프롬프트를 작성하며,
+편집 시 최근 대화 이미지 중 최대 5개를 선택합니다. 서버는 일반·투명 이미지 모두 구독
+Images를 직접 호출하고 요청 로그에는 채팅과 이미지 usage의 추정 비용을 합산합니다.
+텍스트만 응답할 수도 있습니다. 공개 SDK 도구 팩토리는 제공하지 않으며, 자동 채팅 이미지도
+`generateImage`와 같이 PNG만 지원합니다.
 
 ## Telemetry Logger
 

package/README.md

@@ -2,7 +2,7 @@
 
 **English** · [한국어](./README.ko.md)
 
-AI SDK v6 custom `LanguageModelV3` provider for [qgrid](https://github.com/cartanova-ai/Qgrid).
+AI SDK v6 custom `LanguageModelV3` / `ImageModelV3` provider for [qgrid](https://github.com/cartanova-ai/Qgrid).
 
 **Without changing your existing AI SDK code, swap a single `model` line to get subscription-token pooling (N tokens × concurrent permits) + the request log dashboard.**
 
@@ -220,8 +220,6 @@ const { text } = await generateText({
 | `reasoningSummary` | `"auto"` \| `"concise"` \| `"detailed"` \| `"none"` | OpenAI only | Reasoning summary output mode |
 | `serviceTier` | `string` | OpenAI only | OpenAI/codex service tier |
 | `timeoutMs` | positive integer, max `1_800_000` | Anthropic only | Server-side Claude Code process timeout in milliseconds. The SDK's non-stream HTTP budget is 60 seconds longer. Defaults to 240 seconds |
-| `imageGeneration` | `boolean` | OpenAI only, non-stream | Enables codex's built-in `image_generation` tool (see [below](#image-generation)) |
-| `imageGenerationOptions` | `{ quality?, size?, background?, outputFormat? }` | OpenAI only | Image controls; `outputFormat` selects PNG/JPEG/WebP on Responses. `background: "transparent"` selects standalone Images (PNG only). Read actual size/quality from response metadata ([below](#image-generation)). |
 | `fallbackModels` | `string[]` | deprecated | Ignored compatibility field; emits an unsupported-option warning. Remove it from callers. Unrelated to Claude Code's Fable refusal fallback |
 
 ```typescript
@@ -279,78 +277,69 @@ const { text } = await generateText({
 
 ### Image Generation
 
-OpenAI/codex route only, `generateText` only. Enables image generation for that single request and returns the image through AI SDK `files`. Transparent backgrounds use standalone Codex Images; other requests use the hosted `image_generation` tool.
+Use standard AI SDK `generateImage` with `qgrid.image()` for image generation and reference
+editing. This calls the Codex subscription Images endpoint directly, without an Astra/Luna
+chat driver. Update the server and SDK together to versions supporting this interface.
+
+`openai/gpt-image-2` is the Codex wire request identifier, not a guarantee of Images 2.0
+serving weights. OpenAI announced Images 2.5 in Codex, but Flare/Sunburst selection is not
+established on this subscription endpoint. When the response omits its model, metadata falls
+back to the requested identifier; that fallback is not evidence of the serving version.
 
 ```typescript
-const result = await generateText({
-  model: qgrid("openai/gpt-5.6-terra"),
-  prompt: "An illustration of a whale flying through space",
+import { generateImage } from "ai";
+import { qgrid, type QgridImageProviderOptions } from "@cartanova/qgrid-ai-sdk";
+
+const { image, usage, providerMetadata } = await generateImage({
+  model: qgrid.image("openai/gpt-image-2", { projectName: "deti" }),
+  prompt: "Create a portrait poster",
   providerOptions: {
-    qgrid: {
-      imageGeneration: true,
-      imageGenerationOptions: { quality: "medium", size: "1536x1024", outputFormat: "webp" },
-    },
+    qgrid: { background: "opaque" } satisfies QgridImageProviderOptions,
   },
 });
 
-const image = result.files[0]; // mediaType: "image/webp", base64
+image.uint8Array; // Returned PNG bytes
+usage.inputTokens; // Image-model input tokens, not chat-model usage
+providerMetadata.qgrid?.images[0]; // requestLogId and generation settings/detailed usage
 ```
 
-Since 2.9.6, `imageGenerationOptions.outputFormat` accepts `"png" | "jpeg" | "webp"`; omission keeps PNG. qgrid preserves the returned image format in `mediaType` rather than converting the image. Save files with the matching extension. Transparent background requests only support PNG and reject JPEG/WebP before generation. `result.files[].mediaType` retains the AI SDK standard `string` type; no qgrid-specific wrapper or type assertion is needed.
+Prefer `QGRID_PROJECT_NAME=deti` for the project-wide label. The image factory accepts
+`serverUrl` and `projectName`. `providerOptions.qgrid` takes flat image options: `quality`,
+`background`, `outputFormat: "png"`, `tokenName`, and `logger`. Standard `size` belongs at
+the `generateImage` top level, not inside the provider options.
 
-Reference images can be passed through normal AI SDK multimodal message parts:
+Reference editing uses the standard image prompt. Pass `Buffer`, `Uint8Array`, base64 image
+data, or an HTTPS URL string in `images`. References select `/images/edits`; omitting them selects
+`/images/generations`. Compress or resize large reference photos before sending them; oversized
+inline image inputs are rejected before transport.
 
 ```typescript
-const result = await generateText({
-  model: qgrid("openai/gpt-5.6-terra"),
-  messages: [
-    {
-      role: "user",
-      content: [
-        { type: "text", text: "Use this image as a style reference and create a poster" },
-        { type: "file", mediaType: "image/png", data: referenceImageBase64 },
-      ],
-    },
-  ],
-  providerOptions: { qgrid: { imageGeneration: true } },
-});
-```
-
-- Rejected in `streamText` (non-stream only).
-- Image-generation requests do not retain provider conversation state. Their full input is sent directly.
-- Reference images are sent as JSON data URLs. Compress or resize large photos before passing them in; oversized base64 inputs are rejected by the SDK. WebP/JPEG is recommended for photos.
-- Hosted Responses image cost is unknown (`image_cost_usd: null`): requested size/quality and text-driver usage cannot determine image cost. Standalone image usage is priced separately as described below. Legacy responses without generation metadata retain the three-size public price estimate; custom sizes and `auto` never receive an invented estimate.
-- `imageGenerationOptions.background` accepts `"auto" | "opaque" | "transparent"`. Only `"transparent"` uses Codex's standalone `images/generations` or `images/edits` endpoint with the existing ChatGPT subscription token. Other image requests keep the hosted Responses tool. The transparent route runs `gpt-image-2` directly, without a text driver; it rejects tools and structured output. It accepts up to five reference images and preserves PNG bytes. Fully opaque, entirely empty, or invalid PNG results fail explicitly; there is no background-removal fallback.
-- Both routes expose output metadata in `result.providerMetadata.qgrid.imageGeneration` (an array with `contentIndex`, `route`, and optional `model`, `size`, `quality`, `background`, and image `usage`). Routes are `codex-responses` and `codex-images`. An unreported hosted image model stays absent; the text driver is not the image model. Per-file metadata also appears on `result.content` file parts, not on `result.files[]`. PNG dimensions come from the returned bytes; JPEG/WebP dimensions use the backend's reported output size when available. qgrid does not resize output.
-- `imageGenerationOptions.size` accepts `"auto"` or positive integer `WIDTHxHEIGHT` hints, such as `"1152x2560"`. These are not exact-output guarantees. Omit size or use `auto`, and put the desired aspect ratio in the prompt (for example, "9:20 portrait"). On 2026-10-13, both subscription routes ignored explicit size, returned `841x1870` for a 9:20 prompt, `941x1672` for a 4K portrait request, and 3:1 for a 4:1 prompt. The observed approximately 1.57MP output is not a guaranteed account-wide limit. Public Images API rules (16-pixel multiples and up to 4K) do not establish subscription output behavior. Update server and SDK together to use expanded size hints and hosted metadata.
-- On the transparent route, regular token usage/cost is zero because no text driver ran. Image usage is preserved separately and `image_cost_usd` is an API-price estimate from reported usage, with known text/image input splits and conservative pricing for unknown input. It omits cache discounts and is not subscription billing.
-- Image logs distinguish `requestedOptions` from `observedGeneration`. Only legacy responses without observations and with a known size price retain `pricingAssumption`; its `1536x1024`/`medium` defaults never establish actual output settings.
-
-Transparent generation example (requires a server and SDK containing this feature):
-
-```typescript
-import { generateText } from "ai";
-import { qgrid, type QgridProviderOptions } from "@cartanova/qgrid-ai-sdk";
-
-const result = await generateText({
-  model: qgrid("openai/gpt-6.1-sol", { projectName: "deti" }),
-  prompt: "An isolated character. Everything outside the character must be transparent, with no backdrop or checkerboard.",
-  providerOptions: {
-    qgrid: {
-      imageGeneration: true,
-      imageGenerationOptions: {
-        background: "transparent",
-        quality: "high",
-        size: "1024x1536",
-      },
-    } satisfies QgridProviderOptions,
-  },
+const { image } = await generateImage({
+  model: qgrid.image("openai/gpt-image-2"),
+  prompt: { text: "Keep this character and create a poster", images: [referenceImageBytes] },
 });
-const png = result.files[0];
-const observed = result.providerMetadata?.qgrid?.imageGeneration;
 ```
 
-Remove green-screen or other background instructions when requesting transparency. Preserve the returned PNG alpha when saving; exact final dimensions require an explicit downstream crop/resize policy.
+- Up to five PNG/JPEG/WebP references per request; output is PNG. Masks and JPEG/WebP output are unsupported.
+- AI SDK splits `n` into one-image calls. Do not override `maxImagesPerCall` to bypass that backend limit.
+- `size` and `quality` are hints: the subscription backend can choose different values. Read observed settings from metadata. `aspectRatio` and `seed` are unsupported and return AI SDK warnings; describe the desired ratio in the prompt.
+- `usage` contains the image response's token usage. Detailed input categories are preserved under `providerMetadata.qgrid.images[]`. The server records an API-price estimate from this usage, or falls back to per-image pricing when usage is absent. There is no separate chat-driver cost.
+- `logger: false` disables request logging only. Cancellation uses standard `abortSignal`.
+
+For transparent output, set the flat option `background: "transparent"` and describe transparency
+in the prompt. Remove green-screen or other background instructions and preserve the returned PNG
+alpha when saving. Fully opaque, entirely empty, or invalid PNG results fail explicitly; qgrid does
+not remove backgrounds or resize output. Apply any final crop/resize policy in the consuming app.
+
+`generateText` and `streamText` use the language-model interface, which has no image-generation
+options. General vision is also unsupported there: image parts are ignored with a warning. Use
+`generateImage` references when the intended result is a generated or edited image. Dashboard
+`qgrid_chat` registers an internal image tool by default: its chat model decides whether to
+generate an image, writes a self-contained prompt, and selects up to five recent conversation
+images for editing. The server calls subscription Images directly for ordinary and transparent
+output, then combines separate chat and image usage estimates in the request log. Chat may
+still return text only. No public SDK image-tool factory is required; automatic chat images
+are PNG-only, like `generateImage`.
 
 ## Telemetry Logger
 

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { LanguageModelV3 } from "@ai-sdk/provider";
+import { ImageModelV3, LanguageModelV3 } from "@ai-sdk/provider";
 import { TelemetrySettings } from "ai";
 //#region src/index.types.d.ts
 /**
@@ -21,6 +21,21 @@ type QgridCommonProviderConfig = {
   /** request_logs.project_name. default: process.env.QGRID_PROJECT_NAME */
   projectName?: string;
 };
+/** Codex Images request ID, not a guaranteed serving version; does not select a chat model. */
+type QgridImageModel = "openai/gpt-image-2";
+type QgridImageProviderConfig = QgridCommonProviderConfig;
+/** `providerOptions.qgrid` for `generateImage({ model: qgrid.image(...) })`. */
+type QgridImageProviderOptions = {
+  /** Requested hint only; the subscription backend may choose another quality. */
+  quality?: "low" | "medium" | "high";
+  background?: "auto" | "opaque" | "transparent";
+  /** The standalone subscription Images endpoint currently supports PNG only. */
+  outputFormat?: "png";
+  /** Strict active OpenAI token selection, including the `openai/` prefix. */
+  tokenName?: string;
+  /** Defaults to true. Set false to omit qgrid request logs. */
+  logger?: boolean;
+};
 type QgridOpenAIProviderConfig = QgridCommonProviderConfig & {
   defaultEffort?: QgridOpenAIEffort;
 };
@@ -68,26 +83,6 @@ type QgridOpenAIProviderOptions = QgridCommonProviderOptions & {
   reasoningSummary?: "auto" | "concise" | "detailed" | "none";
   /** Codex service tier. */
   serviceTier?: string;
-  /**
-   * OpenAI Responses image_generation tool 을 켠다. non-stream 전용.
-   * generateText 결과의 files 로 이미지를 받는다. streaming(streamText)에서는 거부된다.
-   */
-  imageGeneration?: boolean;
-  /**
-   * Image generation controls. The Responses backend selects the image model;
-   * Size/quality are hints, not output guarantees. Hosted image cost is unknown;
-   * standalone usage is estimated using public image-token prices.
-   */
-  imageGenerationOptions?: {
-    /** Responses output format. Defaults to PNG; transparent output only supports PNG. */
-    outputFormat?: "png" | "jpeg" | "webp";
-    quality?: "low" | "medium" | "high";
-    /** Requested hint only; Codex may ignore it. Put the desired aspect ratio in the prompt.
-     * Omit or use auto for backend sizing; read actual output size from generation metadata. */
-    size?: "auto" | `${number}x${number}`;
-    /** Transparent uses Codex standalone Images and validates PNG alpha. See README for limits. */
-    background?: "auto" | "opaque" | "transparent";
-  };
 };
 /** `providerOptions.qgrid` — Anthropic(Claude Code) 모델용. */
 type QgridAnthropicProviderOptions = QgridCommonProviderOptions & {
@@ -159,11 +154,17 @@ type QgridLoggerConfig = {
   onLogError?: (error: Error) => void;
 };
 //#endregion
+//#region src/image-model.d.ts
+declare function createQgridImage(modelId: QgridImageModel, config?: QgridImageProviderConfig): ImageModelV3;
+//#endregion
 //#region src/logger.d.ts
 declare function createQgridLogger(config?: QgridLoggerConfig): TelemetrySettings;
 //#endregion
 //#region src/index.d.ts
 declare function qgrid(modelId: QgridOpenAIModel, config?: QgridOpenAIProviderConfig): LanguageModelV3;
 declare function qgrid(modelId: QgridAnthropicModel, config?: QgridAnthropicProviderConfig): LanguageModelV3;
+declare namespace qgrid {
+  var image: typeof createQgridImage;
+}
 //#endregion
-export { type QgridAnthropicEffort, type QgridAnthropicModel, type QgridAnthropicProviderConfig, type QgridAnthropicProviderOptions, type QgridImageGenerationMetadata, type QgridLoggerConfig, type QgridOpenAIEffort, type QgridOpenAIModel, type QgridOpenAIProviderConfig, type QgridOpenAIProviderOptions, type QgridProviderConfig, type QgridProviderOptions, type QgridSupportedModel, createQgridLogger, qgrid as default, qgrid };
+export { type QgridAnthropicEffort, type QgridAnthropicModel, type QgridAnthropicProviderConfig, type QgridAnthropicProviderOptions, type QgridImageGenerationMetadata, type QgridImageModel, type QgridImageProviderConfig, type QgridImageProviderOptions, type QgridLoggerConfig, type QgridOpenAIEffort, type QgridOpenAIModel, type QgridOpenAIProviderConfig, type QgridOpenAIProviderOptions, type QgridProviderConfig, type QgridProviderOptions, type QgridSupportedModel, createQgridLogger, qgrid as default, qgrid };

package/dist/index.js

@@ -434,53 +434,43 @@ async function* parseSSE(body, signal) {
 		}
 	}
 }
-function extractPromptAndHistory(messages, options = {}) {
-	const includeImages = options.includeImages ?? true;
-	const imageUrls = [];
+function extractPromptAndHistory(messages) {
 	let droppedImageCount = 0;
 	let system;
 	const nonSystem = [];
-	for (const msg of messages) if (msg.role === "system") system = extractTextFromContent(msg.content);
+	for (const msg of messages) if (msg.role === "system") system = extractPromptTextParts(msg.content).text;
 	else nonSystem.push(msg);
 	if (nonSystem.length === 0) return {
 		prompt: "",
 		system,
 		history: [],
-		imageUrls,
 		droppedImageCount
 	};
 	if (nonSystem.length === 1 && nonSystem[0].role === "user") {
-		const extracted = extractUserContent(nonSystem[0].content, includeImages);
-		imageUrls.push(...extracted.imageUrls);
+		const extracted = extractPromptTextParts(nonSystem[0].content);
 		droppedImageCount += extracted.droppedImageCount;
 		return {
 			prompt: extracted.text,
 			system,
 			history: [],
-			imageUrls,
-			droppedImageCount,
-			...extracted.input ? { input: extracted.input } : {}
+			droppedImageCount
 		};
 	}
 	const last = nonSystem[nonSystem.length - 1];
 	let prompt = "";
-	let input;
 	if (last.role === "user") {
-		const extracted = extractUserContent(last.content, includeImages);
+		const extracted = extractPromptTextParts(last.content);
 		prompt = extracted.text;
-		imageUrls.push(...extracted.imageUrls);
 		droppedImageCount += extracted.droppedImageCount;
-		input = extracted.input;
 	}
 	const historyEnd = last.role === "user" ? nonSystem.length - 1 : nonSystem.length;
 	const history = [];
 	for (let i = 0; i < historyEnd; i++) {
 		const msg = nonSystem[i];
 		if (msg.role === "user") {
-			const extracted = extractUserContent(msg.content, includeImages);
-			imageUrls.push(...extracted.imageUrls);
+			const extracted = extractPromptTextParts(msg.content);
 			droppedImageCount += extracted.droppedImageCount;
-			const content = responsesContentItemsFromExtracted(extracted.parts);
+			const content = extracted.parts;
 			history.push({
 				type: "message",
 				role: "user",
@@ -489,36 +479,23 @@ function extractPromptAndHistory(messages, options = {}) {
 					text: extracted.text
 				}]
 			});
-		} else if (msg.role === "assistant") for (const part of msg.content) if ("text" in part && typeof part.text === "string") history.push({
-			type: "message",
-			role: "assistant",
-			content: [{
-				type: "output_text",
-				text: part.text
-			}]
-		});
-		else if ("toolName" in part && part.type === "tool-call") history.push({
-			type: "function_call",
-			name: part.toolName,
-			arguments: typeof part.input === "string" ? part.input : JSON.stringify(part.input),
-			call_id: part.toolCallId
-		});
-		else {
-			const url = extractImageUrl(part);
-			if (!url) continue;
-			if (includeImages) {
-				imageUrls.push(url);
-				history.push({
-					type: "message",
-					role: "assistant",
-					content: [{
-						type: "input_image",
-						image_url: url
-					}]
-				});
-			} else droppedImageCount++;
-		}
-		else if (msg.role === "tool") {
+		} else if (msg.role === "assistant") {
+			for (const part of msg.content) if ("text" in part && typeof part.text === "string") history.push({
+				type: "message",
+				role: "assistant",
+				content: [{
+					type: "output_text",
+					text: part.text
+				}]
+			});
+			else if ("toolName" in part && part.type === "tool-call") history.push({
+				type: "function_call",
+				name: part.toolName,
+				arguments: typeof part.input === "string" ? part.input : JSON.stringify(part.input),
+				call_id: part.toolCallId
+			});
+			else if (isImagePart(part)) droppedImageCount++;
+		} else if (msg.role === "tool") {
 			for (const part of msg.content) if ("toolName" in part && part.type === "tool-result") {
 				const output = part.output;
 				const text = "value" in output ? typeof output.value === "string" ? output.value : JSON.stringify(output.value) : JSON.stringify(output);
@@ -534,111 +511,35 @@ function extractPromptAndHistory(messages, options = {}) {
 		prompt,
 		system,
 		history,
-		imageUrls,
-		droppedImageCount,
-		...input ? { input } : {}
-	};
-}
-function extractTextFromContent(content) {
-	if (typeof content === "string") return content;
-	const parts = [];
-	for (const part of content) if ("text" in part && typeof part.text === "string") parts.push(part.text);
-	return parts.join("\n");
-}
-function extractUserContent(content, includeImages) {
-	const extracted = extractMessageParts(content, { includeImages });
-	return {
-		text: extractTextFromContent(content),
-		parts: extracted.parts,
-		input: inputPartsFromExtracted(extracted.parts),
-		imageUrls: extracted.imageUrls,
-		droppedImageCount: extracted.droppedImageCount
+		droppedImageCount
 	};
 }
-function extractMessageParts(content, options) {
+function extractPromptTextParts(content) {
 	if (typeof content === "string") return {
+		text: content,
 		parts: [{
-			kind: "text",
+			type: "input_text",
 			text: content
 		}],
-		imageUrls: [],
 		droppedImageCount: 0
 	};
 	const parts = [];
-	const imageUrls = [];
 	let droppedImageCount = 0;
-	for (const part of content) {
-		if ("text" in part && typeof part.text === "string") {
-			parts.push({
-				kind: "text",
-				text: part.text
-			});
-			continue;
-		}
-		const url = extractImageUrl(part);
-		if (!url) continue;
-		if (options.includeImages) {
-			parts.push({
-				kind: "image",
-				url
-			});
-			imageUrls.push(url);
-		} else droppedImageCount++;
-	}
+	for (const part of content) if ("text" in part && typeof part.text === "string") parts.push({
+		type: "input_text",
+		text: part.text
+	});
+	else if (isImagePart(part)) droppedImageCount++;
 	return {
+		text: parts.map((part) => part.text).join("\n"),
 		parts,
-		imageUrls,
 		droppedImageCount
 	};
 }
-function inputPartsFromExtracted(extractedParts) {
-	const parts = [];
-	for (const part of extractedParts) if (part.kind === "text") {
-		if (part.text.length > 0) parts.push({
-			type: "text",
-			text: part.text,
-			text_elements: []
-		});
-	} else parts.push({
-		type: "image",
-		url: part.url
-	});
-	return parts.some((part) => part.type === "image") ? parts : void 0;
-}
-function responsesContentItemsFromExtracted(parts) {
-	const items = [];
-	for (const part of parts) if (part.kind === "text") items.push({
-		type: "input_text",
-		text: part.text
-	});
-	else items.push({
-		type: "input_image",
-		image_url: part.url
-	});
-	return items;
-}
-function extractImageUrl(part) {
-	if (!part || typeof part !== "object") return void 0;
+function isImagePart(part) {
+	if (!part || typeof part !== "object") return false;
 	const record = part;
-	const type = record.type;
-	if (type !== "file" && type !== "image") return void 0;
-	const mediaType = typeof record.mediaType === "string" ? record.mediaType : "image/png";
-	if (type === "file" && !mediaType.toLowerCase().startsWith("image/")) return void 0;
-	const data = record.data ?? record.image;
-	if (typeof data === "string") {
-		if (isSupportedImageUrl(data)) return data;
-		if (/^[a-z][a-z0-9+.-]*:/i.test(data)) return void 0;
-		return `data:${mediaType};base64,${data}`;
-	}
-	if (data instanceof URL) {
-		const url = data.toString();
-		return isSupportedImageUrl(url) ? url : void 0;
-	}
-	if (data instanceof Uint8Array) return `data:${mediaType};base64,${bytesToBase64(data)}`;
-	if (data instanceof ArrayBuffer) return `data:${mediaType};base64,${bytesToBase64(new Uint8Array(data))}`;
-}
-function isSupportedImageUrl(value) {
-	return /^(https?:|data:|blob:)/i.test(value);
+	return record.type === "image" || record.type === "file" && typeof record.mediaType === "string" && record.mediaType.toLowerCase().startsWith("image/");
 }
 function bytesToBase64(bytes) {
 	if (typeof Buffer !== "undefined") return Buffer.from(bytes).toString("base64");
@@ -647,6 +548,17 @@ function bytesToBase64(bytes) {
 	for (let i = 0; i < bytes.length; i += chunkSize) binary += String.fromCharCode(...bytes.subarray(i, i + chunkSize));
 	return btoa(binary);
 }
+const MAX_IMAGE_INPUT_DATA_URL_CHARS = 9e6;
+const MAX_IMAGE_INPUT_DATA_URL_CHARS_LABEL = "9M";
+function assertImageInputFitsJsonTransport(imageUrls) {
+	let totalDataUrlChars = 0;
+	for (const url of imageUrls) {
+		if (!url.toLowerCase().startsWith("data:")) continue;
+		totalDataUrlChars += url.length;
+		if (url.length > MAX_IMAGE_INPUT_DATA_URL_CHARS) throw new Error(`qgrid: image input is too large for JSON transport (${url.length} chars). Compress or resize it before passing it to generateImage, for example as WebP/JPEG under ${MAX_IMAGE_INPUT_DATA_URL_CHARS_LABEL} total base64 data-url chars.`);
+	}
+	if (totalDataUrlChars > MAX_IMAGE_INPUT_DATA_URL_CHARS) throw new Error(`qgrid: image inputs are too large for JSON transport (${totalDataUrlChars} total chars). Compress or resize them before passing them to generateImage, for example as WebP/JPEG under ${MAX_IMAGE_INPUT_DATA_URL_CHARS_LABEL} total base64 data-url chars.`);
+}
 function safeStringify(value) {
 	try {
 		const json = JSON.stringify(value);
@@ -716,6 +628,126 @@ function serializeHistory(messages) {
 	return safeStringify(history);
 }
 //#endregion
+//#region src/image-model.ts
+function imageInputUrl(file) {
+	if (file.type === "url") {
+		if (!/^https:\/\//i.test(file.url)) throw new Error("qgrid.image: reference image URLs must use HTTPS");
+		return file.url;
+	}
+	if (![
+		"image/png",
+		"image/jpeg",
+		"image/webp"
+	].includes(file.mediaType)) throw new Error("qgrid.image: reference images must be PNG, JPEG, or WebP");
+	const data = typeof file.data === "string" ? file.data : bytesToBase64(file.data);
+	return `data:${file.mediaType};base64,${data}`;
+}
+function createQgridImage(modelId, config) {
+	if (modelId !== "openai/gpt-image-2") throw new Error(`qgrid.image: unsupported image model ${modelId}`);
+	const serverUrl = config?.serverUrl ?? process.env.QGRID_URL ?? "http://localhost:44900";
+	const projectName = config?.projectName ?? process.env.QGRID_PROJECT_NAME;
+	return {
+		specificationVersion: "v3",
+		provider: QGRID_PROVIDER_NAME,
+		modelId,
+		maxImagesPerCall: 1,
+		async doGenerate(options) {
+			if (options.mask !== void 0) throw new Error("qgrid.image: masks are not supported by the subscription Images endpoint");
+			if (options.n !== 1) throw new Error("qgrid.image: only one image per call is supported; omit maxImagesPerCall so AI SDK can batch n images");
+			if (!options.prompt?.trim()) throw new Error("qgrid.image: a non-empty text prompt is required");
+			if ((options.files?.length ?? 0) > 5) throw new Error("qgrid.image: at most five reference images are supported");
+			const qgridOptions = options.providerOptions.qgrid ?? {};
+			if (qgridOptions.tokenName !== void 0 && (typeof qgridOptions.tokenName !== "string" || !/^openai\/.+/.test(qgridOptions.tokenName.trim()))) throw new Error("qgrid.image: tokenName must be a non-empty OpenAI token name with the openai/ prefix");
+			if (qgridOptions.logger !== void 0 && typeof qgridOptions.logger !== "boolean") throw new Error("qgrid.image: logger must be a boolean");
+			if (qgridOptions.outputFormat !== void 0 && qgridOptions.outputFormat !== "png") throw new Error("qgrid.image: the subscription Images endpoint supports PNG output only");
+			if (qgridOptions.quality !== void 0 && ![
+				"low",
+				"medium",
+				"high"
+			].includes(qgridOptions.quality)) throw new Error("qgrid.image: quality must be low, medium, or high");
+			if (qgridOptions.background !== void 0 && ![
+				"auto",
+				"opaque",
+				"transparent"
+			].includes(qgridOptions.background)) throw new Error("qgrid.image: background must be auto, opaque, or transparent");
+			if (options.size !== void 0 && !/^[1-9]\d*x[1-9]\d*$/.test(options.size)) throw new Error("qgrid.image: size must be positive integer WIDTHxHEIGHT");
+			const imageUrls = (options.files ?? []).map(imageInputUrl);
+			assertImageInputFitsJsonTransport(imageUrls);
+			const input = [{
+				type: "text",
+				text: options.prompt,
+				text_elements: []
+			}, ...imageUrls.map((url) => ({
+				type: "image",
+				url
+			}))];
+			const warnings = [];
+			for (const feature of ["seed", "aspectRatio"]) if (options[feature] !== void 0) warnings.push({
+				type: "unsupported",
+				feature,
+				details: "The subscription Images endpoint does not support this setting. Describe the desired result in the prompt."
+			});
+			for (const feature of [...options.size !== void 0 ? ["size"] : [], ...qgridOptions.quality !== void 0 ? ["providerOptions.qgrid.quality"] : []]) warnings.push({
+				type: "compatibility",
+				feature,
+				details: "This is a hint only. The subscription backend may choose a different size or quality; inspect the returned generation metadata."
+			});
+			const timestamp = /* @__PURE__ */ new Date();
+			const headers = new Headers();
+			for (const [key, value] of Object.entries(options.headers ?? {})) if (value !== void 0) headers.set(key, value);
+			headers.set("Content-Type", "application/json");
+			const response = await qgridFetch(`${serverUrl}/api/qgrid/query`, {
+				method: "POST",
+				headers,
+				signal: options.abortSignal,
+				body: JSON.stringify({ args: {
+					prompt: options.prompt,
+					model: modelId,
+					imageGeneration: true,
+					imageGenerationOptions: {
+						...options.size !== void 0 ? { size: options.size } : {},
+						...qgridOptions.quality !== void 0 ? { quality: qgridOptions.quality } : {},
+						...qgridOptions.background !== void 0 ? { background: qgridOptions.background } : {},
+						...qgridOptions.outputFormat !== void 0 ? { outputFormat: qgridOptions.outputFormat } : {}
+					},
+					...imageUrls.length ? { input } : {},
+					...projectName ? { projectName } : {},
+					...qgridOptions.tokenName !== void 0 ? { tokenName: qgridOptions.tokenName } : {},
+					...qgridOptions.logger === false ? { logger: false } : {}
+				} })
+			}, {
+				operation: "query",
+				serverUrl
+			});
+			if (!response.ok) throw new Error(`qgrid ${response.status}: ${await response.text().catch(() => "")}`);
+			const data = await response.json();
+			const images = data.content?.filter((item) => item.type === "image") ?? [];
+			const image = images[0];
+			if (images.length !== 1 || !image?.data || image.generation?.route !== "codex-images") throw new Error("qgrid.image: expected one image from the direct subscription Images route; update the qgrid server and SDK together");
+			const usage = image.generation.usage;
+			return {
+				images: [image.data],
+				warnings,
+				response: {
+					timestamp,
+					modelId: image.generation.model ?? data.model,
+					headers: Object.fromEntries(response.headers)
+				},
+				...usage ? { usage: {
+					inputTokens: usage.input_tokens,
+					outputTokens: usage.output_tokens,
+					totalTokens: usage.total_tokens
+				} } : {},
+				providerMetadata: { qgrid: { images: [{
+					...data.requestLogId !== void 0 ? { requestLogId: data.requestLogId } : {},
+					generation: image.generation,
+					...image.revisedPrompt !== null && image.revisedPrompt !== void 0 ? { revisedPrompt: image.revisedPrompt } : {}
+				}] } }
+			};
+		}
+	};
+}
+//#endregion
 //#region src/logger.ts
 const DEFAULT_RUN_KEY = "__qgrid_default_run__";
 const DEFAULT_STALE_RUN_TIMEOUT_MS = 1800 * 1e3;
@@ -1044,20 +1076,9 @@ function createQgridLogger(config = {}) {
 const threadCoordStore = /* @__PURE__ */ new Map();
 const CACHE_AFFINITY_NAMESPACE = "qgrid-cache-affinity-v1";
 const MAX_THREAD_COORDS = 1e3;
-const MAX_IMAGE_INPUT_DATA_URL_CHARS = 9e6;
-const MAX_IMAGE_INPUT_DATA_URL_CHARS_LABEL = "9M";
-function assertImageInputFitsJsonTransport(imageUrls) {
-	let totalDataUrlChars = 0;
-	for (const url of imageUrls) {
-		if (!url.toLowerCase().startsWith("data:")) continue;
-		totalDataUrlChars += url.length;
-		if (url.length > MAX_IMAGE_INPUT_DATA_URL_CHARS) throw new Error(`qgrid: image input is too large for JSON transport (${url.length} chars). Compress or resize it before passing it to imageGeneration, for example as WebP/JPEG under ${MAX_IMAGE_INPUT_DATA_URL_CHARS_LABEL} total base64 data-url chars.`);
-	}
-	if (totalDataUrlChars > MAX_IMAGE_INPUT_DATA_URL_CHARS) throw new Error(`qgrid: image inputs are too large for JSON transport (${totalDataUrlChars} total chars). Compress or resize them before passing them to imageGeneration, for example as WebP/JPEG under ${MAX_IMAGE_INPUT_DATA_URL_CHARS_LABEL} total base64 data-url chars.`);
-}
 function warnDroppedImages(droppedImageCount) {
 	if (droppedImageCount <= 0) return;
-	console.warn(`[qgrid] ${droppedImageCount} image message part(s) were ignored because providerOptions.qgrid.imageGeneration is not enabled.`);
+	console.warn(`[qgrid] ${droppedImageCount} image message part(s) were ignored because qgrid language models do not support image input. For image generation or editing, use generateImage with qgrid.image().`);
 }
 function serializeObjectResponseFormat(responseFormat) {
 	const rawSchema = responseFormat?.type === "json" ? responseFormat.schema : void 0;
@@ -1102,10 +1123,6 @@ async function deriveCacheAffinityKey(modelId, sessionKey) {
 	return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
 }
 function qgridProviderMetadata(data) {
-	const imageGeneration = data.content?.flatMap((item, contentIndex) => item.type === "image" && item.generation ? [{
-		contentIndex,
-		...item.generation
-	}] : []);
 	return { qgrid: {
 		...data.requestLogId !== void 0 ? { requestLogId: data.requestLogId } : {},
 		model: data.model,
@@ -1116,12 +1133,12 @@ function qgridProviderMetadata(data) {
 		costUsd: data.costUsd,
 		costSource: data.costSource,
 		cacheCreation5mInputTokens: data.usage.cache_creation_5m_input_tokens ?? null,
-		cacheCreation1hInputTokens: data.usage.cache_creation_1h_input_tokens ?? null,
-		...imageGeneration?.length ? { imageGeneration } : {}
+		cacheCreation1hInputTokens: data.usage.cache_creation_1h_input_tokens ?? null
 	} };
 }
 function getQgridProviderOptions(options) {
 	const qgridOptions = options.providerOptions?.qgrid ?? {};
+	if ("imageGeneration" in qgridOptions || "imageGenerationOptions" in qgridOptions) throw new Error("qgrid: imageGeneration and imageGenerationOptions were removed from language-model options. Use generateImage with qgrid.image().");
 	if (qgridOptions.tokenName !== void 0 && qgridOptions.tokenName.trim() === "") throw new Error("qgrid: tokenName must not be empty");
 	return qgridOptions;
 }
@@ -1189,9 +1206,8 @@ function qgrid(modelId, config) {
 			const tools = options.tools?.filter((t) => t.type === "function");
 			const hasTools = tools && tools.length > 0;
 			const qgridOptions = getQgridProviderOptions(options);
-			const imageGeneration = qgridOptions.imageGeneration;
-			const { prompt, system, history, input, imageUrls, droppedImageCount } = extractPromptAndHistory(options.prompt, { includeImages: imageGeneration === true });
-			if (!imageGeneration) warnDroppedImages(droppedImageCount);
+			const { prompt, system, history, droppedImageCount } = extractPromptAndHistory(options.prompt);
+			warnDroppedImages(droppedImageCount);
 			const effectiveEffort = qgridOptions.thinking === false ? void 0 : qgridOptions.effort ?? effort;
 			const verbosity = qgridOptions.verbosity;
 			const reasoningSummary = qgridOptions.reasoningSummary;
@@ -1199,10 +1215,8 @@ function qgrid(modelId, config) {
 			const timeoutMs = qgridOptions.timeoutMs;
 			const logger = qgridOptions.logger;
 			const tokenName = qgridOptions.tokenName;
-			const imageGenerationOptions = qgridOptions.imageGenerationOptions;
-			if (imageGeneration) assertImageInputFitsJsonTransport(imageUrls);
 			const sessionKey = qgridOptions.sessionKey;
-			const cacheAffinityKey = imageGeneration ? void 0 : await deriveCacheAffinityKey(modelId, sessionKey);
+			const cacheAffinityKey = await deriveCacheAffinityKey(modelId, sessionKey);
 			const jsonSchema = serializeObjectResponseFormat(options.responseFormat);
 			let runContext;
 			let toolResultsPayload;
@@ -1219,7 +1233,6 @@ function qgrid(modelId, config) {
 				headers: { "Content-Type": "application/json" },
 				body: JSON.stringify({ args: {
 					prompt,
-					...imageGeneration && input ? { input } : {},
 					model: modelId,
 					system,
 					effort: effectiveEffort,
@@ -1236,9 +1249,7 @@ function qgrid(modelId, config) {
 					...logger === false ? { logger: false } : {},
 					...tokenName ? { tokenName } : {},
 					...runContext ? { runContext } : {},
-					...toolResultsPayload ? { toolResults: toolResultsPayload } : {},
-					...imageGeneration ? { imageGeneration } : {},
-					...imageGenerationOptions ? { imageGenerationOptions } : {}
+					...toolResultsPayload ? { toolResults: toolResultsPayload } : {}
 				} }),
 				signal: options.abortSignal,
 				...transport ? { dispatcher: transport.dispatcher } : {}
@@ -1263,12 +1274,6 @@ function qgrid(modelId, config) {
 					type: "text",
 					text: item.text
 				});
-				else if (item.type === "image") content.push({
-					type: "file",
-					mediaType: item.mediaType ?? "image/png",
-					data: item.data,
-					...item.generation ? { providerMetadata: { qgrid: { imageGeneration: item.generation } } } : {}
-				});
 				else if (item.type === "tool-call") content.push({
 					type: "tool-call",
 					toolCallId: item.toolCallId,
@@ -1283,10 +1288,9 @@ function qgrid(modelId, config) {
 				type: "text",
 				text: data.text
 			});
-			if (imageGeneration && finishReason.unified !== "tool-calls" && !content.some((c) => c.type === "file")) throw new Error("qgrid: imageGeneration was requested but the response contained no image — the server may be an older version that does not support image generation.");
 			if (matchedClientRun) clientRuns.delete(matchedClientRun.key);
 			if (finishReason.unified === "tool-calls") rememberClientRun(data.runContext, content.filter((c) => c.type === "tool-call").map((c) => c.toolCallId));
-			if (!imageGeneration && cacheAffinityKey && data.runContext?.threadCoord) setThreadCoord(cacheAffinityKey, data.runContext.threadCoord);
+			if (cacheAffinityKey && data.runContext?.threadCoord) setThreadCoord(cacheAffinityKey, data.runContext.threadCoord);
 			return {
 				content,
 				finishReason,
@@ -1307,8 +1311,7 @@ function qgrid(modelId, config) {
 			const timeoutMs = qgridOptions.timeoutMs;
 			const logger = qgridOptions.logger;
 			const tokenName = qgridOptions.tokenName;
-			if (qgridOptions.imageGeneration) throw new Error("qgrid: imageGeneration is not supported with streamText — use generateText instead.");
-			const { prompt, system, history, droppedImageCount } = extractPromptAndHistory(options.prompt, { includeImages: false });
+			const { prompt, system, history, droppedImageCount } = extractPromptAndHistory(options.prompt);
 			warnDroppedImages(droppedImageCount);
 			const sessionKey = qgridOptions.sessionKey;
 			const cacheAffinityKey = await deriveCacheAffinityKey(modelId, sessionKey);
@@ -1491,5 +1494,6 @@ function qgrid(modelId, config) {
 		}
 	};
 }
+qgrid.image = createQgridImage;
 //#endregion
 export { createQgridLogger, qgrid as default, qgrid };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cartanova/qgrid-ai-sdk",
-  "version": "2.10.5",
-  "description": "AI SDK LanguageModelV3 provider for qgrid",
+  "version": "2.10.6",
+  "description": "AI SDK LanguageModelV3 and ImageModelV3 provider for qgrid",
   "repository": {
     "type": "git",
     "url": "https://github.com/cartanova-ai/qgrid"