@oomol-lab/open-connector 1.9.0 → 1.9.1

package/src/providers/ftshare/actions.js

@@ -0,0 +1,124 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const stockFields = {
+    stock_code: s.string("Stock code returned by FTShare."),
+    stock_name: s.string("Stock name."),
+};
+const reportFields = {
+    ...stockFields,
+    year: s.integer("Report year."),
+    report_type: s.string("Report period type."),
+    report_type_cn: s.string("Chinese report period name."),
+    publish_date: s.string("Publication date in YYYY-MM-DD format."),
+};
+function reportInput(allowHalfYear) {
+    return {
+        ...s.object("Choose either one stock's full history or a paginated market report period.", {
+            stock_code: s.string("Six-digit A-share code with exchange suffix, for example 000001.SZ. Returns all historical periods without pagination.", { pattern: "^[0-9]{6}\\.[A-Z]+$" }),
+            year: s.integer("Report year, required for market-wide queries."),
+            report_type: s.stringEnum("Report period: q1, q2 (half-year), q3, or annual. Income and balance sheets also accept h1 as q2.", allowHalfYear ? ["q1", "q2", "q3", "annual", "h1"] : ["q1", "q2", "q3", "annual"]),
+            page: s.integer("Market query page, starting at 1; defaults to 1.", { minimum: 1 }),
+            page_size: s.integer("Market query page size; defaults to 50, maximum 500.", {
+                minimum: 1,
+                maximum: 500,
+            }),
+        }, { required: [] }),
+        oneOf: [
+            {
+                required: ["stock_code"],
+                not: {
+                    anyOf: ["year", "report_type", "page", "page_size"].map((key) => ({ required: [key] })),
+                },
+            },
+            { required: ["year", "report_type"], not: { required: ["stock_code"] } },
+        ],
+    };
+}
+function envelope(data) {
+    return s.looseObject("FTShare response envelope; upstream extension fields are preserved.", {
+        code: s.integer("Upstream status code; 200 indicates success."),
+        message: s.string("Upstream status message."),
+        data,
+    });
+}
+function report(name, description, fields, allowHalfYear = false) {
+    return defineProviderAction("ftshare", {
+        name,
+        description,
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: reportInput(allowHalfYear),
+        outputSchema: envelope(s.looseObject("Report records and pagination totals.", {
+            items: s.array("Records, retaining financial strings, nulls, and additional upstream fields.", s.looseObject("One report record with provider-defined financial fields.", {
+                ...reportFields,
+                ...fields,
+            })),
+            total_items: s.integer("Total matching records."),
+            total_pages: s.integer("Total result pages."),
+        })),
+    });
+}
+export const ftshareActions = [
+    defineProviderAction("ftshare", {
+        name: "list_companies",
+        description: "List company snapshots with optional exact stock name and unsuffixed stock code filters.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Company filters and pagination.", {
+            stock_code: s.nonEmptyString("Exact stock code without exchange suffix, for example 000001."),
+            stock_name: s.nonEmptyString("Exact stock name."),
+            page: s.integer("Page number; defaults to 1.", { minimum: 1 }),
+            page_size: s.integer("Page size; defaults to 50, maximum 200.", {
+                minimum: 1,
+                maximum: 200,
+            }),
+        }, { required: [] }),
+        outputSchema: envelope(s.looseObject("Company result page.", {
+            pageNum: s.integer("Current page number."),
+            pageSize: s.integer("Current page size."),
+            total: s.integer("Total matching companies."),
+            pages: s.integer("Total result pages."),
+            records: s.array("Company snapshots.", s.looseObject("Company details; additional upstream fields are preserved.", {
+                ...stockFields,
+                company_code: s.string("Company code."),
+                main_business: s.nullableString("Main business activities."),
+                company_profile: s.nullableString("Company profile."),
+                total_market_value: s.nullableString("Total market capitalization as reported by FTShare."),
+            })),
+        })),
+    }),
+    report("get_income_statements", "Read A-share income statements for one stock's full history or one market-wide report period.", {
+        report_form_type: s.string("Statement consolidation and adjustment type."),
+        t_revenue: s.nullableString("Total revenue."),
+        n_profit: s.nullableString("Net profit including minority interests."),
+        parcomp_n_profit: s.nullableString("Net profit attributable to the parent company."),
+    }, true),
+    report("get_balance_sheets", "Read A-share balance sheets for one stock's full history or one market-wide report period.", {
+        report_form_type: s.string("Statement consolidation and adjustment type."),
+        t_assets: s.nullableString("Total assets."),
+        t_liability: s.nullableString("Total liabilities."),
+        t_equity: s.nullableString("Total equity."),
+    }, true),
+    report("get_cashflow_statements", "Read A-share cash flow statements for one stock's full history or one market-wide report period.", {
+        detail_report_type: s.string("Detailed statement consolidation and adjustment type."),
+        net_oper_cash_flow: s.nullableString("Net cash flow from operating activities."),
+        net_invest_cash_flow: s.nullableString("Net cash flow from investing activities."),
+        net_fin_cash_flow: s.nullableString("Net cash flow from financing activities."),
+    }),
+    report("get_earnings_reports", "Read A-share earnings express reports by stock or market report period, preserving multiple disclosures and corrections.", {
+        eps: s.nullableString("Earnings per share."),
+        total_revenue: s.nullableString("Total revenue."),
+        net_profit: s.nullableString("Net profit."),
+        roe: s.nullableString("Return on equity."),
+    }),
+    report("get_earnings_forecasts", "Read A-share earnings forecasts by stock or market report period, including forecast ranges and year-over-year changes.", {
+        forecast_subject: s.string("Forecast financial metric."),
+        forecast_type: s.string("Forecast category reported by FTShare."),
+        forecast_value_min: s.nullableString("Lower forecast value."),
+        forecast_value_max: s.nullableString("Upper forecast value."),
+        unit: s.string("Forecast value unit."),
+        yoy_change_min: s.nullableString("Lower year-over-year percentage change."),
+        yoy_change_max: s.nullableString("Upper year-over-year percentage change."),
+        last_year_value: s.nullableString("Value for the same period last year."),
+    }),
+];

