@oomol-lab/open-connector 1.8.0 → 1.9.0

package/src/providers/freeastroapi/runtime.js

@@ -0,0 +1,294 @@
+import { optionalNumber, optionalRecord, rawStringOrNull, optionalRawString, requiredNumber, requiredString, } from "../../core/cast.js";
+import { readProviderTextBody, mapProviderActionSources, providerResponseError, providerInputError, ProviderRequestError, providerUserAgent, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+import { validateCalendarDate, validateExpansionInput } from "./input-validation.js";
+export const freeastroapiBaseUrl = "https://api.freeastroapi.com";
+const routes = {
+    calculate_bazi: { path: "/api/v1/chinese/bazi", output: "chart", method: "POST" },
+    calculate_bazi_synastry: {
+        path: "/api/v1/chinese/bazi/synastry",
+        output: "compatibility",
+        method: "POST",
+    },
+    correct_bazi_time: {
+        path: "/api/v1/chinese/bazi/time-correction",
+        output: "correction",
+        method: "POST",
+    },
+    calculate_bazi_flow: { path: "/api/v1/chinese/bazi/flow", output: "flow", method: "POST" },
+    calculate_bazi_life_curve: {
+        path: "/api/v1/chinese/bazi/lifespan",
+        output: "lifeCurve",
+        method: "POST",
+    },
+    analyze_bazi_constitution: {
+        path: "/api/v1/chinese/bazi/health",
+        output: "analysis",
+        method: "POST",
+    },
+    get_chinese_calendar: { path: "/api/v1/chinese/calendar", output: "calendar", method: "GET" },
+    get_current_pillars: { path: "/api/v1/chinese/today", output: "pillars", method: "GET" },
+    get_bazi_dictionary: {
+        path: "/api/v1/chinese/bazi/dictionary",
+        output: "dictionary",
+        method: "GET",
+    },
+    search_cities: { path: "/api/v2/geo/search", output: "cities", method: "GET" },
+    get_moon_phase: { path: "/api/v1/moon/phase", output: "moon", method: "GET" },
+    get_moon_calendar: { path: "/api/v1/moon/month", output: "calendar", method: "GET" },
+    list_sky_events: { path: "/api/v1/sky-events", output: "events", method: "GET" },
+    calculate_ephemeris: { path: "/api/v1/ephemeris/calculate", output: "ephemeris", method: "POST" },
+    calculate_transit_timeline: {
+        path: "/api/v1/western/transits/timeline",
+        output: "timeline",
+        method: "POST",
+    },
+    calculate_vedic_chart: { path: "/api/v2/vedic/calculate", output: "calculation", method: "POST" },
+    calculate_numerology_profile: {
+        path: "/api/v1/numerology/profile",
+        output: "profile",
+        method: "POST",
+    },
+};
+const upstreamFields = {
+    latitude: "lat",
+    longitude: "lng",
+    timezone: "tz_str",
+    timeStandard: "time_standard",
+    language: "lang",
+    includeTenGods: "include_ten_gods",
+    includePinyin: "include_pinyin",
+    includeStars: "include_stars",
+    includeInteractions: "include_interactions",
+    includeProfessional: "include_professional",
+    includeDebug: "include_debug",
+    includeCurrentFlow: "include_current_flow",
+    personA: "person_a",
+    personB: "person_b",
+    targetYear: "target_year",
+    targetYearEnd: "target_year_end",
+    dictionaryResponse: "dictionary_response",
+    maxAge: "max_age",
+    cultivationFactor: "cultivation_factor",
+    includeTiming: "include_timing",
+    timingYearsAhead: "timing_years_ahead",
+    includeZodiac: "include_zodiac",
+    includeRiseSet: "include_rise_set",
+    includeVisuals: "include_visuals",
+    includeSpecial: "include_special",
+    includeEclipse: "include_eclipse",
+    includeForecast: "include_forecast",
+    includeInterpretation: "include_interpretation",
+    includeTraditionalMoon: "include_traditional_moon",
+    includeSignTimeline: "include_sign_timeline",
+    moonColor: "style_moon_color",
+    shadowColor: "style_shadow_color",
+    includeMoon: "include_moon",
+    includeExactHits: "include_exact_hits",
+    includeMoonExactHits: "include_moon_exact_hits",
+    includeIngresses: "include_ingresses",
+    includeRetrogrades: "include_retrogrades",
+    includeLunations: "include_lunations",
+    includeFormulation: "include_formulation",
+    tableStyle: "table_style",
+    zodiacType: "zodiac_type",
+    siderealAyanamsa: "sidereal_ayanamsa",
+    houseSystem: "house_system",
+    includeAspects: "include_aspects",
+    includeMinorAspects: "include_minor_aspects",
+    includeMoonVoidOfCourse: "include_moon_void_of_course",
+    includeFixedStars: "include_fixed_stars",
+    fixedStars: "fixed_stars",
+    includeHouses: "include_houses",
+    includeAngles: "include_angles",
+    timeKnown: "time_known",
+    rangeStart: "range_start",
+    rangeEnd: "range_end",
+    transitCategories: "transit_categories",
+    transitPlanets: "transit_planets",
+    natalPoints: "natal_points",
+    aspectTypes: "aspect_types",
+    orbSettings: "orb_settings",
+    byAspect: "by_aspect",
+    byCategory: "by_category",
+    byPlanet: "by_planet",
+    nodeType: "node_type",
+    includeAvastha: "include_avastha",
+    includeYogas: "include_yogas",
+    includePanchang: "include_panchang",
+    includeShadbala: "include_shadbala",
+    includeAshtakavarga: "include_ashtakavarga",
+    dashaLevels: "dasha_levels",
+    referenceDate: "reference_date",
+    masterPolicy: "master_policy",
+    compoundPolicy: "compound_policy",
+    nameSource: "name_source",
+    birthDate: "birth_date",
+    dateContext: "date_context",
+    yearAnchor: "year_anchor",
+    includeInterpretations: "include_interpretations",
+};
+function mapFields(input, fieldMap = upstreamFields) {
+    return Object.fromEntries(Object.entries(input)
+        .filter(([key]) => key !== "idempotencyKey")
+        .map(([key, value]) => {
+        const object = optionalRecord(value);
+        return [fieldMap[key] ?? key, object ? mapFields(object) : value];
+    }));
+}
+function normalizeCities(payload) {
+    if (!Array.isArray(payload.results))
+        throw providerResponseError("FreeAstroAPI city results must be an array");
+    const cities = payload.results.map((value) => {
+        const city = requiredResponseRecord(value, "FreeAstroAPI city");
+        return {
+            name: requiredString(city.name, "FreeAstroAPI city name", providerResponseError),
+            country: requiredString(city.country, "FreeAstroAPI city country", providerResponseError),
+            state: rawStringOrNull(city.state),
+            district: rawStringOrNull(city.district),
+            latitude: requiredNumber(city.lat, "FreeAstroAPI city latitude", providerResponseError),
+            longitude: requiredNumber(city.lng, "FreeAstroAPI city longitude", providerResponseError),
+            timezone: rawStringOrNull(city.timezone),
+            population: optionalNumber(city.population) ?? null,
+            raw: city,
+        };
+    });
+    return { cities, count: cities.length, raw: payload };
+}
+function normalizeActionInput(actionName, input) {
+    if (actionName === "search_cities") {
+        const query = optionalRawString(input.query)?.trim();
+        if (query === undefined || query.length < 2 || query.length > 100)
+            throw providerInputError("query must contain 2-100 characters after trimming");
+        return { ...input, query, country: optionalRawString(input.country)?.trim().toUpperCase() };
+    }
+    // Null location fields mean omitted; explicit zero coordinates remain available to the API.
+    if (actionName === "calculate_vedic_chart")
+        return {
+            ...input,
+            city: input.city ?? undefined,
+            latitude: input.latitude ?? undefined,
+            longitude: input.longitude ?? undefined,
+        };
+    if (actionName !== "calculate_ephemeris")
+        return input;
+    const start = input.start;
+    const end = optionalRawString(input.end);
+    return {
+        ...input,
+        start: start.length === 10 ? `${start}T00:00:00` : start,
+        end: end?.length === 10 ? `${end}T00:00:00` : end,
+    };
+}
+async function executeFreeastroapiAction(actionName, rawInput, apiKey, fetcher, callerSignal) {
+    const route = routes[actionName];
+    const input = normalizeActionInput(actionName, rawInput);
+    validateExpansionInput(actionName, actionName === "calculate_ephemeris" ? rawInput : input);
+    if (actionName === "calculate_bazi_synastry") {
+        validateCalendarDate(input.personA);
+        validateCalendarDate(input.personB);
+    }
+    else if (route.path.startsWith("/api/v1/chinese/") && route.method === "POST") {
+        validateCalendarDate(input);
+    }
+    if (actionName === "calculate_bazi_flow") {
+        const start = input.targetYear;
+        const end = input.targetYearEnd;
+        if (start !== undefined && end !== undefined && end !== null && end !== start) {
+            throw providerInputError("targetYearEnd must equal targetYear; each request supports one prediction year");
+        }
+    }
+    const path = actionName === "get_chinese_calendar" ? `${route.path}/${encodeURIComponent(input.date)}` : route.path;
+    const payload = await requestFreeastroapi({
+        path,
+        method: route.method,
+        apiKey,
+        fetcher,
+        body: route.method === "POST" ? mapFields(input) : undefined,
+        query: route.method === "GET"
+            ? mapFields(actionName === "get_chinese_calendar" ? { language: input.language } : input, {
+                ...upstreamFields,
+                query: "q",
+                longitude: actionName === "get_moon_phase" || actionName === "get_moon_calendar" ? "lon" : "lng",
+                timezone: actionName === "list_sky_events" ? "timezone" : "tz_str",
+            })
+            : undefined,
+        idempotencyKey: optionalRawString(input.idempotencyKey),
+        signal: callerSignal,
+    });
+    return actionName === "search_cities" ? normalizeCities(payload) : { [route.output]: payload };
+}
+export async function validateFreeastroapiCredential(apiKey, fetcher, callerSignal) {
+    await requestFreeastroapi({
+        path: "/api/v1/chinese/bazi/dictionary",
+        method: "GET",
+        apiKey,
+        fetcher,
+        validating: true,
+        signal: callerSignal,
+    });
+    return {
+        profile: { displayName: "FreeAstroAPI API Key" },
+        grantedScopes: [],
+        metadata: {
+            apiBaseUrl: freeastroapiBaseUrl,
+            validationEndpoint: "/api/v1/chinese/bazi/dictionary",
+        },
+    };
+}
+async function requestFreeastroapi(input) {
+    return runProviderRequest({ signal: input.signal, label: "FreeAstroAPI" }, async (signal) => {
+        const url = new URL(input.path, freeastroapiBaseUrl);
+        for (const [key, value] of Object.entries(input.query ?? {})) {
+            if (value !== undefined && value !== null)
+                url.searchParams.set(key, String(value));
+        }
+        const headers = new Headers({
+            accept: "application/json",
+            "x-api-key": input.apiKey,
+            "user-agent": providerUserAgent,
+        });
+        if (input.body)
+            headers.set("content-type", "application/json");
+        if (input.idempotencyKey)
+            headers.set("Idempotency-Key", input.idempotencyKey);
+        const response = await input.fetcher(url.toString(), {
+            method: input.method,
+            headers,
+            signal,
+            body: input.body ? JSON.stringify(input.body) : undefined,
+        });
+        const text = await readProviderTextBody(response, "FreeAstroAPI response");
+        let payload;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            if (response.ok)
+                throw providerResponseError("FreeAstroAPI returned invalid JSON");
+        }
+        if (!response.ok) {
+            const record = optionalRecord(payload);
+            const validationDetails = Array.isArray(record?.detail)
+                ? record.detail
+                    .map((item) => optionalRawString(optionalRecord(item)?.msg))
+                    .filter(Boolean)
+                    .join("; ")
+                : undefined;
+            const detail = optionalRawString(record?.detail) ??
+                optionalRawString(record?.message) ??
+                optionalRawString(record?.error) ??
+                (validationDetails || undefined);
+            const providerCode = optionalRawString(record?.code);
+            const upstreamMessage = detail ?? `FreeAstroAPI request failed with status ${response.status}`;
+            const message = providerCode ? `${upstreamMessage} (${providerCode})` : upstreamMessage;
+            if ((response.status === 401 || response.status === 403) && detail?.trim().toLowerCase() === "invalid api key") {
+                throw new ProviderRequestError(input.validating ? 400 : response.status, message, undefined, input.validating ? "invalid_input" : "authorization_failed");
+            }
+            if (response.status === 429)
+                throw new ProviderRequestError(429, message, undefined, "rate_limited");
+            throw new ProviderRequestError(response.status, message, undefined, "provider_error");
+        }
+        return requiredResponseRecord(payload, "FreeAstroAPI response");
+    });
+}
+export const freeastroapiActionHandlers = mapProviderActionSources("freeastroapi", routes, (name) => (input, context) => executeFreeastroapiAction(name, input, context.apiKey, context.fetcher, context.signal));

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

