@cartanova/qgrid-cli 2.3.7 → 2.3.9

package/README.ko.md

@@ -0,0 +1,131 @@
+# @cartanova/qgrid-cli
+
+[English](./README.md) · **한국어**
+
+Qgrid 서버를 한 줄로 실행. OpenAI/Anthropic 구독 크레딧을 HTTP API + 대시보드로 제공하는 LLM 프록시.
+
+## 설치
+
+```bash
+npm i -g @cartanova/qgrid-cli
+```
+
+설치 시 qgrid skills가 자동 동기화됨:
+
+- global install: `~/.codex/skills/qgrid`, `~/.claude/skills/qgrid`
+- project install: `.agents/skills/qgrid`, `.claude/skills/qgrid`
+
+project install에서는 symlink를 만들고, symlink가 실패하면 copy로 fallback함.
+
+## PostgreSQL 준비
+
+Qgrid는 OAuth 토큰과 request log를 저장하기 위해 PostgreSQL이 필요함.
+이미 접근 가능한 PostgreSQL이 있으면 `--db` 또는 `QGRID_DB_*` 환경변수로 연결하면 됨.
+로컬에 PostgreSQL이 없으면 Docker로 띄울 수 있음:
+
+```bash
+docker run --name qgrid-postgres \
+  -e POSTGRES_USER=postgres \
+  -e POSTGRES_PASSWORD=postgres \
+  -e POSTGRES_DB=qgrid \
+  -p 5432:5432 \
+  -d postgres:18
+```
+
+## 사용법
+
+```bash
+# DB URL로 실행
+qgrid --db postgres://user:password@host:port/dbname
+
+# 포트 지정
+qgrid --db postgres://... -p 3000
+
+# 환경변수로 DB 설정 (플래그 생략 가능)
+export QGRID_DB_HOST=dev.example.com
+export QGRID_DB_PORT=5432
+export QGRID_DB_USER=postgres
+export QGRID_DB_PASSWORD=postgres
+export QGRID_DB_NAME=qgrid
+qgrid
+```
+
+서버가 뜨면 `http://localhost:44900`에서 대시보드 접속 → OAuth 로그인으로 토큰 등록.
+`-p, --port`를 지정하면 해당 포트로 접속.
+
+서버 포트는 기본값 `44900` 또는 `--port`로만 결정됨. `PORT` 환경변수는 CLI 서버 포트 입력으로 사용하지 않음.
+선택한 포트가 이미 사용 중이면 기존 프로세스를 종료하거나 다른 포트로 폴백하지 않고 에러와 함께 종료.
+
+Ctrl+C로 종료.
+
+## 옵션
+
+```
+qgrid [options]
+
+  --db <url>         PostgreSQL 연결 URL
+  -p, --port <port>  서버 포트 (기본: 44900)
+  --skip-update      자동 업데이트 확인 생략
+  -V, --version      버전 출력
+  -h, --help         도움말
+```
+
+CLI는 실행 시 npm의 최신 버전을 확인하고 major/minor 버전이 올라간 경우에만 자동 업데이트함.
+patch 버전 차이는 자동 업데이트 대상으로 보지 않음.
+
+## 환경변수
+
+`--db` 플래그가 없으면 아래 환경변수에서 DB 접속 정보를 읽음:
+
+| 변수 | 기본값 |
+|------|--------|
+| `QGRID_DB_HOST` | `localhost` |
+| `QGRID_DB_PORT` | `5432` |
+| `QGRID_DB_USER` | `postgres` |
+| `QGRID_DB_PASSWORD` | `postgres` |
+| `QGRID_DB_NAME` | `qgrid` |
+
+서버 동작 관련 환경변수:
+
+| 변수 | 설명 | 기본값 |
+|------|------|--------|
+| `QGRID_WORKERS_PER_TOKEN` | OpenAI 토큰당 codex worker 수 | `3` (최대 5) |
+| `QGRID_PUBLIC_BASE_URL` | Anthropic OAuth callback 공개 베이스 URL. 원격 접속 환경에서 설정 | 미설정 시 `http://localhost:<port>/callback` |
+| `QGRID_OPENAI_THREAD_REUSE` | `false`로 설정 시 OpenAI thread reuse(prompt cache) 비활성화 | 활성 |
+
+## 사전 요구사항
+
+- Node.js >= 20
+- PostgreSQL
+- Docker (로컬 PostgreSQL을 컨테이너로 실행할 경우)
+- [Codex CLI](https://github.com/openai/codex) (OpenAI 모델 사용 시)
+- [Claude Code](https://www.anthropic.com/claude-code) (Anthropic 모델 사용 시)
+
+## 동작 방식
+
+CLI는 Sonamu 기반 서버를 내장 번들로 포함. 실행 시:
+
+1. DB 연결 확인
+2. 서버 시작 (API + 대시보드 웹 UI)
+3. DB의 등록된 토큰 로드. 이후 토큰 등록/변경은 PostgreSQL LISTEN/NOTIFY로 실행 중인 서버에 실시간 반영
+4. **OpenAI 토큰**: 토큰당 persistent codex app-server 프로세스 N개 spawn (기본 3, 최대 5). JSON-RPC로 통신. 요청은 idle worker에 round-robin 라우팅, 전부 busy면 큐 대기 (최대 60초). `sessionKey` 멀티턴 요청은 같은 thread로 재라우팅되어 prompt cache 적중
+5. **Anthropic 토큰**: 요청마다 격리된 claude 프로세스를 fresh spawn (`stream-json` 입출력). 토큰은 least-used 우선으로 선택. OAuth 토큰 자동 refresh
+6. 토큰별 quota threshold(기본 80%)를 넘은 토큰은 라우팅에서 제외 (사용률 조회 실패 시에는 fail-open으로 통과)
+
+Qgrid 앱 자체는 Docker에 의존하지 않지만 PostgreSQL은 필요함. 로컬 PostgreSQL이 없으면 Docker로 PostgreSQL을 띄우는 구성이 가장 간단함.
+
+## SDK 연동
+
+서버를 띄운 뒤 [`@cartanova/qgrid-ai-sdk`](../ai-sdk/README.ko.md)로 호출:
+
+```typescript
+import { generateText } from "ai";
+import { qgrid } from "@cartanova/qgrid-ai-sdk";
+
+const { text } = await generateText({
+  model: qgrid("openai/gpt-5.4-mini"),
+  prompt: "서울 날씨 알려줘",
+});
+```
+
+자세한 사용법은 [`@cartanova/qgrid-ai-sdk` README](../ai-sdk/README.ko.md) 참조.

package/README.md

@@ -1,18 +1,27 @@
 # @cartanova/qgrid-cli
 
-Qgrid 서버를 한 줄로 실행. OpenAI/Anthropic 구독 크레딧을 HTTP API + 대시보드로 제공하는 LLM 프록시.
+**English** · [한국어](./README.ko.md)
 
-## 설치
+Run the Qgrid server in one line. An LLM proxy that exposes OpenAI/Anthropic subscription credits as an HTTP API + dashboard.
+
+## Install
 
 ```bash
 npm i -g @cartanova/qgrid-cli
 ```
 
-## PostgreSQL 준비
+Installing also syncs the qgrid skills automatically:
+
+- global install: `~/.codex/skills/qgrid`, `~/.claude/skills/qgrid`
+- project install: `.agents/skills/qgrid`, `.claude/skills/qgrid`
+
+Project installs create symlinks, falling back to copies when symlinking fails.
 
-Qgrid는 OAuth 토큰과 request log를 저장하기 위해 PostgreSQL이 필요함.
-이미 접근 가능한 PostgreSQL이 있으면 `--db` 또는 `QGRID_DB_*` 환경변수로 연결하면 됨.
-로컬에 PostgreSQL이 없으면 Docker로 띄울 수 있음:
+## Preparing PostgreSQL
+
+Qgrid needs PostgreSQL to store OAuth tokens and request logs.
+If you already have a reachable PostgreSQL, connect with `--db` or the `QGRID_DB_*` environment variables.
+If you don't have one locally, you can spin one up with Docker:
 
 ```bash
 docker run --name qgrid-postgres \
@@ -23,16 +32,16 @@ docker run --name qgrid-postgres \
   -d postgres:18
 ```
 
-## 사용법
+## Usage
 
 ```bash
-# DB URL로 실행
+# Run with a DB URL
 qgrid --db postgres://user:password@host:port/dbname
 
-# 포트 지정
+# Specify a port
 qgrid --db postgres://... -p 3000
 
-# 환경변수로 DB 설정 (플래그 생략 가능)
+# Configure the DB with environment variables (flags can be omitted)
 export QGRID_DB_HOST=dev.example.com
 export QGRID_DB_PORT=5432
 export QGRID_DB_USER=postgres
@@ -41,66 +50,73 @@ export QGRID_DB_NAME=qgrid
 qgrid
 ```
 
-서버가 뜨면 `http://localhost:44900`에서 대시보드 접속 → OAuth 로그인으로 토큰 등록.
-`-p, --port`를 지정하면 해당 포트로 접속.
+Once the server is up, open the dashboard at `http://localhost:44900` → register tokens through OAuth login.
+With `-p, --port` set, connect on that port instead.
 
-서버 포트는 기본값 `44900` 또는 `--port`로만 결정됨. `PORT` 환경변수는 CLI 서버 포트 입력으로 사용하지 않음.
-선택한 포트가 이미 사용 중이면 기존 프로세스를 종료하거나 다른 포트로 폴백하지 않고 에러와 함께 종료.
+The server port is determined only by the default `44900` or `--port`. The `PORT` environment variable is not read as CLI server port input.
+If the selected port is already in use, the CLI exits with an error instead of killing the existing process or falling back to another port.
 
-Ctrl+C로 종료.
+Stop with Ctrl+C.
 
-## 옵션
+## Options
 
 ```
 qgrid [options]
 
-  --db <url>         PostgreSQL 연결 URL
-  -p, --port <port>  서버 포트 (기본: 44900)
-  --skip-update      자동 업데이트 확인 생략
-  -V, --version      버전 출력
-  -h, --help         도움말
+  --db <url>         PostgreSQL connection URL
+  -p, --port <port>  Server port (default: 44900)
+  --skip-update      Skip the automatic update check
+  -V, --version      Print version
+  -h, --help         Help
 ```
 
-CLI는 실행 시 npm의 최신 버전을 확인하고 major/minor 버전이 올라간 경우에만 자동 업데이트함.
-patch 버전 차이는 자동 업데이트 대상으로 보지 않음.
+On startup the CLI checks the latest version on npm and self-updates only when the major/minor version has increased.
+Patch-level differences are not treated as auto-update targets.
 
-## 환경변수
+## Environment variables
 
-`--db` 플래그가 없으면 아래 환경변수에서 DB 접속 정보를 읽음:
+Without the `--db` flag, DB connection info is read from:
 
-| 변수 | 기본값 |
+| Variable | Default |
 |------|--------|
 | `QGRID_DB_HOST` | `localhost` |
 | `QGRID_DB_PORT` | `5432` |
 | `QGRID_DB_USER` | `postgres` |
 | `QGRID_DB_PASSWORD` | `postgres` |
 | `QGRID_DB_NAME` | `qgrid` |
-| `QGRID_WORKERS_PER_TOKEN` | `3` (OpenAI 토큰당 codex worker 수, 최대 5) |
 
-## 사전 요구사항
+Server behavior variables:
+
+| Variable | Description | Default |
+|------|------|--------|
+| `QGRID_WORKERS_PER_TOKEN` | codex workers per OpenAI token | `3` (max 5) |
+| `QGRID_PUBLIC_BASE_URL` | Public base URL for the Anthropic OAuth callback. Set it when the server is accessed remotely | `http://localhost:<port>/callback` when unset |
+| `QGRID_OPENAI_THREAD_REUSE` | Set to `false` to disable OpenAI thread reuse (prompt caching) | enabled |
+
+## Prerequisites
 
 - Node.js >= 20
 - PostgreSQL
-- Docker (로컬 PostgreSQL을 컨테이너로 실행할 경우)
-- [Codex CLI](https://github.com/openai/codex) (OpenAI 모델 사용 시)
-- [Claude Code](https://www.anthropic.com/claude-code) (Anthropic 모델 사용 시)
+- Docker (if running PostgreSQL locally as a container)
+- [Codex CLI](https://github.com/openai/codex) (for OpenAI models)
+- [Claude Code](https://www.anthropic.com/claude-code) (for Anthropic models)
 
-## 동작 방식
+## How it works
 
-CLI는 Sonamu 기반 서버를 내장 번들로 포함. 실행 시:
+The CLI ships the Sonamu-based server as a built-in bundle. On launch:
 
-1. DB 연결 확인
-2. 서버 시작 (API + 대시보드 웹 UI)
-3. DB의 등록된 토큰 로드
-4. **OpenAI 토큰**: 토큰당 codex app-server 프로세스 N개 spawn (기본 3). JSON-RPC로 통신. 병렬 요청 처리 + 큐잉.
-5. **Anthropic 토큰**: claude CLI를 통한 호출. OAuth 토큰 자동 refresh.
-6. 요청 도착 → idle worker에 라우팅 (round-robin) → 전부 busy면 큐 대기 (최대 60초)
+1. Verify the DB connection
+2. Start the server (API + dashboard web UI)
+3. Load registered tokens from the DB. Later token additions/changes propagate to the running server in real time via PostgreSQL LISTEN/NOTIFY
+4. **OpenAI tokens**: spawn N persistent codex app-server processes per token (default 3, max 5), communicating over JSON-RPC. Requests are routed round-robin across idle workers; when all are busy they queue (up to 60 seconds). Multi-turn requests carrying a `sessionKey` are routed back to the same thread for prompt-cache hits
+5. **Anthropic tokens**: spawn a fresh, isolated claude process per request (`stream-json` in/out). Tokens are selected least-used-first. OAuth tokens are refreshed automatically
+6. Tokens over their quota threshold (default 80%) are excluded from routing (usage-lookup failures fail open)
 
-Qgrid 앱 자체는 Docker에 의존하지 않지만 PostgreSQL은 필요함. 로컬 PostgreSQL이 없으면 Docker로 PostgreSQL을 띄우는 구성이 가장 간단함.
+The Qgrid app itself does not depend on Docker, but PostgreSQL is required. If you don't run PostgreSQL locally, running it in Docker is the simplest setup.
 
-## SDK 연동
+## SDK integration
 
-서버를 띄운 뒤 [`@cartanova/qgrid-ai-sdk`](../ai-sdk/README.md)로 호출:
+Once the server is running, call it with [`@cartanova/qgrid-ai-sdk`](../ai-sdk/README.md):
 
 ```typescript
 import { generateText } from "ai";
@@ -108,8 +124,8 @@ import { qgrid } from "@cartanova/qgrid-ai-sdk";
 
 const { text } = await generateText({
   model: qgrid("openai/gpt-5.4-mini"),
-  prompt: "서울 날씨 알려줘",
+  prompt: "What's the weather in Seoul?",
 });
 ```
 
-자세한 사용법은 [`@cartanova/qgrid-ai-sdk` README](../ai-sdk/README.md) 참조.
+See the [`@cartanova/qgrid-ai-sdk` README](../ai-sdk/README.md) for details.

package/bundle/dist/application/qgrid/qgrid-image-generation.js

@@ -0,0 +1,42 @@
+import "../../_virtual/_rolldown/runtime.js";
+//#region src/application/qgrid/qgrid-image-generation.ts
+const CODEX_IMAGE_GENERATION_MODEL = "gpt-image-2";
+const DEFAULT_IMAGE_GENERATION_QUALITY = "medium";
+const DEFAULT_IMAGE_GENERATION_SIZE = "1536x1024";
+const IMAGE_OUTPUT_COST_MICRO_USD = {
+	low: {
+		"1024x1024": 6e3,
+		"1024x1536": 5e3,
+		"1536x1024": 5e3
+	},
+	medium: {
+		"1024x1024": 53e3,
+		"1024x1536": 41e3,
+		"1536x1024": 41e3
+	},
+	high: {
+		"1024x1024": 211e3,
+		"1024x1536": 165e3,
+		"1536x1024": 165e3
+	}
+};
+function resolveImageGenerationOptions(options) {
+	return {
+		quality: options?.quality ?? "medium",
+		size: options?.size ?? "1536x1024"
+	};
+}
+function imageGenerationCostMethod(options) {
+	const resolved = resolveImageGenerationOptions(options);
+	return `assumed:${CODEX_IMAGE_GENERATION_MODEL}:${resolved.quality}:${resolved.size}:png`;
+}
+function estimateImageGenerationCostMicroUsd(result, options) {
+	const imageCount = result.content.filter((item) => item.type === "image").length;
+	if (imageCount === 0) return null;
+	const resolved = resolveImageGenerationOptions(options);
+	return imageCount * IMAGE_OUTPUT_COST_MICRO_USD[resolved.quality][resolved.size];
+}
+//#endregion
+export { CODEX_IMAGE_GENERATION_MODEL, DEFAULT_IMAGE_GENERATION_QUALITY, DEFAULT_IMAGE_GENERATION_SIZE, estimateImageGenerationCostMicroUsd, imageGenerationCostMethod, resolveImageGenerationOptions };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicWdyaWQtaW1hZ2UtZ2VuZXJhdGlvbi5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXBwbGljYXRpb24vcWdyaWQvcWdyaWQtaW1hZ2UtZ2VuZXJhdGlvbi50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xuICB0eXBlIEltYWdlR2VuZXJhdGlvbk9wdGlvbnMsXG4gIHR5cGUgSW1hZ2VHZW5lcmF0aW9uUXVhbGl0eSxcbiAgdHlwZSBJbWFnZUdlbmVyYXRpb25TaXplLFxuICB0eXBlIFF1ZXJ5T3V0cHV0LFxufSBmcm9tIFwiLi9xZ3JpZC50eXBlc1wiO1xuXG5leHBvcnQgY29uc3QgQ09ERVhfSU1BR0VfR0VORVJBVElPTl9NT0RFTCA9IFwiZ3B0LWltYWdlLTJcIjtcbmV4cG9ydCBjb25zdCBERUZBVUxUX0lNQUdFX0dFTkVSQVRJT05fUVVBTElUWTogSW1hZ2VHZW5lcmF0aW9uUXVhbGl0eSA9IFwibWVkaXVtXCI7XG5leHBvcnQgY29uc3QgREVGQVVMVF9JTUFHRV9HRU5FUkFUSU9OX1NJWkU6IEltYWdlR2VuZXJhdGlvblNpemUgPSBcIjE1MzZ4MTAyNFwiO1xuXG5leHBvcnQgdHlwZSBSZXNvbHZlZEltYWdlR2VuZXJhdGlvbk9wdGlvbnMgPSB7XG4gIHF1YWxpdHk6IEltYWdlR2VuZXJhdGlvblF1YWxpdHk7XG4gIHNpemU6IEltYWdlR2VuZXJhdGlvblNpemU7XG59O1xuXG4vLyBPcGVuQUkgZ3B0LWltYWdlLTIgaW1hZ2Ugb3V0cHV0IGNvc3QgZXN0aW1hdGVzIGJ5IHF1YWxpdHkvc2l6ZTpcbi8vIGh0dHBzOi8vZGV2ZWxvcGVycy5vcGVuYWkuY29tL2FwaS9kb2NzL2d1aWRlcy9pbWFnZS1nZW5lcmF0aW9uI2NhbGN1bGF0aW5nLWNvc3RzXG5jb25zdCBJTUFHRV9PVVRQVVRfQ09TVF9NSUNST19VU0Q6IFJlY29yZDxcbiAgSW1hZ2VHZW5lcmF0aW9uUXVhbGl0eSxcbiAgUmVjb3JkPEltYWdlR2VuZXJhdGlvblNpemUsIG51bWJlcj5cbj4gPSB7XG4gIGxvdzoge1xuICAgIFwiMTAyNHgxMDI0XCI6IDZfMDAwLFxuICAgIFwiMTAyNHgxNTM2XCI6IDVfMDAwLFxuICAgIFwiMTUzNngxMDI0XCI6IDVfMDAwLFxuICB9LFxuICBtZWRpdW06IHtcbiAgICBcIjEwMjR4MTAyNFwiOiA1M18wMDAsXG4gICAgXCIxMDI0eDE1MzZcIjogNDFfMDAwLFxuICAgIFwiMTUzNngxMDI0XCI6IDQxXzAwMCxcbiAgfSxcbiAgaGlnaDoge1xuICAgIFwiMTAyNHgxMDI0XCI6IDIxMV8wMDAsXG4gICAgXCIxMDI0eDE1MzZcIjogMTY1XzAwMCxcbiAgICBcIjE1MzZ4MTAyNFwiOiAxNjVfMDAwLFxuICB9LFxufTtcblxuZXhwb3J0IGZ1bmN0aW9uIHJlc29sdmVJbWFnZUdlbmVyYXRpb25PcHRpb25zKFxuICBvcHRpb25zOiBJbWFnZUdlbmVyYXRpb25PcHRpb25zIHwgdW5kZWZpbmVkLFxuKTogUmVzb2x2ZWRJbWFnZUdlbmVyYXRpb25PcHRpb25zIHtcbiAgcmV0dXJuIHtcbiAgICBxdWFsaXR5OiBvcHRpb25zPy5xdWFsaXR5ID8/IERFRkFVTFRfSU1BR0VfR0VORVJBVElPTl9RVUFMSVRZLFxuICAgIHNpemU6IG9wdGlvbnM/LnNpemUgPz8gREVGQVVMVF9JTUFHRV9HRU5FUkFUSU9OX1NJWkUsXG4gIH07XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBpbWFnZUdlbmVyYXRpb25Db3N0TWV0aG9kKG9wdGlvbnM6IEltYWdlR2VuZXJhdGlvbk9wdGlvbnMgfCB1bmRlZmluZWQpOiBzdHJpbmcge1xuICBjb25zdCByZXNvbHZlZCA9IHJlc29sdmVJbWFnZUdlbmVyYXRpb25PcHRpb25zKG9wdGlvbnMpO1xuICByZXR1cm4gYGFzc3VtZWQ6JHtDT0RFWF9JTUFHRV9HRU5FUkFUSU9OX01PREVMfToke3Jlc29sdmVkLnF1YWxpdHl9OiR7cmVzb2x2ZWQuc2l6ZX06cG5nYDtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGVzdGltYXRlSW1hZ2VHZW5lcmF0aW9uQ29zdE1pY3JvVXNkKFxuICByZXN1bHQ6IFF1ZXJ5T3V0cHV0LFxuICBvcHRpb25zOiBJbWFnZUdlbmVyYXRpb25PcHRpb25zIHwgdW5kZWZpbmVkLFxuKTogbnVtYmVyIHwgbnVsbCB7XG4gIGNvbnN0IGltYWdlQ291bnQgPSByZXN1bHQuY29udGVudC5maWx0ZXIoKGl0ZW0pID0+IGl0ZW0udHlwZSA9PT0gXCJpbWFnZVwiKS5sZW5ndGg7XG4gIGlmIChpbWFnZUNvdW50ID09PSAwKSByZXR1cm4gbnVsbDtcbiAgY29uc3QgcmVzb2x2ZWQgPSByZXNvbHZlSW1hZ2VHZW5lcmF0aW9uT3B0aW9ucyhvcHRpb25zKTtcbiAgcmV0dXJuIGltYWdlQ291bnQgKiBJTUFHRV9PVVRQVVRfQ09TVF9NSUNST19VU0RbcmVzb2x2ZWQucXVhbGl0eV1bcmVzb2x2ZWQuc2l6ZV07XG59XG4iXSwibWFwcGluZ3MiOiI7O0FBT0EsTUFBYSwrQkFBK0I7QUFDNUMsTUFBYSxtQ0FBMkQ7QUFDeEUsTUFBYSxnQ0FBcUQ7QUFTbEUsTUFBTSw4QkFHRjtDQUNGLEtBQUs7RUFDSCxhQUFhO0VBQ2IsYUFBYTtFQUNiLGFBQWE7RUFDZDtDQUNELFFBQVE7RUFDTixhQUFhO0VBQ2IsYUFBYTtFQUNiLGFBQWE7RUFDZDtDQUNELE1BQU07RUFDSixhQUFhO0VBQ2IsYUFBYTtFQUNiLGFBQWE7RUFDZDtDQUNGO0FBRUQsU0FBZ0IsOEJBQ2QsU0FDZ0M7QUFDaEMsUUFBTztFQUNMLFNBQVMsU0FBUyxXQUFBO0VBQ2xCLE1BQU0sU0FBUyxRQUFBO0VBQ2hCOztBQUdILFNBQWdCLDBCQUEwQixTQUFxRDtDQUM3RixNQUFNLFdBQVcsOEJBQThCLFFBQVE7QUFDdkQsUUFBTyxXQUFXLDZCQUE2QixHQUFHLFNBQVMsUUFBUSxHQUFHLFNBQVMsS0FBSzs7QUFHdEYsU0FBZ0Isb0NBQ2QsUUFDQSxTQUNlO0NBQ2YsTUFBTSxhQUFhLE9BQU8sUUFBUSxRQUFRLFNBQVMsS0FBSyxTQUFTLFFBQVEsQ0FBQztBQUMxRSxLQUFJLGVBQWUsRUFBRyxRQUFPO0NBQzdCLE1BQU0sV0FBVyw4QkFBOEIsUUFBUTtBQUN2RCxRQUFPLGFBQWEsNEJBQTRCLFNBQVMsU0FBUyxTQUFTIn0=

package/bundle/dist/application/qgrid/qgrid-response-format.js

@@ -0,0 +1,44 @@
+import "../../_virtual/_rolldown/runtime.js";
+import { CODEX_IMAGE_GENERATION_MODEL, resolveImageGenerationOptions } from "./qgrid-image-generation.js";
+//#region src/application/qgrid/qgrid-response-format.ts
+const CODEX_IMAGE_GENERATION_TOOL_CONFIG = {
+	type: "image_generation",
+	outputFormat: "png"
+};
+function escapeHtmlAttribute(value) {
+	return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function formatResponseForLog(result) {
+	return result.content.flatMap((item) => {
+		if (item.type === "text") return [item.text];
+		if (item.type === "image") {
+			const alt = escapeHtmlAttribute(item.revisedPrompt ?? "generated image");
+			return [`<img src="data:image/png;base64,${item.data}" alt="${alt}" />`];
+		}
+		return [];
+	}).filter((part) => part.length > 0).join("\n");
+}
+function getImageParts(result) {
+	return result.content.filter((item) => item.type === "image");
+}
+function formatImagePartForLog(image) {
+	const alt = escapeHtmlAttribute(image.revisedPrompt ?? "generated image");
+	return `<img src="data:image/png;base64,${image.data}" alt="${alt}" />`;
+}
+function imageGenerationToolArgs(args) {
+	const resolved = resolveImageGenerationOptions(args.imageGenerationOptions);
+	return JSON.stringify({
+		prompt: args.prompt,
+		driverModel: args.model ?? null,
+		tool: CODEX_IMAGE_GENERATION_TOOL_CONFIG,
+		pricingAssumption: {
+			model: CODEX_IMAGE_GENERATION_MODEL,
+			quality: resolved.quality,
+			size: resolved.size
+		}
+	});
+}
+//#endregion
+export { CODEX_IMAGE_GENERATION_TOOL_CONFIG, formatImagePartForLog, formatResponseForLog, getImageParts, imageGenerationToolArgs };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/bundle/dist/application/qgrid/qgrid-run-lifecycle.js

@@ -1,4 +1,6 @@
 import "../../_virtual/_rolldown/runtime.js";
+import { estimateImageGenerationCostMicroUsd, imageGenerationCostMethod } from "./qgrid-image-generation.js";
+import { formatImagePartForLog, formatResponseForLog, getImageParts, imageGenerationToolArgs } from "./qgrid-response-format.js";
 import { RequestLogModel } from "../request-log/request-log.model.js";
 import { getLogger } from "@logtape/logtape";
 //#region src/application/qgrid/qgrid-run-lifecycle.ts
@@ -39,7 +41,8 @@ async function beforeQuery(args) {
 		system_prompt: args.system,
 		model_name: args.model,
 		effort: args.effort,
-		project_name: args.projectName
+		project_name: args.projectName,
+		is_image_generation: args.imageGeneration
 	});
 	return {
 		requestLogId,
@@ -58,6 +61,20 @@ async function afterQuery(requestLogId, stepIndex, args, result) {
 		ttft_ms: result.ttftMs,
 		finish_reason: result.finishReason
 	});
+	const imageParts = getImageParts(result);
+	const imageCostMicroUsd = estimateImageGenerationCostMicroUsd(result, args.imageGenerationOptions);
+	for (let i = 0; i < imageParts.length; i++) {
+		const image = imageParts[i];
+		await RequestLogModel.appendStep(requestLogId, {
+			step_index: stepIndex,
+			type: "tool_call",
+			tool_call_index: i,
+			tool_call_id: `image_generation:${stepIndex}:${i}`,
+			tool_name: "image_generation",
+			tool_args: imageGenerationToolArgs(args),
+			tool_result: formatImagePartForLog(image)
+		});
+	}
 	if (result.finishReason === "tool-calls") {
 		const toolCalls = result.content.filter((c) => c.type === "tool-call");
 		for (let i = 0; i < toolCalls.length; i++) {
@@ -66,7 +83,7 @@ async function afterQuery(requestLogId, stepIndex, args, result) {
 			await RequestLogModel.appendStep(requestLogId, {
 				step_index: stepIndex,
 				type: "tool_call",
-				tool_call_index: i,
+				tool_call_index: imageParts.length + i,
 				tool_call_id: tc.toolCallId,
 				tool_name: tc.toolName,
 				tool_args: tc.input
@@ -77,13 +94,15 @@ async function afterQuery(requestLogId, stepIndex, args, result) {
 	const agg = await RequestLogModel.aggregateStepUsage(requestLogId);
 	await RequestLogModel.finishRun(requestLogId, {
 		status: "succeeded",
-		response: result.text,
+		response: formatResponseForLog(result),
 		token_name: result.tokenName,
 		input_tokens: agg.input_tokens,
 		output_tokens: agg.output_tokens,
 		cache_read_tokens: agg.cache_read_tokens,
 		cache_creation_tokens: agg.cache_creation_tokens,
 		duration_ms: agg.duration_ms,
+		image_cost_usd: imageCostMicroUsd,
+		image_cost_method: imageCostMicroUsd !== null ? imageGenerationCostMethod(args.imageGenerationOptions) : null,
 		history: filterHistoryForStorage(args.history)
 	});
 	return {};
@@ -135,4 +154,4 @@ async function cleanupStaleRuns() {
 //#endregion
 export { afterQuery, beforeQuery, finishRunAborted, finishRunWithError };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"qgrid-run-lifecycle.js","names":[],"sources":["../../../src/application/qgrid/qgrid-run-lifecycle.ts"],"sourcesContent":["import { getLogger } from \"@logtape/logtape\";\n\nimport { RequestLogModel } from \"../request-log/request-log.model\";\nimport {\n  type QgridRunContext,\n  type QgridToolResultInput,\n  type QueryInput,\n  type QueryOutput,\n} from \"./qgrid.types\";\n\nconst logger = getLogger([\"qgrid\", \"run-lifecycle\"]);\nconst STALE_RUN_THRESHOLD_MS = 30 * 60 * 1000;\n\n/**\n * history는 원본 그대로 저장하기보다는, run 분석에 필요한 user/assistant 정보만 필터링해서 저장\n */\nfunction filterHistoryForStorage(rawHistory: string | undefined): unknown {\n  if (!rawHistory) return undefined;\n  try {\n    const items = JSON.parse(rawHistory) as unknown[];\n    const filtered = items.filter((item) => {\n      if (!item || typeof item !== \"object\") return false;\n      const record = item as Record<string, unknown>;\n      return record.type === \"message\" && (record.role === \"user\" || record.role === \"assistant\");\n    });\n    return filtered.length > 0 ? filtered : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\nexport type RunLifecycleResult = {\n  runContext?: QgridRunContext;\n};\n\n/**\n * logMode:\"run\" 시 query/stream 응답 전후에 호출.\n *\n * 1) beforeQuery: run 생성/계속 + tool result 완료 + stale cleanup\n * 2) afterQuery: generate step + tool-call step + finish/keep-open\n */\nexport async function beforeQuery(args: QueryInput): Promise<{\n  requestLogId: number;\n  stepIndex: number;\n}> {\n  await cleanupStaleRuns();\n\n  let requestLogId: number;\n  let stepIndex = 0;\n\n  // requestLogId 가 있을 때만 기존 run 연장. threadCoord 만 있는 conv 는 새 run 으로 시작.\n  if (args.runContext?.requestLogId !== undefined) {\n    requestLogId = args.runContext.requestLogId;\n\n    if (args.toolResults && args.toolResults.length > 0) {\n      await completeToolResults(requestLogId, args.toolResults);\n    }\n\n    stepIndex = await RequestLogModel.getNextStepIndex(requestLogId);\n  } else {\n    requestLogId = await RequestLogModel.createRun({\n      user_prompt: args.prompt,\n      system_prompt: args.system,\n      model_name: args.model,\n      effort: args.effort,\n      project_name: args.projectName,\n    });\n  }\n\n  return { requestLogId, stepIndex };\n}\n\nexport async function afterQuery(\n  requestLogId: number,\n  stepIndex: number,\n  args: QueryInput,\n  result: QueryOutput,\n): Promise<RunLifecycleResult> {\n  // generate step 기록\n  await RequestLogModel.appendStep(requestLogId, {\n    step_index: stepIndex,\n    type: \"generate\",\n    input_tokens: result.usage.input_tokens,\n    output_tokens: result.usage.output_tokens,\n    cache_read_tokens: result.usage.cache_read_input_tokens,\n    cache_creation_tokens: result.usage.cache_creation_input_tokens,\n    duration_ms: result.durationMs,\n    ttft_ms: result.ttftMs,\n    finish_reason: result.finishReason,\n  });\n\n  if (result.finishReason === \"tool-calls\") {\n    // tool-call step 즉시 기록 (result는 나중에 completeToolCall로 채움)\n    const toolCalls = result.content.filter((c) => c.type === \"tool-call\");\n    for (let i = 0; i < toolCalls.length; i++) {\n      const tc = toolCalls[i]!;\n      if (tc.type !== \"tool-call\") continue;\n      await RequestLogModel.appendStep(requestLogId, {\n        step_index: stepIndex,\n        type: \"tool_call\",\n        tool_call_index: i,\n        tool_call_id: tc.toolCallId,\n        tool_name: tc.toolName,\n        tool_args: tc.input,\n      });\n    }\n\n    return { runContext: { requestLogId } };\n  }\n\n  // finishReason === \"stop\" → run 종료 (전체 step usage 합산)\n  const agg = await RequestLogModel.aggregateStepUsage(requestLogId);\n  await RequestLogModel.finishRun(requestLogId, {\n    status: \"succeeded\",\n    response: result.text,\n    token_name: result.tokenName,\n    input_tokens: agg.input_tokens,\n    output_tokens: agg.output_tokens,\n    cache_read_tokens: agg.cache_read_tokens,\n    cache_creation_tokens: agg.cache_creation_tokens,\n    duration_ms: agg.duration_ms,\n    history: filterHistoryForStorage(args.history),\n  });\n\n  return {};\n}\n\nexport async function finishRunWithError(\n  requestLogId: number,\n  errorMessage: string,\n  args?: QueryInput,\n): Promise<void> {\n  try {\n    await RequestLogModel.finishRun(requestLogId, {\n      status: \"error\",\n      error_message: errorMessage,\n      history: args ? filterHistoryForStorage(args.history) : undefined,\n    });\n  } catch (e) {\n    logger.error(`finishRunWithError failed: ${(e as Error).message}`);\n  }\n}\n\nexport async function finishRunAborted(requestLogId: number, args?: QueryInput): Promise<void> {\n  try {\n    await RequestLogModel.finishRun(requestLogId, {\n      status: \"aborted\",\n      error_message: \"client disconnected\",\n      history: args ? filterHistoryForStorage(args.history) : undefined,\n    });\n  } catch (e) {\n    logger.error(`finishRunAborted failed: ${(e as Error).message}`);\n  }\n}\n\nasync function completeToolResults(\n  requestLogId: number,\n  toolResults: QgridToolResultInput[],\n): Promise<void> {\n  for (const tr of toolResults) {\n    try {\n      await RequestLogModel.completeToolCall(requestLogId, tr.toolCallId, {\n        tool_result: tr.isError ? undefined : tr.output,\n        error: tr.isError ? tr.output : undefined,\n      });\n    } catch (e) {\n      logger.error(`completeToolCall failed for ${tr.toolCallId}: ${(e as Error).message}`);\n    }\n  }\n}\n\nasync function cleanupStaleRuns(): Promise<void> {\n  try {\n    const staleIds = await RequestLogModel.findStaleRunningIds(STALE_RUN_THRESHOLD_MS);\n    for (const id of staleIds) {\n      await RequestLogModel.finishRun(id, {\n        status: \"error\",\n        error_message: \"tool-call run: no follow-up within 30 minutes\",\n      });\n    }\n    if (staleIds.length > 0) {\n      logger.info(`cleaned up ${staleIds.length} stale running request logs`);\n    }\n  } catch (e) {\n    logger.error(`stale cleanup failed: ${(e as Error).message}`);\n  }\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"qgrid-run-lifecycle.js","names":[],"sources":["../../../src/application/qgrid/qgrid-run-lifecycle.ts"],"sourcesContent":["import { getLogger } from \"@logtape/logtape\";\n\nimport { RequestLogModel } from \"../request-log/request-log.model\";\nimport {\n  type QgridRunContext,\n  type QgridToolResultInput,\n  type QueryInput,\n  type QueryOutput,\n} from \"./qgrid.types\";\nimport {\n  formatImagePartForLog,\n  formatResponseForLog,\n  getImageParts,\n  imageGenerationToolArgs,\n} from \"./qgrid-response-format\";\nimport {\n  estimateImageGenerationCostMicroUsd,\n  imageGenerationCostMethod,\n} from \"./qgrid-image-generation\";\n\nconst logger = getLogger([\"qgrid\", \"run-lifecycle\"]);\nconst STALE_RUN_THRESHOLD_MS = 30 * 60 * 1000;\n\n/**\n * history는 원본 그대로 저장하기보다는, run 분석에 필요한 user/assistant 정보만 필터링해서 저장\n */\nfunction filterHistoryForStorage(rawHistory: string | undefined): unknown {\n  if (!rawHistory) return undefined;\n  try {\n    const items = JSON.parse(rawHistory) as unknown[];\n    const filtered = items.filter((item) => {\n      if (!item || typeof item !== \"object\") return false;\n      const record = item as Record<string, unknown>;\n      return record.type === \"message\" && (record.role === \"user\" || record.role === \"assistant\");\n    });\n    return filtered.length > 0 ? filtered : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\nexport type RunLifecycleResult = {\n  runContext?: QgridRunContext;\n};\n\n/**\n * logMode:\"run\" 시 query/stream 응답 전후에 호출.\n *\n * 1) beforeQuery: run 생성/계속 + tool result 완료 + stale cleanup\n * 2) afterQuery: generate step + tool-call step + finish/keep-open\n */\nexport async function beforeQuery(args: QueryInput): Promise<{\n  requestLogId: number;\n  stepIndex: number;\n}> {\n  await cleanupStaleRuns();\n\n  let requestLogId: number;\n  let stepIndex = 0;\n\n  // requestLogId 가 있을 때만 기존 run 연장. threadCoord 만 있는 conv 는 새 run 으로 시작.\n  if (args.runContext?.requestLogId !== undefined) {\n    requestLogId = args.runContext.requestLogId;\n\n    if (args.toolResults && args.toolResults.length > 0) {\n      await completeToolResults(requestLogId, args.toolResults);\n    }\n\n    stepIndex = await RequestLogModel.getNextStepIndex(requestLogId);\n  } else {\n    requestLogId = await RequestLogModel.createRun({\n      user_prompt: args.prompt,\n      system_prompt: args.system,\n      model_name: args.model,\n      effort: args.effort,\n      project_name: args.projectName,\n      is_image_generation: args.imageGeneration,\n    });\n  }\n\n  return { requestLogId, stepIndex };\n}\n\nexport async function afterQuery(\n  requestLogId: number,\n  stepIndex: number,\n  args: QueryInput,\n  result: QueryOutput,\n): Promise<RunLifecycleResult> {\n  // generate step 기록\n  await RequestLogModel.appendStep(requestLogId, {\n    step_index: stepIndex,\n    type: \"generate\",\n    input_tokens: result.usage.input_tokens,\n    output_tokens: result.usage.output_tokens,\n    cache_read_tokens: result.usage.cache_read_input_tokens,\n    cache_creation_tokens: result.usage.cache_creation_input_tokens,\n    duration_ms: result.durationMs,\n    ttft_ms: result.ttftMs,\n    finish_reason: result.finishReason,\n  });\n\n  const imageParts = getImageParts(result);\n  const imageCostMicroUsd = estimateImageGenerationCostMicroUsd(\n    result,\n    args.imageGenerationOptions,\n  );\n  for (let i = 0; i < imageParts.length; i++) {\n    const image = imageParts[i]!;\n    await RequestLogModel.appendStep(requestLogId, {\n      step_index: stepIndex,\n      type: \"tool_call\",\n      tool_call_index: i,\n      tool_call_id: `image_generation:${stepIndex}:${i}`,\n      tool_name: \"image_generation\",\n      tool_args: imageGenerationToolArgs(args),\n      tool_result: formatImagePartForLog(image),\n    });\n  }\n\n  if (result.finishReason === \"tool-calls\") {\n    // tool-call step 즉시 기록 (result는 나중에 completeToolCall로 채움)\n    const toolCalls = result.content.filter((c) => c.type === \"tool-call\");\n    for (let i = 0; i < toolCalls.length; i++) {\n      const tc = toolCalls[i]!;\n      if (tc.type !== \"tool-call\") continue;\n      await RequestLogModel.appendStep(requestLogId, {\n        step_index: stepIndex,\n        type: \"tool_call\",\n        tool_call_index: imageParts.length + i,\n        tool_call_id: tc.toolCallId,\n        tool_name: tc.toolName,\n        tool_args: tc.input,\n      });\n    }\n\n    return { runContext: { requestLogId } };\n  }\n\n  // finishReason === \"stop\" → run 종료 (전체 step usage 합산)\n  const agg = await RequestLogModel.aggregateStepUsage(requestLogId);\n  await RequestLogModel.finishRun(requestLogId, {\n    status: \"succeeded\",\n    response: formatResponseForLog(result),\n    token_name: result.tokenName,\n    input_tokens: agg.input_tokens,\n    output_tokens: agg.output_tokens,\n    cache_read_tokens: agg.cache_read_tokens,\n    cache_creation_tokens: agg.cache_creation_tokens,\n    duration_ms: agg.duration_ms,\n    image_cost_usd: imageCostMicroUsd,\n    image_cost_method:\n      imageCostMicroUsd !== null ? imageGenerationCostMethod(args.imageGenerationOptions) : null,\n    history: filterHistoryForStorage(args.history),\n  });\n\n  return {};\n}\n\nexport async function finishRunWithError(\n  requestLogId: number,\n  errorMessage: string,\n  args?: QueryInput,\n): Promise<void> {\n  try {\n    await RequestLogModel.finishRun(requestLogId, {\n      status: \"error\",\n      error_message: errorMessage,\n      history: args ? filterHistoryForStorage(args.history) : undefined,\n    });\n  } catch (e) {\n    logger.error(`finishRunWithError failed: ${(e as Error).message}`);\n  }\n}\n\nexport async function finishRunAborted(requestLogId: number, args?: QueryInput): Promise<void> {\n  try {\n    await RequestLogModel.finishRun(requestLogId, {\n      status: \"aborted\",\n      error_message: \"client disconnected\",\n      history: args ? filterHistoryForStorage(args.history) : undefined,\n    });\n  } catch (e) {\n    logger.error(`finishRunAborted failed: ${(e as Error).message}`);\n  }\n}\n\nasync function completeToolResults(\n  requestLogId: number,\n  toolResults: QgridToolResultInput[],\n): Promise<void> {\n  for (const tr of toolResults) {\n    try {\n      await RequestLogModel.completeToolCall(requestLogId, tr.toolCallId, {\n        tool_result: tr.isError ? undefined : tr.output,\n        error: tr.isError ? tr.output : undefined,\n      });\n    } catch (e) {\n      logger.error(`completeToolCall failed for ${tr.toolCallId}: ${(e as Error).message}`);\n    }\n  }\n}\n\nasync function cleanupStaleRuns(): Promise<void> {\n  try {\n    const staleIds = await RequestLogModel.findStaleRunningIds(STALE_RUN_THRESHOLD_MS);\n    for (const id of staleIds) {\n      await RequestLogModel.finishRun(id, {\n        status: \"error\",\n        error_message: \"tool-call run: no follow-up within 30 minutes\",\n      });\n    }\n    if (staleIds.length > 0) {\n      logger.info(`cleaned up ${staleIds.length} stale running request logs`);\n    }\n  } catch (e) {\n    logger.error(`stale cleanup failed: ${(e as Error).message}`);\n  }\n}\n"],"mappings":"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"}