package/src/providers/ftshare/executors.d.ts

@@ -0,0 +1,4 @@
+import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+export declare const executors: ProviderExecutors;
+export declare const credentialValidators: CredentialValidators;
+export declare const proxy: ProviderProxyExecutor;

package/src/providers/ftshare/executors.js

@@ -0,0 +1,102 @@
+import { optionalRecord, optionalRawString, optionalNumber } from "../../core/cast.js";
+import { requiredInputString, requiredResponseRecord, ProviderRequestError, runProviderRequest, defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, readProviderProxyErrorMessage, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { ftshareActions } from "./actions.js";
+const baseUrl = "https://market.ft.tech/gateway";
+const defaultHeaders = { accept: "application/json", "content-type": "application/json" };
+const routes = {
+    list_companies: "/api/v1/market/data/company-list",
+    get_income_statements: "/api/v1/market/data/finance/income",
+    get_balance_sheets: "/api/v1/market/data/finance/balance",
+    get_cashflow_statements: "/api/v1/market/data/finance/cashflow",
+    get_earnings_reports: "/api/v1/market/data/finance/stock-performance-express",
+    get_earnings_forecasts: "/api/v1/market/data/finance/stock-performance-forecast",
+};
+async function request({ route, input, apiKey, fetcher, parentSignal }) {
+    try {
+        return await runProviderRequest({ signal: parentSignal, label: "FTShare" }, async (signal) => {
+            const url = new URL(`${baseUrl}${route}`);
+            for (const [key, value] of Object.entries(input)) {
+                if (value != null)
+                    url.searchParams.set(key, String(value));
+            }
+            const response = await fetcher(url.toString(), {
+                method: "GET",
+                headers: { ...defaultHeaders, FTSHARE_API_KEY: apiKey },
+                signal,
+            });
+            const text = await response.text();
+            let payload;
+            try {
+                payload = JSON.parse(text);
+            }
+            catch {
+                payload = undefined;
+            }
+            const body = optionalRecord(payload);
+            if (!response.ok || (body?.code != null && body.code !== 200)) {
+                const code = optionalRawString(body?.code) ?? optionalNumber(body?.code);
+                const detail = [
+                    code,
+                    optionalRawString(body?.msg),
+                    optionalRawString(body?.message),
+                    optionalRawString(optionalRecord(body?.data)?.reason),
+                ]
+                    .filter((value) => value != null && value !== "")
+                    .join(": ") || `HTTP ${response.status}`;
+                throw new ProviderRequestError(response.ok ? 502 : response.status, `FTShare request failed: ${detail}`, undefined, response.status === 429 ? "rate_limited" : "provider_error");
+            }
+            return requiredResponseRecord(payload, "FTShare response");
+        });
+    }
+    catch (error) {
+        if (error instanceof ProviderRequestError)
+            error.message = error.message.split(apiKey).join("[REDACTED]");
+        throw error;
+    }
+}
+const handlers = mapProviderActionHandlers("ftshare", ftshareActions, (action) => async (dataInput, context) => {
+    const route = routes[action.name];
+    const query = { ...dataInput };
+    if (action.name === "list_companies" || query.stock_code == null) {
+        query.page ??= 1;
+        query.page_size ??= 50;
+    }
+    if (query.report_type === "h1")
+        query.report_type = "q2";
+    return request({
+        route: route,
+        input: query,
+        apiKey: context.apiKey,
+        fetcher: context.fetcher,
+        parentSignal: context.signal,
+    });
+});
+export const executors = defineApiKeyProviderExecutors("ftshare", handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        await request({
+            route: routes.list_companies,
+            input: { page: 1, page_size: 1 },
+            apiKey: requiredInputString(input.apiKey, "API Key"),
+            fetcher: fetcher,
+            parentSignal: signal,
+        });
+        return { profile: { displayName: "FTShare API Key" }, grantedScopes: [], metadata: { apiBaseUrl: baseUrl } };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "ftshare",
+    baseUrl,
+    auth: { type: "api_key_header", name: "FTSHARE_API_KEY" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        for (const [name, value] of Object.entries({ accept: "application/json", "content-type": "application/json" }))
+            if (!headers.has(name))
+                headers.set(name, value);
+    },
+    async readError(response) {
+        return new ProviderRequestError(response.status, await readProviderProxyErrorMessage(response, "Provider request failed"), withRetryAfterSeconds(response), response.status === 429 ? "rate_limited" : "provider_error");
+    },
+});

