@cartanova/qgrid-cli 1.9.0 → 2.0.1

package/bundle/dist/utils/providers/openai/codex-rpc.js

@@ -0,0 +1,151 @@
+import "../../../_virtual/_rolldown/runtime.js";
+import { getLogger } from "@logtape/logtape";
+import { createInterface } from "node:readline";
+//#region src/utils/providers/openai/codex-rpc.ts
+const logger = getLogger(["qgrid", "codex-rpc"]);
+const DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var CodexRpcError = class extends Error {
+	constructor(rpcCode, message, rpcData) {
+		super(`codex rpc ${rpcCode}: ${message}`);
+		this.rpcCode = rpcCode;
+		this.rpcData = rpcData;
+		this.name = "CodexRpcError";
+	}
+};
+var CodexRpcClient = class {
+	nextId = 1;
+	pending = /* @__PURE__ */ new Map();
+	serverRequestHandlers = /* @__PURE__ */ new Map();
+	notificationHandlers = /* @__PURE__ */ new Map();
+	rl;
+	closed = false;
+	constructor(proc) {
+		this.proc = proc;
+		this.rl = createInterface({ input: proc.stdout });
+		this.rl.on("line", (line) => {
+			if (!line.trim()) return;
+			this.handleLine(line);
+		});
+		proc.on("exit", (code) => {
+			this.closed = true;
+			this.rejectAllPending(/* @__PURE__ */ new Error(`codex process exited with code ${code}`));
+		});
+		proc.stderr?.on("data", (chunk) => {
+			const text = chunk.toString().trim();
+			if (text) logger.debug(`stderr: ${text}`);
+		});
+	}
+	async request(method, params, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+		if (this.closed) throw new Error("codex rpc client is closed");
+		const id = this.nextId++;
+		const msg = JSON.stringify({
+			jsonrpc: "2.0",
+			id,
+			method,
+			params
+		});
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.pending.delete(id);
+				reject(/* @__PURE__ */ new Error(`codex rpc timeout: ${method} (${timeoutMs}ms)`));
+			}, timeoutMs);
+			this.pending.set(id, {
+				resolve,
+				reject: (e) => {
+					clearTimeout(timer);
+					reject(e);
+				},
+				timer
+			});
+			this.proc.stdin.write(msg + "\n");
+		});
+	}
+	onServerRequest(method, handler) {
+		this.serverRequestHandlers.set(method, handler);
+	}
+	onNotification(method, handler) {
+		this.notificationHandlers.set(method, handler);
+	}
+	get isClosed() {
+		return this.closed;
+	}
+	destroy() {
+		this.closed = true;
+		this.rl.close();
+		this.rejectAllPending(/* @__PURE__ */ new Error("codex rpc client destroyed"));
+	}
+	handleLine(line) {
+		let msg;
+		try {
+			msg = JSON.parse(line);
+		} catch {
+			logger.debug(`unparseable line: ${line.slice(0, 200)}`);
+			return;
+		}
+		const id = msg.id;
+		const method = msg.method;
+		if (id !== null && id !== void 0 && this.pending.has(id)) {
+			const p = this.pending.get(id);
+			this.pending.delete(id);
+			clearTimeout(p.timer);
+			if (msg.error) {
+				const err = msg.error;
+				p.reject(new CodexRpcError(err.code, err.message, err.data));
+			} else p.resolve(msg.result);
+			return;
+		}
+		if (method && id !== null && id !== void 0) {
+			this.handleServerRequest(id, method, msg.params);
+			return;
+		}
+		if (method) {
+			this.handleNotification(method, msg.params);
+			return;
+		}
+	}
+	handleServerRequest(id, method, params) {
+		const handler = this.serverRequestHandlers.get(method);
+		if (!handler) {
+			logger.warn(`unhandled server-request: ${method}`);
+			this.respondToServerRequest(id, null, {
+				code: -32601,
+				message: `unhandled: ${method}`
+			});
+			return;
+		}
+		handler(params).then((result) => {
+			this.respondToServerRequest(id, result);
+		}).catch((e) => {
+			logger.warn(`server-request handler error (${method}): ${e.message}`);
+			this.respondToServerRequest(id, null, {
+				code: -32603,
+				message: e.message
+			});
+		});
+	}
+	respondToServerRequest(id, result, error) {
+		if (this.closed) return;
+		const resp = {
+			jsonrpc: "2.0",
+			id
+		};
+		if (error) resp.error = error;
+		else resp.result = result;
+		this.proc.stdin.write(JSON.stringify(resp) + "\n");
+	}
+	handleNotification(method, params) {
+		const handler = this.notificationHandlers.get(method);
+		if (handler) handler(params);
+	}
+	rejectAllPending(error) {
+		for (const [, p] of this.pending) {
+			clearTimeout(p.timer);
+			p.reject(error);
+		}
+		this.pending.clear();
+	}
+};
+//#endregion
+export { CodexRpcClient, CodexRpcError };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"codex-rpc.js","names":[],"sources":["../../../../src/utils/providers/openai/codex-rpc.ts"],"sourcesContent":["/**\n * Codex App-Server stdio JSON-RPC 2.0 클라이언트.\n *\n * - request/response 매칭 (id 기반)\n * - server-request 핸들러 등록 (codex → qgrid 방향)\n * - notification 핸들러\n * - EventEmitter 기반 메시지 분류\n */\nimport { type ChildProcess } from \"node:child_process\";\nimport { createInterface, type Interface } from \"node:readline\";\n\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { type AccountLoginCompletedNotification } from \"../../../codex-protocol/v2/AccountLoginCompletedNotification\";\nimport { type AgentMessageDeltaNotification } from \"../../../codex-protocol/v2/AgentMessageDeltaNotification\";\nimport { type ErrorNotification } from \"../../../codex-protocol/v2/ErrorNotification\";\nimport { type ItemCompletedNotification } from \"../../../codex-protocol/v2/ItemCompletedNotification\";\nimport { type ThreadTokenUsageUpdatedNotification } from \"../../../codex-protocol/v2/ThreadTokenUsageUpdatedNotification\";\nimport { type TurnCompletedNotification } from \"../../../codex-protocol/v2/TurnCompletedNotification\";\n\nconst logger = getLogger([\"qgrid\", \"codex-rpc\"]);\n\nconst DEFAULT_REQUEST_TIMEOUT_MS = 30_000;\n\n// ── Types ───────────────────────────────────────────────────────────\n\nexport type NotificationMap = {\n  \"turn/completed\": TurnCompletedNotification;\n  \"item/completed\": ItemCompletedNotification;\n  \"item/agentMessage/delta\": AgentMessageDeltaNotification;\n  \"thread/tokenUsage/updated\": ThreadTokenUsageUpdatedNotification;\n  error: ErrorNotification;\n  \"account/login/completed\": AccountLoginCompletedNotification;\n};\n\nexport interface RpcError {\n  code: number;\n  message: string;\n  data?: unknown;\n}\n\nexport class CodexRpcError extends Error {\n  constructor(\n    public rpcCode: number,\n    message: string,\n    public rpcData?: unknown,\n  ) {\n    super(`codex rpc ${rpcCode}: ${message}`);\n    this.name = \"CodexRpcError\";\n  }\n}\n\ntype PendingRequest = {\n  resolve: (value: unknown) => void;\n  reject: (error: Error) => void;\n  timer: ReturnType<typeof setTimeout>;\n};\n\ntype ServerRequestHandler = (params: unknown) => Promise<unknown>;\ntype NotificationHandler = (params: unknown) => void;\n\n// ── Client ──────────────────────────────────────────────────────────\n\nexport class CodexRpcClient {\n  private nextId = 1;\n  private pending = new Map<number, PendingRequest>();\n  private serverRequestHandlers = new Map<string, ServerRequestHandler>();\n  private notificationHandlers = new Map<string, NotificationHandler>();\n  private rl: Interface;\n  private closed = false;\n\n  constructor(private proc: ChildProcess) {\n    this.rl = createInterface({ input: proc.stdout! });\n\n    this.rl.on(\"line\", (line) => {\n      if (!line.trim()) return;\n      this.handleLine(line);\n    });\n\n    proc.on(\"exit\", (code) => {\n      this.closed = true;\n      this.rejectAllPending(new Error(`codex process exited with code ${code}`));\n    });\n\n    proc.stderr?.on(\"data\", (chunk: Buffer) => {\n      const text = chunk.toString().trim();\n      if (text) logger.debug(`stderr: ${text}`);\n    });\n  }\n\n  // ── Public API ──────────────────────────────────────────────────\n\n  async request<T = unknown>(\n    method: string,\n    params: unknown,\n    timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS,\n  ): Promise<T> {\n    if (this.closed) throw new Error(\"codex rpc client is closed\");\n\n    const id = this.nextId++;\n    const msg = JSON.stringify({ jsonrpc: \"2.0\", id, method, params });\n\n    return new Promise<T>((resolve, reject) => {\n      const timer = setTimeout(() => {\n        this.pending.delete(id);\n        reject(new Error(`codex rpc timeout: ${method} (${timeoutMs}ms)`));\n      }, timeoutMs);\n\n      this.pending.set(id, {\n        resolve: resolve as (v: unknown) => void,\n        reject: (e: Error) => {\n          clearTimeout(timer);\n          reject(e);\n        },\n        timer,\n      });\n\n      this.proc.stdin!.write(msg + \"\\n\");\n    });\n  }\n\n  onServerRequest(method: string, handler: ServerRequestHandler): void {\n    this.serverRequestHandlers.set(method, handler);\n  }\n\n  onNotification<M extends keyof NotificationMap>(\n    method: M,\n    handler: (params: NotificationMap[M]) => void,\n  ): void;\n  onNotification(method: string, handler: NotificationHandler): void;\n  onNotification(method: string, handler: NotificationHandler): void {\n    this.notificationHandlers.set(method, handler);\n  }\n\n  get isClosed(): boolean {\n    return this.closed;\n  }\n\n  destroy(): void {\n    this.closed = true;\n    this.rl.close();\n    this.rejectAllPending(new Error(\"codex rpc client destroyed\"));\n  }\n\n  // ── Internal ────────────────────────────────────────────────────\n\n  private handleLine(line: string): void {\n    let msg: Record<string, unknown>;\n    try {\n      msg = JSON.parse(line);\n    } catch {\n      logger.debug(`unparseable line: ${line.slice(0, 200)}`);\n      return;\n    }\n\n    const id = msg.id as number | undefined;\n    const method = msg.method as string | undefined;\n\n    // 1. Response to our request\n    if (id !== null && id !== undefined && this.pending.has(id)) {\n      const p = this.pending.get(id)!;\n      this.pending.delete(id);\n      clearTimeout(p.timer);\n\n      if (msg.error) {\n        const err = msg.error as RpcError;\n        p.reject(new CodexRpcError(err.code, err.message, err.data));\n      } else {\n        p.resolve(msg.result);\n      }\n      return;\n    }\n\n    // 2. Server-request (has method + id, but we didn't send it)\n    if (method && id !== null && id !== undefined) {\n      this.handleServerRequest(id, method, msg.params);\n      return;\n    }\n\n    // 3. Notification (has method, no id)\n    if (method) {\n      this.handleNotification(method, msg.params);\n      return;\n    }\n  }\n\n  private handleServerRequest(id: number, method: string, params: unknown): void {\n    const handler = this.serverRequestHandlers.get(method);\n    if (!handler) {\n      logger.warn(`unhandled server-request: ${method}`);\n      this.respondToServerRequest(id, null, {\n        code: -32601,\n        message: `unhandled: ${method}`,\n      });\n      return;\n    }\n\n    handler(params)\n      .then((result) => {\n        this.respondToServerRequest(id, result);\n      })\n      .catch((e) => {\n        logger.warn(`server-request handler error (${method}): ${(e as Error).message}`);\n        this.respondToServerRequest(id, null, {\n          code: -32603,\n          message: (e as Error).message,\n        });\n      });\n  }\n\n  private respondToServerRequest(id: number, result: unknown, error?: RpcError): void {\n    if (this.closed) return;\n    const resp: Record<string, unknown> = { jsonrpc: \"2.0\", id };\n    if (error) {\n      resp.error = error;\n    } else {\n      resp.result = result;\n    }\n    this.proc.stdin!.write(JSON.stringify(resp) + \"\\n\");\n  }\n\n  private handleNotification(method: string, params: unknown): void {\n    const handler = this.notificationHandlers.get(method);\n    if (handler) {\n      handler(params);\n    }\n  }\n\n  private rejectAllPending(error: Error): void {\n    for (const [, p] of this.pending) {\n      clearTimeout(p.timer);\n      p.reject(error);\n    }\n    this.pending.clear();\n  }\n}\n"],"mappings":";;;;AAoBA,MAAM,SAAS,UAAU,CAAC,SAAS,YAAY,CAAC;AAEhD,MAAM,6BAA6B;AAmBnC,IAAa,gBAAb,cAAmC,MAAM;CACvC,YACE,SACA,SACA,SACA;AACA,QAAM,aAAa,QAAQ,IAAI,UAAU;AAJlC,OAAA,UAAA;AAEA,OAAA,UAAA;AAGP,OAAK,OAAO;;;AAehB,IAAa,iBAAb,MAA4B;CAC1B,SAAiB;CACjB,0BAAkB,IAAI,KAA6B;CACnD,wCAAgC,IAAI,KAAmC;CACvE,uCAA+B,IAAI,KAAkC;CACrE;CACA,SAAiB;CAEjB,YAAY,MAA4B;AAApB,OAAA,OAAA;AAClB,OAAK,KAAK,gBAAgB,EAAE,OAAO,KAAK,QAAS,CAAC;AAElD,OAAK,GAAG,GAAG,SAAS,SAAS;AAC3B,OAAI,CAAC,KAAK,MAAM,CAAE;AAClB,QAAK,WAAW,KAAK;IACrB;AAEF,OAAK,GAAG,SAAS,SAAS;AACxB,QAAK,SAAS;AACd,QAAK,iCAAiB,IAAI,MAAM,kCAAkC,OAAO,CAAC;IAC1E;AAEF,OAAK,QAAQ,GAAG,SAAS,UAAkB;GACzC,MAAM,OAAO,MAAM,UAAU,CAAC,MAAM;AACpC,OAAI,KAAM,QAAO,MAAM,WAAW,OAAO;IACzC;;CAKJ,MAAM,QACJ,QACA,QACA,YAAY,4BACA;AACZ,MAAI,KAAK,OAAQ,OAAM,IAAI,MAAM,6BAA6B;EAE9D,MAAM,KAAK,KAAK;EAChB,MAAM,MAAM,KAAK,UAAU;GAAE,SAAS;GAAO;GAAI;GAAQ;GAAQ,CAAC;AAElE,SAAO,IAAI,SAAY,SAAS,WAAW;GACzC,MAAM,QAAQ,iBAAiB;AAC7B,SAAK,QAAQ,OAAO,GAAG;AACvB,2BAAO,IAAI,MAAM,sBAAsB,OAAO,IAAI,UAAU,KAAK,CAAC;MACjE,UAAU;AAEb,QAAK,QAAQ,IAAI,IAAI;IACV;IACT,SAAS,MAAa;AACpB,kBAAa,MAAM;AACnB,YAAO,EAAE;;IAEX;IACD,CAAC;AAEF,QAAK,KAAK,MAAO,MAAM,MAAM,KAAK;IAClC;;CAGJ,gBAAgB,QAAgB,SAAqC;AACnE,OAAK,sBAAsB,IAAI,QAAQ,QAAQ;;CAQjD,eAAe,QAAgB,SAAoC;AACjE,OAAK,qBAAqB,IAAI,QAAQ,QAAQ;;CAGhD,IAAI,WAAoB;AACtB,SAAO,KAAK;;CAGd,UAAgB;AACd,OAAK,SAAS;AACd,OAAK,GAAG,OAAO;AACf,OAAK,iCAAiB,IAAI,MAAM,6BAA6B,CAAC;;CAKhE,WAAmB,MAAoB;EACrC,IAAI;AACJ,MAAI;AACF,SAAM,KAAK,MAAM,KAAK;UAChB;AACN,UAAO,MAAM,qBAAqB,KAAK,MAAM,GAAG,IAAI,GAAG;AACvD;;EAGF,MAAM,KAAK,IAAI;EACf,MAAM,SAAS,IAAI;AAGnB,MAAI,OAAO,QAAQ,OAAO,UAAa,KAAK,QAAQ,IAAI,GAAG,EAAE;GAC3D,MAAM,IAAI,KAAK,QAAQ,IAAI,GAAG;AAC9B,QAAK,QAAQ,OAAO,GAAG;AACvB,gBAAa,EAAE,MAAM;AAErB,OAAI,IAAI,OAAO;IACb,MAAM,MAAM,IAAI;AAChB,MAAE,OAAO,IAAI,cAAc,IAAI,MAAM,IAAI,SAAS,IAAI,KAAK,CAAC;SAE5D,GAAE,QAAQ,IAAI,OAAO;AAEvB;;AAIF,MAAI,UAAU,OAAO,QAAQ,OAAO,QAAW;AAC7C,QAAK,oBAAoB,IAAI,QAAQ,IAAI,OAAO;AAChD;;AAIF,MAAI,QAAQ;AACV,QAAK,mBAAmB,QAAQ,IAAI,OAAO;AAC3C;;;CAIJ,oBAA4B,IAAY,QAAgB,QAAuB;EAC7E,MAAM,UAAU,KAAK,sBAAsB,IAAI,OAAO;AACtD,MAAI,CAAC,SAAS;AACZ,UAAO,KAAK,6BAA6B,SAAS;AAClD,QAAK,uBAAuB,IAAI,MAAM;IACpC,MAAM;IACN,SAAS,cAAc;IACxB,CAAC;AACF;;AAGF,UAAQ,OAAO,CACZ,MAAM,WAAW;AAChB,QAAK,uBAAuB,IAAI,OAAO;IACvC,CACD,OAAO,MAAM;AACZ,UAAO,KAAK,iCAAiC,OAAO,KAAM,EAAY,UAAU;AAChF,QAAK,uBAAuB,IAAI,MAAM;IACpC,MAAM;IACN,SAAU,EAAY;IACvB,CAAC;IACF;;CAGN,uBAA+B,IAAY,QAAiB,OAAwB;AAClF,MAAI,KAAK,OAAQ;EACjB,MAAM,OAAgC;GAAE,SAAS;GAAO;GAAI;AAC5D,MAAI,MACF,MAAK,QAAQ;MAEb,MAAK,SAAS;AAEhB,OAAK,KAAK,MAAO,MAAM,KAAK,UAAU,KAAK,GAAG,KAAK;;CAGrD,mBAA2B,QAAgB,QAAuB;EAChE,MAAM,UAAU,KAAK,qBAAqB,IAAI,OAAO;AACrD,MAAI,QACF,SAAQ,OAAO;;CAInB,iBAAyB,OAAoB;AAC3C,OAAK,MAAM,GAAG,MAAM,KAAK,SAAS;AAChC,gBAAa,EAAE,MAAM;AACrB,KAAE,OAAO,MAAM;;AAEjB,OAAK,QAAQ,OAAO"}

