@oomol-lab/open-connector 1.7.0 → 1.9.0

package/src/providers/freeastroapi/input-validation.js

@@ -0,0 +1,186 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { providerInputError } from "../provider-runtime.js";
+import { numerologyProfiles } from "./constants.js";
+export function validateCalendarDate(input) {
+    const year = input.year;
+    const month = input.month;
+    const day = input.day;
+    const leap = year % 4 === 0 && (input.calendar === "julian" || year % 100 !== 0 || year % 400 === 0);
+    const days = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    if (month < 1 || month > 12 || day < 1 || day > days[month - 1])
+        throw providerInputError("The supplied calendar date does not exist");
+}
+function hasLocation(input) {
+    return (Boolean(optionalRawString(input.city)?.trim()) || (input.latitude !== undefined && input.longitude !== undefined));
+}
+function validateCoordinates(input) {
+    if ((input.latitude !== undefined) !== (input.longitude !== undefined))
+        throw providerInputError("latitude and longitude must be supplied together");
+}
+function validateTimezone(value, allowAuto = true, allowLmt = false) {
+    const timezone = optionalRawString(value);
+    if (timezone === undefined || (allowAuto && timezone === "AUTO") || (allowLmt && timezone === "LMT"))
+        return;
+    try {
+        if (timezone.startsWith("+") || timezone.startsWith("-"))
+            throw new Error("fixed offset");
+        new Intl.DateTimeFormat("en", { timeZone: timezone });
+    }
+    catch {
+        throw providerInputError("timezone must be an IANA timezone name or a documented automatic time mode");
+    }
+}
+function parseInstant(value, field, dateEnd = false) {
+    const date = value.slice(0, 10);
+    const parts = date.split("-");
+    if (parts.length !== 3 ||
+        parts[0].length !== 4 ||
+        parts[1].length !== 2 ||
+        parts[2].length !== 2 ||
+        !parts.every((part) => [...part].every((character) => character >= "0" && character <= "9")))
+        throw providerInputError(`${field} must be an ISO date or datetime`);
+    const [year, month, day] = parts.map(Number);
+    validateCalendarDate({ year, month, day });
+    if (year < 1)
+        throw providerInputError(`${field} year must be positive`);
+    if (value.length !== 10 && value[10] !== "T")
+        throw providerInputError(`${field} must be an ISO date or datetime`);
+    const time = value.slice(11);
+    const hasOffset = time.endsWith("Z") || time.includes("+") || time.includes("-");
+    const normalized = value.length === 10 ? `${value}T${dateEnd ? "23:59:59" : "00:00:00"}Z` : hasOffset ? value : `${value}Z`;
+    const instant = Date.parse(normalized);
+    if (!Number.isFinite(instant))
+        throw providerInputError(`${field} must be an ISO date or datetime`);
+    return { instant, comparable: hasOffset };
+}
+export function validateExpansionInput(actionName, input) {
+    if (actionName === "get_moon_phase" || actionName === "get_moon_calendar" || actionName === "calculate_ephemeris") {
+        validateCoordinates(input);
+        validateTimezone(input.timezone);
+    }
+    if (actionName === "get_moon_phase") {
+        if (input.includeRiseSet === true && !hasLocation(input))
+            throw providerInputError("includeRiseSet requires a city or paired coordinates");
+        if (input.date !== undefined && input.date !== "now")
+            parseInstant(input.date, "date");
+    }
+    if (actionName === "list_sky_events")
+        validateTimezone(input.timezone, false);
+    if (actionName === "calculate_vedic_chart") {
+        validateCalendarDate(input);
+        validateCoordinates(input);
+        validateTimezone(input.timezone, true, true);
+    }
+    if (actionName === "calculate_ephemeris") {
+        const startValue = input.start;
+        const endValue = optionalRawString(input.end);
+        const start = parseInstant(startValue, "start");
+        const end = endValue === undefined ? undefined : parseInstant(endValue, "end");
+        const dateOnlyRange = startValue.length === 10 && endValue?.length === 10;
+        const knownInstants = (start.comparable && end?.comparable) || input.timezone === "UTC";
+        if (end && (dateOnlyRange || knownInstants) && end.instant < start.instant)
+            throw providerInputError("end must not precede start");
+        const step = (input.step ?? "1d");
+        const unit = step.slice(-1);
+        const digits = step.slice(0, -1);
+        if (!digits ||
+            ![...digits].every((character) => character >= "0" && character <= "9") ||
+            !Number.isInteger(Number(digits)) ||
+            Number(digits) <= 0 ||
+            !["m", "h", "d"].includes(unit))
+            throw providerInputError("step must be a positive whole minute, hour, or day interval such as 5m, 1h, or 1d");
+        if (end && knownInstants) {
+            const stepMs = Number(digits) * { m: 60000, h: 3600000, d: 86400000 }[unit];
+            const rows = Math.floor((end.instant - start.instant) / stepMs) + 1;
+            if (unit === "m" && rows > 1440)
+                throw providerInputError("Minute-step ephemeris ranges cannot exceed 1440 rows");
+            if (input.format === "table" && input.tableStyle === "grid" && rows > 31)
+                throw providerInputError("Grid ephemeris ranges cannot exceed 31 rows");
+        }
+    }
+    if (actionName === "calculate_transit_timeline") {
+        const natal = input.natal;
+        validateCalendarDate(natal);
+        validateTimezone(natal.timezone);
+        const anglePoints = ["ascendant", "midheaven", "descendant", "ic", "vertex", "part_of_fortune"];
+        const natalPoints = input.natalPoints;
+        const usesAngles = natalPoints === undefined ||
+            natalPoints.some((point) => anglePoints.includes(point)) ||
+            input.includeHouses === true;
+        if (natal.timeKnown !== false && usesAngles && natal.hour === undefined)
+            throw providerInputError("natal.hour is required for angle-sensitive timelines; otherwise provide planet-only natalPoints or set natal.timeKnown to false");
+        const start = parseInstant(input.rangeStart, "rangeStart");
+        const end = parseInstant(input.rangeEnd, "rangeEnd", true);
+        if (end.instant < start.instant)
+            throw providerInputError("rangeEnd must not precede rangeStart");
+        if (input.mode === "year_slow") {
+            if (end.instant - start.instant > 366 * 86400000)
+                throw providerInputError("year_slow ranges cannot exceed 366 days");
+            const categories = input.transitCategories;
+            if (categories?.some((category) => category !== "medium" && category !== "slow"))
+                throw providerInputError("year_slow transitCategories can only contain medium and slow");
+        }
+        else {
+            const a = new Date(start.instant), b = new Date(end.instant);
+            if (a.getUTCFullYear() !== b.getUTCFullYear() || a.getUTCMonth() !== b.getUTCMonth())
+                throw providerInputError("month mode must stay within one UTC calendar month");
+        }
+        if (natal.timeKnown === false &&
+            input.natalPoints?.some((point) => anglePoints.includes(point)))
+            throw providerInputError("Angle-derived natal points require a known birth time");
+    }
+    if (actionName === "calculate_numerology_profile")
+        validateNumerologyInput(input);
+}
+function validateNumerologyInput(input) {
+    const method = input.method;
+    const subject = input.subject;
+    const system = method.system;
+    const profiles = numerologyProfiles[system];
+    if (method.profile !== undefined && !profiles.includes(method.profile))
+        throw providerInputError("method.profile must belong to the selected numerology system");
+    const master = system === "pythagorean" ? "preserve_core_11_22_33" : system === "kabbalah" ? "not_applicable" : "reduce_all";
+    if (method.masterPolicy !== undefined && method.masterPolicy !== master)
+        throw providerInputError("method.masterPolicy is incompatible with the selected numerology system");
+    if (method.compoundPolicy === "root_only" && system !== "pythagorean")
+        throw providerInputError("root_only is only supported by Pythagorean profiles");
+    if ((system === "pythagorean" || system === "chaldean") && method.nameSource !== undefined)
+        throw providerInputError("method.nameSource is only supported by Kabbalah and Ank Jyotish; Chaldean selects names through method.profile");
+    validateCoordinates(subject);
+    if (system === "pythagorean") {
+        const referenceDate = optionalRecord(input.dateContext)?.referenceDate;
+        if (referenceDate === undefined && subject.timezone === undefined)
+            throw providerInputError("Pythagorean cycles require dateContext.referenceDate or subject.timezone");
+        validateTimezone(subject.timezone);
+        if (referenceDate === undefined && subject.timezone === "AUTO" && !hasLocation(subject))
+            throw providerInputError("AUTO timezone requires a city or paired coordinates when no referenceDate is provided");
+    }
+    const name = optionalRecord(subject.name);
+    if (!name)
+        return;
+    const bothNames = name.birth !== undefined && name.current !== undefined;
+    let selected = optionalRawString(method.nameSource);
+    if (system === "chaldean") {
+        const profile = optionalRawString(method.profile);
+        if (profile === "birth_name" || profile === "chaldean-cheiro-birth-name-v1")
+            selected = "birth";
+        if (profile === "current_name" || profile === "chaldean-cheiro-current-name-v1")
+            selected = "current";
+        if (bothNames && !selected)
+            throw providerInputError("Chaldean input with both names requires an explicit current_name or birth_name profile");
+    }
+    if ((system === "kabbalah" || system === "ank_jyotish") && bothNames && !selected)
+        throw providerInputError("method.nameSource is required when both birth and current names are supplied");
+    if (selected && name[selected] === undefined)
+        throw providerInputError(`The selected ${selected} name is missing`);
+    const transliteration = optionalRecord(name.transliteration);
+    const needsTransliteration = name.script !== undefined && name.script !== "Latn" && system !== "kabbalah";
+    const sources = system === "ank_jyotish" ? [selected ?? (name.birth === undefined ? "current" : "birth")] : ["birth", "current"];
+    for (const source of sources) {
+        if (name[source] !== undefined &&
+            (needsTransliteration ||
+                (transliteration !== undefined && (system === "pythagorean" || system === "chaldean"))) &&
+            transliteration?.[source] === undefined)
+            throw providerInputError(`subject.name.transliteration.${source} is required for the supplied name`);
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { CredentialValidationResult } from "../../core/types.ts";
+import type { ProviderActionHandlers, ApiKeyProviderContext, ProviderRuntimeHandler } from "../provider-runtime.ts";
+export declare const freeastroapiBaseUrl = "https://api.freeastroapi.com";
+export declare function validateFreeastroapiCredential(apiKey: string, fetcher: typeof fetch, callerSignal?: AbortSignal): Promise<CredentialValidationResult>;
+export declare const freeastroapiActionHandlers: ProviderActionHandlers<"freeastroapi", ProviderRuntimeHandler<ApiKeyProviderContext>>;

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,
+};