package/src/providers/fusion-api/operations.js

@@ -1,4 +1,41 @@
 export const fusionApiOperations = [
+    {
+        actionName: "oomol_ocr_submit",
+        operationType: "write",
+        method: "POST",
+        path: "/v1/oomol-ocr/submit",
+        tag: "oomol-ocr",
+        description: "Recognize image text and suggest corrections for Chinese typos",
+        successStatuses: [200],
+        pathParams: [],
+        inputFields: [
+            {
+                name: "imageURL",
+                kind: "string",
+                required: true,
+                description: "Publicly accessible image URL.",
+                format: "uri",
+            },
+            {
+                name: "correct",
+                kind: "boolean",
+                required: false,
+                description: "Generate Chinese typo correction suggestions after text recognition.",
+                defaultValue: true,
+            },
+        ],
+    },
+    {
+        actionName: "oomol_ocr_result",
+        operationType: "read",
+        method: "GET",
+        path: "/v1/oomol-ocr/result/{sessionID}",
+        tag: "oomol-ocr",
+        description: "Get image text recognition and Chinese typo correction results",
+        successStatuses: [200, 202, 404],
+        pathParams: ["sessionID"],
+        inputFields: [{ name: "sessionID", kind: "string", required: true, description: "Session ID" }],
+    },
     {
         actionName: "cphone_nano_banana_result",
         operationType: "read",

package/src/providers/fxbaogao/actions.d.ts

@@ -0,0 +1,2 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export declare const fxbaogaoActions: ActionDefinition[];

package/src/providers/fxbaogao/actions.js

@@ -0,0 +1,74 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const reportId = s.integer("Report ID returned by search_reports.");
+const raw = s.looseObject("Original upstream response, including additional fields.", {});
+const paragraph = s.looseObject("A matching report paragraph.", {
+    content: s.string("Paragraph text, possibly containing highlight markup."),
+    pageNum: s.integer("Page number within the report."),
+});
+export const fxbaogaoActions = [
+    defineProviderAction("fxbaogao", {
+        name: "search_reports",
+        description: "Search research reports by keywords, institutions, and publication time. Provide keywords or at least one institution; pages range from 1 to 10.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: {
+            ...s.object("Report search filters.", {
+                keywords: s.nonEmptyString("Search keywords; required unless orgNames contains an institution."),
+                orgNames: s.array("Institution names; required unless keywords is provided.", s.nonEmptyString("Institution name.")),
+                startTime: s.string("Start time as a millisecond timestamp string or last3day, last7day, last1mon, last3mon, last1year."),
+                endTime: s.string("End time as a millisecond timestamp string."),
+                pageNum: s.integer("Result page from 1 to 10; defaults to 1.", { minimum: 1, maximum: 10 }),
+            }, { required: [] }),
+            anyOf: [{ required: ["keywords"] }, { required: ["orgNames"], properties: { orgNames: { minItems: 1 } } }],
+        },
+        outputSchema: s.requiredObject("Search results with the original response retained.", {
+            reports: s.array("Matching research reports.", s.looseObject("Report metadata with upstream extension fields preserved.", {
+                reportId,
+                title: s.string("Report title, possibly containing highlight markup."),
+                orgName: s.string("Publishing institution, possibly containing highlight markup."),
+                pubTime: s.unknown("Publication timestamp as returned by the provider."),
+                pubTimeStr: s.string("Formatted publication date."),
+                industryName: s.string("Industry name."),
+                pageNum: s.integer("Number of pages in the report."),
+                paragraphs: s.array("Matching text excerpts.", paragraph),
+                reportUrl: s.string("Official report reading URL."),
+            })),
+            raw,
+        }),
+    }),
+    defineProviderAction("fxbaogao", {
+        name: "get_paragraphs",
+        description: "Read a report's summary and matching paragraphs. Use the PDF for full reading and original-source citations.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Report and optional context keyword.", {
+            reportId,
+            keyword: s.string("Keyword used to locate relevant context within the report."),
+        }, { optional: ["keyword"] }),
+        outputSchema: s.object("Original report paragraph response.", {
+            code: s.integer("Upstream result code; zero indicates success."),
+            msg: s.string("Upstream message."),
+            data: s.looseObject("Report summary and matching passages.", {
+                title: s.string("Report title."),
+                summary: s.string("Report summary."),
+                paragraphs: s.array("Matching report paragraphs.", paragraph),
+            }),
+        }, { required: ["code", "data"], additionalProperties: true }),
+    }),
+    defineProviderAction("fxbaogao", {
+        name: "get_pdf_url",
+        description: "Get downloadable PDF URLs for a report without transferring binary content through the action response.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.requiredObject("Report to download.", { reportId }),
+        outputSchema: s.requiredObject("PDF resources and original upstream response.", {
+            reportId,
+            resources: s.array("Available PDF resources; empty when upstream returns no download URL.", s.requiredObject("A PDF resource.", {
+                field: s.string("Upstream field containing this resource."),
+                url: s.string("Absolute PDF download URL; it may expire."),
+            })),
+            raw,
+        }),
+    }),
+];

