@moxxy/plugin-provider-openai-codex 0.21.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Moxxy (moxxy.ai)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/codex/headers.d.ts

@@ -0,0 +1,5 @@
+import type { CodexTokens } from '../types.js';
+export declare const PLUGIN_VERSION: string;
+export declare const CODEX_USER_AGENT: string;
+export declare function buildCodexHeaders(tokens: CodexTokens, sessionId: string): Record<string, string>;
+//# sourceMappingURL=headers.d.ts.map

package/dist/codex/headers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headers.d.ts","sourceRoot":"","sources":["../../src/codex/headers.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAuB/C,eAAO,MAAM,cAAc,QAAyB,CAAC;AAErD,eAAO,MAAM,gBAAgB,QAAoC,CAAC;AAElE,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAWhG"}

package/dist/codex/headers.js

@@ -0,0 +1,39 @@
+import { createRequire } from 'node:module';
+import { ORIGINATOR } from '../oauth.js';
+/**
+ * Resolve this plugin's real version from its package.json once at module load
+ * rather than freezing a stale literal in two places (the UA and the plugin
+ * def). The User-Agent is sent on every request to the ChatGPT backend; a
+ * permanently-`0.0.0` UA defeats server-side version gating and diverges from
+ * the real release. Resolves correctly when the package runs from its own dist
+ * (dev, tests, third-party `~/.moxxy/plugins` installs); falls back to `0.0.0`
+ * defensively — never throws on a header build. (NOTE: when inlined into the
+ * single-file CLI bundle the relative resolve fails and we keep the `0.0.0`
+ * fallback; a build-time constant would close that gap — see TECH_DEBT.)
+ */
+function resolvePluginVersion() {
+    try {
+        const require = createRequire(import.meta.url);
+        const pkg = require('../../package.json');
+        return typeof pkg.version === 'string' && pkg.version ? pkg.version : '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+export const PLUGIN_VERSION = resolvePluginVersion();
+export const CODEX_USER_AGENT = `moxxy/${PLUGIN_VERSION} (codex)`;
+export function buildCodexHeaders(tokens, sessionId) {
+    const headers = {
+        'Content-Type': 'application/json',
+        Accept: 'text/event-stream',
+        Authorization: `Bearer ${tokens.access}`,
+        originator: ORIGINATOR,
+        'User-Agent': CODEX_USER_AGENT,
+        session_id: sessionId,
+    };
+    if (tokens.accountId)
+        headers['ChatGPT-Account-Id'] = tokens.accountId;
+    return headers;
+}
+//# sourceMappingURL=headers.js.map

package/dist/codex/headers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"headers.js","sourceRoot":"","sources":["../../src/codex/headers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAGzC;;;;;;;;;;GAUG;AACH,SAAS,oBAAoB;IAC3B,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC/C,MAAM,GAAG,GAAG,OAAO,CAAC,oBAAoB,CAA0B,CAAC;QACnE,OAAO,OAAO,GAAG,CAAC,OAAO,KAAK,QAAQ,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC;IAChF,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,OAAO,CAAC;IACjB,CAAC;AACH,CAAC;AAED,MAAM,CAAC,MAAM,cAAc,GAAG,oBAAoB,EAAE,CAAC;AAErD,MAAM,CAAC,MAAM,gBAAgB,GAAG,SAAS,cAAc,UAAU,CAAC;AAElE,MAAM,UAAU,iBAAiB,CAAC,MAAmB,EAAE,SAAiB;IACtE,MAAM,OAAO,GAA2B;QACtC,cAAc,EAAE,kBAAkB;QAClC,MAAM,EAAE,mBAAmB;QAC3B,aAAa,EAAE,UAAU,MAAM,CAAC,MAAM,EAAE;QACxC,UAAU,EAAE,UAAU;QACtB,YAAY,EAAE,gBAAgB;QAC9B,UAAU,EAAE,SAAS;KACtB,CAAC;IACF,IAAI,MAAM,CAAC,SAAS;QAAE,OAAO,CAAC,oBAAoB,CAAC,GAAG,MAAM,CAAC,SAAS,CAAC;IACvE,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/codex/sse-event-handler.d.ts

@@ -0,0 +1,16 @@
+import { type PendingFunctionCall, type ResponsesSseEvent, type SseStepResult } from './stream-types.js';
+/**
+ * Map a single Responses-API SSE event to zero or more moxxy ProviderEvents.
+ * Centralized here so the streaming loop stays a thin "read frame → call
+ * this → yield" structure and the event taxonomy is easy to test directly.
+ *
+ * Events we care about (subset of the full Responses API surface):
+ *   response.output_text.delta         → text_delta
+ *   response.output_item.added         → tool_use_start (if it's a function_call)
+ *   response.function_call_arguments.delta → tool_use_delta
+ *   response.function_call_arguments.done  → finalize tool_use_end
+ *   response.completed                 → message_end (sets stopReason)
+ *   response.failed / response.error   → error
+ */
+export declare function handleSseEvent(ev: ResponsesSseEvent, pending: Map<string, PendingFunctionCall>, emitReasoning?: boolean): SseStepResult;
+//# sourceMappingURL=sse-event-handler.d.ts.map

package/dist/codex/sse-event-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse-event-handler.d.ts","sourceRoot":"","sources":["../../src/codex/sse-event-handler.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,aAAa,EACnB,MAAM,mBAAmB,CAAC;AA2B3B;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAC5B,EAAE,EAAE,iBAAiB,EACrB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,EACzC,aAAa,UAAQ,GACpB,aAAa,CA0Hf"}

package/dist/codex/sse-event-handler.js

@@ -0,0 +1,155 @@
+import { parseToolArgs, } from './stream-types.js';
+/**
+ * Hard cap on a single tool call's accumulated argument text. `entry.args` grows
+ * by every `function_call_arguments.delta`; unlike the consumer's per-frame
+ * reassembly buffer (which shrinks once a frame is parsed), this accumulates
+ * ACROSS frames and is otherwise unbounded — a hostile stream of millions of
+ * small, individually-valid delta frames would grow it to OOM without ever
+ * tripping the frame-buffer cap. 16 MiB is far beyond any legitimate tool-call
+ * payload. Exceeding it is treated as a hostile stream (terminal error).
+ */
+const MAX_TOOL_ARGS_CHARS = 16 * 1024 * 1024;
+/**
+ * Hard cap on the number of concurrently-pending function calls. Each distinct
+ * `output_item.added` function_call seeds a `pending` entry that lives until its
+ * `.done` (or the post-stream flush); a hostile stream could emit unbounded
+ * distinct ids and never finish them, growing the Map without limit. No real
+ * turn fans out to anywhere near this many parallel tool calls.
+ */
+const MAX_PENDING_TOOL_CALLS = 1024;
+const TOOL_STREAM_LIMIT_ERROR = (what) => ({
+    events: [{ type: 'error', message: `Codex tool-call stream exceeded ${what} limit`, retryable: false }],
+    terminal: true,
+});
+/**
+ * Map a single Responses-API SSE event to zero or more moxxy ProviderEvents.
+ * Centralized here so the streaming loop stays a thin "read frame → call
+ * this → yield" structure and the event taxonomy is easy to test directly.
+ *
+ * Events we care about (subset of the full Responses API surface):
+ *   response.output_text.delta         → text_delta
+ *   response.output_item.added         → tool_use_start (if it's a function_call)
+ *   response.function_call_arguments.delta → tool_use_delta
+ *   response.function_call_arguments.done  → finalize tool_use_end
+ *   response.completed                 → message_end (sets stopReason)
+ *   response.failed / response.error   → error
+ */
+export function handleSseEvent(ev, pending, emitReasoning = false) {
+    const type = ev.type ?? '';
+    if (type === 'response.output_text.delta' && typeof ev.delta === 'string' && ev.delta) {
+        return { events: [{ type: 'text_delta', delta: ev.delta }] };
+    }
+    // Reasoning summary text (Codex requests `summary: 'auto'`) → reasoning_delta.
+    // The streamed summary is the visible "thinking" between tool calls. Gated on
+    // the per-provider reasoning toggle; off → discard as before.
+    if (emitReasoning && type === 'response.reasoning_summary_text.delta' && typeof ev.delta === 'string' && ev.delta) {
+        return { events: [{ type: 'reasoning_delta', delta: ev.delta }] };
+    }
+    // A `reasoning` output item carries the encrypted_content we must replay
+    // verbatim on the next request (Codex requests `include: ['reasoning.encrypted_content']`).
+    if (emitReasoning && type === 'response.output_item.added' && ev.item?.type === 'reasoning') {
+        return ev.item.encrypted_content
+            ? { events: [{ type: 'reasoning_signature', encrypted: ev.item.encrypted_content }] }
+            : {};
+    }
+    if (type === 'response.output_item.added' && ev.item?.type === 'function_call') {
+        const id = ev.item.id ?? ev.item.call_id ?? `call_${pending.size}`;
+        // Bound the number of in-flight tool calls: a hostile stream could otherwise
+        // seed unbounded distinct ids and never `.done` them, growing the Map to OOM.
+        // (A new id that would overflow is rejected; re-using an existing id is fine.)
+        if (!pending.has(id) && pending.size >= MAX_PENDING_TOOL_CALLS) {
+            return TOOL_STREAM_LIMIT_ERROR('pending-call count');
+        }
+        const callId = ev.item.call_id ?? id;
+        const name = ev.item.name ?? '';
+        const entry = {
+            id,
+            callId,
+            name,
+            args: ev.item.arguments ?? '',
+            emittedStart: false,
+        };
+        pending.set(id, entry);
+        if (name) {
+            entry.emittedStart = true;
+            return { events: [{ type: 'tool_use_start', id: callId, name }] };
+        }
+        return {};
+    }
+    if (type === 'response.function_call_arguments.delta') {
+        const id = ev.item_id ?? ev.call_id ?? '';
+        const entry = pending.get(id);
+        const delta = ev.delta ?? '';
+        if (entry && typeof delta === 'string') {
+            // Bound the per-call argument accumulation: this grows across frames and
+            // is not covered by the consumer's per-frame reassembly cap.
+            if (entry.args.length + delta.length > MAX_TOOL_ARGS_CHARS) {
+                return TOOL_STREAM_LIMIT_ERROR('argument size');
+            }
+            entry.args += delta;
+            const outId = entry.callId || entry.id;
+            // If we hadn't emitted tool_use_start yet (server sent the args
+            // before the item.added with a name), do so now using whatever
+            // name landed later. Defensive — opencode's pattern.
+            const startEvents = [];
+            if (!entry.emittedStart && entry.name) {
+                entry.emittedStart = true;
+                startEvents.push({ type: 'tool_use_start', id: outId, name: entry.name });
+            }
+            return {
+                events: [...startEvents, { type: 'tool_use_delta', id: outId, partialInput: delta }],
+            };
+        }
+        return {};
+    }
+    if (type === 'response.function_call_arguments.done') {
+        const id = ev.item_id ?? ev.call_id ?? '';
+        const entry = pending.get(id);
+        if (!entry)
+            return {};
+        pending.delete(id);
+        if (typeof ev.arguments === 'string' && ev.arguments)
+            entry.args = ev.arguments;
+        const input = parseToolArgs(entry.args);
+        const outId = entry.callId || entry.id;
+        const events = [];
+        if (!entry.emittedStart && entry.name) {
+            events.push({ type: 'tool_use_start', id: outId, name: entry.name });
+        }
+        events.push({ type: 'tool_use_end', id: outId, input });
+        return { events };
+    }
+    if (type === 'response.completed') {
+        const usage = ev.response?.usage;
+        const input = usage?.input_tokens ?? 0;
+        const cacheRead = usage?.input_tokens_details?.cached_tokens ?? 0;
+        const incomplete = ev.response?.incomplete_details?.reason;
+        let stopReason = 'end_turn';
+        if (incomplete === 'max_output_tokens')
+            stopReason = 'max_tokens';
+        else if (incomplete === 'stop_sequence')
+            stopReason = 'stop_sequence';
+        // The presence of unflushed function calls would already get mapped to
+        // tool_use by the post-loop logic; the explicit "completed" event
+        // doesn't carry a tool_use stop reason on its own.
+        return {
+            stopReason,
+            ...(usage
+                ? {
+                    usage: {
+                        input: Math.max(0, input - cacheRead),
+                        output: usage.output_tokens ?? 0,
+                        ...(usage.input_tokens_details?.cached_tokens !== undefined ? { cacheRead } : {}),
+                    },
+                }
+                : {}),
+            terminal: true,
+        };
+    }
+    if (type === 'response.failed' || type === 'response.error' || type === 'error') {
+        const msg = ev.error?.message ?? `Codex stream failed: ${type}`;
+        return { events: [{ type: 'error', message: msg, retryable: false }], terminal: true };
+    }
+    return {};
+}
+//# sourceMappingURL=sse-event-handler.js.map

package/dist/codex/sse-event-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse-event-handler.js","sourceRoot":"","sources":["../../src/codex/sse-event-handler.ts"],"names":[],"mappings":"AACA,OAAO,EACL,aAAa,GAId,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;;GAQG;AACH,MAAM,mBAAmB,GAAG,EAAE,GAAG,IAAI,GAAG,IAAI,CAAC;AAE7C;;;;;;GAMG;AACH,MAAM,sBAAsB,GAAG,IAAI,CAAC;AAEpC,MAAM,uBAAuB,GAAG,CAAC,IAAY,EAAiB,EAAE,CAAC,CAAC;IAChE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,mCAAmC,IAAI,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;IACvG,QAAQ,EAAE,IAAI;CACf,CAAC,CAAC;AAEH;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,cAAc,CAC5B,EAAqB,EACrB,OAAyC,EACzC,aAAa,GAAG,KAAK;IAErB,MAAM,IAAI,GAAG,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC;IAE3B,IAAI,IAAI,KAAK,4BAA4B,IAAI,OAAO,EAAE,CAAC,KAAK,KAAK,QAAQ,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC;QACtF,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC;IAC/D,CAAC;IAED,+EAA+E;IAC/E,8EAA8E;IAC9E,8DAA8D;IAC9D,IAAI,aAAa,IAAI,IAAI,KAAK,uCAAuC,IAAI,OAAO,EAAE,CAAC,KAAK,KAAK,QAAQ,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC;QAClH,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,iBAAiB,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC;IACpE,CAAC;IAED,yEAAyE;IACzE,4FAA4F;IAC5F,IAAI,aAAa,IAAI,IAAI,KAAK,4BAA4B,IAAI,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,WAAW,EAAE,CAAC;QAC5F,OAAO,EAAE,CAAC,IAAI,CAAC,iBAAiB;YAC9B,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,qBAAqB,EAAE,SAAS,EAAE,EAAE,CAAC,IAAI,CAAC,iBAAiB,EAAE,CAAC,EAAE;YACrF,CAAC,CAAC,EAAE,CAAC;IACT,CAAC;IAED,IAAI,IAAI,KAAK,4BAA4B,IAAI,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,eAAe,EAAE,CAAC;QAC/E,MAAM,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC,IAAI,CAAC,OAAO,IAAI,QAAQ,OAAO,CAAC,IAAI,EAAE,CAAC;QACnE,6EAA6E;QAC7E,8EAA8E;QAC9E,+EAA+E;QAC/E,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,OAAO,CAAC,IAAI,IAAI,sBAAsB,EAAE,CAAC;YAC/D,OAAO,uBAAuB,CAAC,oBAAoB,CAAC,CAAC;QACvD,CAAC;QACD,MAAM,MAAM,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,IAAI,EAAE,CAAC;QACrC,MAAM,IAAI,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC;QAChC,MAAM,KAAK,GAAwB;YACjC,EAAE;YACF,MAAM;YACN,IAAI;YACJ,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,IAAI,EAAE;YAC7B,YAAY,EAAE,KAAK;SACpB,CAAC;QACF,OAAO,CAAC,GAAG,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;QACvB,IAAI,IAAI,EAAE,CAAC;YACT,KAAK,CAAC,YAAY,GAAG,IAAI,CAAC;YAC1B,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,gBAAgB,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC;QACpE,CAAC;QACD,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,IAAI,IAAI,KAAK,wCAAwC,EAAE,CAAC;QACtD,MAAM,EAAE,GAAG,EAAE,CAAC,OAAO,IAAI,EAAE,CAAC,OAAO,IAAI,EAAE,CAAC;QAC1C,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAC9B,MAAM,KAAK,GAAG,EAAE,CAAC,KAAK,IAAI,EAAE,CAAC;QAC7B,IAAI,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YACvC,yEAAyE;YACzE,6DAA6D;YAC7D,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,mBAAmB,EAAE,CAAC;gBAC3D,OAAO,uBAAuB,CAAC,eAAe,CAAC,CAAC;YAClD,CAAC;YACD,KAAK,CAAC,IAAI,IAAI,KAAK,CAAC;YACpB,MAAM,KAAK,GAAG,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,EAAE,CAAC;YACvC,gEAAgE;YAChE,+DAA+D;YAC/D,qDAAqD;YACrD,MAAM,WAAW,GAAoB,EAAE,CAAC;YACxC,IAAI,CAAC,KAAK,CAAC,YAAY,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;gBACtC,KAAK,CAAC,YAAY,GAAG,IAAI,CAAC;gBAC1B,WAAW,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,gBAAgB,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;YAC5E,CAAC;YACD,OAAO;gBACL,MAAM,EAAE,CAAC,GAAG,WAAW,EAAE,EAAE,IAAI,EAAE,gBAAgB,EAAE,EAAE,EAAE,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,CAAC;aACrF,CAAC;QACJ,CAAC;QACD,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,IAAI,IAAI,KAAK,uCAAuC,EAAE,CAAC;QACrD,MAAM,EAAE,GAAG,EAAE,CAAC,OAAO,IAAI,EAAE,CAAC,OAAO,IAAI,EAAE,CAAC;QAC1C,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAC9B,IAAI,CAAC,KAAK;YAAE,OAAO,EAAE,CAAC;QACtB,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QACnB,IAAI,OAAO,EAAE,CAAC,SAAS,KAAK,QAAQ,IAAI,EAAE,CAAC,SAAS;YAAE,KAAK,CAAC,IAAI,GAAG,EAAE,CAAC,SAAS,CAAC;QAChF,MAAM,KAAK,GAAG,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACxC,MAAM,KAAK,GAAG,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,EAAE,CAAC;QACvC,MAAM,MAAM,GAAoB,EAAE,CAAC;QACnC,IAAI,CAAC,KAAK,CAAC,YAAY,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;YACtC,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,gBAAgB,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;QACvE,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;QACxD,OAAO,EAAE,MAAM,EAAE,CAAC;IACpB,CAAC;IAED,IAAI,IAAI,KAAK,oBAAoB,EAAE,CAAC;QAClC,MAAM,KAAK,GAAG,EAAE,CAAC,QAAQ,EAAE,KAAK,CAAC;QACjC,MAAM,KAAK,GAAG,KAAK,EAAE,YAAY,IAAI,CAAC,CAAC;QACvC,MAAM,SAAS,GAAG,KAAK,EAAE,oBAAoB,EAAE,aAAa,IAAI,CAAC,CAAC;QAClE,MAAM,UAAU,GAAG,EAAE,CAAC,QAAQ,EAAE,kBAAkB,EAAE,MAAM,CAAC;QAC3D,IAAI,UAAU,GAAe,UAAU,CAAC;QACxC,IAAI,UAAU,KAAK,mBAAmB;YAAE,UAAU,GAAG,YAAY,CAAC;aAC7D,IAAI,UAAU,KAAK,eAAe;YAAE,UAAU,GAAG,eAAe,CAAC;QACtE,uEAAuE;QACvE,kEAAkE;QAClE,mDAAmD;QACnD,OAAO;YACL,UAAU;YACV,GAAG,CAAC,KAAK;gBACP,CAAC,CAAC;oBACE,KAAK,EAAE;wBACL,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;wBACrC,MAAM,EAAE,KAAK,CAAC,aAAa,IAAI,CAAC;wBAChC,GAAG,CAAC,KAAK,CAAC,oBAAoB,EAAE,aAAa,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;qBAClF;iBACF;gBACH,CAAC,CAAC,EAAE,CAAC;YACP,QAAQ,EAAE,IAAI;SACf,CAAC;IACJ,CAAC;IAED,IAAI,IAAI,KAAK,iBAAiB,IAAI,IAAI,KAAK,gBAAgB,IAAI,IAAI,KAAK,OAAO,EAAE,CAAC;QAChF,MAAM,GAAG,GAAG,EAAE,CAAC,KAAK,EAAE,OAAO,IAAI,wBAAwB,IAAI,EAAE,CAAC;QAChE,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;IACzF,CAAC;IAED,OAAO,EAAE,CAAC;AACZ,CAAC"}

package/dist/codex/stream-consumer.d.ts

@@ -0,0 +1,4 @@
+import { type ProviderEvent } from '@moxxy/sdk';
+export declare function toErrorEvent(err: unknown): ProviderEvent;
+export declare function consumeResponsesSse(body: ReadableStream<Uint8Array>, signal: AbortSignal | undefined, emitReasoning?: boolean, onActivity?: () => void): AsyncIterable<ProviderEvent>;
+//# sourceMappingURL=stream-consumer.d.ts.map

package/dist/codex/stream-consumer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-consumer.d.ts","sourceRoot":"","sources":["../../src/codex/stream-consumer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,aAAa,EAAmB,MAAM,YAAY,CAAC;AAKlF,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,aAAa,CAKxD;AASD,wBAAuB,mBAAmB,CACxC,IAAI,EAAE,cAAc,CAAC,UAAU,CAAC,EAChC,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,aAAa,UAAQ,EAGrB,UAAU,CAAC,EAAE,MAAM,IAAI,GACtB,aAAa,CAAC,aAAa,CAAC,CA0J9B"}

package/dist/codex/stream-consumer.js

@@ -0,0 +1,176 @@
+import { toFriendlyError } from '@moxxy/sdk';
+import { handleSseEvent } from './sse-event-handler.js';
+import { CODEX_RESPONSES_URL } from '../oauth.js';
+import { parseToolArgs } from './stream-types.js';
+export function toErrorEvent(err) {
+    return {
+        type: 'error',
+        ...toFriendlyError(err, { provider: 'openai-codex', url: CODEX_RESPONSES_URL }),
+    };
+}
+// Hard cap on the unparsed reassembly buffer. A misbehaving/MITM'd endpoint (or
+// a wedged proxy emitting a continuous body with no blank-line frame separator)
+// would otherwise grow `buffer` without bound until OOM, since it's only ever
+// truncated when a separator is found. 8 MiB is far larger than any legitimate
+// single SSE frame; exceeding it with no separator is treated as a hostile stream.
+const MAX_SSE_BUFFER_BYTES = 8 * 1024 * 1024;
+export async function* consumeResponsesSse(body, signal, emitReasoning = false, 
+// Called on every successful body read so the caller can reset an idle
+// watchdog (a stalled stream that stops sending bytes must not hang forever).
+onActivity) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder('utf-8');
+    let buffer = '';
+    const pending = new Map();
+    let stopReason = 'end_turn';
+    let usageIn = 0;
+    let usageOut = 0;
+    let usageCacheRead = 0;
+    // Tracks whether ANY tool_use_end was yielded during the stream.
+    // The Responses API's `response.completed` event doesn't differentiate
+    // text-only vs tool-use turns, so without this we'd report end_turn
+    // even when tools were requested — the upstream tool-use loop would
+    // then drop the calls without executing them.
+    let sawToolCall = false;
+    // Set when an error frame (response.failed/error) surfaced the failure, so
+    // we don't also flush tool calls / emit a normal message_end on top of it.
+    let errored = false;
+    try {
+        try {
+            outer: while (true) {
+                if (signal?.aborted) {
+                    yield { type: 'error', message: 'aborted', retryable: false };
+                    return;
+                }
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                onActivity?.();
+                buffer += decoder.decode(value, { stream: true });
+                // Bound the unparsed buffer: if it grows past the cap without yielding a
+                // single complete frame, the peer is feeding us an unframed/oversized
+                // body. Bail rather than accumulate to OOM. (The `finally` cancels the
+                // reader so the socket is released.)
+                if (buffer.length > MAX_SSE_BUFFER_BYTES) {
+                    yield {
+                        type: 'error',
+                        message: 'Codex stream frame exceeded size limit',
+                        retryable: false,
+                    };
+                    return;
+                }
+                // SSE frames are separated by blank lines. Some servers emit \r\n\r\n;
+                // match either form at the separator and line boundaries rather than
+                // rescanning the whole accumulated buffer with a global CRLF replace on
+                // every chunk. A `\r` split across two reads is handled because the
+                // boundary regexes tolerate the optional `\r`.
+                let m;
+                const sepRe = /\r?\n\r?\n/g;
+                while ((m = sepRe.exec(buffer)) !== null) {
+                    const frame = buffer.slice(0, m.index);
+                    buffer = buffer.slice(m.index + m[0].length);
+                    sepRe.lastIndex = 0;
+                    for (const line of frame.split(/\r?\n/)) {
+                        if (!line.startsWith('data:'))
+                            continue;
+                        const payload = line.slice(5).trimStart();
+                        if (!payload || payload === '[DONE]')
+                            continue;
+                        let json;
+                        try {
+                            json = JSON.parse(payload);
+                        }
+                        catch {
+                            continue;
+                        }
+                        const result = handleSseEvent(json, pending, emitReasoning);
+                        if (result.events) {
+                            for (const ev of result.events) {
+                                if (ev.type === 'tool_use_end')
+                                    sawToolCall = true;
+                                if (ev.type === 'error')
+                                    errored = true;
+                                yield ev;
+                            }
+                        }
+                        if (result.stopReason)
+                            stopReason = result.stopReason;
+                        if (result.usage) {
+                            usageIn = result.usage.input ?? usageIn;
+                            usageOut = result.usage.output ?? usageOut;
+                            usageCacheRead = result.usage.cacheRead ?? usageCacheRead;
+                        }
+                        // Terminal frame (response.completed / failed / error): stop
+                        // consuming. Honoring this prevents a failed turn from emitting
+                        // both an `error` AND a trailing `message_end`, and ignores any
+                        // stray frames after completion.
+                        if (result.terminal)
+                            break outer;
+                    }
+                }
+            }
+        }
+        catch (err) {
+            yield toErrorEvent(err);
+            return;
+        }
+        // The error frame already surfaced the failure; nothing more to emit. Drop
+        // any pending function calls so a later code path can't flush a phantom
+        // tool_use on top of a failed turn — the error supersedes them.
+        if (errored) {
+            pending.clear();
+            return;
+        }
+        // Flush any tool_call_end events that didn't have a matching .done frame
+        // (defensive — the server normally sends function_call.done, but a
+        // truncated stream shouldn't drop the entire tool-use sequence).
+        for (const entry of pending.values()) {
+            const outId = entry.callId || entry.id;
+            // If we have a name but never emitted the start (server sent args.delta
+            // for an item whose .added carried no name, then truncated before .done),
+            // emit the start first — mirrors the .done branch — so the call isn't
+            // dropped just because its start frame never landed.
+            if (!entry.emittedStart && entry.name) {
+                entry.emittedStart = true;
+                yield { type: 'tool_use_start', id: outId, name: entry.name };
+            }
+            if (entry.emittedStart) {
+                sawToolCall = true;
+                yield { type: 'tool_use_end', id: outId, input: parseToolArgs(entry.args) };
+            }
+            else if (process.env.MOXXY_DEBUG) {
+                // A pending function call that never carried a name and never started:
+                // we cannot synthesize a valid tool_use, so it is dropped — but make
+                // it observable rather than silently swallowed.
+                console.error(`[openai-codex] dropping a truncated function_call with no name (id=${outId}, args=${entry.args.length}B)`);
+            }
+        }
+        // If we yielded any tool_use_end this stream, the turn IS a tool-use
+        // turn regardless of what `response.completed` said. The Responses API
+        // sends `completed` with no stop_reason field, so we infer from the
+        // events we actually emitted. Without this upgrade, codex turns with
+        // tool calls were reported as end_turn and the loop dropped them.
+        if (stopReason === 'end_turn' && sawToolCall) {
+            stopReason = 'tool_use';
+        }
+        yield {
+            type: 'message_end',
+            stopReason,
+            ...(usageIn > 0 || usageOut > 0
+                ? {
+                    usage: {
+                        inputTokens: usageIn,
+                        outputTokens: usageOut,
+                        ...(usageCacheRead > 0 ? { cacheReadTokens: usageCacheRead } : {}),
+                    },
+                }
+                : {}),
+        };
+    }
+    finally {
+        // Always release the HTTP body — on normal completion, error, abort, or
+        // the consumer abandoning the stream early — so the socket isn't leaked.
+        reader.cancel().catch(() => { });
+    }
+}
+//# sourceMappingURL=stream-consumer.js.map

package/dist/codex/stream-consumer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-consumer.js","sourceRoot":"","sources":["../../src/codex/stream-consumer.ts"],"names":[],"mappings":"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"}

package/dist/codex/stream-types.d.ts

@@ -0,0 +1,61 @@
+import type { ProviderEvent, StopReason } from '@moxxy/sdk';
+export interface PendingFunctionCall {
+    id: string;
+    callId: string;
+    name: string;
+    args: string;
+    emittedStart: boolean;
+}
+export interface ResponsesSseEvent {
+    type?: string;
+    delta?: string;
+    item?: {
+        type?: string;
+        id?: string;
+        call_id?: string;
+        name?: string;
+        arguments?: string;
+        /** On a `reasoning` output item: the opaque blob to replay (round-trip). */
+        encrypted_content?: string;
+    };
+    item_id?: string;
+    call_id?: string;
+    name?: string;
+    arguments?: string;
+    response?: {
+        status?: string;
+        incomplete_details?: {
+            reason?: string;
+        };
+        usage?: {
+            input_tokens?: number;
+            output_tokens?: number;
+            input_tokens_details?: {
+                cached_tokens?: number;
+            };
+        };
+    };
+    error?: {
+        message?: string;
+    };
+}
+export interface SseStepResult {
+    events?: ProviderEvent[];
+    stopReason?: StopReason;
+    usage?: {
+        input?: number;
+        output?: number;
+        cacheRead?: number;
+    };
+    terminal?: boolean;
+}
+/**
+ * Parse accumulated function-call argument text into the tool input. The
+ * server normally sends well-formed JSON, but a truncated stream can leave
+ * partial JSON; rather than drop the call we surface the raw text under
+ * `_rawPartial` so the upstream loop still sees the tool request. Shared by
+ * the per-event handler (`function_call_arguments.done`) and the consumer's
+ * truncated-stream flush so the two stay in lockstep.
+ */
+export declare function parseToolArgs(args: string): unknown;
+//# sourceMappingURL=stream-types.d.ts.map

package/dist/codex/stream-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-types.d.ts","sourceRoot":"","sources":["../../src/codex/stream-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE5D,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE;QACL,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,4EAA4E;QAC5E,iBAAiB,CAAC,EAAE,MAAM,CAAC;KAC5B,CAAC;IACF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE;QACT,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,kBAAkB,CAAC,EAAE;YAAE,MAAM,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;QACzC,KAAK,CAAC,EAAE;YACN,YAAY,CAAC,EAAE,MAAM,CAAC;YACtB,aAAa,CAAC,EAAE,MAAM,CAAC;YACvB,oBAAoB,CAAC,EAAE;gBAAE,aAAa,CAAC,EAAE,MAAM,CAAA;aAAE,CAAC;SACnD,CAAC;KACH,CAAC;IACF,KAAK,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC9B;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,aAAa,EAAE,CAAC;IACzB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,KAAK,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAChE,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAOnD"}

package/dist/codex/stream-types.js

@@ -0,0 +1,19 @@
+/**
+ * Parse accumulated function-call argument text into the tool input. The
+ * server normally sends well-formed JSON, but a truncated stream can leave
+ * partial JSON; rather than drop the call we surface the raw text under
+ * `_rawPartial` so the upstream loop still sees the tool request. Shared by
+ * the per-event handler (`function_call_arguments.done`) and the consumer's
+ * truncated-stream flush so the two stay in lockstep.
+ */
+export function parseToolArgs(args) {
+    if (!args)
+        return {};
+    try {
+        return JSON.parse(args);
+    }
+    catch {
+        return { _rawPartial: args };
+    }
+}
+//# sourceMappingURL=stream-types.js.map

package/dist/codex/stream-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-types.js","sourceRoot":"","sources":["../../src/codex/stream-types.ts"],"names":[],"mappings":"AA6CA;;;;;;;GAOG;AACH,MAAM,UAAU,aAAa,CAAC,IAAY;IACxC,IAAI,CAAC,IAAI;QAAE,OAAO,EAAE,CAAC;IACrB,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC;IAC/B,CAAC;AACH,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export declare const openaiCodexProviderDef: import("@moxxy/sdk").ProviderDef;
+export declare const openaiCodexPlugin: import("@moxxy/sdk").Plugin;
+export default openaiCodexPlugin;
+export { CodexProvider } from './provider.js';
+export { codexModels, DEFAULT_CODEX_MODEL } from './models.js';
+export { CLIENT_ID, ISSUER, AUTHORIZE_URL, TOKEN_URL, CODEX_RESPONSES_URL, DEFAULT_CALLBACK_PORT, DEFAULT_REDIRECT_PATH, DEFAULT_REDIRECT_URI, SCOPES, ORIGINATOR, generatePKCE, generateState, buildAuthorizeUrl, parseJwtClaims, extractAccountId, exchangeCodeForTokens, refreshTokens, } from './oauth.js';
+export { CODEX_PROVIDER_ID, codexOauthProfile, } from './profile.js';
+export { codexLogin, codexLogout, codexStatus, ensureFreshCodexTokens, persistCodexTokens, readStoredTokens, readStoredTokens as readCodexStoredTokens, } from './login.js';
+export type { CodexProviderConfig } from './provider.js';
+export type { CodexTokens, PkceCodes, OAuthTokenResponse } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,sBAAsB,kCAajC,CAAC;AAEH,eAAO,MAAM,iBAAiB,6BAI5B,CAAC;AAEH,eAAe,iBAAiB,CAAC;AAEjC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAC/D,OAAO,EACL,SAAS,EACT,MAAM,EACN,aAAa,EACb,SAAS,EACT,mBAAmB,EACnB,qBAAqB,EACrB,qBAAqB,EACrB,oBAAoB,EACpB,MAAM,EACN,UAAU,EACV,YAAY,EACZ,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,gBAAgB,EAChB,qBAAqB,EACrB,aAAa,GACd,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,UAAU,EACV,WAAW,EACX,WAAW,EACX,sBAAsB,EACtB,kBAAkB,EAClB,gBAAgB,EAChB,gBAAgB,IAAI,qBAAqB,GAC1C,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACzD,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,31 @@
+import { defineProvider, definePlugin } from '@moxxy/sdk';
+import { CodexProvider } from './provider.js';
+import { codexModels } from './models.js';
+import { codexLogin, codexLogout, codexStatus } from './login.js';
+import { PLUGIN_VERSION } from './codex/headers.js';
+export const openaiCodexProviderDef = defineProvider({
+    name: 'openai-codex',
+    models: [...codexModels],
+    createClient: (config) => new CodexProvider(config),
+    // No validateKey: OAuth credentials are validated by the OAuth token
+    // exchange itself, not by a synchronous key check.
+    auth: {
+        kind: 'oauth',
+        serviceName: 'ChatGPT Pro/Plus',
+        login: codexLogin,
+        logout: codexLogout,
+        status: codexStatus,
+    },
+});
+export const openaiCodexPlugin = definePlugin({
+    name: '@moxxy/plugin-provider-openai-codex',
+    version: PLUGIN_VERSION,
+    providers: [openaiCodexProviderDef],
+});
+export default openaiCodexPlugin;
+export { CodexProvider } from './provider.js';
+export { codexModels, DEFAULT_CODEX_MODEL } from './models.js';
+export { CLIENT_ID, ISSUER, AUTHORIZE_URL, TOKEN_URL, CODEX_RESPONSES_URL, DEFAULT_CALLBACK_PORT, DEFAULT_REDIRECT_PATH, DEFAULT_REDIRECT_URI, SCOPES, ORIGINATOR, generatePKCE, generateState, buildAuthorizeUrl, parseJwtClaims, extractAccountId, exchangeCodeForTokens, refreshTokens, } from './oauth.js';
+export { CODEX_PROVIDER_ID, codexOauthProfile, } from './profile.js';
+export { codexLogin, codexLogout, codexStatus, ensureFreshCodexTokens, persistCodexTokens, readStoredTokens, readStoredTokens as readCodexStoredTokens, } from './login.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1D,OAAO,EAAE,aAAa,EAA4B,MAAM,eAAe,CAAC;AACxE,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEpD,MAAM,CAAC,MAAM,sBAAsB,GAAG,cAAc,CAAC;IACnD,IAAI,EAAE,cAAc;IACpB,MAAM,EAAE,CAAC,GAAG,WAAW,CAAC;IACxB,YAAY,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,aAAa,CAAC,MAA6B,CAAC;IAC1E,qEAAqE;IACrE,mDAAmD;IACnD,IAAI,EAAE;QACJ,IAAI,EAAE,OAAO;QACb,WAAW,EAAE,kBAAkB;QAC/B,KAAK,EAAE,UAAU;QACjB,MAAM,EAAE,WAAW;QACnB,MAAM,EAAE,WAAW;KACpB;CACF,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,iBAAiB,GAAG,YAAY,CAAC;IAC5C,IAAI,EAAE,qCAAqC;IAC3C,OAAO,EAAE,cAAc;IACvB,SAAS,EAAE,CAAC,sBAAsB,CAAC;CACpC,CAAC,CAAC;AAEH,eAAe,iBAAiB,CAAC;AAEjC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAC/D,OAAO,EACL,SAAS,EACT,MAAM,EACN,aAAa,EACb,SAAS,EACT,mBAAmB,EACnB,qBAAqB,EACrB,qBAAqB,EACrB,oBAAoB,EACpB,MAAM,EACN,UAAU,EACV,YAAY,EACZ,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,gBAAgB,EAChB,qBAAqB,EACrB,aAAa,GACd,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,UAAU,EACV,WAAW,EACX,WAAW,EACX,sBAAsB,EACtB,kBAAkB,EAClB,gBAAgB,EAChB,gBAAgB,IAAI,qBAAqB,GAC1C,MAAM,YAAY,CAAC"}