@openai-oauth/core 2.0.0-beta.0

package/dist/state.js

@@ -0,0 +1,154 @@
+const MAX_ITEM_CACHE_SIZE = 2_000;
+const MAX_RESPONSE_CACHE_SIZE = 256;
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const cloneValue = (value) => structuredClone(value);
+const trimOldestEntries = (map, maxEntries) => {
+    while (map.size > maxEntries) {
+        const oldestKey = map.keys().next().value;
+        if (oldestKey == null) {
+            break;
+        }
+        map.delete(oldestKey);
+    }
+};
+export class CodexResponsesState {
+    items = new Map();
+    responses = new Map();
+    pendingCaptures = new Set();
+    onChange;
+    constructor(options = {}) {
+        this.onChange = options.onChange;
+        for (const entry of options.snapshot?.items ?? []) {
+            if (typeof entry.id !== "string") {
+                continue;
+            }
+            this.items.set(entry.id, cloneValue(entry.item));
+        }
+        for (const entry of options.snapshot?.responses ?? []) {
+            if (typeof entry.id !== "string") {
+                continue;
+            }
+            this.responses.set(entry.id, {
+                input: entry.input.map((item) => cloneValue(item)),
+                output: entry.output.map((item) => cloneValue(item)),
+            });
+        }
+        trimOldestEntries(this.items, MAX_ITEM_CACHE_SIZE);
+        trimOldestEntries(this.responses, MAX_RESPONSE_CACHE_SIZE);
+    }
+    async waitForPendingCaptures() {
+        if (this.pendingCaptures.size === 0) {
+            return;
+        }
+        await Promise.allSettled([...this.pendingCaptures]);
+    }
+    trackPendingCapture(promise) {
+        this.pendingCaptures.add(promise);
+        void promise.finally(() => {
+            this.pendingCaptures.delete(promise);
+        });
+    }
+    requiresCachedState(body) {
+        if (typeof body.previous_response_id === "string") {
+            return true;
+        }
+        if (!Array.isArray(body.input)) {
+            return false;
+        }
+        return body.input.some((item) => isRecord(item) &&
+            item.type === "item_reference" &&
+            typeof item.id === "string");
+    }
+    expandRequestBody(body) {
+        const nextBody = { ...body };
+        const previousResponseId = typeof body.previous_response_id === "string"
+            ? body.previous_response_id
+            : undefined;
+        const previousHistory = previousResponseId == null
+            ? undefined
+            : this.responses.get(previousResponseId);
+        const directInput = Array.isArray(body.input)
+            ? this.expandInput(body.input)
+            : body.input;
+        if (previousHistory != null) {
+            nextBody.input = [
+                ...cloneValue(previousHistory.input),
+                ...cloneValue(previousHistory.output),
+                ...(Array.isArray(directInput) ? directInput : []),
+            ];
+            delete nextBody.previous_response_id;
+            return nextBody;
+        }
+        if (Array.isArray(directInput)) {
+            nextBody.input = directInput;
+        }
+        return nextBody;
+    }
+    rememberResponse(response, requestBody) {
+        if (!isRecord(response)) {
+            return;
+        }
+        let changed = false;
+        const responseId = typeof response.id === "string" ? response.id : undefined;
+        const output = Array.isArray(response.output)
+            ? response.output.filter(isRecord).map((item) => cloneValue(item))
+            : [];
+        for (const item of output) {
+            if (typeof item.id !== "string") {
+                continue;
+            }
+            this.items.delete(item.id);
+            this.items.set(item.id, item);
+            changed = true;
+        }
+        trimOldestEntries(this.items, MAX_ITEM_CACHE_SIZE);
+        if (responseId == null || requestBody == null) {
+            if (changed) {
+                this.emitChange();
+            }
+            return;
+        }
+        const input = Array.isArray(requestBody.input)
+            ? requestBody.input.map((item) => cloneValue(item))
+            : [];
+        this.responses.delete(responseId);
+        this.responses.set(responseId, {
+            input,
+            output,
+        });
+        changed = true;
+        trimOldestEntries(this.responses, MAX_RESPONSE_CACHE_SIZE);
+        if (changed) {
+            this.emitChange();
+        }
+    }
+    snapshot() {
+        return {
+            items: [...this.items.entries()].map(([id, item]) => ({
+                id,
+                item: cloneValue(item),
+            })),
+            responses: [...this.responses.entries()].map(([id, response]) => ({
+                id,
+                input: response.input.map((item) => cloneValue(item)),
+                output: response.output.map((item) => cloneValue(item)),
+            })),
+        };
+    }
+    expandInput(input) {
+        return input.map((item) => {
+            if (isRecord(item) &&
+                item.type === "item_reference" &&
+                typeof item.id === "string") {
+                const cachedItem = this.items.get(item.id);
+                if (cachedItem != null) {
+                    return cloneValue(cachedItem);
+                }
+            }
+            return cloneValue(item);
+        });
+    }
+    emitChange() {
+        this.onChange?.(this.snapshot());
+    }
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+	"name": "@openai-oauth/core",
+	"version": "2.0.0-beta.0",
+	"description": "Core auth and in-memory OpenAI-compatible transport for openai-oauth.",
+	"keywords": [
+		"openai",
+		"oauth",
+		"chatgpt",
+		"codex",
+		"transport"
+	],
+	"type": "module",
+	"sideEffects": false,
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"default": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist",
+		"README.md",
+		"LICENSE"
+	],
+	"scripts": {
+		"build": "tsc -p tsconfig.build.json",
+		"prepublishOnly": "bun run build",
+		"typecheck": "tsc --noEmit",
+		"test": "vitest run"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"dependencies": {
+		"@ai-sdk/provider-utils": "4.0.19"
+	},
+	"devDependencies": {
+		"@types/node": "20.17.24",
+		"typescript": "latest",
+		"vitest": "latest"
+	},
+	"author": "EvanZhouDev",
+	"license": "AGPL-3.0-only",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/EvanZhouDev/openai-oauth.git",
+		"directory": "packages/core"
+	},
+	"bugs": {
+		"url": "https://github.com/EvanZhouDev/openai-oauth/issues"
+	},
+	"homepage": "https://github.com/EvanZhouDev/openai-oauth#readme"
+}