package/src/providers/fxbaogao/executors.d.ts

@@ -0,0 +1,4 @@
+import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+export declare const executors: ProviderExecutors;
+export declare const credentialValidators: CredentialValidators;
+export declare const proxy: ProviderProxyExecutor;

package/src/providers/fxbaogao/executors.js

@@ -0,0 +1,155 @@
+import { optionalRecord, optionalRawString, optionalNumber } from "../../core/cast.js";
+import { requiredInputString, requiredResponseRecord, ProviderRequestError, runProviderRequest, defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, readProviderProxyErrorMessage, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { fxbaogaoActions } from "./actions.js";
+const baseUrl = "https://api.fxbaogao.com";
+const defaultHeaders = { accept: "application/json", "content-type": "application/json" };
+const routes = {
+    search_reports: "/mofoun/agent/search",
+    get_paragraphs: "/mofoun/agent/paragraph",
+    get_pdf_url: "/mofoun/agent/download",
+};
+async function request({ route, input, apiKey, fetcher, parentSignal }) {
+    try {
+        return await runProviderRequest({ signal: parentSignal, label: "Fxbaogao" }, async (signal) => {
+            const download = route === routes.get_pdf_url;
+            const url = new URL(`${baseUrl}${route}`);
+            if (download)
+                url.searchParams.set("reportId", String(input.reportId));
+            const response = await fetcher(url.toString(), {
+                method: download ? "GET" : "POST",
+                headers: { ...defaultHeaders, authorization: `Bearer ${apiKey}` },
+                body: download ? undefined : JSON.stringify(input),
+                signal,
+            });
+            const text = await response.text();
+            let payload;
+            try {
+                payload = JSON.parse(text);
+            }
+            catch {
+                payload = undefined;
+            }
+            const body = optionalRecord(payload);
+            if (!response.ok || (body?.code != null && body.code !== 0)) {
+                const detail = [
+                    optionalRawString(body?.code) ?? optionalNumber(body?.code),
+                    optionalRawString(body?.msg) ?? optionalRawString(body?.message),
+                ]
+                    .filter((value) => value != null && value !== "")
+                    .join(": ") || `HTTP ${response.status}`;
+                throw new ProviderRequestError(response.ok ? 502 : response.status, `Fxbaogao request failed: ${detail}`, undefined, response.status === 429 ? "rate_limited" : "provider_error");
+            }
+            return requiredResponseRecord(payload, "Fxbaogao response");
+        });
+    }
+    catch (error) {
+        if (error instanceof ProviderRequestError)
+            error.message = error.message.split(apiKey).join("[REDACTED]");
+        throw error;
+    }
+}
+function extractPdfResources(payload) {
+    const resources = [];
+    const seen = new Set();
+    const urlKeys = new Set(["pdfurl", "url", "fileurl", "downloadurl"]);
+    function walk(value) {
+        if (Array.isArray(value)) {
+            for (const item of value)
+                walk(item);
+            return;
+        }
+        const object = optionalRecord(value);
+        if (!object)
+            return;
+        for (const [field, child] of Object.entries(object)) {
+            if (typeof child !== "string") {
+                walk(child);
+                continue;
+            }
+            const key = field.toLowerCase();
+            const reference = child.trim();
+            if (!reference ||
+                !(urlKeys.has(key) ||
+                    (key === "data" &&
+                        (reference.startsWith("http://") ||
+                            reference.startsWith("https://") ||
+                            reference.startsWith("/") ||
+                            reference.toLowerCase().includes(".pdf")))))
+                continue;
+            try {
+                const url = new URL(reference, "https://dr.fxbaogao.com/");
+                if ((url.protocol === "https:" || url.protocol === "http:") && !seen.has(url.href)) {
+                    seen.add(url.href);
+                    resources.push({ field, url: url.href });
+                }
+            }
+            catch {
+                /* 忽略上游不可解析的下载地址。 */
+            }
+        }
+    }
+    walk(payload);
+    return resources;
+}
+const handlers = mapProviderActionHandlers("fxbaogao", fxbaogaoActions, (action) => async (dataInput, context) => {
+    const route = routes[action.name];
+    const query = dataInput;
+    const body = action.name === "search_reports"
+        ? {
+            ...query,
+            keywords: query.keywords ?? "",
+            orgNames: query.orgNames ?? [],
+            pageNum: query.pageNum ?? 1,
+        }
+        : query;
+    const raw = await request({
+        route: route,
+        input: body,
+        apiKey: context.apiKey,
+        fetcher: context.fetcher,
+        parentSignal: context.signal,
+    });
+    if (action.name === "search_reports") {
+        const reports = Array.isArray(raw.data) ? raw.data : optionalRecord(raw.data)?.dataList;
+        if (!Array.isArray(reports))
+            throw new ProviderRequestError(502, "Fxbaogao search response is missing its report list", undefined, "provider_error");
+        return {
+            reports: reports.map((value) => {
+                const report = optionalRecord(value);
+                if (!report || report.reportId == null)
+                    return value;
+                return {
+                    ...report,
+                    reportUrl: `https://www.fxbaogao.com/view?id=${encodeURIComponent(String(report.reportId))}`,
+                };
+            }),
+            raw,
+        };
+    }
+    if (action.name === "get_pdf_url")
+        return { reportId: query.reportId, resources: extractPdfResources(raw), raw };
+    return raw;
+});
+export const executors = defineApiKeyProviderExecutors("fxbaogao", handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input) {
+        requiredInputString(input.apiKey, "API Key");
+        return { profile: { displayName: "Fxbaogao API Key" }, grantedScopes: [], metadata: { apiBaseUrl: baseUrl } };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "fxbaogao",
+    baseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        for (const [name, value] of Object.entries({ accept: "application/json", "content-type": "application/json" }))
+            if (!headers.has(name))
+                headers.set(name, value);
+    },
+    async readError(response) {
+        return new ProviderRequestError(response.status, await readProviderProxyErrorMessage(response, "Provider request failed"), withRetryAfterSeconds(response), response.status === 429 ? "rate_limited" : "provider_error");
+    },
+});