@@ -1179,7 +1179,7 @@ export const fusionApiOperations = [
         method: "POST",
         path: "/v1/openai-image-async/submit",
         tag: "openai-image-async",
-        description: "Submit asynchronous OpenAI image generation requests, including gpt-image-2 image creation.",
+        description: "Submit asynchronous OpenAI image generation requests, including gpt-image-2 and gpt-image-2.5 image creation.",
         successStatuses: [200],
         pathParams: [],
         inputFields: [
@@ -1193,7 +1193,7 @@ export const fusionApiOperations = [
                 name: "model",
                 kind: "string",
                 required: false,
-                description: "OpenAI image model name",
+                description: "OpenAI image model: gpt-image-2 or gpt-image-2.5. Defaults to gpt-image-2.",
             },
             {
                 name: "background",
@@ -1251,7 +1251,7 @@ export const fusionApiOperations = [
                 name: "size",
                 kind: "string",
                 required: false,
-                description: "Output image size. For GPT Image 2, use auto or WIDTHxHEIGHT. Official constraints: largest dimension <= 3840, width and height multiples of 16, longest side at most 3x the shortest side, and total pixels between 655360 and 8294400 inclusive.",
+                description: "Output image size. For GPT Image 2 and 2.5, use auto or WIDTHxHEIGHT. Official constraints: largest dimension <= 3840, width and height multiples of 16, longest side at most 3x the shortest side, and total pixels between 655360 and 8294400 inclusive.",
             },
             {
                 name: "user",
@@ -1285,7 +1285,7 @@ export const fusionApiOperations = [
         method: "POST",
         path: "/v1/openai-image-edit-async/submit",
         tag: "openai-image-edit-async",
-        description: "Submit asynchronous OpenAI image edit requests, including gpt-image-2 image editing.",
+        description: "Submit asynchronous OpenAI image edit requests, including gpt-image-2 and gpt-image-2.5 image editing.",
         successStatuses: [200],
         pathParams: [],
         inputFields: [
@@ -1299,7 +1299,7 @@ export const fusionApiOperations = [
                 name: "model",
                 kind: "string",
                 required: false,
-                description: "OpenAI image model name",
+                description: "OpenAI image model: gpt-image-2 or gpt-image-2.5. Defaults to gpt-image-2.",
             },
             {
                 name: "background",
@@ -1350,7 +1350,7 @@ export const fusionApiOperations = [
                 name: "size",
                 kind: "string",
                 required: false,
-                description: "Output image size. For GPT Image 2, use auto or WIDTHxHEIGHT. Official constraints: largest dimension <= 3840, width and height multiples of 16, longest side at most 3x the shortest side, and total pixels between 655360 and 8294400 inclusive.",
+                description: "Output image size. For GPT Image 2 and 2.5, use auto or WIDTHxHEIGHT. Official constraints: largest dimension <= 3840, width and height multiples of 16, longest side at most 3x the shortest side, and total pixels between 655360 and 8294400 inclusive.",
             },
             {
                 name: "user",
@@ -1362,13 +1362,13 @@ export const fusionApiOperations = [
                 name: "images",
                 kind: "array",
                 required: true,
-                description: "Reference images to edit or compose from",
+                description: "Reference images to edit or compose from: 1 to 16 objects with image_url, a public HTTP(S) URL or base64 image data URL. Each image must be at most 10 MiB. file_id is not supported.",
             },
             {
                 name: "mask",
                 kind: "object",
                 required: false,
-                description: "Mask image reference for partial edits",
+                description: "Mask object with image_url, a public HTTP(S) URL or base64 image data URL, at most 10 MiB. file_id is not supported.",
             },
         ],
     },

package/src/providers/fuxin/executors.js

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 import { basename } from "node:path";
 import { stringify as stringifyQuery } from "node:querystring";
 import { compactObject, optionalInteger, optionalNumber, optionalRecord, optionalScalarString, optionalString, } from "../../core/cast.js";
-import { assertPublicHttpUrl, readBoundedResponseBytes } from "../../core/request.js";
+import { assertPublicHttpUrl, storeResponseInTransit } from "../../core/request.js";
 import { defineProviderExecutors, isAbortLikeError, normalizeProviderProxyEndpoint, normalizeProviderProxyHeaders, normalizeProviderProxyQuery, providerFetch, ProviderRequestError, providerUserAgent, readProviderProxyResponse, requireCustomCredential, requiredInputString, toProviderProxyError, } from "../provider-runtime.js";
 const service = "fuxin";
 const fuxinApiBaseUrl = "https://servicesapi.foxitsoftware.cn/api/";
@@ -254,23 +254,24 @@ async function fuxinDownloadFile(input, context) {
         }),
         signal: context.signal,
     });
-    const bytes = await readBoundedResponseBytes(response, {
-        maxBytes: context.transitFiles.maxBytes,
-        fieldName: "Foxit file download",
-        createError: (message) => new ProviderRequestError(413, message),
-    });
     const mimeType = normalizeMimeType(response.headers.get("content-type")) ?? fuxinBinaryMimeTypeFallback;
     const resolvedFileName = fileName ??
         readDispositionFileName(response.headers.get("content-disposition")) ??
         buildDefaultFileName("foxit-download", mimeType);
-    const upload = await context.transitFiles.create(new File([Uint8Array.from(bytes)], resolvedFileName, { type: mimeType }));
+    const upload = await storeResponseInTransit(response, context.transitFiles, {
+        name: resolvedFileName,
+        mimeType,
+        fieldName: "Foxit file download",
+        createError: (message) => new ProviderRequestError(413, message),
+        signal: context.signal,
+    });
     return {
         file: {
             name: resolvedFileName,
             mimetype: mimeType,
             downloadUrl: upload.downloadUrl,
         },
-        contentLength: bytes.byteLength,
+        contentLength: upload.sizeBytes,
     };
 }
 async function fuxinGetUserStock(context, phase = "execute") {

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

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

package/src/providers/fxmacrodata/executors.js

@@ -0,0 +1,32 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { defineProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
+import { createFxmacrodataContext, fxmacrodataActionHandlers, fxmacrodataApiBaseUrl, readFxmacrodataError, validateFxmacrodataCredential, } from "./runtime.js";
+const service = "fxmacrodata";
+export const executors = defineProviderExecutors({
+    service,
+    handlers: fxmacrodataActionHandlers,
+    createContext: createFxmacrodataContext,
+    skipDnsValidation: true,
+});
+/**
+ * Holds, per proxied request, the key the runtime attached, so the error reader can
+ * remove it from upstream error text without a second credential lookup.
+ */
+const proxyRequestKey = new AsyncLocalStorage();
+const keyedProxy = defineProviderProxy({
+    service,
+    baseUrl: fxmacrodataApiBaseUrl,
+    auth: { type: "optional_api_key_header", name: "X-API-Key" },
+    customizeRequest({ credential }) {
+        const request = proxyRequestKey.getStore();
+        if (request && credential?.authType === "api_key") {
+            request.apiKey = credential.apiKey;
+        }
+    },
+    readError: (response) => readFxmacrodataError(response, proxyRequestKey.getStore()?.apiKey),
+    skipDnsValidation: true,
+});
+export const proxy = (input, context) => proxyRequestKey.run({}, () => keyedProxy(input, context));
+export const credentialValidators = {
+    apiKey: validateFxmacrodataCredential,
+};

package/src/providers/fxmacrodata/runtime.d.ts

@@ -0,0 +1,34 @@
+import type { CredentialValidationResult, ExecutionContext } from "../../core/types.ts";
+import type { ProviderActionHandlers, ProviderFetch } from "../provider-runtime.ts";
+import { ProviderRequestError } from "../provider-runtime.ts";
+export declare const fxmacrodataApiBaseUrl = "https://api.fxmacrodata.com";
+interface FxmacrodataContext {
+    apiKey?: string;
+    fetcher: ProviderFetch;
+    signal?: AbortSignal;
+}
+type FxmacrodataActionHandler = (input: Record<string, unknown>, context: FxmacrodataContext) => Promise<unknown>;
+export declare const fxmacrodataActionHandlers: ProviderActionHandlers<"fxmacrodata", FxmacrodataActionHandler>;
+/**
+ * Build the action context. A no_auth connection has no key and reaches the keyless USD data only.
+ */
+export declare function createFxmacrodataContext(context: ExecutionContext, fetcher: ProviderFetch): Promise<FxmacrodataContext>;
+/**
+ * Validate a key against the USD indicator catalogue, which answers without a key
+ * but rejects a key it does not recognise.
+ */
+export declare function validateFxmacrodataCredential(input: {
+    apiKey: string;
+}, options: {
+    fetcher: typeof fetch;
+    signal?: AbortSignal;
+}): Promise<CredentialValidationResult>;
+/**
+ * Read an FXMacroData error response and map it onto the runtime's status conventions.
+ * The API answers a keyless request for data that needs a key with a 401 and the code
+ * api_key_required; that is reported as invalid input, not as a credential to reconnect,
+ * for actions and the proxy alike. Other authorization failures retain the upstream status without guessing that
+ * reconnecting will help. Known keys are removed from diagnostic messages.
+ */
+export declare function readFxmacrodataError(response: Response, apiKey?: string): Promise<ProviderRequestError>;
+export {};

package/src/providers/fxmacrodata/runtime.js

@@ -0,0 +1,154 @@
+import { optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
+import { queryParams } from "../../core/request.js";
+import { parseProviderJsonBodyText, providerInputError, ProviderRequestError, providerUserAgent, readProviderErrorTextBody, readProviderTextBody, requiredInputString, requiredResponseRecord, runProviderRequest, withRetryAfterSeconds, } from "../provider-runtime.js";
+export const fxmacrodataApiBaseUrl = "https://api.fxmacrodata.com";
+export const fxmacrodataActionHandlers = {
+    async get_announcements(input, context) {
+        return requestFxmacrodata({
+            context,
+            path: `/v1/announcements/${currencyCode(input.currency, "currency")}/${indicatorSlug(input.indicator)}`,
+            query: dateWindow(input),
+        });
+    },
+    async get_latest_announcements(input, context) {
+        return requestFxmacrodata({
+            context,
+            path: `/v1/announcements/${currencyCode(input.currency, "currency")}/latest`,
+        });
+    },
+    async get_release_calendar(input, context) {
+        return requestFxmacrodata({
+            context,
+            path: `/v1/calendar/${currencyCode(input.currency, "currency")}`,
+            query: {
+                indicator: input.indicator === undefined ? undefined : indicatorSlug(input.indicator),
+                start_date: optionalString(input.startDate),
+                end_date: optionalString(input.endDate),
+            },
+        });
+    },
+    async get_data_catalogue(input, context) {
+        return requestFxmacrodata({
+            context,
+            path: `/v1/data_catalogue/${currencyCode(input.currency, "currency")}`,
+        });
+    },
+    async get_forex(input, context) {
+        return requestFxmacrodata({
+            context,
+            path: `/v1/forex/${currencyCode(input.base, "base")}/${currencyCode(input.quote, "quote")}`,
+            query: dateWindow(input),
+        });
+    },
+    async get_cot(input, context) {
+        return requestFxmacrodata({
+            context,
+            path: `/v1/cot/${currencyCode(input.currency, "currency")}`,
+            query: dateWindow(input),
+        });
+    },
+};
+/**
+ * Build the action context. A no_auth connection has no key and reaches the keyless USD data only.
+ */
+export async function createFxmacrodataContext(context, fetcher) {
+    const credential = await context.getCredential("fxmacrodata");
+    return {
+        apiKey: credential?.authType === "api_key" ? credential.apiKey : undefined,
+        fetcher,
+        signal: context.signal,
+    };
+}
+/**
+ * Validate a key against the USD indicator catalogue, which answers without a key
+ * but rejects a key it does not recognise.
+ */
+export async function validateFxmacrodataCredential(input, options) {
+    await requestFxmacrodata({
+        context: { apiKey: input.apiKey, fetcher: options.fetcher, signal: options.signal },
+        path: "/v1/data_catalogue/usd",
+    });
+    return {
+        profile: { displayName: "FXMacroData API Key" },
+        grantedScopes: [],
+        metadata: { apiBaseUrl: fxmacrodataApiBaseUrl, validationEndpoint: "/v1/data_catalogue/usd" },
+    };
+}
+/**
+ * Read an FXMacroData error response and map it onto the runtime's status conventions.
+ * The API answers a keyless request for data that needs a key with a 401 and the code
+ * api_key_required; that is reported as invalid input, not as a credential to reconnect,
+ * for actions and the proxy alike. Other authorization failures retain the upstream status without guessing that
+ * reconnecting will help. Known keys are removed from diagnostic messages.
+ */
+export async function readFxmacrodataError(response, apiKey) {
+    const status = response.status;
+    const payload = parseProviderJsonBodyText(await readProviderErrorTextBody(response, "FXMacroData error response"), {
+        emptyBody: {},
+        invalidJsonMessage: "FXMacroData returned malformed JSON",
+        invalidJsonFallback: () => ({}),
+    });
+    const body = optionalRecord(payload);
+    const upstreamMessage = optionalString(body?.detail) ?? optionalString(body?.message) ?? `FXMacroData request failed with HTTP ${status}`;
+    const message = apiKey ? upstreamMessage.replaceAll(apiKey, "[REDACTED]") : upstreamMessage;
+    const containsApiKey = apiKey && JSON.stringify(payload).includes(JSON.stringify(apiKey).slice(1, -1));
+    const details = withRetryAfterSeconds(response, containsApiKey ? {} : payload);
+    if ((status === 401 || status === 403) && optionalString(body?.code) === "api_key_required") {
+        return new ProviderRequestError(400, message, details);
+    }
+    return new ProviderRequestError(status, message, details, status === 429 ? "rate_limited" : "provider_error");
+}
+/**
+ * Check the key before it goes into a header. The platform's own error for an invalid
+ * header value quotes the value, so a malformed key is refused here without echoing it.
+ */
+function apiKeyHeaderValue(apiKey) {
+    if (!/^[!-~]+$/.test(apiKey)) {
+        throw providerInputError("The FXMacroData API key contains characters that are not valid in an HTTP header.");
+    }
+    return apiKey;
+}
+function currencyCode(value, fieldName) {
+    const code = requiredInputString(value, fieldName).toLowerCase();
+    if (!/^[a-z]{3}$/.test(code)) {
+        throw providerInputError(`${fieldName} must be a three-letter currency code.`);
+    }
+    return code;
+}
+function indicatorSlug(value) {
+    const slug = requiredInputString(value, "indicator").toLowerCase();
+    if (!/^[a-z0-9_]+$/.test(slug)) {
+        throw providerInputError("indicator must be a slug such as inflation or policy_rate.");
+    }
+    return slug;
+}
+function dateWindow(input) {
+    return {
+        start_date: optionalString(input.startDate),
+        end_date: optionalString(input.endDate),
+        limit: optionalInteger(input.limit),
+        offset: optionalInteger(input.offset),
+    };
+}
+async function requestFxmacrodata(input) {
+    const { context } = input;
+    const url = new URL(`${fxmacrodataApiBaseUrl}${input.path}`);
+    for (const [key, value] of Object.entries(queryParams(input.query ?? {}))) {
+        url.searchParams.set(key, value);
+    }
+    const headers = new Headers({ accept: "application/json", "user-agent": providerUserAgent });
+    if (context.apiKey)
+        headers.set("x-api-key", apiKeyHeaderValue(context.apiKey));
+    return runProviderRequest({ signal: context.signal, label: "FXMacroData" }, async (signal) => {
+        // context.fetcher follows redirects itself and drops X-API-Key on any change of origin or scheme.
+        const response = await context.fetcher(url, { method: "GET", headers, signal });
+        if (!response.ok) {
+            throw await readFxmacrodataError(response, context.apiKey);
+        }
+        const payload = parseProviderJsonBodyText(await readProviderTextBody(response, "FXMacroData response"), {
+            emptyBody: {},
+            invalidJsonMessage: "FXMacroData returned malformed JSON",
+        });
+        return requiredResponseRecord(payload, "FXMacroData response");
+    });
+}

package/src/providers/gemini/runtime.d.ts

@@ -2,7 +2,7 @@ import type { ApiKeyProviderContext } from "../provider-runtime.ts";
 export declare const geminiApiBaseUrl = "https://generativelanguage.googleapis.com/v1beta";
 export declare const geminiDefaultTextModel = "gemini-2.5-flash";
 export declare const geminiDefaultEmbeddingModel = "text-embedding-004";
-export declare const geminiDefaultTokenCountModel = "gemini-2.0-flash";
+export declare const geminiDefaultTokenCountModel = "gemini-3.6-flash";
 export declare const geminiDefaultImageModel = "gemini-3-pro-image-preview";
 export declare const geminiDefaultVideoModel = "veo-3.0-generate-001";
 export declare const geminiDefaultVideoPollIntervalMs = 10000;

package/src/providers/gemini/runtime.js

@@ -4,7 +4,7 @@ import { isAbortLikeError, providerUserAgent, ProviderRequestError } from "../pr
 export const geminiApiBaseUrl = "https://generativelanguage.googleapis.com/v1beta";
 export const geminiDefaultTextModel = "gemini-2.5-flash";
 export const geminiDefaultEmbeddingModel = "text-embedding-004";
-export const geminiDefaultTokenCountModel = "gemini-2.0-flash";
+export const geminiDefaultTokenCountModel = "gemini-3.6-flash";
 export const geminiDefaultImageModel = "gemini-3-pro-image-preview";
 export const geminiDefaultVideoModel = "veo-3.0-generate-001";
 export const geminiDefaultVideoPollIntervalMs = 10_000;

package/src/providers/getyoutubetranscript/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;