package/bundle/dist/utils/providers/openai/codex-worker.js

@@ -0,0 +1,371 @@
+import "../../../_virtual/_rolldown/runtime.js";
+import { CodexRpcClient } from "./codex-rpc.js";
+import { getLogger } from "@logtape/logtape";
+import { spawn } from "node:child_process";
+import { mkdirSync, readFileSync, rmSync } from "node:fs";
+//#region src/utils/providers/openai/codex-worker.ts
+const logger = getLogger(["qgrid", "codex-worker"]);
+const MAX_RESTART_ATTEMPTS = 3;
+const RESTART_BACKOFF_BASE_MS = 1e3;
+const THREAD_DEFAULTS = {
+	sandbox: "read-only",
+	approvalPolicy: "never",
+	config: { apps: { _default: {
+		enabled: false,
+		destructive_enabled: false,
+		open_world_enabled: false
+	} } }
+};
+const BASE_INSTRUCTIONS = {
+	text: "You are a helpful assistant. Do not use any tools such as shell, file operations, or web search. Respond with text only.",
+	withSchema: "You are a helpful assistant. Respond using the provided output schema."
+};
+var CodexAppServerWorker = class {
+	proc = null;
+	rpc = null;
+	codexHome;
+	restartAttempts = 0;
+	ready = false;
+	destroyed = false;
+	busy = false;
+	active = true;
+	onReady;
+	constructor(config) {
+		this.config = config;
+		const suffix = config.workerIndex !== void 0 ? `-${config.workerIndex}` : "";
+		this.codexHome = `/tmp/qgrid-codex/${config.tokenId}${suffix}`;
+	}
+	async spawnAndInit() {
+		const cwd = `${this.codexHome}/cwd`;
+		mkdirSync(cwd, { recursive: true });
+		this.proc = spawn("codex", [
+			"app-server",
+			"--listen",
+			"stdio://"
+		], {
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			cwd,
+			env: {
+				PATH: process.env.PATH,
+				TMPDIR: process.env.TMPDIR,
+				CODEX_HOME: this.codexHome
+			}
+		});
+		this.proc.on("exit", (code) => {
+			logger.info(`worker ${this.config.tokenName} exited (code=${code})`);
+			this.ready = false;
+			this.rpc = null;
+			this.proc = null;
+			if (!this.destroyed) this.scheduleRestart();
+		});
+		this.rpc = new CodexRpcClient(this.proc);
+		await this.rpc.request("initialize", {
+			clientInfo: {
+				name: "qgrid",
+				version: "1.0.0"
+			},
+			capabilities: { experimentalApi: true }
+		});
+	}
+	waitForLoginCompleted() {
+		return new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => reject(/* @__PURE__ */ new Error("login timeout")), 12e4);
+			this.rpc.onNotification("account/login/completed", (p) => {
+				clearTimeout(timeout);
+				if (p.success) resolve();
+				else reject(/* @__PURE__ */ new Error(`login failed: ${p.error ?? "unknown"}`));
+			});
+		});
+	}
+	async initialize() {
+		await this.spawnAndInit();
+		await this.rpc.request("account/login/start", {
+			type: "chatgptAuthTokens",
+			accessToken: this.config.accessToken,
+			chatgptAccountId: this.config.accountId,
+			...this.config.planType ? { chatgptPlanType: this.config.planType } : {}
+		});
+		await this.waitForLoginCompleted();
+		this.ready = true;
+		this.restartAttempts = 0;
+		logger.info(`worker ${this.config.tokenName} ready`);
+	}
+	async startBrowserLogin() {
+		await this.spawnAndInit();
+		const result = await this.rpc.request("account/login/start", { type: "chatgpt" });
+		logger.info(`worker ${this.config.tokenName} browser login started`);
+		return result.authUrl;
+	}
+	async waitForBrowserLoginComplete() {
+		await this.waitForLoginCompleted();
+		this.ready = true;
+		this.restartAttempts = 0;
+		logger.info(`worker ${this.config.tokenName} browser login completed`);
+	}
+	async readManagedCredentials() {
+		try {
+			const raw = JSON.parse(readFileSync(`${this.codexHome}/auth.json`, "utf-8"));
+			return {
+				accessToken: raw.tokens?.access_token ?? "",
+				refreshToken: raw.tokens?.refresh_token ?? "",
+				idToken: raw.tokens?.id_token,
+				accountId: raw.tokens?.account_id ?? ""
+			};
+		} catch {
+			return null;
+		}
+	}
+	async kill() {
+		this.destroyed = true;
+		this.ready = false;
+		this.rpc?.destroy();
+		if (this.proc) {
+			this.proc.kill("SIGTERM");
+			await new Promise((resolve) => {
+				const timer = setTimeout(() => {
+					this.proc?.kill("SIGKILL");
+					resolve();
+				}, 3e3);
+				this.proc.on("exit", () => {
+					clearTimeout(timer);
+					resolve();
+				});
+			});
+		}
+		try {
+			rmSync(this.codexHome, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+	}
+	get isReady() {
+		return this.ready && !this.destroyed;
+	}
+	get isDestroyed() {
+		return this.destroyed;
+	}
+	get tokenId() {
+		return this.config.tokenId;
+	}
+	get tokenName() {
+		return this.config.tokenName;
+	}
+	async getRateLimits() {
+		if (!this.rpc || !this.ready) throw new Error("worker not ready");
+		return this.rpc.request("account/rateLimits/read", {});
+	}
+	setServerRequestHandler(handler) {
+		this.rpc?.onServerRequest("account/chatgptAuthTokens/refresh", (params) => handler("account/chatgptAuthTokens/refresh", params));
+	}
+	tryAcquireTurn() {
+		if (this.busy) return false;
+		this.busy = true;
+		return true;
+	}
+	releaseTurn() {
+		this.busy = false;
+	}
+	get hasCapacity() {
+		return !this.busy;
+	}
+	async startThread(req) {
+		if (!this.rpc || !this.ready) throw new Error("worker not ready");
+		const threadConfig = {
+			...THREAD_DEFAULTS.config,
+			...req.verbosity ? { model_verbosity: req.verbosity } : {}
+		};
+		const { thread, model: threadModel } = await this.rpc.request("thread/start", {
+			ephemeral: true,
+			cwd: `${this.codexHome}/cwd`,
+			baseInstructions: req.outputSchema ? BASE_INSTRUCTIONS.withSchema : BASE_INSTRUCTIONS.text,
+			developerInstructions: req.developerInstructions ?? "",
+			sandbox: THREAD_DEFAULTS.sandbox,
+			approvalPolicy: THREAD_DEFAULTS.approvalPolicy,
+			config: threadConfig
+		});
+		const threadId = thread.id;
+		const model = req.model ?? threadModel;
+		if (req.history?.length) await this.rpc.request("thread/inject_items", {
+			threadId,
+			items: req.history
+		});
+		const { turn } = await this.rpc.request("turn/start", {
+			threadId,
+			input: req.input,
+			...req.outputSchema ? { outputSchema: req.outputSchema } : {},
+			...req.effort ? { effort: req.effort } : {},
+			...req.model ? { model: req.model } : {},
+			...req.reasoningSummary ? { summary: req.reasoningSummary } : {},
+			...req.serviceTier ? { serviceTier: req.serviceTier } : {}
+		});
+		return {
+			threadId,
+			turnId: turn.id,
+			model
+		};
+	}
+	async executeTurn(req) {
+		const { threadId, model } = await this.startThread(req);
+		return this.consumeTurnNotifications(threadId, model);
+	}
+	async executeTurnStream(req, cb) {
+		const { threadId, turnId, model } = await this.startThread(req);
+		cb.onThreadId?.(threadId);
+		cb.onTurnId?.(turnId);
+		return this.consumeStreamNotifications(threadId, model, cb);
+	}
+	async interruptTurn(threadId, turnId) {
+		if (!this.rpc || !this.ready) return;
+		try {
+			await this.rpc.request("turn/interrupt", {
+				threadId,
+				turnId
+			});
+		} catch {}
+	}
+	consumeTurnNotifications(threadId, model) {
+		return new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				cleanup();
+				reject(/* @__PURE__ */ new Error("turn timeout (600s)"));
+			}, 6e5);
+			let text = "";
+			let usage = {
+				totalTokens: 0,
+				inputTokens: 0,
+				outputTokens: 0,
+				cachedInputTokens: 0,
+				reasoningOutputTokens: 0
+			};
+			let durationMs = 0;
+			const cleanup = () => {
+				clearTimeout(timeout);
+				for (const n of [
+					"item/completed",
+					"item/agentMessage/delta",
+					"turn/completed",
+					"thread/tokenUsage/updated",
+					"error"
+				]) this.rpc?.onNotification(n, () => {});
+			};
+			this.rpc.onNotification("item/completed", (p) => {
+				if (p.threadId !== threadId) return;
+				if (p.item.type === "agentMessage") text = p.item.text;
+			});
+			this.rpc.onNotification("thread/tokenUsage/updated", (p) => {
+				if (p.threadId !== threadId) return;
+				usage = p.tokenUsage.total;
+			});
+			this.rpc.onNotification("turn/completed", (p) => {
+				if (p.threadId !== threadId) return;
+				durationMs = p.turn.durationMs ?? 0;
+				cleanup();
+				if (p.turn.status === "completed") resolve({
+					text,
+					usage,
+					durationMs,
+					model
+				});
+				else reject(/* @__PURE__ */ new Error(`turn failed: ${JSON.stringify(p.turn.error)}`));
+			});
+			this.rpc.onNotification("error", (p) => {
+				if (p.threadId !== threadId) return;
+				if (!p.willRetry) {
+					cleanup();
+					reject(/* @__PURE__ */ new Error(`codex error: ${p.error.message}`));
+				}
+			});
+		});
+	}
+	consumeStreamNotifications(threadId, model, cb) {
+		return new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				cleanup();
+				cb.onError(/* @__PURE__ */ new Error("turn timeout (600s)"));
+				reject(/* @__PURE__ */ new Error("turn timeout (600s)"));
+			}, 6e5);
+			let text = "";
+			let usage = {
+				totalTokens: 0,
+				inputTokens: 0,
+				outputTokens: 0,
+				cachedInputTokens: 0,
+				reasoningOutputTokens: 0
+			};
+			const cleanup = () => {
+				clearTimeout(timeout);
+				for (const n of [
+					"item/completed",
+					"item/agentMessage/delta",
+					"turn/completed",
+					"thread/tokenUsage/updated",
+					"error"
+				]) this.rpc?.onNotification(n, () => {});
+			};
+			this.rpc.onNotification("item/agentMessage/delta", (p) => {
+				if (p.threadId !== threadId) return;
+				text += p.delta;
+				cb.onDelta(p.delta);
+			});
+			this.rpc.onNotification("item/completed", (p) => {
+				if (p.threadId !== threadId) return;
+				if (p.item.type === "agentMessage") text = p.item.text;
+			});
+			this.rpc.onNotification("thread/tokenUsage/updated", (p) => {
+				if (p.threadId !== threadId) return;
+				usage = p.tokenUsage.total;
+			});
+			this.rpc.onNotification("turn/completed", (p) => {
+				if (p.threadId !== threadId) return;
+				cleanup();
+				if (p.turn.status === "completed") {
+					cb.onComplete({
+						text,
+						usage,
+						durationMs: p.turn.durationMs ?? 0,
+						model
+					});
+					resolve();
+				} else {
+					const err = /* @__PURE__ */ new Error(`turn ${p.turn.status}: ${JSON.stringify(p.turn.error)}`);
+					cb.onError(err);
+					reject(err);
+				}
+			});
+			this.rpc.onNotification("error", (p) => {
+				if (p.threadId !== threadId) return;
+				if (!p.willRetry) {
+					cleanup();
+					const err = /* @__PURE__ */ new Error(`codex error: ${p.error.message}`);
+					cb.onError(err);
+					reject(err);
+				}
+			});
+		});
+	}
+	scheduleRestart() {
+		if (this.destroyed || this.restartAttempts >= MAX_RESTART_ATTEMPTS) {
+			if (this.restartAttempts >= MAX_RESTART_ATTEMPTS) logger.warn(`worker ${this.config.tokenName} max restart attempts reached`);
+			return;
+		}
+		this.restartAttempts++;
+		const delay = RESTART_BACKOFF_BASE_MS * 2 ** (this.restartAttempts - 1) + (this.config.workerIndex ?? 0) * 2e3;
+		logger.info(`worker ${this.config.tokenName}[${this.config.workerIndex ?? 0}] restarting in ${delay}ms (attempt ${this.restartAttempts})`);
+		setTimeout(() => {
+			if (this.destroyed) return;
+			this.initialize().then(() => this.onReady?.()).catch((e) => {
+				logger.warn(`worker ${this.config.tokenName} restart failed: ${e.message}`);
+				this.scheduleRestart();
+			});
+		}, delay);
+	}
+};
+//#endregion
+export { CodexAppServerWorker };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"codex-worker.js","names":[],"sources":["../../../../src/utils/providers/openai/codex-worker.ts"],"sourcesContent":["import { spawn, type ChildProcess } from \"node:child_process\";\nimport { mkdirSync, readFileSync, rmSync } from \"node:fs\";\n\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { type ThreadInjectItemsParams } from \"../../../codex-protocol/v2/ThreadInjectItemsParams\";\nimport { type ThreadStartParams } from \"../../../codex-protocol/v2/ThreadStartParams\";\nimport { type ThreadStartResponse } from \"../../../codex-protocol/v2/ThreadStartResponse\";\nimport { type TokenUsageBreakdown } from \"../../../codex-protocol/v2/TokenUsageBreakdown\";\nimport { type TurnStartParams } from \"../../../codex-protocol/v2/TurnStartParams\";\nimport { type TurnStartResponse } from \"../../../codex-protocol/v2/TurnStartResponse\";\nimport { CodexRpcClient } from \"./codex-rpc\";\n\nconst logger = getLogger([\"qgrid\", \"codex-worker\"]);\n\nconst MAX_RESTART_ATTEMPTS = 3;\nconst RESTART_BACKOFF_BASE_MS = 1_000;\n\n// ── Types ───────────────────────────────────────────────────────────\n\nexport interface WorkerConfig {\n  tokenId: number;\n  tokenName: string;\n  accessToken: string;\n  accountId: string;\n  planType?: string;\n  workerIndex?: number;\n}\n\nexport interface TurnRequest {\n  input: TurnStartParams[\"input\"];\n  outputSchema?: TurnStartParams[\"outputSchema\"];\n  effort?: string;\n  model?: string;\n  developerInstructions?: string;\n  history?: ThreadInjectItemsParams[\"items\"];\n  verbosity?: string;\n  reasoningSummary?: string;\n  serviceTier?: string;\n}\n\nexport interface TurnResult {\n  text: string;\n  usage: TokenUsageBreakdown;\n  durationMs: number;\n  model: string;\n}\n\nexport interface StreamCallbacks {\n  onDelta: (text: string) => void;\n  onComplete: (result: TurnResult) => void;\n  onError: (error: Error) => void;\n  onThreadId?: (threadId: string) => void;\n  onTurnId?: (turnId: string) => void;\n}\n\n// thread/start 공통 옵션\nconst THREAD_DEFAULTS = {\n  sandbox: \"read-only\",\n  approvalPolicy: \"never\",\n  config: {\n    apps: { _default: { enabled: false, destructive_enabled: false, open_world_enabled: false } },\n  },\n} satisfies Partial<ThreadStartParams>;\n\nconst BASE_INSTRUCTIONS = {\n  text: \"You are a helpful assistant. Do not use any tools such as shell, file operations, or web search. Respond with text only.\",\n  withSchema: \"You are a helpful assistant. Respond using the provided output schema.\",\n} as const;\n\n// ── Worker ──────────────────────────────────────────────────────────\n\nexport class CodexAppServerWorker {\n  private proc: ChildProcess | null = null;\n  private rpc: CodexRpcClient | null = null;\n  private codexHome: string;\n  private restartAttempts = 0;\n  private ready = false;\n  private destroyed = false;\n  private busy = false;\n  active = true;\n  onReady?: () => void;\n\n  constructor(private config: WorkerConfig) {\n    const suffix = config.workerIndex !== undefined ? `-${config.workerIndex}` : \"\";\n    this.codexHome = `/tmp/qgrid-codex/${config.tokenId}${suffix}`;\n  }\n\n  // ── Lifecycle ───────────────────────────────────────────────────\n\n  private async spawnAndInit(): Promise<void> {\n    const cwd = `${this.codexHome}/cwd`;\n    mkdirSync(cwd, { recursive: true });\n\n    this.proc = spawn(\"codex\", [\"app-server\", \"--listen\", \"stdio://\"], {\n      stdio: [\"pipe\", \"pipe\", \"pipe\"],\n      cwd,\n      env: { PATH: process.env.PATH, TMPDIR: process.env.TMPDIR, CODEX_HOME: this.codexHome },\n    });\n\n    this.proc.on(\"exit\", (code) => {\n      logger.info(`worker ${this.config.tokenName} exited (code=${code})`);\n      this.ready = false;\n      this.rpc = null;\n      this.proc = null;\n      if (!this.destroyed) this.scheduleRestart();\n    });\n\n    this.rpc = new CodexRpcClient(this.proc);\n\n    await this.rpc.request(\"initialize\", {\n      clientInfo: { name: \"qgrid\", version: \"1.0.0\" },\n      capabilities: { experimentalApi: true },\n    });\n  }\n\n  private waitForLoginCompleted(): Promise<void> {\n    return new Promise<void>((resolve, reject) => {\n      const timeout = setTimeout(() => reject(new Error(\"login timeout\")), 120_000);\n      this.rpc!.onNotification(\"account/login/completed\", (p) => {\n        clearTimeout(timeout);\n        if (p.success) resolve();\n        else reject(new Error(`login failed: ${p.error ?? \"unknown\"}`));\n      });\n    });\n  }\n\n  async initialize(): Promise<void> {\n    await this.spawnAndInit();\n\n    await this.rpc!.request(\"account/login/start\", {\n      type: \"chatgptAuthTokens\",\n      accessToken: this.config.accessToken,\n      chatgptAccountId: this.config.accountId,\n      ...(this.config.planType ? { chatgptPlanType: this.config.planType } : {}),\n    });\n\n    await this.waitForLoginCompleted();\n    this.ready = true;\n    this.restartAttempts = 0;\n    logger.info(`worker ${this.config.tokenName} ready`);\n  }\n\n  async startBrowserLogin(): Promise<string> {\n    await this.spawnAndInit();\n    const result = await this.rpc!.request<{ authUrl: string }>(\"account/login/start\", {\n      type: \"chatgpt\",\n    });\n    logger.info(`worker ${this.config.tokenName} browser login started`);\n    return result.authUrl;\n  }\n\n  async waitForBrowserLoginComplete(): Promise<void> {\n    await this.waitForLoginCompleted();\n    this.ready = true;\n    this.restartAttempts = 0;\n    logger.info(`worker ${this.config.tokenName} browser login completed`);\n  }\n\n  async readManagedCredentials(): Promise<{\n    accessToken: string;\n    refreshToken: string;\n    idToken?: string;\n    accountId: string;\n  } | null> {\n    try {\n      const raw = JSON.parse(readFileSync(`${this.codexHome}/auth.json`, \"utf-8\"));\n      return {\n        accessToken: raw.tokens?.access_token ?? \"\",\n        refreshToken: raw.tokens?.refresh_token ?? \"\",\n        idToken: raw.tokens?.id_token,\n        accountId: raw.tokens?.account_id ?? \"\",\n      };\n    } catch {\n      return null;\n    }\n  }\n\n  async kill(): Promise<void> {\n    this.destroyed = true;\n    this.ready = false;\n    this.rpc?.destroy();\n\n    if (this.proc) {\n      this.proc.kill(\"SIGTERM\");\n      await new Promise<void>((resolve) => {\n        const timer = setTimeout(() => {\n          this.proc?.kill(\"SIGKILL\");\n          resolve();\n        }, 3_000);\n        this.proc!.on(\"exit\", () => {\n          clearTimeout(timer);\n          resolve();\n        });\n      });\n    }\n\n    try {\n      rmSync(this.codexHome, { recursive: true, force: true });\n    } catch {}\n  }\n\n  get isReady(): boolean {\n    return this.ready && !this.destroyed;\n  }\n  get isDestroyed(): boolean {\n    return this.destroyed;\n  }\n  get tokenId(): number {\n    return this.config.tokenId;\n  }\n  get tokenName(): string {\n    return this.config.tokenName;\n  }\n\n  // ── Rate limits ─────────────────────────────────────────────────\n\n  async getRateLimits(): Promise<unknown> {\n    if (!this.rpc || !this.ready) throw new Error(\"worker not ready\");\n    return this.rpc.request(\"account/rateLimits/read\", {});\n  }\n\n  // ── Server-request delegation ───────────────────────────────────\n\n  setServerRequestHandler(handler: (method: string, params: unknown) => Promise<unknown>): void {\n    this.rpc?.onServerRequest(\"account/chatgptAuthTokens/refresh\", (params) =>\n      handler(\"account/chatgptAuthTokens/refresh\", params),\n    );\n  }\n\n  // ── Turn execution ──────────────────────────────────────────────\n\n  tryAcquireTurn(): boolean {\n    if (this.busy) return false;\n    this.busy = true;\n    return true;\n  }\n  releaseTurn(): void {\n    this.busy = false;\n  }\n  get hasCapacity(): boolean {\n    return !this.busy;\n  }\n\n  async startThread(\n    req: TurnRequest,\n  ): Promise<{ threadId: string; turnId: string; model: string }> {\n    if (!this.rpc || !this.ready) throw new Error(\"worker not ready\");\n\n    const threadConfig: ThreadStartParams[\"config\"] = {\n      ...THREAD_DEFAULTS.config,\n      ...(req.verbosity ? { model_verbosity: req.verbosity } : {}),\n    };\n    const { thread, model: threadModel } = await this.rpc.request<ThreadStartResponse>(\n      \"thread/start\",\n      {\n        ephemeral: true,\n        cwd: `${this.codexHome}/cwd`,\n        baseInstructions: req.outputSchema ? BASE_INSTRUCTIONS.withSchema : BASE_INSTRUCTIONS.text,\n        developerInstructions: req.developerInstructions ?? \"\",\n        sandbox: THREAD_DEFAULTS.sandbox,\n        approvalPolicy: THREAD_DEFAULTS.approvalPolicy,\n        config: threadConfig,\n      } satisfies Partial<ThreadStartParams>,\n    );\n\n    const threadId = thread.id;\n    const model = req.model ?? threadModel;\n    if (req.history?.length) {\n      await this.rpc.request(\"thread/inject_items\", {\n        threadId,\n        items: req.history,\n      } satisfies ThreadInjectItemsParams);\n    }\n\n    const { turn } = await this.rpc.request<TurnStartResponse>(\"turn/start\", {\n      threadId,\n      input: req.input,\n      ...(req.outputSchema ? { outputSchema: req.outputSchema } : {}),\n      ...(req.effort ? { effort: req.effort } : {}),\n      ...(req.model ? { model: req.model } : {}),\n      ...(req.reasoningSummary ? { summary: req.reasoningSummary } : {}),\n      ...(req.serviceTier ? { serviceTier: req.serviceTier } : {}),\n    });\n\n    return { threadId, turnId: turn.id, model };\n  }\n\n  async executeTurn(req: TurnRequest): Promise<TurnResult> {\n    const { threadId, model } = await this.startThread(req);\n    return this.consumeTurnNotifications(threadId, model);\n  }\n\n  async executeTurnStream(req: TurnRequest, cb: StreamCallbacks): Promise<void> {\n    const { threadId, turnId, model } = await this.startThread(req);\n    cb.onThreadId?.(threadId);\n    cb.onTurnId?.(turnId);\n    return this.consumeStreamNotifications(threadId, model, cb);\n  }\n\n  async interruptTurn(threadId: string, turnId: string): Promise<void> {\n    if (!this.rpc || !this.ready) return;\n    try {\n      await this.rpc.request(\"turn/interrupt\", { threadId, turnId });\n    } catch {}\n  }\n\n  private consumeTurnNotifications(threadId: string, model: string): Promise<TurnResult> {\n    return new Promise<TurnResult>((resolve, reject) => {\n      const timeout = setTimeout(() => {\n        cleanup();\n        reject(new Error(\"turn timeout (600s)\"));\n      }, 600_000);\n\n      let text = \"\";\n      let usage: TokenUsageBreakdown = {\n        totalTokens: 0,\n        inputTokens: 0,\n        outputTokens: 0,\n        cachedInputTokens: 0,\n        reasoningOutputTokens: 0,\n      };\n      let durationMs = 0;\n\n      const cleanup = () => {\n        clearTimeout(timeout);\n        for (const n of [\n          \"item/completed\",\n          \"item/agentMessage/delta\",\n          \"turn/completed\",\n          \"thread/tokenUsage/updated\",\n          \"error\",\n        ] as const) {\n          this.rpc?.onNotification(n, () => {});\n        }\n      };\n\n      this.rpc!.onNotification(\"item/completed\", (p) => {\n        if (p.threadId !== threadId) return;\n        if (p.item.type === \"agentMessage\") text = p.item.text;\n      });\n\n      this.rpc!.onNotification(\"thread/tokenUsage/updated\", (p) => {\n        if (p.threadId !== threadId) return;\n        usage = p.tokenUsage.total;\n      });\n\n      this.rpc!.onNotification(\"turn/completed\", (p) => {\n        if (p.threadId !== threadId) return;\n        durationMs = p.turn.durationMs ?? 0;\n        cleanup();\n        if (p.turn.status === \"completed\") resolve({ text, usage, durationMs, model });\n        else reject(new Error(`turn failed: ${JSON.stringify(p.turn.error)}`));\n      });\n\n      this.rpc!.onNotification(\"error\", (p) => {\n        if (p.threadId !== threadId) return;\n        if (!p.willRetry) {\n          cleanup();\n          reject(new Error(`codex error: ${p.error.message}`));\n        }\n      });\n    });\n  }\n\n  private consumeStreamNotifications(\n    threadId: string,\n    model: string,\n    cb: StreamCallbacks,\n  ): Promise<void> {\n    return new Promise<void>((resolve, reject) => {\n      const timeout = setTimeout(() => {\n        cleanup();\n        cb.onError(new Error(\"turn timeout (600s)\"));\n        reject(new Error(\"turn timeout (600s)\"));\n      }, 600_000);\n\n      let text = \"\";\n      let usage: TokenUsageBreakdown = {\n        totalTokens: 0,\n        inputTokens: 0,\n        outputTokens: 0,\n        cachedInputTokens: 0,\n        reasoningOutputTokens: 0,\n      };\n\n      const cleanup = () => {\n        clearTimeout(timeout);\n        for (const n of [\n          \"item/completed\",\n          \"item/agentMessage/delta\",\n          \"turn/completed\",\n          \"thread/tokenUsage/updated\",\n          \"error\",\n        ] as const) {\n          this.rpc?.onNotification(n, () => {});\n        }\n      };\n\n      this.rpc!.onNotification(\"item/agentMessage/delta\", (p) => {\n        if (p.threadId !== threadId) return;\n        text += p.delta;\n        cb.onDelta(p.delta);\n      });\n\n      this.rpc!.onNotification(\"item/completed\", (p) => {\n        if (p.threadId !== threadId) return;\n        if (p.item.type === \"agentMessage\") text = p.item.text;\n      });\n\n      this.rpc!.onNotification(\"thread/tokenUsage/updated\", (p) => {\n        if (p.threadId !== threadId) return;\n        usage = p.tokenUsage.total;\n      });\n\n      this.rpc!.onNotification(\"turn/completed\", (p) => {\n        if (p.threadId !== threadId) return;\n        cleanup();\n        if (p.turn.status === \"completed\") {\n          cb.onComplete({ text, usage, durationMs: p.turn.durationMs ?? 0, model });\n          resolve();\n        } else {\n          const err = new Error(`turn ${p.turn.status}: ${JSON.stringify(p.turn.error)}`);\n          cb.onError(err);\n          reject(err);\n        }\n      });\n\n      this.rpc!.onNotification(\"error\", (p) => {\n        if (p.threadId !== threadId) return;\n        if (!p.willRetry) {\n          cleanup();\n          const err = new Error(`codex error: ${p.error.message}`);\n          cb.onError(err);\n          reject(err);\n        }\n      });\n    });\n  }\n\n  // ── Restart ─────────────────────────────────────────────────────\n\n  private scheduleRestart(): void {\n    if (this.destroyed || this.restartAttempts >= MAX_RESTART_ATTEMPTS) {\n      if (this.restartAttempts >= MAX_RESTART_ATTEMPTS) {\n        logger.warn(`worker ${this.config.tokenName} max restart attempts reached`);\n      }\n      return;\n    }\n\n    this.restartAttempts++;\n    const baseDelay = RESTART_BACKOFF_BASE_MS * 2 ** (this.restartAttempts - 1);\n    const stagger = (this.config.workerIndex ?? 0) * 2_000;\n    const delay = baseDelay + stagger;\n    logger.info(\n      `worker ${this.config.tokenName}[${this.config.workerIndex ?? 0}] restarting in ${delay}ms (attempt ${this.restartAttempts})`,\n    );\n\n    setTimeout(() => {\n      if (this.destroyed) return;\n      this.initialize()\n        .then(() => this.onReady?.())\n        .catch((e) => {\n          logger.warn(`worker ${this.config.tokenName} restart failed: ${(e as Error).message}`);\n          this.scheduleRestart();\n        });\n    }, delay);\n  }\n}\n"],"mappings":"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"}

