@eum-agent/llm-provider-chatgpt 0.0.0-stage → 1.1.0

package/dist/index.js

@@ -0,0 +1,2926 @@
+import { z } from "zod";
+import { createHash, randomBytes } from "node:crypto";
+import { setImmediate, setTimeout } from "node:timers/promises";
+import { createServer } from "node:http";
+//#endregion
+//#region src/catalog.ts
+/** This extension's endpoint declarations and offline catalogue seed. */
+const catalog = {
+	vendors: [{
+		kind: "vendor",
+		id: "chatgpt",
+		logo: "data:image/svg+xml,%3Csvg%20fill%3D%22currentColor%22%20fill-rule%3D%22evenodd%22%20height%3D%2224%22%20style%3D%22flex%3Anone%3Bline-height%3A1%22%20viewBox%3D%220%200%2024%2024%22%20width%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Ctitle%3EOpenAI%3C%2Ftitle%3E%3Cpath%20d%3D%22M9.205%208.658v-2.26c0-.19.072-.333.238-.428l4.543-2.616c.619-.357%201.356-.523%202.117-.523%202.854%200%204.662%202.212%204.662%204.566%200%20.167%200%20.357-.024.547l-4.71-2.759a.797.797%200%2000-.856%200l-5.97%203.473zm10.609%208.8V12.06c0-.333-.143-.57-.429-.737l-5.97-3.473%201.95-1.118a.433.433%200%2001.476%200l4.543%202.617c1.309.76%202.189%202.378%202.189%203.948%200%201.808-1.07%203.473-2.76%204.163zM7.802%2012.703l-1.95-1.142c-.167-.095-.239-.238-.239-.428V5.899c0-2.545%201.95-4.472%204.591-4.472%201%200%201.927.333%202.712.928L8.23%205.067c-.285.166-.428.404-.428.737v6.898zM12%2015.128l-2.795-1.57v-3.33L12%208.658l2.795%201.57v3.33L12%2015.128zm1.796%207.23c-1%200-1.927-.332-2.712-.927l4.686-2.712c.285-.166.428-.404.428-.737v-6.898l1.974%201.142c.167.095.238.238.238.428v5.233c0%202.545-1.974%204.472-4.614%204.472zm-5.637-5.303l-4.544-2.617c-1.308-.761-2.188-2.378-2.188-3.948A4.482%204.482%200%20014.21%206.327v5.423c0%20.333.143.571.428.738l5.947%203.449-1.95%201.118a.432.432%200%2001-.476%200zm-.262%203.9c-2.688%200-4.662-2.021-4.662-4.519%200-.19.024-.38.047-.57l4.686%202.71c.286.167.571.167.856%200l5.97-3.448v2.26c0%20.19-.07.333-.237.428l-4.543%202.616c-.619.357-1.356.523-2.117.523zm5.899%202.83a5.947%205.947%200%20005.827-4.756C22.287%2018.339%2024%2015.84%2024%2013.296c0-1.665-.713-3.282-1.998-4.448.119-.5.19-.999.19-1.498%200-3.401-2.759-5.947-5.946-5.947-.642%200-1.26.095-1.88.31A5.962%205.962%200%200010.205%200a5.947%205.947%200%2000-5.827%204.757C1.713%205.447%200%207.945%200%2010.49c0%201.666.713%203.283%201.998%204.448-.119.5-.19%201-.19%201.499%200%203.401%202.759%205.946%205.946%205.946.642%200%201.26-.095%201.88-.309a5.96%205.96%200%20004.162%201.713z%22%3E%3C%2Fpath%3E%3C%2Fsvg%3E",
+		name: "ChatGPT",
+		region: null,
+		market: "international",
+		catalogKey: "openai",
+		canListModels: true,
+		endpoints: [{
+			type: "chatgpt",
+			endpointId: "subscription",
+			protocolIds: ["chatgpt-subscription"],
+			baseUrl: "https://chatgpt.com/backend-api/codex"
+		}]
+	}],
+	snapshot: { "chatgpt": {
+		"gpt-5-nano": {
+			"id": "gpt-5-nano",
+			"name": "GPT-5 Nano",
+			"family": "gpt-nano",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": [
+					"minimal",
+					"low",
+					"medium",
+					"high"
+				]
+			}],
+			"temperature": false,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": ["text", "image"],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 4e5,
+				"output": 128e3
+			},
+			"release_date": "2025-08-07"
+		},
+		"gpt-4.1-nano": {
+			"id": "gpt-4.1-nano",
+			"name": "GPT-4.1 nano",
+			"family": "gpt-nano",
+			"reasoning": false,
+			"temperature": true,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": ["text", "image"],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 1047576,
+				"output": 32768
+			},
+			"release_date": "2025-04-14"
+		},
+		"gpt-4o-2024-05-13": {
+			"id": "gpt-4o-2024-05-13",
+			"name": "GPT-4o (2024-05-13)",
+			"family": "gpt",
+			"reasoning": false,
+			"temperature": true,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": ["text", "image"],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 128e3,
+				"output": 4096
+			},
+			"release_date": "2024-05-13"
+		},
+		"gpt-5-pro": {
+			"id": "gpt-5-pro",
+			"name": "GPT-5 Pro",
+			"family": "gpt-pro",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": ["high"]
+			}],
+			"temperature": false,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": ["text", "image"],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 4e5,
+				"output": 272e3
+			},
+			"release_date": "2025-10-06"
+		},
+		"chatgpt-image-latest": {
+			"id": "chatgpt-image-latest",
+			"name": "chatgpt-image-latest",
+			"family": "gpt-image",
+			"reasoning": false,
+			"temperature": false,
+			"tool_call": false,
+			"attachment": true,
+			"modalities": {
+				"input": ["text", "image"],
+				"output": ["text", "image"]
+			},
+			"limit": {
+				"context": 0,
+				"output": 0
+			},
+			"release_date": "2025-12-16"
+		},
+		"gpt-5.6-sol": {
+			"id": "gpt-5.6-sol",
+			"name": "GPT-5.6 Sol",
+			"family": "gpt-sol",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": [
+					"none",
+					"low",
+					"medium",
+					"high",
+					"xhigh",
+					"max"
+				]
+			}],
+			"temperature": false,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": [
+					"text",
+					"image",
+					"pdf"
+				],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 105e4,
+				"output": 128e3
+			},
+			"release_date": "2026-07-09"
+		},
+		"gpt-4o-2024-08-06": {
+			"id": "gpt-4o-2024-08-06",
+			"name": "GPT-4o (2024-08-06)",
+			"family": "gpt",
+			"reasoning": false,
+			"temperature": true,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": ["text", "image"],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 128e3,
+				"output": 16384
+			},
+			"release_date": "2024-08-06"
+		},
+		"gpt-6-astra": {
+			"id": "gpt-6-astra",
+			"name": "GPT-6 Astra",
+			"family": "gpt-astra",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": [
+					"low",
+					"medium",
+					"high",
+					"xhigh",
+					"max"
+				]
+			}],
+			"temperature": false,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": [
+					"text",
+					"image",
+					"pdf"
+				],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 105e4,
+				"output": 128e3
+			},
+			"release_date": "2026-09-04"
+		},
+		"gpt-5.2-pro": {
+			"id": "gpt-5.2-pro",
+			"name": "GPT-5.2 Pro",
+			"family": "gpt-pro",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": [
+					"medium",
+					"high",
+					"xhigh"
+				]
+			}],
+			"temperature": false,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": ["text", "image"],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 4e5,
+				"output": 128e3
+			},
+			"release_date": "2025-12-11"
+		},
+		"gpt-5.3-codex-spark": {
+			"id": "gpt-5.3-codex-spark",
+			"name": "GPT-5.3 Codex Spark",
+			"family": "gpt-codex-spark",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": [
+					"none",
+					"low",
+					"medium",
+					"high",
+					"xhigh"
+				]
+			}],
+			"temperature": false,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": [
+					"text",
+					"image",
+					"pdf"
+				],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 128e3,
+				"output": 32e3
+			},
+			"release_date": "2026-02-05"
+		},
+		"gpt-4.1-mini": {
+			"id": "gpt-4.1-mini",
+			"name": "GPT-4.1 mini",
+			"family": "gpt-mini",
+			"reasoning": false,
+			"temperature": true,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": [
+					"text",
+					"image",
+					"pdf"
+				],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 1047576,
+				"output": 32768
+			},
+			"release_date": "2025-04-14"
+		},
+		"gpt-5.4": {
+			"id": "gpt-5.4",
+			"name": "GPT-5.4",
+			"family": "gpt",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": [
+					"none",
+					"low",
+					"medium",
+					"high",
+					"xhigh"
+				]
+			}],
+			"temperature": true,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": [
+					"text",
+					"image",
+					"pdf"
+				],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 105e4,
+				"output": 128e3
+			},
+			"release_date": "2026-03-05"
+		},
+		"gpt-4-turbo": {
+			"id": "gpt-4-turbo",
+			"name": "GPT-4 Turbo",
+			"family": "gpt",
+			"reasoning": false,
+			"temperature": true,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": ["text", "image"],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 128e3,
+				"output": 4096
+			},
+			"release_date": "2023-11-06"
+		},
+		"gpt-5.1": {
+			"id": "gpt-5.1",
+			"name": "GPT-5.1",
+			"family": "gpt",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": [
+					"none",
+					"low",
+					"medium",
+					"high"
+				]
+			}],
+			"temperature": true,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": ["text", "image"],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 4e5,
+				"output": 128e3
+			},
+			"release_date": "2025-11-13"
+		},
+		"o1": {
+			"id": "o1",
+			"name": "o1",
+			"family": "o",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": [
+					"low",
+					"medium",
+					"high"
+				]
+			}],
+			"temperature": false,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": [
+					"text",
+					"image",
+					"pdf"
+				],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 2e5,
+				"output": 1e5
+			},
+			"release_date": "2024-12-05"
+		},
+		"gpt-4o": {
+			"id": "gpt-4o",
+			"name": "GPT-4o",
+			"family": "gpt",
+			"reasoning": false,
+			"temperature": true,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": [
+					"text",
+					"image",
+					"pdf"
+				],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 128e3,
+				"output": 16384
+			},
+			"release_date": "2024-05-13"
+		},
+		"gpt-5.6-luna": {
+			"id": "gpt-5.6-luna",
+			"name": "GPT-5.6 Luna",
+			"family": "gpt-luna",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": [
+					"none",
+					"low",
+					"medium",
+					"high",
+					"xhigh",
+					"max"
+				]
+			}],
+			"temperature": false,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": [
+					"text",
+					"image",
+					"pdf"
+				],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 105e4,
+				"output": 128e3
+			},
+			"release_date": "2026-07-09"
+		},
+		"gpt-5.3-codex": {
+			"id": "gpt-5.3-codex",
+			"name": "GPT-5.3 Codex",
+			"family": "gpt-codex",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": [
+					"none",
+					"low",
+					"medium",
+					"high",
+					"xhigh"
+				]
+			}],
+			"temperature": true,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": [
+					"text",
+					"image",
+					"pdf"
+				],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 4e5,
+				"output": 128e3
+			},
+			"release_date": "2026-02-05"
+		},
+		"gpt-4o-mini": {
+			"id": "gpt-4o-mini",
+			"name": "GPT-4o mini",
+			"family": "gpt-mini",
+			"reasoning": false,
+			"temperature": true,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": [
+					"text",
+					"image",
+					"pdf"
+				],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 128e3,
+				"output": 16384
+			},
+			"release_date": "2024-07-18"
+		},
+		"gpt-image-1.5": {
+			"id": "gpt-image-1.5",
+			"name": "gpt-image-1.5",
+			"family": "gpt-image",
+			"reasoning": false,
+			"temperature": false,
+			"tool_call": false,
+			"attachment": true,
+			"modalities": {
+				"input": ["text", "image"],
+				"output": ["text", "image"]
+			},
+			"limit": {
+				"context": 0,
+				"output": 0
+			},
+			"release_date": "2025-11-25"
+		},
+		"o1-pro": {
+			"id": "o1-pro",
+			"name": "o1-pro",
+			"family": "o-pro",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": [
+					"low",
+					"medium",
+					"high"
+				]
+			}],
+			"temperature": false,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": ["text", "image"],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 2e5,
+				"output": 1e5
+			},
+			"release_date": "2025-03-19"
+		},
+		"gpt-4.1": {
+			"id": "gpt-4.1",
+			"name": "GPT-4.1",
+			"family": "gpt",
+			"reasoning": false,
+			"temperature": true,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": [
+					"text",
+					"image",
+					"pdf"
+				],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 1047576,
+				"output": 32768
+			},
+			"release_date": "2025-04-14"
+		},
+		"text-embedding-ada-002": {
+			"id": "text-embedding-ada-002",
+			"name": "text-embedding-ada-002",
+			"family": "text-embedding",
+			"reasoning": false,
+			"temperature": false,
+			"tool_call": false,
+			"attachment": false,
+			"modalities": {
+				"input": ["text"],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 8192,
+				"output": 1536
+			},
+			"release_date": "2022-12-15"
+		},
+		"gpt-image-1": {
+			"id": "gpt-image-1",
+			"name": "gpt-image-1",
+			"family": "gpt-image",
+			"reasoning": false,
+			"temperature": false,
+			"tool_call": false,
+			"attachment": true,
+			"modalities": {
+				"input": ["text", "image"],
+				"output": ["image"]
+			},
+			"limit": {
+				"context": 0,
+				"output": 0
+			},
+			"release_date": "2025-04-24"
+		},
+		"gpt-5.4-nano": {
+			"id": "gpt-5.4-nano",
+			"name": "GPT-5.4 nano",
+			"family": "gpt-nano",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": [
+					"none",
+					"low",
+					"medium",
+					"high",
+					"xhigh"
+				]
+			}],
+			"temperature": true,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": ["text", "image"],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 4e5,
+				"output": 128e3
+			},
+			"release_date": "2026-03-17"
+		},
+		"gpt-5.5-pro": {
+			"id": "gpt-5.5-pro",
+			"name": "GPT-5.5 Pro",
+			"family": "gpt-pro",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": [
+					"medium",
+					"high",
+					"xhigh"
+				]
+			}],
+			"temperature": false,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": [
+					"text",
+					"image",
+					"pdf"
+				],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 105e4,
+				"output": 128e3
+			},
+			"release_date": "2026-04-23"
+		},
+		"gpt-image-1-mini": {
+			"id": "gpt-image-1-mini",
+			"name": "gpt-image-1-mini",
+			"family": "gpt-image",
+			"reasoning": false,
+			"temperature": false,
+			"tool_call": false,
+			"attachment": true,
+			"modalities": {
+				"input": ["text", "image"],
+				"output": ["text", "image"]
+			},
+			"limit": {
+				"context": 0,
+				"output": 0
+			},
+			"release_date": "2025-09-26"
+		},
+		"gpt-5.4-mini": {
+			"id": "gpt-5.4-mini",
+			"name": "GPT-5.4 mini",
+			"family": "gpt-mini",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": [
+					"none",
+					"low",
+					"medium",
+					"high",
+					"xhigh"
+				]
+			}],
+			"temperature": true,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": ["text", "image"],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 4e5,
+				"output": 128e3
+			},
+			"release_date": "2026-03-17"
+		},
+		"gpt-image-2": {
+			"id": "gpt-image-2",
+			"name": "gpt-image-2",
+			"family": "gpt-image",
+			"reasoning": false,
+			"temperature": false,
+			"tool_call": false,
+			"attachment": true,
+			"modalities": {
+				"input": ["text", "image"],
+				"output": ["image"]
+			},
+			"limit": {
+				"context": 0,
+				"output": 0
+			},
+			"release_date": "2026-04-21"
+		},
+		"gpt-3.5-turbo": {
+			"id": "gpt-3.5-turbo",
+			"name": "GPT-3.5-turbo",
+			"family": "gpt",
+			"reasoning": false,
+			"temperature": true,
+			"tool_call": false,
+			"attachment": false,
+			"modalities": {
+				"input": ["text"],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 16385,
+				"output": 4096
+			},
+			"release_date": "2023-03-01"
+		},
+		"gpt-5.6": {
+			"id": "gpt-5.6",
+			"name": "GPT-5.6",
+			"family": "gpt-sol",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": [
+					"none",
+					"low",
+					"medium",
+					"high",
+					"xhigh",
+					"max"
+				]
+			}],
+			"temperature": false,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": [
+					"text",
+					"image",
+					"pdf"
+				],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 105e4,
+				"output": 128e3
+			},
+			"release_date": "2026-07-09"
+		},
+		"text-embedding-3-small": {
+			"id": "text-embedding-3-small",
+			"name": "text-embedding-3-small",
+			"family": "text-embedding",
+			"reasoning": false,
+			"temperature": false,
+			"tool_call": false,
+			"attachment": false,
+			"modalities": {
+				"input": ["text"],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 8191,
+				"output": 1536
+			},
+			"release_date": "2024-01-25"
+		},
+		"gpt-5-mini": {
+			"id": "gpt-5-mini",
+			"name": "GPT-5 Mini",
+			"family": "gpt-mini",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": [
+					"minimal",
+					"low",
+					"medium",
+					"high"
+				]
+			}],
+			"temperature": false,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": ["text", "image"],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 4e5,
+				"output": 128e3
+			},
+			"release_date": "2025-08-07"
+		},
+		"gpt-5.4-pro": {
+			"id": "gpt-5.4-pro",
+			"name": "GPT-5.4 Pro",
+			"family": "gpt-pro",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": [
+					"medium",
+					"high",
+					"xhigh"
+				]
+			}],
+			"temperature": false,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": ["text", "image"],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 105e4,
+				"output": 128e3
+			},
+			"release_date": "2026-03-05"
+		},
+		"text-embedding-3-large": {
+			"id": "text-embedding-3-large",
+			"name": "text-embedding-3-large",
+			"family": "text-embedding",
+			"reasoning": false,
+			"temperature": false,
+			"tool_call": false,
+			"attachment": false,
+			"modalities": {
+				"input": ["text"],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 8191,
+				"output": 3072
+			},
+			"release_date": "2024-01-25"
+		},
+		"gpt-5.6-terra": {
+			"id": "gpt-5.6-terra",
+			"name": "GPT-5.6 Terra",
+			"family": "gpt-terra",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": [
+					"none",
+					"low",
+					"medium",
+					"high",
+					"xhigh",
+					"max"
+				]
+			}],
+			"temperature": false,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": [
+					"text",
+					"image",
+					"pdf"
+				],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 105e4,
+				"output": 128e3
+			},
+			"release_date": "2026-07-09"
+		},
+		"gpt-4": {
+			"id": "gpt-4",
+			"name": "GPT-4",
+			"family": "gpt",
+			"reasoning": false,
+			"temperature": true,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": ["text"],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 8192,
+				"output": 8192
+			},
+			"release_date": "2023-11-06"
+		},
+		"gpt-5.2": {
+			"id": "gpt-5.2",
+			"name": "GPT-5.2",
+			"family": "gpt",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": [
+					"none",
+					"low",
+					"medium",
+					"high",
+					"xhigh"
+				]
+			}],
+			"temperature": true,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": ["text", "image"],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 4e5,
+				"output": 128e3
+			},
+			"release_date": "2025-12-11"
+		},
+		"gpt-5": {
+			"id": "gpt-5",
+			"name": "GPT-5",
+			"family": "gpt",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": [
+					"minimal",
+					"low",
+					"medium",
+					"high"
+				]
+			}],
+			"temperature": false,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": ["text", "image"],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 4e5,
+				"output": 128e3
+			},
+			"release_date": "2025-08-07"
+		},
+		"gpt-5.2-chat-latest": {
+			"id": "gpt-5.2-chat-latest",
+			"name": "GPT-5.2 Chat",
+			"family": "gpt-codex",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": ["medium"]
+			}],
+			"temperature": false,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": ["text", "image"],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 128e3,
+				"output": 16384
+			},
+			"release_date": "2025-12-11"
+		},
+		"o4-mini": {
+			"id": "o4-mini",
+			"name": "o4-mini",
+			"family": "o-mini",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": [
+					"low",
+					"medium",
+					"high"
+				]
+			}],
+			"temperature": false,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": ["text", "image"],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 2e5,
+				"output": 1e5
+			},
+			"release_date": "2025-04-16"
+		},
+		"gpt-realtime-2.1": {
+			"id": "gpt-realtime-2.1",
+			"name": "GPT-Realtime-2.1",
+			"family": "gpt",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": [
+					"minimal",
+					"low",
+					"medium",
+					"high",
+					"xhigh"
+				]
+			}],
+			"temperature": false,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": [
+					"text",
+					"audio",
+					"image"
+				],
+				"output": ["text", "audio"]
+			},
+			"limit": {
+				"context": 128e3,
+				"output": 32e3
+			},
+			"release_date": "2026-07-06"
+		},
+		"o3-mini": {
+			"id": "o3-mini",
+			"name": "o3-mini",
+			"family": "o-mini",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": [
+					"low",
+					"medium",
+					"high"
+				]
+			}],
+			"temperature": false,
+			"tool_call": true,
+			"attachment": false,
+			"modalities": {
+				"input": ["text"],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 2e5,
+				"output": 1e5
+			},
+			"release_date": "2024-12-20"
+		},
+		"o3": {
+			"id": "o3",
+			"name": "o3",
+			"family": "o",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": [
+					"low",
+					"medium",
+					"high"
+				]
+			}],
+			"temperature": false,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": [
+					"text",
+					"image",
+					"pdf"
+				],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 2e5,
+				"output": 1e5
+			},
+			"release_date": "2025-04-16"
+		},
+		"o3-pro": {
+			"id": "o3-pro",
+			"name": "o3-pro",
+			"family": "o-pro",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": [
+					"low",
+					"medium",
+					"high"
+				]
+			}],
+			"temperature": false,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": ["text", "image"],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 2e5,
+				"output": 1e5
+			},
+			"release_date": "2025-06-10"
+		},
+		"gpt-5.3-chat-latest": {
+			"id": "gpt-5.3-chat-latest",
+			"name": "GPT-5.3 Chat (latest)",
+			"family": "gpt",
+			"reasoning": false,
+			"temperature": true,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": ["text", "image"],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 128e3,
+				"output": 16384
+			},
+			"release_date": "2026-03-03"
+		},
+		"gpt-5.5": {
+			"id": "gpt-5.5",
+			"name": "GPT-5.5",
+			"family": "gpt",
+			"reasoning": true,
+			"reasoning_options": [{
+				"type": "effort",
+				"values": [
+					"none",
+					"low",
+					"medium",
+					"high",
+					"xhigh"
+				]
+			}],
+			"temperature": false,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": [
+					"text",
+					"image",
+					"pdf"
+				],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 105e4,
+				"output": 128e3
+			},
+			"release_date": "2026-04-23"
+		},
+		"gpt-4o-2024-11-20": {
+			"id": "gpt-4o-2024-11-20",
+			"name": "GPT-4o (2024-11-20)",
+			"family": "gpt",
+			"reasoning": false,
+			"temperature": true,
+			"tool_call": true,
+			"attachment": true,
+			"modalities": {
+				"input": ["text", "image"],
+				"output": ["text"]
+			},
+			"limit": {
+				"context": 128e3,
+				"output": 16384
+			},
+			"release_date": "2024-11-20"
+		}
+	} },
+	snapshotAt: Date.parse("2026-09-17")
+};
+//#endregion
+//#region src/facts.ts
+/** Parameter ranges and request limits for this provider wire. */
+const facts = {
+	outputLimit: { support: "unsupported" },
+	temperature: null,
+	thinkingSwitch: false,
+	limits: {
+		requestBytes: 50331648,
+		images: 100
+	}
+};
+//#endregion
+//#region src/image-generation/model.ts
+/** The fixed subscription image model. */
+const IMAGE_MODEL = "gpt-image-2";
+/** Strict generation parameters; opaque output is the default. */
+const IMAGE_PARAMS_SCHEMA = z.object({ transparent_background: z.boolean().default(false) }).strict();
+/** Declares the image model's executable operations. */
+const IMAGE_GENERATION_MODEL = {
+	id: IMAGE_MODEL,
+	label: IMAGE_MODEL,
+	outputKinds: ["image"],
+	operations: [{
+		id: "create",
+		inputKinds: [],
+		minInputs: 0,
+		maxInputs: 0,
+		paramsSchema: IMAGE_PARAMS_SCHEMA
+	}, {
+		id: "edit",
+		inputKinds: ["image"],
+		minInputs: 1,
+		maxInputs: 5,
+		paramsSchema: IMAGE_PARAMS_SCHEMA
+	}]
+};
+//#endregion
+//#region src/failure.ts
+var LoginFailure = class extends Error {
+	name = "LoginFailure";
+	code;
+	detail;
+	constructor(code, detail = null) {
+		super(detail === null ? `sign-in ${code}` : `sign-in ${code} (${detail})`);
+		this.code = code;
+		this.detail = detail;
+	}
+};
+//#endregion
+//#region src/oauth.ts
+/**
+* Signing a ChatGPT account in, and keeping its tokens fresh.
+*
+* The client is the Codex CLI's public one: it has no secret, so what stops
+* an intercepted authorization code from being spent is PKCE alone. The
+* addresses and the request shapes are the ones the Codex CLI and opencode
+* use; none of them is a published contract, and each was verified against a
+* Pro account on 2026-09-24.
+*
+* Every function here takes the addresses it reaches as an argument, so a
+* test points them at a server of its own.
+*/
+const CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+/** Who this client says it is, on the authorization and on every call. */
+const ORIGINATOR = "yaoguang";
+const CALLBACK_PATH = "/auth/callback";
+/** The listing answers only models whose minimal client version this reaches. */
+const CODEX_CLIENT_VERSION = "1.0.0";
+/** The reasoning efforts the endpoint accepts. The listing names more
+*  (`ultra`), which the endpoint refuses. */
+const ACCEPTED_EFFORTS = [
+	"none",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+const SCOPE = "openid profile email offline_access";
+const REQUEST_TIMEOUT_MS = 3e4;
+/** How long before expiry a token without `earliest_refresh_at` is refreshed. */
+const REFRESH_AHEAD_MS = 6e4;
+const ENDPOINTS = {
+	issuer: "https://auth.openai.com",
+	codex: "https://chatgpt.com/backend-api/codex"
+};
+function pkce() {
+	const verifier = randomBytes(48).toString("base64url");
+	return {
+		verifier,
+		challenge: createHash("sha256").update(verifier).digest("base64url")
+	};
+}
+function newState() {
+	return randomBytes(32).toString("base64url");
+}
+function authorizeUrl(endpoints, redirectUri, codes, state) {
+	const params = new URLSearchParams({
+		response_type: "code",
+		client_id: CLIENT_ID,
+		redirect_uri: redirectUri,
+		scope: SCOPE,
+		code_challenge: codes.challenge,
+		code_challenge_method: "S256",
+		id_token_add_organizations: "true",
+		codex_cli_simplified_flow: "true",
+		state,
+		originator: ORIGINATOR
+	});
+	return `${endpoints.issuer}/oauth/authorize?${params.toString()}`;
+}
+function claimsOf(jwt) {
+	if (typeof jwt !== "string") return void 0;
+	const payload = jwt.split(".")[1];
+	if (payload === void 0) return void 0;
+	try {
+		const parsed = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+		return typeof parsed === "object" && parsed !== null ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+function authClaim(claims, key) {
+	const nested = claims?.["https://api.openai.com/auth"];
+	const value = (typeof nested === "object" && nested !== null ? nested[key] : void 0) ?? claims?.[key];
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+/** Who signed in, as a person reads it: the email, else the account id's
+*  last four characters. */
+function accountLabel(email, accountId) {
+	return email ?? `····${accountId.slice(-4)}`;
+}
+/**
+* The tokens an exchange or a refresh answered, as they are stored. `before`
+* is the credential being refreshed: a refresh that answers no id token keeps
+* the account it had.
+*/
+function storedFrom(body, now, before) {
+	const access = body.access_token;
+	const refresh = body.refresh_token ?? before?.refresh;
+	if (typeof access !== "string" || typeof refresh !== "string") return void 0;
+	const id = claimsOf(body.id_token);
+	const accessClaims = claimsOf(access);
+	const accountId = authClaim(id, "chatgpt_account_id") ?? authClaim(accessClaims, "chatgpt_account_id") ?? before?.accountId;
+	if (accountId === void 0) return void 0;
+	const email = typeof id?.email === "string" ? id.email : void 0;
+	const expiresIn = typeof body.expires_in === "number" ? body.expires_in : 3600;
+	const earliest = typeof body.earliest_refresh_at === "number" ? body.earliest_refresh_at * 1e3 : void 0;
+	const residency = authClaim(accessClaims, "chatgpt_compute_residency");
+	return {
+		access,
+		refresh,
+		expiresAt: String(now + expiresIn * 1e3),
+		...earliest === void 0 ? {} : { earliestRefreshAt: String(earliest) },
+		accountId,
+		account: email === void 0 && before !== void 0 ? before.account : accountLabel(email, accountId),
+		...residency === void 0 || residency === "no_constraint" ? {} : { residency }
+	};
+}
+function parseStored(credential) {
+	if (credential === void 0) return void 0;
+	try {
+		const parsed = JSON.parse(credential);
+		return typeof parsed.access === "string" && typeof parsed.refresh === "string" && typeof parsed.expiresAt === "string" && typeof parsed.accountId === "string" && typeof parsed.account === "string" ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+/** UTC milliseconds when the host should refresh this credential. */
+function refreshAfterOf(tokens) {
+	const expiresAt = Number(tokens.expiresAt) - REFRESH_AHEAD_MS;
+	const earliest = tokens.earliestRefreshAt === void 0 ? expiresAt : Number(tokens.earliestRefreshAt);
+	return Math.min(expiresAt, earliest);
+}
+async function postForm(fetch, url, form, signal) {
+	return fetch(url, {
+		method: "POST",
+		headers: { "content-type": "application/x-www-form-urlencoded" },
+		body: new URLSearchParams(form).toString(),
+		signal: signal === void 0 ? AbortSignal.timeout(REQUEST_TIMEOUT_MS) : AbortSignal.any([signal, AbortSignal.timeout(REQUEST_TIMEOUT_MS)])
+	});
+}
+/** Spends an authorization code. Rejects with `exchange-failed`. */
+async function exchangeCode(fetch, endpoints, input, now, signal) {
+	let response;
+	try {
+		response = await postForm(fetch, `${endpoints.issuer}/oauth/token`, {
+			grant_type: "authorization_code",
+			code: input.code,
+			redirect_uri: input.redirectUri,
+			client_id: CLIENT_ID,
+			code_verifier: input.verifier
+		}, signal);
+	} catch {
+		throw new LoginFailure("exchange-failed", "unreachable");
+	}
+	if (!response.ok) throw new LoginFailure("exchange-failed", `HTTP ${String(response.status)}`);
+	const stored = storedFrom(await response.json().catch(() => ({})), now());
+	if (stored === void 0) throw new LoginFailure("exchange-failed", "unreadable answer");
+	return stored;
+}
+async function refreshTokens(fetch, endpoints, before, now, signal) {
+	let response;
+	try {
+		response = await postForm(fetch, `${endpoints.issuer}/oauth/token`, {
+			grant_type: "refresh_token",
+			refresh_token: before.refresh,
+			client_id: CLIENT_ID
+		}, signal);
+	} catch {
+		if (signal?.aborted) throw new LoginFailure("cancelled");
+		return {
+			kind: "failed",
+			detail: "unreachable"
+		};
+	}
+	if (response.status === 400 || response.status === 401) return { kind: "refused" };
+	if (!response.ok) return {
+		kind: "failed",
+		detail: `HTTP ${String(response.status)}`
+	};
+	const tokens = storedFrom(await response.json().catch(() => ({})), now(), before);
+	return tokens === void 0 ? {
+		kind: "failed",
+		detail: "unreadable answer"
+	} : {
+		kind: "ok",
+		tokens
+	};
+}
+//#endregion
+//#region src/image-generation/client.ts
+const responseSchema = z.object({
+	data: z.array(z.unknown()).min(1),
+	background: z.enum(["opaque", "transparent"]).optional()
+});
+const itemSchema = z.object({ b64_json: z.string() });
+const RESPONSE_LIMIT = 41943040;
+const PNG_SIGNATURE = Buffer.from([
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+]);
+const errorSchema = z.object({ error: z.object({
+	type: z.string().optional(),
+	code: z.string().optional(),
+	limit_id: z.string().optional(),
+	resets_at: z.number().int().optional()
+}) });
+/** A body-only provider failure with explicit submission and delivery knowledge. */
+var ImageGenerationFailure = class extends Error {
+	/** Public failure discriminator. */
+	name = "GenerationFailure";
+	/** Normalized failure category. */
+	code;
+	/** Remote submission and local delivery knowledge. */
+	resultState;
+	/** Provider response status, when available. */
+	status;
+	/** Explicit provider reset time in UTC epoch milliseconds. */
+	retryAt;
+	/** Bounded provider body with known access and refresh tokens removed. */
+	providerText;
+	/** Creates a failure without copying HTTP headers. */
+	constructor(code, message, resultState, metadata = {}) {
+		super(message);
+		this.code = code;
+		this.resultState = resultState;
+		this.status = metadata.status;
+		this.retryAt = metadata.retryAt;
+		this.providerText = metadata.providerText;
+	}
+};
+/** Sends exactly one JSON POST and decodes the first inline image. */
+async function submitImage(options, submission, signal) {
+	if (signal.aborted) await withImageSignal(async () => {}, signal, "not-submitted");
+	let response;
+	try {
+		response = await withImageSignal(() => options.fetch(`${options.baseUrl.replace(/\/$/, "")}/images/${submission.operation === "create" ? "generations" : "edits"}`, {
+			method: "POST",
+			signal,
+			body: submission.body,
+			headers: {
+				"content-type": "application/json",
+				authorization: `Bearer ${submission.tokens.access}`,
+				...submission.tokens.accountId ? { "ChatGPT-Account-ID": submission.tokens.accountId } : {},
+				"x-codex-image-turn-id": submission.callId,
+				originator: ORIGINATOR,
+				"User-Agent": options.userAgent
+			}
+		}).then((response) => {
+			if (signal.aborted) response.body?.cancel().catch(() => {});
+			return response;
+		}), signal, "unknown");
+	} catch (error) {
+		if (error instanceof ImageGenerationFailure) throw error;
+		throw new ImageGenerationFailure("network", "ChatGPT image request failed; its remote result is unknown", "unknown");
+	}
+	if (response.status === 401) {
+		response.body?.cancel().catch(() => {});
+		throw new ImageGenerationFailure("expired", "ChatGPT sign-in expired; sign in again in model settings (status 401)", "unknown", { status: 401 });
+	}
+	const text = await readResponse(response, signal);
+	if (!response.ok) {
+		let parsedError;
+		try {
+			const result = errorSchema.safeParse(JSON.parse(text));
+			if (result.success) parsedError = result.data;
+		} catch {}
+		const reportedCode = parsedError?.error.code ?? parsedError?.error.type;
+		const quota = reportedCode === "usage_limit_reached" || reportedCode === "insufficient_quota" || parsedError?.error.limit_id === "image_gen";
+		const code = response.status === 401 ? "expired" : response.status === 403 ? "forbidden" : response.status === 429 || quota ? "quota" : "provider";
+		const seconds = parsedError?.error.resets_at;
+		const retryAt = code === "quota" && seconds !== void 0 && seconds > 0 && seconds * 1e3 <= 864e13 ? seconds * 1e3 : void 0;
+		const message = code === "expired" ? "ChatGPT sign-in expired; sign in again in model settings" : code === "forbidden" ? "ChatGPT image generation is forbidden for this account" : code === "quota" ? parsedError?.error.limit_id === "image_gen" ? "ChatGPT image generation quota reached" : "ChatGPT quota reached" : "ChatGPT image generation failed";
+		let providerText = text;
+		for (const token of [submission.tokens.access, submission.tokens.refresh]) if (token) providerText = providerText.split(token).join("****");
+		throw new ImageGenerationFailure(code, `${message} (status ${response.status})`, "unknown", {
+			status: response.status,
+			...retryAt === void 0 ? {} : { retryAt },
+			providerText: providerText.slice(0, 512)
+		});
+	}
+	let parsed;
+	let item;
+	try {
+		parsed = responseSchema.parse(JSON.parse(text));
+		item = itemSchema.parse(parsed.data[0]);
+	} catch {
+		throw new ImageGenerationFailure("invalid-output", "ChatGPT returned an invalid image response", "not-delivered");
+	}
+	const encoded = item.b64_json;
+	if (encoded.length > Math.ceil(20971520 / 3) * 4) throw new ImageGenerationFailure("too-large", "Generated PNG exceeds 20 MiB", "not-delivered");
+	if (!/^[A-Za-z0-9+/]*={0,2}$/.test(encoded) || encoded.length === 0 || encoded.length % 4 !== 0) throw new ImageGenerationFailure("invalid-output", "ChatGPT returned invalid image base64", "not-delivered");
+	const bytes = Buffer.from(encoded, "base64");
+	if (bytes.byteLength > 20971520) throw new ImageGenerationFailure("too-large", "Generated PNG exceeds 20 MiB", "not-delivered");
+	if (bytes.toString("base64") !== encoded || !bytes.subarray(0, 8).equals(PNG_SIGNATURE)) throw new ImageGenerationFailure("invalid-output", "ChatGPT did not return a valid PNG", "not-delivered");
+	return {
+		bytes,
+		...parsed.background === void 0 ? {} : { background: parsed.background }
+	};
+}
+async function readResponse(response, signal) {
+	const length = response.headers.get("content-length");
+	if (length !== null && Number(length) > RESPONSE_LIMIT) {
+		response.body?.cancel().catch(() => {});
+		throw new ImageGenerationFailure("too-large", "Image response exceeds 40 MiB", "not-delivered");
+	}
+	if (!response.body) return "";
+	const reader = response.body.getReader();
+	const cancel = () => {
+		reader.cancel().catch(() => {});
+	};
+	signal.addEventListener("abort", cancel, { once: true });
+	const chunks = [];
+	let size = 0;
+	try {
+		while (true) {
+			const next = await withImageSignal(() => reader.read(), signal, "unknown");
+			if (next.done) break;
+			size += next.value.byteLength;
+			if (size > RESPONSE_LIMIT) throw new ImageGenerationFailure("too-large", "Image response exceeds 40 MiB", "not-delivered");
+			chunks.push(Buffer.from(next.value));
+		}
+		return Buffer.concat(chunks).toString("utf8");
+	} catch (error) {
+		reader.cancel().catch(() => {});
+		if (error instanceof ImageGenerationFailure) throw error;
+		throw new ImageGenerationFailure("network", "ChatGPT image response was interrupted; its remote result is unknown", "unknown");
+	} finally {
+		signal.removeEventListener("abort", cancel);
+		reader.releaseLock();
+	}
+}
+/** Ends a provider wait promptly on abort without claiming that its remote work stopped. */
+async function withImageSignal(work, signal, resultState) {
+	const aborted = () => new ImageGenerationFailure(signal.reason instanceof Error && signal.reason.name === "TimeoutError" ? "timeout" : "cancelled", signal.reason instanceof Error && signal.reason.name === "TimeoutError" ? "Image generation timed out" : "Image generation was cancelled", resultState);
+	if (signal.aborted) throw aborted();
+	let onAbort;
+	try {
+		return await new Promise((resolve, reject) => {
+			onAbort = () => reject(aborted());
+			signal.addEventListener("abort", onAbort, { once: true });
+			work().then((value) => signal.aborted ? reject(aborted()) : resolve(value), reject);
+		});
+	} finally {
+		if (onAbort) signal.removeEventListener("abort", onAbort);
+	}
+}
+//#endregion
+//#region src/image-generation/port.ts
+/** Creates an image port without network activity or retaining call credentials. */
+function createImageGenerationPort(options) {
+	return { async generate(request, signal) {
+		await withImageSignal(async () => {}, signal, "not-submitted");
+		const operation = request.operation;
+		if (request.outputKind !== "image" || operation !== "create" && operation !== "edit") throw new ImageGenerationFailure("unsupported", "Unsupported image operation", "not-submitted");
+		if (operation === "create" && request.inputs.length !== 0 || operation === "edit" && (request.inputs.length < 1 || request.inputs.length > 5)) throw new ImageGenerationFailure("invalid-input", "Image edits require one to five references; creation requires none", "not-submitted");
+		const prompt = request.prompt.trim();
+		if ([...prompt].length < 1 || [...prompt].length > 32e3) throw new ImageGenerationFailure("invalid-input", "Image prompt must contain 1 to 32000 characters", "not-submitted");
+		const parsed = IMAGE_PARAMS_SCHEMA.safeParse(request.params);
+		if (!parsed.success) throw new ImageGenerationFailure("invalid-params", "Invalid image generation parameters", "not-submitted");
+		const params = parsed.data;
+		const login = options.login;
+		if (!login) throw new ImageGenerationFailure("not-signed-in", "Sign in to ChatGPT in model settings", "not-submitted");
+		let credential;
+		try {
+			credential = await withImageSignal(() => login.get(signal), signal, "not-submitted");
+		} catch (error) {
+			if (error instanceof ImageGenerationFailure) throw error;
+			throw new ImageGenerationFailure(typeof error === "object" && error !== null && "name" in error && error.name === "CredentialUnavailableError" ? "credential-unavailable" : "not-signed-in", "ChatGPT sign-in is unavailable; sign in again in model settings", "not-submitted");
+		}
+		const tokens = parseStored(credential.credential);
+		if (!tokens?.access.trim()) throw new ImageGenerationFailure("not-signed-in", "Sign in to ChatGPT in model settings", "not-submitted");
+		const images = [];
+		for (const input of request.inputs) {
+			if (![
+				"image/png",
+				"image/jpeg",
+				"image/webp",
+				"image/gif"
+			].includes(input.mediaType) || !Number.isSafeInteger(input.size) || input.size <= 0) throw new ImageGenerationFailure("invalid-input", "Unsupported reference image", "not-submitted");
+			if (input.size > 20971520) throw new ImageGenerationFailure("too-large", "Reference image exceeds 20 MiB", "not-submitted");
+			const chunks = [];
+			let length = 0;
+			const iterator = input.read(signal)[Symbol.asyncIterator]();
+			try {
+				while (true) {
+					const next = await withImageSignal(() => iterator.next(), signal, "not-submitted");
+					if (next.done) break;
+					const chunk = next.value;
+					length += chunk.byteLength;
+					if (length > 20971520) throw new ImageGenerationFailure("too-large", "Reference image exceeds 20 MiB", "not-submitted");
+					if (length > input.size) throw new ImageGenerationFailure("invalid-input", "Reference image size changed", "not-submitted");
+					chunks.push(Buffer.from(chunk));
+				}
+			} catch (error) {
+				if (error instanceof ImageGenerationFailure) throw error;
+				throw new ImageGenerationFailure("invalid-input", "Reference image could not be read", "not-submitted");
+			} finally {
+				iterator.return?.().catch(() => {});
+			}
+			if (length !== input.size) throw new ImageGenerationFailure("invalid-input", "Reference image size changed", "not-submitted");
+			images.push({ image_url: `data:${input.mediaType};base64,${Buffer.concat(chunks).toString("base64")}` });
+		}
+		const body = JSON.stringify({
+			model: IMAGE_MODEL,
+			prompt,
+			background: params.transparent_background ? "transparent" : "opaque",
+			quality: "auto",
+			size: "auto",
+			...request.operation === "edit" ? { images } : {}
+		});
+		if (Buffer.byteLength(body, "utf8") > 50331648) throw new ImageGenerationFailure("too-large", "Encoded image request exceeds 48 MiB", "not-submitted");
+		let image;
+		try {
+			image = await submitImage(options, {
+				operation,
+				body,
+				callId: request.identity.callId,
+				tokens
+			}, signal);
+		} catch (error) {
+			if (error instanceof ImageGenerationFailure && error.code === "expired") login.expire(credential.credential);
+			throw error;
+		}
+		const { bytes, background } = image;
+		const expectedBackground = params.transparent_background ? "transparent" : "opaque";
+		if (background !== void 0 && background !== expectedBackground) throw new ImageGenerationFailure("invalid-output", "ChatGPT did not satisfy the requested background", "not-delivered");
+		let info;
+		try {
+			info = await withImageSignal(() => options.imageInfo(bytes, signal), signal, "unknown");
+		} catch (error) {
+			if (error instanceof ImageGenerationFailure) throw error;
+			throw new ImageGenerationFailure("invalid-output", "ChatGPT returned an undecodable PNG", "not-delivered");
+		}
+		if (!Number.isSafeInteger(info.width) || !Number.isSafeInteger(info.height) || info.width <= 0 || info.height <= 0 || info.width > 1e4 || info.height > 1e4 || info.mediaType !== "image/png" || info.hasTransparentPixels !== params.transparent_background || params.transparent_background && !info.hasAlpha) throw new ImageGenerationFailure("invalid-output", "ChatGPT did not satisfy the requested background", "not-delivered");
+		return { assets: [{
+			mediaType: "image/png",
+			name: "generated-image.png",
+			body: (async function* () {
+				yield bytes;
+			})()
+		}] };
+	} };
+}
+//#endregion
+//#region src/errors.ts
+const failureKindOf = (status) => status === 413 ? "request-too-large" : void 0;
+/** Same shape as the other adapters' port error, and `authored`: every
+*  message this module builds is written here, from fixed words, a status
+*  and a code matched against a fixed spelling, so the runtime may show it
+*  as it stands. */
+var ModelCallError = class extends Error {
+	/** Stable fact selected by this local producer, independent of display text. */
+	failureCode;
+	status;
+	retryable;
+	authored = true;
+	/** The endpoint's own error body, unredacted, on a refusal this module did
+	*  not recognise. The runtime's guard removes every credential of the
+	*  endpoint from it before it reaches a reason. */
+	providerText;
+	/** How long the endpoint asked to wait before trying again, when it said. */
+	retryAfterMs;
+	/** The endpoint's error code, matched against a fixed spelling. */
+	code;
+	/** What the status alone says the refusal is (`failureKindOf`). */
+	kind;
+	constructor(message, options) {
+		super(message);
+		this.name = "ModelCallError";
+		this.failureCode = options.failureCode;
+		this.status = options.status;
+		this.retryable = options.retryable;
+		this.providerText = options.providerText;
+		this.retryAfterMs = options.retryAfterMs;
+		this.code = options.code;
+		this.kind = failureKindOf(options.status);
+	}
+};
+const NOT_SIGNED_IN = "not signed in to ChatGPT; sign in again in settings";
+const SIGN_IN_EXPIRED = "ChatGPT sign-in expired; sign in again in settings";
+function notSignedIn() {
+	return new ModelCallError(NOT_SIGNED_IN, {
+		retryable: false,
+		failureCode: "authentication-required"
+	});
+}
+function signInExpired(status) {
+	return new ModelCallError(SIGN_IN_EXPIRED, {
+		failureCode: "authentication-expired",
+		...status === void 0 ? {} : { status },
+		retryable: false
+	});
+}
+const SAFE_CODES = /* @__PURE__ */ new Set([
+	"usage_not_included",
+	"usage_limit_reached",
+	"insufficient_quota",
+	"context_length_exceeded",
+	"rate_limit_exceeded",
+	"overloaded_error",
+	"api_error",
+	"rate_limit_error",
+	"cyber_policy",
+	"invalid_prompt",
+	"bio_policy",
+	"misalignment_policy_violation"
+]);
+function codeOf(body) {
+	const code = body.error?.code ?? body.error?.type;
+	return typeof code === "string" && SAFE_CODES.has(code) ? code : void 0;
+}
+function resetOf(body) {
+	const at = Number(body.error?.resets_at);
+	return Number.isFinite(at) && at > 0 ? `; resets ${(/* @__PURE__ */ new Date(at * 1e3)).toISOString()}` : "";
+}
+/** A refused HTTP answer, read into a port error. */
+function toPortError(status, text) {
+	let body = {};
+	try {
+		const parsed = JSON.parse(text);
+		if (typeof parsed === "object" && parsed !== null) body = parsed;
+	} catch {}
+	const code = codeOf(body);
+	const detail = typeof body.detail === "string" ? body.detail : "";
+	const at = `(status ${String(status)})`;
+	if (code === "usage_not_included") return new ModelCallError(`your ChatGPT plan does not include Codex ${at}`, {
+		failureCode: "model-unavailable",
+		code,
+		status,
+		retryable: false
+	});
+	if (code === "usage_limit_reached" || code === "insufficient_quota") return new ModelCallError(`ChatGPT usage limit reached ${at}${resetOf(body)}`, {
+		failureCode: "quota-exceeded",
+		code,
+		status,
+		retryable: false
+	});
+	if (code === "context_length_exceeded") return new ModelCallError(`input exceeds the model's context window ${at}`, {
+		failureCode: "context-limit-exceeded",
+		code,
+		status,
+		retryable: false
+	});
+	if (detail.includes("is not supported when using Codex with a ChatGPT account")) return new ModelCallError(`this model is not available with a ChatGPT subscription ${at}`, {
+		failureCode: "model-unavailable",
+		status,
+		retryable: false
+	});
+	return new ModelCallError(`ChatGPT API error (status ${String(status)}${code === void 0 ? "" : `, code ${code}`})`, {
+		status,
+		failureCode: status === 413 ? "request-too-large" : "http-error",
+		...code === void 0 ? {} : { code },
+		retryable: status === 429 || status >= 500,
+		...text.trim() === "" ? {} : { providerText: text }
+	});
+}
+/** A failure that is not an HTTP answer: a dropped connection, a body that
+*  could not be read — worth a second attempt. Its message comes from this
+*  side, never the network. */
+function toCallError(error) {
+	if (error instanceof ModelCallError) return error;
+	const name = error instanceof Error ? error.name : "";
+	return new ModelCallError(`ChatGPT call failed${name === "" ? "" : ` (${name})`}`, { retryable: true });
+}
+/** Codes a `response.failed` carries that a second attempt cannot change. */
+const FINAL_CODES = /* @__PURE__ */ new Set([
+	"context_length_exceeded",
+	"insufficient_quota",
+	"usage_not_included",
+	"usage_limit_reached",
+	"cyber_policy",
+	"invalid_prompt",
+	"bio_policy",
+	"misalignment_policy_violation"
+]);
+/** `try again in 1.5s` / `in 250ms`: the wait a rate-limit message names. */
+function waitIn(message) {
+	if (typeof message !== "string") return void 0;
+	const match = /try again in\s*(\d+(?:\.\d+)?)\s*(s|ms|seconds?)\b/i.exec(message);
+	if (match === null) return void 0;
+	const value = Number(match[1]);
+	const milliseconds = match[2]?.toLowerCase() === "ms" ? value : value * 1e3;
+	return Number.isFinite(milliseconds) && milliseconds >= 0 ? milliseconds : void 0;
+}
+/**
+* A `response.failed` event, read into a port error: rate limits, overload
+* and unclassified server errors are retried — a rate limit after the wait
+* its message names — while an oversized input, a spent quota and a policy
+* refusal are final. Only the code travels; the message is read for the wait.
+*/
+function toFailedError(failure) {
+	const code = typeof failure.code === "string" && SAFE_CODES.has(failure.code) ? failure.code : void 0;
+	const retryAfterMs = code === "rate_limit_exceeded" ? waitIn(failure.message) : void 0;
+	return new ModelCallError(`ChatGPT response failed${code === void 0 ? "" : ` (code ${code})`}`, {
+		failureCode: code === "context_length_exceeded" ? "context-limit-exceeded" : code === "insufficient_quota" || code === "usage_limit_reached" ? "quota-exceeded" : code === "usage_not_included" ? "model-unavailable" : "provider-error",
+		retryable: code === void 0 || !FINAL_CODES.has(code),
+		...code === void 0 ? {} : { code },
+		...retryAfterMs === void 0 ? {} : { retryAfterMs }
+	});
+}
+/** Converts locally identified failures to host candidates without copying provider text. */
+function toModelFailure(error, failures) {
+	if (failures.owns(error)) return error;
+	const converted = toCallError(error);
+	const known = error instanceof ModelCallError;
+	const code = converted.code;
+	const diagnosis = !known ? "unknown" : converted.failureCode ?? (converted.status === void 0 ? "response-invalid" : "http-error");
+	const providerCodes = /* @__PURE__ */ new Set([
+		"usage_not_included",
+		"usage_limit_reached",
+		"insufficient_quota",
+		"context_length_exceeded",
+		"rate_limit_exceeded",
+		"overloaded_error",
+		"api_error",
+		"rate_limit_error",
+		"cyber_policy",
+		"invalid_prompt",
+		"bio_policy",
+		"misalignment_policy_violation"
+	]);
+	const status = Number.isInteger(converted.status) && Number(converted.status) >= 100 && Number(converted.status) <= 599 ? converted.status : void 0;
+	return failures.create({
+		code: diagnosis,
+		stage: diagnosis === "unknown" ? "unknown" : diagnosis.startsWith("authentication") || diagnosis === "request-too-large" ? "request" : status !== void 0 ? "transport" : diagnosis === "response-invalid" ? "response-validation" : "stream",
+		category: diagnosis === "unknown" ? "unknown" : diagnosis === "stream-interrupted" ? "network" : diagnosis === "response-invalid" ? "protocol" : diagnosis === "request-too-large" ? "request-too-large" : "provider",
+		source: known ? "protocol" : "unknown",
+		retryable: converted.retryable,
+		...status === void 0 ? {} : { status },
+		...code !== void 0 && providerCodes.has(code) ? { providerCode: code } : {}
+	});
+}
+//#endregion
+//#region src/stream.ts
+/**
+* A Codex Responses event stream → `ModelChunk`s.
+*
+* Deltas are forwarded as they arrive. The final message is assembled from
+* the `response.output_item.done` events, in order — the `response.completed`
+* event's own `output` arrives empty from this endpoint — and a reasoning
+* item becomes a thinking part whose `signature` is its encrypted content,
+* attributed to the model that produced it so the request side can decide
+* whether it may go back.
+*/
+const EVENT_LIMIT = 8388608;
+const SLAB_SIZE = 65536;
+/**
+* Reads JSON SSE events across fragmented LF, CRLF or CR separators.
+* Yields after 64 KiB of work, counting each incoming byte and each read, including empty reads.
+* Rejects bodies above 8 MiB before decoding; ignores non-JSON and unfinished EOF events.
+*/
+async function* sseEvents(body) {
+	const decoder = new TextDecoder();
+	let slabs = [];
+	let slab;
+	let used = 0;
+	let size = 0;
+	let suffix = 0;
+	let pendingDelimiter = 0;
+	let work = 0;
+	const oversized = () => new ModelCallError("SSE event exceeds 8 MiB", { retryable: false });
+	function completed(delimiter) {
+		const length = size - delimiter;
+		if (length > EVENT_LIMIT) throw oversized();
+		const block = decoder.decode(Buffer.concat(slabs, length));
+		slabs = [];
+		slab = void 0;
+		size = 0;
+		used = 0;
+		suffix = 0;
+		pendingDelimiter = 0;
+		const data = block.split(/\r\n|\n|\r/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
+		if (data !== "" && data !== "[DONE]") try {
+			return JSON.parse(data);
+		} catch {}
+	}
+	for await (const bytes of body) {
+		work += 1;
+		if (work >= SLAB_SIZE) {
+			work = 0;
+			await setImmediate();
+		}
+		if (bytes.length === 0) continue;
+		if (pendingDelimiter !== 0) {
+			const event = completed(pendingDelimiter);
+			if (event !== void 0) yield event;
+		}
+		for (let index = 0; index < bytes.length; index += 1) {
+			if (size >= 8388612) throw oversized();
+			if (slab === void 0 || used === SLAB_SIZE) {
+				slab = Buffer.allocUnsafe(SLAB_SIZE);
+				slabs.push(slab);
+				used = 0;
+			}
+			const byte = bytes[index];
+			slab[used++] = byte;
+			size += 1;
+			suffix = (suffix << 8 | byte) >>> 0;
+			const delimiter = (suffix & 65535) === 2570 || (suffix & 65535) === 3341 ? 2 : suffix === 218762506 ? 4 : 0;
+			if (delimiter !== 0) {
+				if (byte === 13 && index === bytes.length - 1) pendingDelimiter = delimiter;
+				else {
+					const event = completed(delimiter);
+					if (event !== void 0) yield event;
+				}
+			}
+			work += 1;
+			if (work >= SLAB_SIZE) {
+				work = 0;
+				await setImmediate();
+			}
+		}
+	}
+	if (pendingDelimiter !== 0) {
+		const event = completed(pendingDelimiter);
+		if (event !== void 0) yield event;
+	} else if (size > EVENT_LIMIT) throw oversized();
+}
+const str = (value) => typeof value === "string" ? value : "";
+const num = (value) => typeof value === "number" && value >= 0 ? value : 0;
+function partsOf(item, model) {
+	if (item.type === "reasoning") {
+		const text = (Array.isArray(item.summary) ? item.summary : []).map((one) => str(one.text)).join("\n\n");
+		const encrypted = str(item.encrypted_content);
+		return [{
+			type: "thinking",
+			text,
+			...encrypted === "" ? {} : {
+				signature: encrypted,
+				originModel: model
+			}
+		}];
+	}
+	if (item.type === "message") {
+		const text = (Array.isArray(item.content) ? item.content : []).map((one) => {
+			const part = one;
+			return part.type === "output_text" ? str(part.text) : part.type === "refusal" ? str(part.refusal) : "";
+		}).join("");
+		return text === "" ? [] : [{
+			type: "text",
+			text
+		}];
+	}
+	if (item.type === "function_call") {
+		const id = str(item.call_id);
+		const name = str(item.name);
+		if (id.trim() === "" || name.trim() === "") throw new ModelCallError("invalid model function_call: missing call_id or name", { retryable: false });
+		let input;
+		try {
+			input = JSON.parse(str(item.arguments));
+		} catch {
+			throw new ModelCallError("invalid model function_call: arguments are not complete JSON", { retryable: false });
+		}
+		return [{
+			type: "tool-use",
+			id,
+			name,
+			input
+		}];
+	}
+	return [];
+}
+/** UTF-8 bytes over four: rough, and only ever used as a ceiling. */
+const tokensOf = (text) => Math.ceil(Buffer.byteLength(text, "utf8") / 4);
+/**
+* Forwards deltas immediately and assembles terminal output from completed items.
+* Completed unusable replies and malformed tool calls fail without retry; refusals remain visible.
+*/
+async function* mapResponsesStream(events, options) {
+	const items = [];
+	const callIds = /* @__PURE__ */ new Map();
+	const pendingCalls = /* @__PURE__ */ new Map();
+	let openThinking = "";
+	let written = 0;
+	let capped = false;
+	let refused = false;
+	let open = "";
+	for await (const event of events) {
+		switch (event.type) {
+			case "response.output_text.delta":
+			case "response.refusal.delta": {
+				if (event.type === "response.refusal.delta") refused = true;
+				const text = str(event.delta);
+				if (text === "") break;
+				yield {
+					kind: "text-delta",
+					text
+				};
+				open += text;
+				written += tokensOf(text);
+				if (options.outputCap !== void 0 && written >= options.outputCap) capped = true;
+				break;
+			}
+			case "response.reasoning_summary_text.delta": {
+				const text = str(event.delta);
+				if (text !== "") {
+					openThinking += text;
+					yield {
+						kind: "thinking-delta",
+						text
+					};
+				}
+				break;
+			}
+			case "response.output_item.added": {
+				const item = event.item;
+				if (item?.type === "function_call") {
+					const callId = str(item.call_id);
+					callIds.set(str(item.id), callId);
+					pendingCalls.set(str(item.id), {
+						id: callId,
+						...str(item.name) === "" ? {} : { name: str(item.name) }
+					});
+					yield {
+						kind: "tool-call-delta",
+						id: callId,
+						name: str(item.name),
+						inputDelta: ""
+					};
+				}
+				break;
+			}
+			case "response.function_call_arguments.delta": {
+				const callId = callIds.get(str(event.item_id));
+				if (callId !== void 0) yield {
+					kind: "tool-call-delta",
+					id: callId,
+					inputDelta: str(event.delta)
+				};
+				break;
+			}
+			case "response.output_item.done": {
+				const item = event.item;
+				if (item !== void 0) items.push(item);
+				if (item?.type === "function_call") {
+					pendingCalls.delete(str(item.id));
+					for (const [key, call] of pendingCalls) if (call.id === str(item.call_id)) pendingCalls.delete(key);
+				}
+				if (item?.type === "reasoning") openThinking = "";
+				if (item?.type === "message" && Array.isArray(item.content)) refused ||= item.content.some((part) => part.type === "refusal");
+				if (item?.type === "message") open = "";
+				break;
+			}
+			case "response.completed":
+			case "response.incomplete": {
+				const response = event.response ?? {};
+				const usage = response.usage ?? {};
+				const details = usage.input_tokens_details ?? {};
+				const cache = typeof details.cached_tokens === "number" && details.cached_tokens >= 0 ? { cacheReadTokens: details.cached_tokens } : {};
+				const truncated = event.type === "response.incomplete" && response.incomplete_details?.reason === "max_output_tokens";
+				if (event.type === "response.incomplete" && !truncated && !refused) throw new ModelCallError(`incomplete model reply (${event.type})`, { retryable: false });
+				const incompleteToolCalls = [...pendingCalls.values()];
+				const content = items.flatMap((item) => {
+					try {
+						return partsOf(item, options.model);
+					} catch (error) {
+						if (!truncated || item.type !== "function_call" || str(item.call_id) === "") throw error;
+						incompleteToolCalls.push({
+							id: str(item.call_id),
+							...str(item.name) === "" ? {} : { name: str(item.name) }
+						});
+						return [];
+					}
+				});
+				if (truncated && open !== "") content.push({
+					type: "text",
+					text: open
+				});
+				if (truncated && openThinking !== "") content.unshift({
+					type: "thinking",
+					text: openThinking
+				});
+				if (!truncated && !refused && !content.some((part) => part.type === "text" || part.type === "tool-use")) throw new ModelCallError(`incomplete model reply (${event.type})`, {
+					retryable: false,
+					failureCode: "response-empty"
+				});
+				const finishReason = refused ? "refusal" : truncated ? "max-tokens" : content.some((part) => part.type === "tool-use") ? "tool-calls" : "stop";
+				yield {
+					kind: "final",
+					finishReason,
+					...finishReason === "max-tokens" ? { outputTruncation: {
+						incompleteToolCalls,
+						...openThinking !== "" ? { incompleteThinking: true } : {}
+					} } : {},
+					usage: {
+						inputTokens: num(usage.input_tokens),
+						outputTokens: num(usage.output_tokens),
+						...cache
+					},
+					message: {
+						role: "assistant",
+						content
+					}
+				};
+				return;
+			}
+			case "response.failed":
+			case "error": throw toFailedError(event.response?.error ?? event.error ?? event);
+		}
+		if (capped) {
+			options.stop?.();
+			const content = items.flatMap((item) => partsOf(item, options.model));
+			if (open !== "") content.push({
+				type: "text",
+				text: open
+			});
+			if (openThinking !== "") content.unshift({
+				type: "thinking",
+				text: openThinking
+			});
+			yield {
+				kind: "final",
+				finishReason: "max-tokens",
+				outputTruncation: {
+					incompleteToolCalls: [...pendingCalls.values()],
+					...openThinking !== "" ? { incompleteThinking: true } : {}
+				},
+				usage: {
+					inputTokens: 0,
+					outputTokens: written
+				},
+				message: {
+					role: "assistant",
+					content
+				}
+			};
+			return;
+		}
+	}
+	throw new ModelCallError("model stream interrupted", {
+		retryable: true,
+		failureCode: "stream-interrupted"
+	});
+}
+//#endregion
+//#region src/port.ts
+/** Requires one host-owned transport identity before any network request. */
+function transportIdOf(request) {
+	const identity = request.sessionId ?? request.callId;
+	if (!identity || request.sessionId !== void 0 && request.callId !== void 0) throw new Error("a model request requires exactly one session or call identity");
+	return identity;
+}
+/** Builds authenticated headers without exposing the token in request metadata. */
+function headersOf(tokens, sessionId, userAgent) {
+	return {
+		authorization: `Bearer ${tokens.access}`,
+		"chatgpt-account-id": tokens.accountId,
+		originator: ORIGINATOR,
+		"user-agent": userAgent,
+		"session-id": sessionId,
+		"content-type": "application/json",
+		accept: "text/event-stream",
+		...tokens.residency === void 0 ? {} : { "x-openai-internal-codex-residency": tokens.residency }
+	};
+}
+/** Creates a port whose retries preserve the host-selected transport identity. */
+function createChatGPTPort(options) {
+	function build(request, inspection = false) {
+		const plan = options.params(request.params ?? {});
+		const media = options.media?.(request.params ?? {}) ?? {
+			acceptsImages: true,
+			limits: void 0
+		};
+		const replay = options.support.planEffortCache({
+			request,
+			inspection,
+			effort: plan.effort,
+			capability: plan.thinking === false || plan.effort === "none" ? {
+				status: "unsupported",
+				reason: "reasoning-required"
+			} : { status: "supported" },
+			bindingFingerprint: options.support.inspectionFingerprint({
+				connectionFingerprint: options.connectionFingerprint,
+				providerId: options.providerId,
+				endpoint: options.endpoints.codex,
+				model: options.model,
+				system: request.system,
+				tools: request.tools,
+				thinking: plan.thinking
+			})
+		});
+		const body = options.codec.render(request, {
+			model: options.model,
+			endpoint: options.providerId,
+			effort: replay.baseEffort,
+			effortUpdates: replay.updates,
+			media
+		}, options.support.planMedia(request, media));
+		const sessionId = transportIdOf(request);
+		return {
+			body: {
+				...body,
+				prompt_cache_key: sessionId
+			},
+			sessionId,
+			media,
+			replay
+		};
+	}
+	async function send(body, sessionId, signal, login, reportProgress) {
+		const envelope = await login.get(signal);
+		const tokens = parseStored(envelope.credential);
+		if (tokens === void 0) throw notSignedIn();
+		const response = await options.fetch(`${options.endpoints.codex}/responses`, {
+			method: "POST",
+			headers: headersOf(tokens, sessionId, options.userAgent),
+			body: JSON.stringify(body),
+			signal
+		});
+		return {
+			response: options.support.observeResponseProgress(response, reportProgress),
+			credential: envelope.credential
+		};
+	}
+	return {
+		inspect(request) {
+			const { body, media } = build(request, true);
+			const capacity = options.catalogue()?.limit;
+			return options.support.inspect({
+				body,
+				textTokens: options.support.measureText(options.support.requestText("responses", body)),
+				tokenizer: "o200k_base-protocol-text-v2",
+				hiddenInputTokens: options.codec.hiddenInputTokens(request, {
+					model: options.model,
+					endpoint: options.providerId
+				}),
+				request,
+				capacity,
+				outputReserve: capacity?.output ?? 0,
+				outputReserveSource: "capacity",
+				mediaTokens: options.support.planMedia(request, media).tokens,
+				fingerprint: {
+					rendering: "chatgpt-codex-responses-v2",
+					endpoint: options.providerId,
+					model: options.model,
+					purpose: request.purpose,
+					contextWindow: request.params?.contextWindow,
+					capacity,
+					settings: { effort: body.reasoning?.effort }
+				}
+			});
+		},
+		stream(request, signal, observer) {
+			signal.throwIfAborted();
+			const login = options.login;
+			const { body, sessionId, replay } = build(request);
+			const cap = request.purpose === "summary" && request.summaryMaxTokens !== void 0 ? request.summaryMaxTokens : void 0;
+			return options.support.withChatAttempts({
+				signal,
+				...options.maxRetries === void 0 ? {} : { maxRetries: options.maxRetries },
+				...options.sleep === void 0 ? {} : { sleep: options.sleep },
+				...options.idleMs === void 0 ? {} : { idleMs: options.idleMs },
+				async *attempt(attemptSignal, reportProgress, attempt) {
+					const observe = (event) => {
+						try {
+							observer?.observe?.(event);
+						} catch {}
+					};
+					const attemptCount = attempt + 1;
+					let outcome = "unknown";
+					let firstResponseFinished = false;
+					observe({
+						stage: "attempt",
+						phase: "start",
+						attempt: attemptCount
+					});
+					observe({
+						stage: "first-response",
+						phase: "start",
+						attempt: attemptCount
+					});
+					try {
+						attemptSignal.throwIfAborted();
+						if (login === void 0) throw notSignedIn();
+						const { response, credential } = await send(body, sessionId, attemptSignal, login, reportProgress);
+						firstResponseFinished = true;
+						observe({
+							stage: "first-response",
+							phase: "end",
+							attempt: attemptCount,
+							outcome: "ok"
+						});
+						if (response.status === 401) {
+							await response.body?.cancel();
+							login.expire(credential);
+							throw signInExpired(401);
+						}
+						if (!response.ok || response.body === null) {
+							const refused = toPortError(response.status, await response.text().catch(() => ""));
+							const wait = Number(response.headers.get("retry-after"));
+							throw Number.isFinite(wait * 1e3) && wait > 0 && refused.retryable ? new ModelCallError(refused.message, {
+								failureCode: refused.failureCode,
+								code: refused.code,
+								...refused.status === void 0 ? {} : { status: refused.status },
+								retryable: true,
+								retryAfterMs: wait * 1e3,
+								...refused.providerText === void 0 ? {} : { providerText: refused.providerText }
+							}) : refused;
+						}
+						attemptSignal.throwIfAborted();
+						try {
+							observer?.dispatched({ attempt });
+						} catch {}
+						attemptSignal.throwIfAborted();
+						const stream = response.body;
+						for await (const chunk of mapResponsesStream(sseEvents(stream), {
+							model: options.model,
+							...cap === void 0 ? {} : { outputCap: cap },
+							stop: () => void stream.cancel().catch(() => {})
+						})) {
+							if (chunk.kind === "final") outcome = "ok";
+							yield chunk.kind === "final" && replay.replayData ? {
+								...chunk,
+								replayData: replay.replayData
+							} : chunk;
+						}
+					} catch (error) {
+						outcome = attemptSignal.aborted ? "cancelled" : "error";
+						throw error;
+					} finally {
+						if (!firstResponseFinished) observe({
+							stage: "first-response",
+							phase: "end",
+							attempt: attemptCount,
+							outcome
+						});
+						observe({
+							stage: "attempt",
+							phase: "end",
+							attempt: attemptCount,
+							outcome
+						});
+					}
+				},
+				classify(error) {
+					const portError = toCallError(error);
+					return {
+						error: toModelFailure(error, options.support.failures),
+						retryable: portError.retryable,
+						retryAfterMs: portError.retryAfterMs
+					};
+				}
+			});
+		}
+	};
+}
+//#endregion
+//#region src/probe.ts
+function effortsOf(levels) {
+	if (!Array.isArray(levels)) return void 0;
+	const named = levels.map((one) => typeof one === "string" ? one : one?.effort).filter((one) => typeof one === "string");
+	const accepted = ACCEPTED_EFFORTS.filter((effort) => named.includes(effort));
+	return accepted.length === 0 ? void 0 : accepted;
+}
+function offerOf(model) {
+	if (typeof model.slug !== "string" || model.visibility !== "list") return void 0;
+	const efforts = effortsOf(model.supported_reasoning_levels);
+	return {
+		model: model.slug,
+		...typeof model.display_name === "string" ? { name: model.display_name } : {},
+		...Number.isInteger(model.context_window) && Number(model.context_window) > 0 ? { contextWindow: Number(model.context_window) } : {},
+		...efforts === void 0 ? {} : { efforts }
+	};
+}
+/**
+* The secret tokens this probe could have carried: the ones it called with
+* and the ones stored now. A refresh during the probe writes tokens after the
+* host collected its redaction set, so the probe checks the endpoint's words
+* against them itself.
+*/
+function heldTokens(used, stored) {
+	const now = parseStored(stored);
+	return [
+		used.access,
+		used.refresh,
+		now?.access,
+		now?.refresh
+	].filter((one) => one !== void 0 && one !== "");
+}
+function createProbes(deps) {
+	async function listModels(probe) {
+		const login = probe.login;
+		if (login === void 0) throw new Error("not signed in");
+		const envelope = await login.get(probe.signal);
+		const tokens = parseStored(envelope.credential);
+		if (tokens === void 0) throw new Error("not signed in");
+		const response = await deps.fetch(`${deps.endpoints.codex}/models?client_version=${CODEX_CLIENT_VERSION}`, {
+			method: "GET",
+			headers: {
+				authorization: `Bearer ${tokens.access}`,
+				"chatgpt-account-id": tokens.accountId,
+				originator: ORIGINATOR,
+				"user-agent": deps.userAgent,
+				accept: "application/json"
+			},
+			signal: probe.signal
+		});
+		if (!response.ok) {
+			const body = await response.text().catch(() => "");
+			const echoes = heldTokens(tokens, envelope.credential).some((token) => body.includes(token));
+			throw Object.assign(new Error(body === "" || echoes ? response.statusText : body), { status: response.status });
+		}
+		const body = await response.json();
+		return (Array.isArray(body.models) ? body.models : []).map(offerOf).filter((one) => one !== void 0);
+	}
+	return {
+		listModels,
+		async testConnection(probe) {
+			await listModels(probe);
+		}
+	};
+}
+//#endregion
+//#region src/support.ts
+/** Normalizes official facts without requiring an installed Chat capability. */
+function normalizeOffers(input) {
+	return Object.fromEntries(input.offers.map((offer) => [offer.model, {
+		id: offer.model,
+		...offer.name === void 0 ? {} : { name: offer.name },
+		...offer.reasoning === void 0 && !offer.efforts?.length ? {} : { reasoning: offer.efforts?.length ? true : offer.reasoning },
+		...offer.efforts?.length ? { reasoning_options: [{
+			type: "effort",
+			values: [...offer.efforts]
+		}] } : {},
+		...offer.temperature === void 0 ? {} : { temperature: offer.temperature },
+		...offer.toolCall === void 0 ? {} : { tool_call: offer.toolCall },
+		...offer.input === void 0 ? {} : { attachment: offer.input.some((one) => one !== "text") },
+		...offer.input === void 0 && offer.output === void 0 ? {} : { modalities: {
+			...offer.input === void 0 ? {} : { input: [...offer.input] },
+			...offer.output === void 0 ? {} : { output: [...offer.output] }
+		} },
+		...!offer.contextWindow && !offer.maxOutput ? {} : { limit: {
+			...offer.contextWindow && offer.contextWindow > 0 ? { context: offer.contextWindow } : {},
+			...offer.maxOutput && offer.maxOutput > 0 ? { output: offer.maxOutput } : {}
+		} },
+		...offer.releaseDate === void 0 ? {} : { release_date: offer.releaseDate }
+	}]));
+}
+/** The owner-qualified accessor is read per operation; withdrawal never exposes an old service. */
+function lazySupport(read) {
+	return new Proxy({}, { get(_target, key) {
+		if (key === "normalizeListing") return normalizeOffers;
+		const service = read();
+		if (!service) throw new Error("Chat model support is unavailable");
+		const value = Reflect.get(service, key);
+		return typeof value === "function" ? value.bind(service) : value;
+	} });
+}
+//#endregion
+//#region src/protocol.ts
+const USER_AGENT = "yaoguang";
+/** Builds the subscription provider using host-owned planning, routing and login credentials. */
+function chatgptProtocolType(support, fetch, codec, options = {}, imageInfo = (bytes, signal) => support.imageInfo(bytes, signal)) {
+	const endpoints = options.endpoints ?? ENDPOINTS;
+	const probes = createProbes({
+		fetch,
+		endpoints,
+		userAgent: USER_AGENT
+	});
+	return {
+		type: "chatgpt-subscription",
+		label: "ChatGPT Subscription",
+		logo: catalog.vendors[0]?.logo,
+		fields: [],
+		userConfigurable: false,
+		optionsSchema: z.strictObject({}),
+		facts,
+		effortCacheCapability(input) {
+			return input.params.thinking === false || input.params.effort === "none" ? {
+				status: "unsupported",
+				reason: "reasoning-required"
+			} : { status: "supported" };
+		},
+		prepareParams: (input) => support.prepareParams(input, facts),
+		adapters: {
+			chat: {
+				fileKinds: ["image"],
+				supportsModel: (model) => !/^gpt-image(?:-|$)/.test(model),
+				createPort: (call) => createChatGPTPort({
+					fetch,
+					codec,
+					connectionFingerprint: call.connectionFingerprint,
+					endpoints,
+					model: call.model,
+					providerId: call.providerId,
+					login: call.login,
+					support,
+					userAgent: USER_AGENT,
+					catalogue: () => support.catalogue(call.providerId, call.model),
+					media: (stored) => support.mediaContextOf({
+						entry: support.catalogue(call.providerId, call.model),
+						stored,
+						facts,
+						endpoint: support.endpoint(call.providerId)
+					}),
+					params: (stored) => support.resolveParams({
+						facts,
+						model: call.model,
+						endpoint: support.endpoint(call.providerId),
+						entry: support.catalogue(call.providerId, call.model),
+						stored
+					}),
+					...options.sleep === void 0 ? {} : { sleep: options.sleep }
+				})
+			},
+			image: {
+				models: () => [IMAGE_GENERATION_MODEL],
+				createPort: (call) => createImageGenerationPort({
+					fetch,
+					baseUrl: endpoints.codex,
+					login: call.login,
+					imageInfo,
+					userAgent: USER_AGENT
+				})
+			}
+		},
+		normalizeListing: (input) => normalizeOffers(input),
+		async listModels(probe) {
+			const offers = await probes.listModels(probe);
+			if (offers.some((offer) => offer.model === IMAGE_GENERATION_MODEL.id)) return { offers };
+			return { offers: [...offers, {
+				model: IMAGE_GENERATION_MODEL.id,
+				name: IMAGE_GENERATION_MODEL.label,
+				input: ["text", "image"],
+				output: [...IMAGE_GENERATION_MODEL.outputKinds]
+			}] };
+		},
+		testConnection: (probe) => probes.testConnection(probe)
+	};
+}
+//#endregion
+//#region src/callback.ts
+/**
+* The loopback listener a browser sign-in returns to.
+*
+* The redirect address is fixed by the client's registration —
+* `http://localhost:1455/auth/callback` — and a browser may resolve
+* `localhost` to either loopback address, while Node's `listen('localhost')`
+* binds only the first one it resolves. So the same port is opened on both
+* `127.0.0.1` and `::1`, one flow behind the two; a machine with no IPv6
+* loopback serves IPv4 alone. Either address being taken refuses the whole
+* sign-in: a browser landing on the other program would hand it the code.
+*/
+/** The listener is in use by something else. */
+var CallbackPortInUse = class extends Error {
+	constructor(port) {
+		super(`port ${String(port)} is in use`);
+		this.name = "CallbackPortInUse";
+	}
+};
+function listen(port, host) {
+	return new Promise((resolve, reject) => {
+		const server = createServer();
+		server.once("error", reject);
+		server.listen({
+			port,
+			host,
+			exclusive: true
+		}, () => {
+			server.off("error", reject);
+			resolve(server);
+		});
+	});
+}
+function page(ok) {
+	return `<!doctype html><html><head><meta charset="utf-8"><title>YaoGuang</title></head><body style="font-family:system-ui;margin:3rem"><p>${ok ? "Sign-in complete. You can close this page. 登录完成，可以关闭此页。" : "Sign-in was not completed. You can close this page. 登录未完成，可以关闭此页。"}</p><script>setTimeout(function(){window.close()},300)<\/script></body></html>`;
+}
+function respond(res, status, ok) {
+	res.writeHead(status, {
+		"content-type": "text/html; charset=utf-8",
+		"cache-control": "no-store"
+	});
+	res.end(page(ok));
+}
+/**
+* Opens the listener pair for one flow. Rejects with `CallbackPortInUse`
+* when either address is taken, closing whichever one had opened.
+*/
+async function openCallback(port, state) {
+	const servers = [];
+	let bound = port;
+	try {
+		const v4 = await listen(port, "127.0.0.1");
+		servers.push(v4);
+		bound = v4.address().port;
+		try {
+			servers.push(await listen(bound, "::1"));
+		} catch (error) {
+			const code = error.code;
+			if (code !== "EADDRNOTAVAIL" && code !== "EAFNOSUPPORT") throw error;
+		}
+	} catch (error) {
+		for (const server of servers) server.close();
+		if (error.code === "EADDRINUSE") throw new CallbackPortInUse(bound);
+		throw error;
+	}
+	let settle = () => {};
+	const result = new Promise((resolve) => {
+		settle = resolve;
+	});
+	let waiting;
+	let taken = false;
+	const handle = (req, res) => {
+		const url = new URL(req.url ?? "/", `http://localhost:${String(bound)}`);
+		if (req.method !== "GET" || url.pathname !== "/auth/callback") {
+			res.writeHead(404).end();
+			return;
+		}
+		if (url.searchParams.get("state") !== state || taken) {
+			respond(res, 400, false);
+			return;
+		}
+		taken = true;
+		const error = url.searchParams.get("error");
+		const code = url.searchParams.get("code");
+		if (error !== null || code === null || code === "") {
+			respond(res, 200, false);
+			settle({
+				kind: "error",
+				error: error !== null && /^[a-z_]{1,64}$/.test(error) ? error : "error"
+			});
+			return;
+		}
+		waiting = res;
+		settle({
+			kind: "code",
+			code
+		});
+	};
+	for (const server of servers) server.on("request", handle);
+	let closed = false;
+	return {
+		port: bound,
+		result,
+		finish(ok) {
+			if (closed) return;
+			closed = true;
+			if (waiting !== void 0) respond(waiting, 200, ok);
+			for (const server of servers) {
+				server.close();
+				server.closeAllConnections();
+			}
+		}
+	};
+}
+//#endregion
+//#region src/login.ts
+/**
+* The two ways a ChatGPT account signs in.
+*
+* Browser: a loopback listener waits for the authorization page to send the
+* person back with a code. Device code: the person types a code at an
+* address on any device, and this side polls until the account confirms it.
+* Both end in the same token exchange and the same stored shape.
+*
+* The host owns each flow's life — its deadline, its cancellation, where the
+* result goes — and hands that over as the `signal`. What this module owns is
+* the one process-wide listener: its port is fixed, so a second browser
+* sign-in while one waits is refused rather than queued.
+*/
+function resultOf(tokens) {
+	return {
+		credential: JSON.stringify(tokens),
+		account: tokens.account,
+		refreshAfter: refreshAfterOf(tokens)
+	};
+}
+function aborted(signal) {
+	return new Promise((_, reject) => {
+		const fail = () => reject(new LoginFailure("cancelled"));
+		if (signal.aborted) fail();
+		else signal.addEventListener("abort", fail, { once: true });
+	});
+}
+function createLogin(deps) {
+	let listening = false;
+	async function browser(signal) {
+		if (listening) throw new Error("another ChatGPT sign-in is in progress; finish or cancel it, or use device code sign-in");
+		const codes = pkce();
+		const state = newState();
+		listening = true;
+		let callback;
+		try {
+			callback = await openCallback(deps.callbackPort, state);
+		} catch (error) {
+			listening = false;
+			if (error instanceof CallbackPortInUse) throw new Error(`port ${String(deps.callbackPort)} is in use (another ChatGPT sign-in, such as the Codex CLI, may be running); use device code sign-in instead`);
+			throw error;
+		}
+		const redirectUri = `http://localhost:${String(callback.port)}${CALLBACK_PATH}`;
+		const completion = (async () => {
+			try {
+				const answer = await Promise.race([callback.result, aborted(signal)]);
+				if (answer.kind === "error") throw new LoginFailure("declined", answer.error);
+				const tokens = await exchangeCode(deps.fetch, deps.endpoints, {
+					code: answer.code,
+					verifier: codes.verifier,
+					redirectUri
+				}, deps.now, signal);
+				callback.finish(true);
+				return resultOf(tokens);
+			} catch (error) {
+				callback.finish(false);
+				throw error;
+			} finally {
+				listening = false;
+			}
+		})();
+		completion.catch(() => {});
+		return {
+			url: authorizeUrl(deps.endpoints, redirectUri, codes, state),
+			completion
+		};
+	}
+	async function device(signal) {
+		const headers = {
+			"content-type": "application/json",
+			"user-agent": deps.userAgent
+		};
+		let response;
+		try {
+			response = await deps.fetch(`${deps.endpoints.issuer}/api/accounts/deviceauth/usercode`, {
+				method: "POST",
+				headers,
+				body: JSON.stringify({ client_id: CLIENT_ID }),
+				signal
+			});
+		} catch {
+			throw new Error("could not start device code sign-in (unreachable)");
+		}
+		if (!response.ok) throw new Error(`could not start device code sign-in (HTTP ${String(response.status)})`);
+		const started = await response.json().catch(() => ({}));
+		const deviceAuthId = started.device_auth_id;
+		const userCode = started.user_code;
+		if (typeof deviceAuthId !== "string" || typeof userCode !== "string") throw new Error("could not start device code sign-in (unreadable answer)");
+		const named = Number(started.interval);
+		const interval = (Number.isFinite(named) && named >= 0 ? named : 5) * 1e3 + deps.pollMarginMs;
+		const completion = (async () => {
+			for (;;) {
+				await Promise.race([setTimeout(interval, void 0, { signal }), aborted(signal)]).catch(() => {
+					throw new LoginFailure("cancelled");
+				});
+				let poll;
+				try {
+					poll = await deps.fetch(`${deps.endpoints.issuer}/api/accounts/deviceauth/token`, {
+						method: "POST",
+						headers,
+						body: JSON.stringify({
+							device_auth_id: deviceAuthId,
+							user_code: userCode
+						}),
+						signal
+					});
+				} catch {
+					if (signal.aborted) throw new LoginFailure("cancelled");
+					continue;
+				}
+				if (poll.status === 403 || poll.status === 404) continue;
+				if (!poll.ok) throw new LoginFailure("device-failed", `HTTP ${String(poll.status)}`);
+				const granted = await poll.json().catch(() => ({}));
+				if (typeof granted.authorization_code !== "string" || typeof granted.code_verifier !== "string") throw new LoginFailure("device-failed", "unreadable answer");
+				return resultOf(await exchangeCode(deps.fetch, deps.endpoints, {
+					code: granted.authorization_code,
+					verifier: granted.code_verifier,
+					redirectUri: `${deps.endpoints.issuer}/deviceauth/callback`
+				}, deps.now, signal));
+			}
+		})();
+		completion.catch(() => {});
+		return {
+			url: `${deps.endpoints.issuer}/codex/device`,
+			userCode,
+			completion
+		};
+	}
+	return {
+		async refresh(credential, signal) {
+			const before = parseStored(credential);
+			if (before === void 0) throw new LoginFailure("expired");
+			const outcome = await refreshTokens(deps.fetch, deps.endpoints, before, deps.now, signal);
+			if (outcome.kind === "refused") throw new LoginFailure("expired");
+			if (outcome.kind === "failed") throw new LoginFailure("exchange-failed", outcome.detail);
+			return resultOf(outcome.tokens);
+		},
+		methods: [{
+			id: "browser",
+			label: "Sign in with a browser",
+			kind: "browser"
+		}, {
+			id: "device",
+			label: "Sign in with a device code",
+			kind: "device"
+		}],
+		begin(method, signal) {
+			if (method === "browser") return browser(signal);
+			if (method === "device") return device(signal);
+			return Promise.reject(/* @__PURE__ */ new Error(`no sign-in method "${method}"`));
+		}
+	};
+}
+//#endregion
+//#region src/type.ts
+/** Stable subscription supplier identity. */
+const TYPE = "chatgpt";
+/** Host-managed sealed login field. */
+const LOGIN_FIELD = "account";
+/** Declares login and subscription access while the protocol owns concrete model calls. */
+function chatgptProviderType(fetch, options = {}, support) {
+	return {
+		type: TYPE,
+		label: "ChatGPT subscription",
+		fields: [{
+			key: LOGIN_FIELD,
+			kind: "login",
+			label: "ChatGPT account",
+			required: true
+		}],
+		endpoints: [{
+			id: "subscription",
+			label: "ChatGPT subscription",
+			capabilities: {
+				chat: {
+					protocolIds: ["chatgpt-subscription"],
+					defaultProtocolId: "chatgpt-subscription"
+				},
+				image: {
+					protocolIds: ["chatgpt-subscription"],
+					defaultProtocolId: "chatgpt-subscription"
+				}
+			}
+		}],
+		login: createLogin({
+			fetch,
+			endpoints: options.endpoints ?? ENDPOINTS,
+			now: options.now ?? Date.now,
+			callbackPort: options.callbackPort ?? 1455,
+			pollMarginMs: options.pollMarginMs ?? 3e3,
+			userAgent: "yaoguang"
+		}),
+		catalog: support ? {
+			...catalog,
+			source: support.catalogueSource("https://models.dev/api.json", "models")
+		} : catalog
+	};
+}
+//#endregion
+//#region src/index.ts
+const plugin = {
+	name: "@eum-agent/llm-provider-chatgpt",
+	requires: [
+		"model-catalogue-sources",
+		"network",
+		"openai-responses-codec",
+		"file-media"
+	],
+	optionalServices: ["model-support"],
+	apply(ctx) {
+		const support = lazySupport(() => ctx.services.find("model-support"));
+		const catalogue = ctx.services.get("model-catalogue-sources");
+		const network = ctx.services.get("network");
+		ctx.modelProtocols.register(chatgptProtocolType(support, network.fetch, ctx.services.get("openai-responses-codec"), {}, ctx.services.get("file-media").imageInfo));
+		ctx.modelProviders.register(chatgptProviderType(network.fetch, {}, catalogue));
+	}
+};
+//#endregion
+export { plugin as default };