@cjhyy/code-shell-capability-coding 0.8.0

package/dist/quota/credentials.js

@@ -0,0 +1,80 @@
+/**
+ * Coding capability resolver for the tokens `quota/` needs.
+ *
+ * This is the ONE platform-specific file in the module — it reads a vendor's
+ * Keychain entry / auth.json. A host that stores secrets differently (or a
+ * future plugin) can bypass this and build QuotaCredentials itself; core logic
+ * in index.ts only depends on the QuotaCredentials shape.
+ *
+ * All reads are best-effort: a missing token yields `undefined`, never a throw,
+ * so a machine without Codex or without Keychain access degrades to "quota
+ * unavailable for that provider" instead of failing the whole call.
+ */
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function userHome() {
+    return process.env.HOME || process.env.USERPROFILE || homedir();
+}
+/** Read the Codex OAuth token + account id from ~/.codex/auth.json. */
+async function readCodexCreds() {
+    try {
+        const raw = await readFile(join(userHome(), ".codex", "auth.json"), "utf8");
+        const j = JSON.parse(raw);
+        const tokens = (j.tokens ?? {});
+        const token = typeof tokens.access_token === "string" ? tokens.access_token : undefined;
+        const acct = typeof tokens.account_id === "string" ? tokens.account_id : undefined;
+        return { codexAccessToken: token, codexAccountId: acct };
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Read the Claude Code OAuth access token.
+ * macOS: Keychain generic-password "Claude Code-credentials".
+ * Other platforms: fall back to a plaintext ~/.claude/.credentials.json if present.
+ */
+async function readClaudeCreds() {
+    // macOS Keychain first.
+    if (process.platform === "darwin") {
+        const raw = await runSecurity();
+        const token = parseClaudeToken(raw);
+        if (token)
+            return { claudeAccessToken: token };
+    }
+    // Cross-platform fallback: some installs keep a plaintext credentials file.
+    try {
+        const raw = await readFile(join(userHome(), ".claude", ".credentials.json"), "utf8");
+        const token = parseClaudeToken(raw);
+        if (token)
+            return { claudeAccessToken: token };
+    }
+    catch {
+        /* not present */
+    }
+    return {};
+}
+function parseClaudeToken(raw) {
+    if (!raw)
+        return undefined;
+    try {
+        const j = JSON.parse(raw);
+        const oauth = (j.claudeAiOauth ?? {});
+        return typeof oauth.accessToken === "string" ? oauth.accessToken : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function runSecurity() {
+    return new Promise((resolve) => {
+        execFile("security", ["find-generic-password", "-s", "Claude Code-credentials", "-w"], { timeout: 4000 }, (err, stdout) => resolve(err ? null : stdout.toString().trim()));
+    });
+}
+/** Resolve all tokens from their standard local locations. Never throws. */
+export async function resolveQuotaCredentials() {
+    const [codex, claude] = await Promise.all([readCodexCreds(), readClaudeCreds()]);
+    return { ...codex, ...claude };
+}

package/dist/quota/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Coding capability quota for external coding-agent CLIs.
+ *
+ * Both lookups are verified against the real backends (2026-07-01):
+ *   - Codex: GET https://chatgpt.com/backend-api/wham/usage → JSON
+ *            rate_limit.{primary_window,secondary_window}.{used_percent,reset_at}.
+ *            Zero cost (no message sent).
+ *   - Claude: POST /v1/messages (max_tokens:1) → response headers
+ *            anthropic-ratelimit-unified-{5h,7d}-{utilization,reset}.
+ *            Costs ~1 output token (Claude exposes quota only via response
+ *            headers — there is no standalone usage endpoint).
+ *
+ * The `fetch` and credentials are injected so this is unit-testable offline and
+ * so the host owns secret resolution (see types.ts boundary note).
+ */
+import type { ProviderQuota, QuotaCredentials, QuotaResult } from "./types.js";
+type FetchLike = typeof fetch;
+export interface CheckQuotaOptions {
+    creds: QuotaCredentials;
+    /** Restrict to specific providers; defaults to both. */
+    providers?: ("claude" | "codex")[];
+    /** Injected for tests; defaults to global fetch. */
+    fetchImpl?: FetchLike;
+    /** Caller's abort signal (user Stop); composed with an internal timeout. */
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+/** Codex: GET the usage endpoint and map its JSON to ProviderQuota. */
+export declare function queryCodexQuota(creds: QuotaCredentials, fetchImpl: FetchLike, signal: AbortSignal): Promise<ProviderQuota>;
+/** Claude: POST a 1-token probe and read the unified rate-limit headers. */
+export declare function queryClaudeQuota(creds: QuotaCredentials, fetchImpl: FetchLike, signal: AbortSignal): Promise<ProviderQuota>;
+/** Query both providers (or the subset requested), concurrently. */
+export declare function checkQuota(opts: CheckQuotaOptions): Promise<QuotaResult>;
+/** Render a QuotaResult as a compact human/agent-readable summary. */
+export declare function formatQuota(result: QuotaResult, nowSec: number): string;
+export {};

package/dist/quota/index.js

@@ -0,0 +1,161 @@
+const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+const CLAUDE_MESSAGES_URL = "https://api.anthropic.com/v1/messages";
+/** Cheapest always-available model for the 1-token probe. */
+const CLAUDE_PROBE_MODEL = "claude-haiku-4-5-20251001";
+const DEFAULT_TIMEOUT_MS = 8000;
+/** Compose the caller signal with a timeout so a hung backend can't block. */
+function withTimeout(signal, timeoutMs) {
+    const timeout = AbortSignal.timeout(timeoutMs);
+    return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+function num(v) {
+    const n = typeof v === "string" ? parseFloat(v) : typeof v === "number" ? v : NaN;
+    return Number.isFinite(n) ? n : null;
+}
+/** Codex: GET the usage endpoint and map its JSON to ProviderQuota. */
+export async function queryCodexQuota(creds, fetchImpl, signal) {
+    if (!creds.codexAccessToken) {
+        return { provider: "codex", error: "no Codex token (是否已 codex login?)" };
+    }
+    let resp;
+    try {
+        resp = await fetchImpl(CODEX_USAGE_URL, {
+            method: "GET",
+            headers: {
+                authorization: `Bearer ${creds.codexAccessToken}`,
+                ...(creds.codexAccountId ? { "chatgpt-account-id": creds.codexAccountId } : {}),
+                originator: "codex_cli_rs",
+                "user-agent": "codex_cli_rs",
+            },
+            signal,
+        });
+    }
+    catch (err) {
+        return { provider: "codex", error: `请求失败: ${err.message}` };
+    }
+    if (!resp.ok) {
+        return {
+            provider: "codex",
+            error: `HTTP ${resp.status}${resp.status === 401 ? " (token 可能已过期)" : ""}`,
+        };
+    }
+    let body;
+    try {
+        body = (await resp.json());
+    }
+    catch {
+        return { provider: "codex", error: "响应非 JSON" };
+    }
+    const rl = (body.rate_limit ?? {});
+    const windows = [];
+    const map = [
+        ["primary_window", "5h"],
+        ["secondary_window", "7d"],
+    ];
+    for (const [key, kind] of map) {
+        const w = rl[key];
+        if (!w)
+            continue;
+        const usedPercent = num(w.used_percent);
+        if (usedPercent == null)
+            continue;
+        windows.push({ kind, usedPercent, resetsAt: num(w.reset_at) });
+    }
+    if (windows.length === 0)
+        return { provider: "codex", error: "响应无 rate_limit 窗口" };
+    return {
+        provider: "codex",
+        windows,
+        planType: typeof body.plan_type === "string" ? body.plan_type : null,
+    };
+}
+/** Claude: POST a 1-token probe and read the unified rate-limit headers. */
+export async function queryClaudeQuota(creds, fetchImpl, signal) {
+    if (!creds.claudeAccessToken) {
+        return { provider: "claude", error: "no Claude Code token (是否已登录 Claude Code?)" };
+    }
+    let resp;
+    try {
+        resp = await fetchImpl(CLAUDE_MESSAGES_URL, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${creds.claudeAccessToken}`,
+                "anthropic-version": "2023-06-01",
+                "anthropic-beta": "oauth-2025-04-20",
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({
+                model: CLAUDE_PROBE_MODEL,
+                max_tokens: 1,
+                messages: [{ role: "user", content: "hi" }],
+            }),
+            signal,
+        });
+    }
+    catch (err) {
+        return { provider: "claude", error: `请求失败: ${err.message}` };
+    }
+    if (!resp.ok) {
+        return {
+            provider: "claude",
+            error: `HTTP ${resp.status}${resp.status === 401 ? " (token 可能已过期)" : ""}`,
+        };
+    }
+    const h = resp.headers;
+    const windows = [];
+    const map = [
+        ["anthropic-ratelimit-unified-5h-utilization", "anthropic-ratelimit-unified-5h-reset", "5h"],
+        ["anthropic-ratelimit-unified-7d-utilization", "anthropic-ratelimit-unified-7d-reset", "7d"],
+    ];
+    for (const [utilKey, resetKey, kind] of map) {
+        const util = num(h.get(utilKey)); // 0–1
+        if (util == null)
+            continue;
+        windows.push({ kind, usedPercent: util * 100, resetsAt: num(h.get(resetKey)) });
+    }
+    if (windows.length === 0)
+        return { provider: "claude", error: "响应头无 rate-limit 字段" };
+    return { provider: "claude", windows };
+}
+/** Query both providers (or the subset requested), concurrently. */
+export async function checkQuota(opts) {
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    const providers = opts.providers ?? ["claude", "codex"];
+    const signal = withTimeout(opts.signal, opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    const result = {};
+    await Promise.all(providers.map(async (p) => {
+        if (p === "codex")
+            result.codex = await queryCodexQuota(opts.creds, fetchImpl, signal);
+        else
+            result.claude = await queryClaudeQuota(opts.creds, fetchImpl, signal);
+    }));
+    return result;
+}
+/** Render a QuotaResult as a compact human/agent-readable summary. */
+export function formatQuota(result, nowSec) {
+    const lines = [];
+    for (const pq of [result.claude, result.codex]) {
+        if (!pq)
+            continue;
+        const name = pq.provider === "claude" ? "Claude Code" : "Codex";
+        if (pq.error || !pq.windows) {
+            lines.push(`${name}: 查询失败 — ${pq.error ?? "unknown"}`);
+            continue;
+        }
+        const plan = pq.planType ? ` [${pq.planType}]` : "";
+        const parts = pq.windows.map((w) => {
+            const reset = w.resetsAt != null ? ` (重置 ${formatReset(w.resetsAt - nowSec)})` : "";
+            return `${w.kind} 用了 ${w.usedPercent.toFixed(0)}%${reset}`;
+        });
+        lines.push(`${name}${plan}: ${parts.join("，")}`);
+    }
+    return lines.length ? lines.join("\n") : "(无可用额度信息)";
+}
+/** "2h13m" / "45m" / "已重置" from a seconds delta. */
+function formatReset(deltaSec) {
+    if (deltaSec <= 0)
+        return "已重置";
+    const h = Math.floor(deltaSec / 3600);
+    const m = Math.floor((deltaSec % 3600) / 60);
+    return h > 0 ? `${h}h${m}m 后` : `${m}m 后`;
+}

package/dist/quota/types.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Coding-agent quota (rate-limit / usage) types.
+ *
+ * DESIGN / BOUNDARY NOTE (see project_core_minimal_harness_business_layer):
+ * "how to read Claude Code / Codex remaining quota" is provider-specific
+ * BUSINESS policy, not core harness mechanism — it pokes a vendor's Keychain
+ * entry, an undocumented usage endpoint, and private response headers. It lives
+ * in this self-contained `quota/` module (one interface out: `checkQuota`) on
+ * purpose, so it can be lifted wholesale into a plugin later without untangling
+ * it from the rest of core. Nothing outside this module should know about
+ * Keychain / wham endpoints / `anthropic-ratelimit-*` header names.
+ */
+/** A single rolling limit window (e.g. the 5-hour or 7-day window). */
+export interface QuotaWindow {
+    /** Which window this is. */
+    kind: "5h" | "7d";
+    /** Percent of the window's limit already used, 0–100. */
+    usedPercent: number;
+    /** Unix epoch seconds when this window resets, or null if unknown. */
+    resetsAt: number | null;
+}
+/** Quota for one provider (claude | codex). */
+export interface ProviderQuota {
+    provider: "claude" | "codex";
+    /** Present when the lookup succeeded. */
+    windows?: QuotaWindow[];
+    /** Subscription tier, when the source exposes it (e.g. "team", "pro"). */
+    planType?: string | null;
+    /** Human-readable failure reason when the lookup did not succeed. */
+    error?: string;
+}
+export interface QuotaResult {
+    claude?: ProviderQuota;
+    codex?: ProviderQuota;
+}
+/**
+ * A credential the host supplies so this module can talk to a vendor backend.
+ * Core never reads the Keychain / auth.json itself — the host (desktop main /
+ * server) resolves the secret and hands it in. This is the seam that makes the
+ * whole module portable to a plugin.
+ */
+export interface QuotaCredentials {
+    /** Claude Code OAuth access token (from Keychain "Claude Code-credentials"). */
+    claudeAccessToken?: string;
+    /** Codex OAuth access token + account id (from ~/.codex/auth.json). */
+    codexAccessToken?: string;
+    codexAccountId?: string;
+}

package/dist/quota/types.js

@@ -0,0 +1,13 @@
+/**
+ * Coding-agent quota (rate-limit / usage) types.
+ *
+ * DESIGN / BOUNDARY NOTE (see project_core_minimal_harness_business_layer):
+ * "how to read Claude Code / Codex remaining quota" is provider-specific
+ * BUSINESS policy, not core harness mechanism — it pokes a vendor's Keychain
+ * entry, an undocumented usage endpoint, and private response headers. It lives
+ * in this self-contained `quota/` module (one interface out: `checkQuota`) on
+ * purpose, so it can be lifted wholesale into a plugin later without untangling
+ * it from the rest of core. Nothing outside this module should know about
+ * Keychain / wham endpoints / `anthropic-ratelimit-*` header names.
+ */
+export {};

package/dist/review/review-prompt.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Coding capability review-prompt builder. Produces the instruction sent to the
+ * model for `/review`. Pure + testable — the TUI/desktop command gathers the
+ * diff or file contents and calls this; the model does the actual reasoning.
+ *
+ * Findings are structured: priority P0–P3, a confidence score, and a precise
+ * location, so the output is consistent and (optionally) machine-readable for
+ * CI/CD via `--json`.
+ */
+export type ReviewDimension = "security" | "performance" | "readability" | "correctness";
+export declare const ALL_DIMENSIONS: ReviewDimension[];
+export interface ReviewPromptOptions {
+    /** The unified diff (incremental) or full file contents to review. */
+    content: string;
+    /** Which dimensions to weigh. Defaults to all four. */
+    dimensions?: ReviewDimension[];
+    /** True when reviewing a diff (incremental); false when reviewing whole files. */
+    incremental?: boolean;
+    /** Emit a machine-readable JSON findings array (for CI/CD) instead of prose. */
+    json?: boolean;
+    /** Optional label for what's under review (e.g. a file path). */
+    label?: string;
+    /** Truncate content to this many chars (default 12000). */
+    maxChars?: number;
+}
+/** Normalize a comma/space list of dimension names; invalid names dropped. */
+export declare function parseDimensions(input: string | undefined): ReviewDimension[];
+export declare function buildReviewPrompt(opts: ReviewPromptOptions): string;

package/dist/review/review-prompt.js

@@ -0,0 +1,81 @@
+/**
+ * Coding capability review-prompt builder. Produces the instruction sent to the
+ * model for `/review`. Pure + testable — the TUI/desktop command gathers the
+ * diff or file contents and calls this; the model does the actual reasoning.
+ *
+ * Findings are structured: priority P0–P3, a confidence score, and a precise
+ * location, so the output is consistent and (optionally) machine-readable for
+ * CI/CD via `--json`.
+ */
+export const ALL_DIMENSIONS = [
+    "correctness",
+    "security",
+    "performance",
+    "readability",
+];
+const DIMENSION_LABEL = {
+    security: "安全 (injection, authz, secret leakage, unsafe deserialization)",
+    performance: "性能 (N+1, needless allocation, blocking I/O, complexity)",
+    readability: "可读性 (naming, structure, dead code, comment accuracy)",
+    correctness: "正确性 (logic bugs, edge cases, error handling, races)",
+};
+/** Normalize a comma/space list of dimension names; invalid names dropped. */
+export function parseDimensions(input) {
+    if (!input)
+        return ALL_DIMENSIONS;
+    const wanted = input
+        .split(/[\s,]+/)
+        .map((s) => s.trim().toLowerCase())
+        .filter(Boolean);
+    const picked = ALL_DIMENSIONS.filter((d) => wanted.includes(d));
+    return picked.length > 0 ? picked : ALL_DIMENSIONS;
+}
+const PRIORITY_GUIDE = "Priority: P0 = must fix before merge (data loss, security hole, crash); " +
+    "P1 = should fix (likely bug, real risk); " +
+    "P2 = nice to fix (smell, minor inefficiency); " +
+    "P3 = optional (style, nit).";
+export function buildReviewPrompt(opts) {
+    const dims = opts.dimensions?.length ? opts.dimensions : ALL_DIMENSIONS;
+    const maxChars = opts.maxChars ?? 12_000;
+    const body = opts.content.length > maxChars
+        ? opts.content.slice(0, maxChars) + "\n…(truncated)…"
+        : opts.content;
+    const fence = opts.incremental === false ? "" : "diff";
+    const what = opts.incremental === false ? "code" : "code changes (diff)";
+    const subject = opts.label ? ` for \`${opts.label}\`` : "";
+    const dimLines = dims.map((d) => `  - ${DIMENSION_LABEL[d]}`).join("\n");
+    if (opts.json) {
+        return [
+            `Review the following ${what}${subject} across these dimensions:`,
+            dimLines,
+            ``,
+            PRIORITY_GUIDE,
+            ``,
+            `Respond with ONLY a JSON object (no prose, no markdown fence) of the form:`,
+            `{"summary": string, "findings": [{"priority": "P0"|"P1"|"P2"|"P3", ` +
+                `"dimension": ${dims.map((d) => `"${d}"`).join("|")}, ` +
+                `"confidence": number /*0..1*/, "location": string /*file:line*/, ` +
+                `"title": string, "detail": string, "suggestion": string}]}`,
+            `Order findings by priority then confidence. Omit a finding rather than guess.`,
+            ``,
+            "```" + fence,
+            body,
+            "```",
+        ].join("\n");
+    }
+    return [
+        `Review the following ${what}${subject} across these dimensions:`,
+        dimLines,
+        ``,
+        PRIORITY_GUIDE,
+        ``,
+        `For each finding, give: **[P0-P3]** a short title, the location (file:line), ` +
+            `your confidence (low/med/high), what's wrong, and a concrete fix.`,
+        `Start with a one-line summary, then list findings ordered by priority. ` +
+            `If nothing warrants a finding, say so plainly. Don't pad with nits to look thorough.`,
+        ``,
+        "```" + fence,
+        body,
+        "```",
+    ].join("\n");
+}

package/dist/tools/apply-patch/LICENSE-codex

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1.  Definitions.
+
+    "License" shall mean the terms and conditions for use, reproduction,
+    and distribution as defined by Sections 1 through 9 of this document.
+
+    "Licensor" shall mean the copyright owner or entity authorized by
+    the copyright owner that is granting the License.
+
+    "Legal Entity" shall mean the union of the acting entity and all
+    other entities that control, are controlled by, or are under common
+    control with that entity. For the purposes of this definition,
+    "control" means (i) the power, direct or indirect, to cause the
+    direction or management of such entity, whether by contract or
+    otherwise, or (ii) ownership of fifty percent (50%) or more of the
+    outstanding shares, or (iii) beneficial ownership of such entity.
+
+    "You" (or "Your") shall mean an individual or Legal Entity
+    exercising permissions granted by this License.
+
+    "Source" form shall mean the preferred form for making modifications,
+    including but not limited to software source code, documentation
+    source, and configuration files.
+
+    "Object" form shall mean any form resulting from mechanical
+    transformation or translation of a Source form, including but
+    not limited to compiled object code, generated documentation,
+    and conversions to other media types.
+
+    "Work" shall mean the work of authorship, whether in Source or
+    Object form, made available under the License, as indicated by a
+    copyright notice that is included in or attached to the work
+    (an example is provided in the Appendix below).
+
+    "Derivative Works" shall mean any work, whether in Source or Object
+    form, that is based on (or derived from) the Work and for which the
+    editorial revisions, annotations, elaborations, or other modifications
+    represent, as a whole, an original work of authorship. For the purposes
+    of this License, Derivative Works shall not include works that remain
+    separable from, or merely link (or bind by name) to the interfaces of,
+    the Work and Derivative Works thereof.
+
+    "Contribution" shall mean any work of authorship, including
+    the original version of the Work and any modifications or additions
+    to that Work or Derivative Works thereof, that is intentionally
+    submitted to Licensor for inclusion in the Work by the copyright owner
+    or by an individual or Legal Entity authorized to submit on behalf of
+    the copyright owner. For the purposes of this definition, "submitted"
+    means any form of electronic, verbal, or written communication sent
+    to the Licensor or its representatives, including but not limited to
+    communication on electronic mailing lists, source code control systems,
+    and issue tracking systems that are managed by, or on behalf of, the
+    Licensor for the purpose of discussing and improving the Work, but
+    excluding communication that is conspicuously marked or otherwise
+    designated in writing by the copyright owner as "Not a Contribution."
+
+    "Contributor" shall mean Licensor and any individual or Legal Entity
+    on behalf of whom a Contribution has been received by Licensor and
+    subsequently incorporated within the Work.
+
+2.  Grant of Copyright License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    copyright license to reproduce, prepare Derivative Works of,
+    publicly display, publicly perform, sublicense, and distribute the
+    Work and such Derivative Works in Source or Object form.
+
+3.  Grant of Patent License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    (except as stated in this section) patent license to make, have made,
+    use, offer to sell, sell, import, and otherwise transfer the Work,
+    where such license applies only to those patent claims licensable
+    by such Contributor that are necessarily infringed by their
+    Contribution(s) alone or by combination of their Contribution(s)
+    with the Work to which such Contribution(s) was submitted. If You
+    institute patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Work
+    or a Contribution incorporated within the Work constitutes direct
+    or contributory patent infringement, then any patent licenses
+    granted to You under this License for that Work shall terminate
+    as of the date such litigation is filed.
+
+4.  Redistribution. You may reproduce and distribute copies of the
+    Work or Derivative Works thereof in any medium, with or without
+    modifications, and in Source or Object form, provided that You
+    meet the following conditions:
+
+    (a) You must give any other recipients of the Work or
+    Derivative Works a copy of this License; and
+
+    (b) You must cause any modified files to carry prominent notices
+    stating that You changed the files; and
+
+    (c) You must retain, in the Source form of any Derivative Works
+    that You distribute, all copyright, patent, trademark, and
+    attribution notices from the Source form of the Work,
+    excluding those notices that do not pertain to any part of
+    the Derivative Works; and
+
+    (d) If the Work includes a "NOTICE" text file as part of its
+    distribution, then any Derivative Works that You distribute must
+    include a readable copy of the attribution notices contained
+    within such NOTICE file, excluding those notices that do not
+    pertain to any part of the Derivative Works, in at least one
+    of the following places: within a NOTICE text file distributed
+    as part of the Derivative Works; within the Source form or
+    documentation, if provided along with the Derivative Works; or,
+    within a display generated by the Derivative Works, if and
+    wherever such third-party notices normally appear. The contents
+    of the NOTICE file are for informational purposes only and
+    do not modify the License. You may add Your own attribution
+    notices within Derivative Works that You distribute, alongside
+    or as an addendum to the NOTICE text from the Work, provided
+    that such additional attribution notices cannot be construed
+    as modifying the License.
+
+    You may add Your own copyright statement to Your modifications and
+    may provide additional or different license terms and conditions
+    for use, reproduction, or distribution of Your modifications, or
+    for any such Derivative Works as a whole, provided Your use,
+    reproduction, and distribution of the Work otherwise complies with
+    the conditions stated in this License.
+
+5.  Submission of Contributions. Unless You explicitly state otherwise,
+    any Contribution intentionally submitted for inclusion in the Work
+    by You to the Licensor shall be under the terms and conditions of
+    this License, without any additional terms or conditions.
+    Notwithstanding the above, nothing herein shall supersede or modify
+    the terms of any separate license agreement you may have executed
+    with Licensor regarding such Contributions.
+
+6.  Trademarks. This License does not grant permission to use the trade
+    names, trademarks, service marks, or product names of the Licensor,
+    except as required for reasonable and customary use in describing the
+    origin of the Work and reproducing the content of the NOTICE file.
+
+7.  Disclaimer of Warranty. Unless required by applicable law or
+    agreed to in writing, Licensor provides the Work (and each
+    Contributor provides its Contributions) on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+    implied, including, without limitation, any warranties or conditions
+    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+    PARTICULAR PURPOSE. You are solely responsible for determining the
+    appropriateness of using or redistributing the Work and assume any
+    risks associated with Your exercise of permissions under this License.
+
+8.  Limitation of Liability. In no event and under no legal theory,
+    whether in tort (including negligence), contract, or otherwise,
+    unless required by applicable law (such as deliberate and grossly
+    negligent acts) or agreed to in writing, shall any Contributor be
+    liable to You for damages, including any direct, indirect, special,
+    incidental, or consequential damages of any character arising as a
+    result of this License or out of the use or inability to use the
+    Work (including but not limited to damages for loss of goodwill,
+    work stoppage, computer failure or malfunction, or any and all
+    other commercial damages or losses), even if such Contributor
+    has been advised of the possibility of such damages.
+
+9.  Accepting Warranty or Additional Liability. While redistributing
+    the Work or Derivative Works thereof, You may choose to offer,
+    and charge a fee for, acceptance of support, warranty, indemnity,
+    or other liability obligations and/or rights consistent with this
+    License. However, in accepting such obligations, You may act only
+    on Your own behalf and on Your sole responsibility, not on behalf
+    of any other Contributor, and only if You agree to indemnify,
+    defend, and hold each Contributor harmless for any liability
+    incurred by, or claims asserted against, such Contributor by reason
+    of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+Copyright 2025 OpenAI
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.