package/bundle/dist/utils/providers/openai/openai-constants.js

@@ -0,0 +1,10 @@
+import "../../../_virtual/_rolldown/runtime.js";
+//#region src/utils/providers/openai/openai-constants.ts
+const OPENAI_ISSUER = "https://auth.openai.com";
+const OPENAI_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+const OPENAI_TOKEN_URL = `${OPENAI_ISSUER}/oauth/token`;
+const OPENAI_SCOPES = "openid profile email offline_access api.connectors.read api.connectors.invoke";
+//#endregion
+export { OPENAI_CLIENT_ID, OPENAI_ISSUER, OPENAI_SCOPES, OPENAI_TOKEN_URL };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3BlbmFpLWNvbnN0YW50cy5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvcHJvdmlkZXJzL29wZW5haS9vcGVuYWktY29uc3RhbnRzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBPUEVOQUlfSVNTVUVSID0gXCJodHRwczovL2F1dGgub3BlbmFpLmNvbVwiO1xuZXhwb3J0IGNvbnN0IE9QRU5BSV9DTElFTlRfSUQgPSBcImFwcF9FTW9hbUVFWjczZjBDa1hhWHA3aHJhbm5cIjtcbmV4cG9ydCBjb25zdCBPUEVOQUlfVE9LRU5fVVJMID0gYCR7T1BFTkFJX0lTU1VFUn0vb2F1dGgvdG9rZW5gO1xuZXhwb3J0IGNvbnN0IE9QRU5BSV9TQ09QRVMgPVxuICBcIm9wZW5pZCBwcm9maWxlIGVtYWlsIG9mZmxpbmVfYWNjZXNzIGFwaS5jb25uZWN0b3JzLnJlYWQgYXBpLmNvbm5lY3RvcnMuaW52b2tlXCI7XG4iXSwibWFwcGluZ3MiOiI7O0FBQUEsTUFBYSxnQkFBZ0I7QUFDN0IsTUFBYSxtQkFBbUI7QUFDaEMsTUFBYSxtQkFBbUIsR0FBRyxjQUFjO0FBQ2pELE1BQWEsZ0JBQ1gifQ==