package/src/providers/github/app-installation.d.ts

@@ -0,0 +1,37 @@
+export interface GitHubAppInstallationCredential {
+    appId: string;
+    installationId: string;
+    /** PKCS#8 PEM, converted from the PKCS#1 PEM GitHub downloads when needed. */
+    privateKey: string;
+}
+interface GitHubInstallationToken {
+    token: string;
+    /** ISO timestamp from GitHub; tokens live one hour. */
+    expiresAt: string;
+    permissions: Record<string, string>;
+    repositorySelection: string | undefined;
+}
+interface GitHubAppInstallation {
+    id: number;
+    account: Record<string, unknown>;
+    permissions: Record<string, string>;
+    repository_selection: string;
+    [key: string]: unknown;
+}
+export declare function readGitHubAppInstallationCredential(values: Record<string, string>): GitHubAppInstallationCredential;
+/**
+ * Wrap a PKCS#1 RSAPrivateKey in the PKCS#8 PrivateKeyInfo structure WebCrypto
+ * imports. The wrapper is fixed for RSA: version 0, the rsaEncryption algorithm
+ * identifier with a NULL parameter, then the PKCS#1 DER as an OCTET STRING.
+ */
+export declare function pkcs1ToPkcs8Pem(pkcs1Pem: string): string;
+/** Sign the App JWT GitHub's App endpoints and the token mint take as bearer. */
+export declare function signGitHubAppJwt(credential: GitHubAppInstallationCredential): Promise<string>;
+/** Describe the installation the credential names, authenticated as the App. */
+export declare function fetchGitHubAppInstallation(credential: GitHubAppInstallationCredential, fetcher: typeof fetch, signal?: AbortSignal): Promise<GitHubAppInstallation>;
+/** Mint an installation access token with the App's full granted permissions. */
+export declare function mintGitHubInstallationToken(credential: GitHubAppInstallationCredential, fetcher: typeof fetch, signal?: AbortSignal): Promise<GitHubInstallationToken>;
+export declare function clearGitHubInstallationTokenCache(): void;
+/** Resolve installation tokens without letting one caller cancel a shared mint. */
+export declare function createGitHubInstallationTokenResolver(values: Record<string, string>, fetcher: typeof fetch): (signal?: AbortSignal) => Promise<string>;
+export {};