@oomol-lab/open-connector 1.6.2 → 1.6.3

package/src/providers/linkfox/actions.js

@@ -6,6 +6,7 @@ import { chuhaijiangActions } from "./chuhaijiang-actions.js";
 import { maidalvAction } from "./maidalv-actions.js";
 import { mercadoActions } from "./mercado-actions.js";
 import { seerfarActions } from "./seerfar-actions.js";
+import { sifActions } from "./sif-actions.js";
 import { zhihuiyaActions } from "./zhihuiya-actions.js";
 const service = "linkfox";
 const amazonDomains = [
@@ -974,6 +975,7 @@ const tiktokShopProductInput = s.object("TikTok Shop product detail parameters."
     region: s.optional(s.stringEnum("The TikTok Shop region.", ["US", "GB", "ID", "MY", "TH", "VN", "PH", "SG", "DE", "FR", "IT", "ES"])),
 });
 export const linkfoxActions = [
+    ...sifActions,
     ...mercadoActions,
     ...zhihuiyaActions,
     ...chuhaijiangActions,

package/src/providers/linkfox/runtime.js

@@ -4,6 +4,7 @@ import { chuhaijiangOperations } from "./chuhaijiang-actions.js";
 import { normalizeChuhaijiang, searchChuhaijiangImage } from "./chuhaijiang-runtime.js";
 import { mercadoOperations } from "./mercado-actions.js";
 import { seerfarOperations } from "./seerfar-actions.js";
+import { sifOperations } from "./sif-actions.js";
 import { zhihuiyaOperations } from "./zhihuiya-actions.js";
 import { validateZhihuiyaInput } from "./zhihuiya-runtime.js";
 const zhihuiyaOperationsByName = new Map(zhihuiyaOperations.map(({ action, path }) => [action.name, { path }]));
@@ -32,6 +33,10 @@ const directOperations = {
             normalize: (payload) => requiredResponseRecord(payload, "LinkFox Seerfar response"),
         },
     ])),
+    ...Object.fromEntries(sifOperations.map(({ action, path }) => [
+        action.name,
+        { path, gatewayBusinessCodeOnly: true, normalize: normalizeSifResult },
+    ])),
     get_current_account: {
         path: "/account/currentByAPI",
         method: "GET",
@@ -299,10 +304,13 @@ export async function executeLinkfoxAction(actionName, input, apiKey, fetcher, p
     }
     const direct = directOperations[actionName];
     if (direct) {
+        if (direct.gatewayBusinessCodeOnly)
+            validateSifInput(actionName, input);
         const body = direct.buildBody ? direct.buildBody(input) : input;
         const payload = await requestLinkfoxPayload(direct.path, {
             method: direct.method ?? "POST",
             timeoutMs: direct.timeoutMs,
+            gatewayBusinessCodeOnly: direct.gatewayBusinessCodeOnly,
             ...((direct.method ?? "POST") === "POST" ? { body } : {}),
         }, apiKey, fetcher, "execute", false, parentSignal);
         return direct.normalize(payload);
@@ -313,6 +321,32 @@ export async function executeLinkfoxAction(actionName, input, apiKey, fetcher, p
     }
     return handler(input, { apiKey, fetcher, signal: parentSignal });
 }
+function validateSifInput(actionName, input) {
+    if (actionName === "list_sif_asin_keywords") {
+        const periodType = optionalString(input.timePieceType) ?? "latelyDay";
+        const periodValue = optionalString(input.timePieceValue);
+        if ((periodType === "month" || periodType === "week") && !periodValue) {
+            throw new ProviderRequestError(400, "timePieceValue is required for month or week periods");
+        }
+    }
+    const startDate = optionalString(input.startDate);
+    const endDate = optionalString(input.endDate);
+    if ((startDate && !endDate) || (!startDate && endDate)) {
+        throw new ProviderRequestError(400, "startDate and endDate must be provided together");
+    }
+    if ((startDate || endDate) && input.last7d !== false) {
+        throw new ProviderRequestError(400, "last7d must be false when a date range is provided");
+    }
+    if (startDate && endDate && startDate > endDate) {
+        throw new ProviderRequestError(400, "startDate must not be later than endDate");
+    }
+    if (actionName === "get_sif_asin_traffic_summary") {
+        const asins = optionalString(input.asins);
+        if (asins && asins.split(",").length > 10) {
+            throw new ProviderRequestError(400, "asins must contain at most 10 comma-separated ASINs");
+        }
+    }
+}
 function validateLinkfoxActionInput(actionName, input) {
     if (actionName === "search_amazon_by_image" && input.deliveryZip && input.countryOrAreaCode) {
         throw new ProviderRequestError(400, "deliveryZip and countryOrAreaCode cannot be used together");
@@ -422,7 +456,9 @@ async function requestLinkfoxPayload(path, options, apiKey, fetcher, phase = "ex
             signal,
         });
         const payload = await readJsonPayload(response);
-        const businessCode = readBusinessCode(payload);
+        const businessCode = options.gatewayBusinessCodeOnly
+            ? readGatewayBusinessCode(payload)
+            : readBusinessCode(payload);
         if (acceptCreditError && businessCode === 402)
             return payload;
         if (!response.ok || (businessCode !== undefined && businessCode !== 200)) {
@@ -482,6 +518,17 @@ function readBusinessCode(payload) {
     }
     return undefined;
 }
+function readGatewayBusinessCode(payload) {
+    const record = optionalRecord(payload);
+    for (const key of ["errcode", "errorCode"]) {
+        const value = record?.[key];
+        if (typeof value === "number" && Number.isFinite(value))
+            return value;
+        if (typeof value === "string" && value.trim() && Number.isFinite(Number(value)))
+            return Number(value);
+    }
+    return undefined;
+}
 function readErrorMessage(payload) {
     if (typeof payload === "string" && payload.trim()) {
         return payload.trim();
@@ -522,6 +569,28 @@ function normalizeDataList(payload) {
         costToken: readNumber(record.costToken),
     };
 }
+function normalizeSifResult(payload) {
+    const record = requireRecord(payload, "LinkFox returned an invalid SIF response");
+    const code = typeof record.code === "string" || typeof record.code === "number" ? String(record.code) : undefined;
+    if (code !== "1") {
+        throw new ProviderRequestError(502, readString(record.msg) ?? "LinkFox SIF returned an unsuccessful business response", record);
+    }
+    const data = readArray(record.data);
+    if (!data)
+        throw new ProviderRequestError(502, "LinkFox SIF response did not include data", record);
+    return {
+        ...record,
+        code,
+        msg: readString(record.msg) ?? null,
+        total: readInteger(record.total) ?? data.length,
+        data,
+        columns: readArray(record.columns) ?? [],
+        type: readString(record.type) ?? null,
+        title: readString(record.title) ?? null,
+        costTime: readInteger(record.costTime),
+        costToken: readNumber(record.costToken),
+    };
+}
 function normalizeVideoList(payload) {
     const record = requireRecord(payload, "LinkFox returned an invalid video response");
     const videos = readArray(record.videos) ?? readArray(record.data) ?? [];

package/src/providers/linkfox/sif-actions.d.ts

@@ -0,0 +1,10 @@
+import type { ProviderActionDefinition } from "../../core/provider-definition.ts";
+import type { ActionDefinition } from "../../core/types.ts";
+interface SifOperation {
+    path: string;
+    usage: number;
+    action: ProviderActionDefinition;
+}
+export declare const sifOperations: readonly SifOperation[];
+export declare const sifActions: readonly ActionDefinition[];
+export {};

package/src/providers/linkfox/sif-actions.js

@@ -0,0 +1,193 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const sifCountries = ["US", "UK", "DE", "CA", "JP", "FR", "ES", "IT", "MX", "AU", "AE", "BR", "SA"];
+const summarySortFields = [
+    "totalKeywordNum",
+    "naturalKeywordNum",
+    "brandKeywordNum",
+    "vedioKeywordNum",
+    "acKeywordNum",
+    "erKeywordNum",
+    "trKeywordNum",
+    "sumScore",
+    "totalNfScore",
+    "totalSpSocre",
+    "totalBrandScore",
+    "totalVedioScore",
+    "totalAcScore",
+    "totalTrScore",
+    "totalErScore",
+];
+const keywordSummaryConditions = [
+    "nfPosition",
+    "isSpAd",
+    "isVedioAd",
+    "isBrandAd",
+    "isPPCAd",
+    "isSearchRecommend",
+    "acAd",
+    "totalPeriod.in",
+    "nfKeywordCnt.total",
+    "nfKeywordCnt.in",
+    "adKeywordCnt.total",
+    "adKeywordCnt.in",
+    "allSpKeywordCnt.total",
+    "allSpKeywordCnt.in",
+    "spKeywordCnt.total",
+    "spKeywordCnt.in",
+    "recSpKeywordCnt.total",
+    "recSpKeywordCnt.in",
+    "allSbKeywordCnt.total",
+    "allSbKeywordCnt.in",
+    "sbKeywordCnt.total",
+    "sbKeywordCnt.in",
+    "sbvKeywordCnt.total",
+    "sbvKeywordCnt.in",
+];
+const _asinKeywordConditionValues = [
+    "nfPosition",
+    "isSpAd",
+    "isBrandAd",
+    "isVedioAd",
+    "isAC",
+    "isAccurateKw",
+    "isAccurateTailKw",
+    "isPurchaseKw",
+    "isQualityKw",
+    "isStableKw",
+    "isLossKw",
+    "isInvalidKw",
+    "isMultiVariantKw",
+    "isSearchVolUpKw",
+    "isSearchVolDownKw",
+    "totalPeriod.in",
+    "nfKeywordCnt.total",
+    "nfKeywordCnt.in",
+    "adKeywordCnt.total",
+    "adKeywordCnt.in",
+    "allSpKeywordCnt.total",
+    "allSpKeywordCnt.in",
+    "spKeywordCnt.total",
+    "spKeywordCnt.in",
+    "recSpKeywordCnt.total",
+    "recSpKeywordCnt.in",
+    "allSbKeywordCnt.total",
+    "allSbKeywordCnt.in",
+    "sbKeywordCnt.total",
+    "sbKeywordCnt.in",
+    "sbvKeywordCnt.total",
+    "sbvKeywordCnt.in",
+];
+const _asinSummaryConditionValues = ["nf", "sp", "sb", "sbv", "ad", "acAd", "totalPeriod.in"];
+const countrySchema = s.optional(s.stringEnum("The Amazon marketplace code. LinkFox defaults to US when omitted.", sifCountries));
+const nullableInteger = (description) => s.nullable(s.integer(description));
+const nullableNumber = (description) => s.nullable(s.number(description));
+const nullableString = (description) => s.nullable(s.string(description));
+function resultSchema(description, recordDescription, extra = {}) {
+    return s.looseRequiredObject(description, {
+        code: s.string("The SIF business code; 1 indicates success."),
+        msg: nullableString("The SIF response message."),
+        total: s.integer("The number of records returned by this request.", { minimum: 0 }),
+        data: s.array("The SIF records returned by this request.", s.looseObject(recordDescription)),
+        columns: s.array("The LinkFox rendering-column definitions.", s.looseObject("A provider-defined rendering-column definition.")),
+        type: nullableString("The LinkFox rendering style when provided."),
+        title: nullableString("The result title when provided."),
+        costTime: nullableInteger("The upstream processing time in milliseconds."),
+        costToken: nullableNumber("The LinkFox token cost when provided."),
+        ...extra,
+    });
+}
+const asinKeywordsInputBase = s.object("Parameters for reverse-searching one ASIN's SIF keywords.", {
+    asin: s.nonEmptyString("The single Amazon ASIN to analyze.", { maxLength: 1000 }),
+    country: countrySchema,
+    keyword: s.optional(s.string("An optional localized keyword used to filter the result.", { maxLength: 1000 })),
+    timePieceType: s.optional(s.stringEnum("The analysis period type. LinkFox defaults to latelyDay.", ["latelyDay", "month", "week"])),
+    timePieceValue: s.optional(s.string("The period value: 7 or 30 for latelyDay, YYYY-MM for month, or the week-start date in YYYY-MM-DD format.", { maxLength: 1000 })),
+    conditions: s.optional(s.string("Comma-separated SIF keyword filters, including traffic-position, advertising, conversion, stability, and period-entry markers.", { maxLength: 1000 })),
+    sortBy: s.optional(s.stringEnum("The keyword sort field. Omit it to use SIF's system order.", [
+        "lastRank",
+        "adLastRank",
+        "updateTime",
+        "searchesRank",
+        "estSearchesNum",
+    ])),
+    desc: s.optional(s.boolean("Whether to sort descending. LinkFox defaults to true.")),
+    pageNum: s.optional(s.integer("The one-based result page. LinkFox defaults to 1.", { minimum: 1 })),
+    pageSize: s.optional(s.integer("The number of keyword records per page. LinkFox defaults to 100.", {
+        minimum: 10,
+        maximum: 100,
+    })),
+});
+const asinKeywordsInput = asinKeywordsInputBase;
+const dateRangeFields = {
+    last7d: s.optional(s.boolean("Whether to use the latest seven days. Set false to use startDate and endDate; LinkFox defaults to true.")),
+    startDate: s.optional(s.date("The period start date, used when last7d is false.")),
+    endDate: s.optional(s.date("The period end date, paired with startDate.")),
+};
+const asinSummaryInputBase = s.object("Parameters for summarizing SIF traffic sources by ASIN.", {
+    searchValue: s.nonEmptyString("One to ten comma-separated Amazon ASINs.", { maxLength: 1000 }),
+    country: countrySchema,
+    ...dateRangeFields,
+    conditions: s.optional(s.string("Comma-separated SIF filters: nf, sp, sb, sbv, ad, acAd, or totalPeriod.in.", {
+        maxLength: 1000,
+    })),
+    sortBy: s.optional(s.stringEnum("The ASIN traffic-summary sort field.", summarySortFields)),
+    pageNum: s.optional(s.integer("The one-based result page. LinkFox defaults to 1.", { minimum: 1 })),
+    pageSize: s.optional(s.integer("The number of ASIN summaries per page. LinkFox defaults to 10000.", {
+        minimum: 10,
+        maximum: 10_000,
+    })),
+    desc: s.optional(s.boolean("Whether to sort descending. LinkFox defaults to true.")),
+});
+const asinSummaryInput = asinSummaryInputBase;
+const keywordOverviewInputBase = s.object("Parameters for retrieving a SIF keyword overview.", {
+    keyword: s.nonEmptyString("The localized Amazon keyword to analyze.", { maxLength: 1000 }),
+    country: countrySchema,
+    ...dateRangeFields,
+});
+const keywordOverviewInput = keywordOverviewInputBase;
+const keywordSummaryInputBase = s.object("Parameters for summarizing competitor traffic sources for one keyword.", {
+    searchKeyword: s.nonEmptyString("The localized Amazon keyword to analyze.", {
+        maxLength: 1000,
+    }),
+    country: countrySchema,
+    asins: s.optional(s.string("An optional comma-separated ASIN filter.", { maxLength: 1000 })),
+    condition: s.optional(s.stringEnum("One SIF traffic or period filter, such as nfPosition, isSpAd, isBrandAd, isPPCAd, acAd, or totalPeriod.in.", keywordSummaryConditions)),
+    ...dateRangeFields,
+    sortBy: s.optional(s.stringEnum("The competitor traffic-summary sort field.", summarySortFields)),
+    pageNum: s.optional(s.integer("The one-based result page. LinkFox defaults to 1.", { minimum: 1 })),
+    pageSize: s.optional(s.integer("The number of competitor ASINs per page. LinkFox defaults to 100.", {
+        minimum: 10,
+        maximum: 100,
+    })),
+    desc: s.optional(s.boolean("Whether to sort descending. LinkFox defaults to true.")),
+});
+const keywordSummaryInput = keywordSummaryInputBase;
+function operation(name, path, description, inputSchema, outputSchema) {
+    return {
+        path,
+        usage: 9,
+        action: defineProviderAction("linkfox", {
+            name,
+            description,
+            operationType: "read",
+            inputSchema,
+            outputSchema,
+        }),
+    };
+}
+export const sifOperations = [
+    operation("list_sif_asin_keywords", "/sif/asinKeywords", "Reverse-search one Amazon ASIN's SIF traffic keywords, ranks, traffic shares, and conversion markers through LinkFox.", asinKeywordsInput, resultSchema("SIF keyword intelligence for one Amazon ASIN.", "A SIF keyword record with ranks, search volume, traffic shares, exposure scores, placements, and conversion markers.", {
+        isParentAsin: s.optional(s.boolean("Whether the queried ASIN is a parent ASIN.")),
+        hasVaiants: s.optional(s.boolean("Whether the queried product has variants.")),
+        abaCreateDateWeek: nullableString("The latest week represented by the ABA data."),
+    })),
+    operation("get_sif_asin_traffic_summary", "/sif/asinSummary", "Summarize natural, advertising, and recommendation traffic sources for up to ten Amazon ASINs through LinkFox and SIF.", asinSummaryInput, resultSchema("SIF traffic-source summaries for Amazon ASINs.", "A SIF ASIN summary with product context, current and previous exposure scores, traffic shares, keyword counts, entry or exit counts, and source markers.", {
+        isParentAsin: s.optional(s.boolean("Whether the search target is a parent ASIN.")),
+        variantsNum: nullableInteger("The number of variants with traffic keywords."),
+        noKeywordVariantsNum: nullableInteger("The number of variants without traffic keywords."),
+    })),
+    operation("get_sif_keyword_overview", "/sif/keywordOverview", "Get SIF search demand, supply-demand ratio, and advertising or recommendation competition for one Amazon keyword through LinkFox.", keywordOverviewInput, resultSchema("A SIF market-competition overview for one Amazon keyword.", "A SIF keyword overview with search volume, supply-demand ratio, product counts by traffic placement, tracked ASIN totals, and data-period timestamps.")),
+    operation("get_sif_keyword_traffic_summary", "/sif/keywordSummary", "Analyze competitor ASIN traffic shares and natural, advertising, or recommendation exposure for one Amazon keyword through LinkFox and SIF.", keywordSummaryInput, resultSchema("SIF competitor traffic-source summaries for one Amazon keyword.", "A SIF competitor record with product context, overall and queried-keyword exposure scores, traffic shares, and source markers.")),
+];
+export const sifActions = sifOperations.map(({ action }) => action);

package/src/providers/metatraderapi/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/metatraderapi/executors.js

@@ -0,0 +1,18 @@
+import { defineApiKeyProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
+import { metatraderapiActionHandlers, metatraderapiApiBaseUrl, validateMetaTraderApiCredential } from "./runtime.js";
+const service = "metatraderapi";
+export const executors = defineApiKeyProviderExecutors(service, metatraderapiActionHandlers);
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: metatraderapiApiBaseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        headers.set("accept", "application/json");
+    },
+});
+export const credentialValidators = {
+    apiKey(input, { fetcher, signal }) {
+        return validateMetaTraderApiCredential(input.apiKey, fetcher, signal);
+    },
+};

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

@@ -0,0 +1,7 @@
+import type { CredentialValidationResult } from "../../core/types.ts";
+import type { ApiKeyProviderContext, ProviderActionHandlers, ProviderFetch } from "../provider-runtime.ts";
+export declare const metatraderapiApiBaseUrl = "https://metatraderapi.cloud/api/";
+type MetaTraderHandler = (input: Record<string, unknown>, context: ApiKeyProviderContext) => Promise<unknown>;
+export declare const metatraderapiActionHandlers: ProviderActionHandlers<"metatraderapi", MetaTraderHandler>;
+export declare function validateMetaTraderApiCredential(apiKey: string, fetcher: ProviderFetch, signal?: AbortSignal): Promise<CredentialValidationResult>;
+export {};

package/src/providers/metatraderapi/runtime.js

@@ -0,0 +1,216 @@
+import { compactObject, optionalInteger, optionalRecord, optionalString, recordOrEmpty } from "../../core/cast.js";
+import { providerInputError, ProviderRequestError, providerResponseError, providerUserAgent, readProviderTextBody, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+export const metatraderapiApiBaseUrl = "https://metatraderapi.cloud/api/";
+const maxResponseBytes = 16 * 1024 * 1024;
+export const metatraderapiActionHandlers = {
+    async list_sessions(_input, context) {
+        const payload = await requestMetaTrader({ ...context, path: "sessions/", phase: "execute" });
+        return { sessions: readArrayPayload(payload, "sessions", "MetaTraderAPI sessions response") };
+    },
+    async start_session(input, context) {
+        const payload = await requestMetaTrader({
+            ...context,
+            path: "sessions/start/",
+            method: "POST",
+            phase: "execute",
+            body: {
+                account_id: requiredInputString(input.accountId, "accountId"),
+                password: requirePassword(input.password),
+                server: requiredInputString(input.server, "server"),
+                platform: requiredInputString(input.platform, "platform"),
+            },
+        });
+        return { session: requireMutationObject(payload, "MetaTraderAPI start session") };
+    },
+    async stop_session(input, context) {
+        return { result: recordOrEmpty(await requestSession(input, context, "stop/", "POST")) };
+    },
+    async close_all_sessions(_input, context) {
+        return {
+            result: recordOrEmpty(await requestMetaTrader({
+                ...context,
+                path: "sessions/close-all/",
+                method: "POST",
+                phase: "execute",
+            })),
+        };
+    },
+    async get_account_info(input, context) {
+        return {
+            accountInfo: requiredResponseRecord(await requestSession(input, context, "account-info/"), "MetaTraderAPI account information response"),
+        };
+    },
+    async get_equity(input, context) {
+        return {
+            equity: requiredResponseRecord(await requestSession(input, context, "equity/"), "MetaTraderAPI equity response"),
+        };
+    },
+    async list_deals(input, context) {
+        const payload = await requestHistory(input, context, "history/deals/");
+        return { deals: readArrayPayload(payload, "deals", "MetaTraderAPI deals response") };
+    },
+    async list_history_orders(input, context) {
+        const payload = await requestHistory(input, context, "history/orders/");
+        return { orders: readArrayPayload(payload, "orders", "MetaTraderAPI order history response") };
+    },
+    async get_margin(input, context) {
+        return {
+            margin: requiredResponseRecord(await requestSession(input, context, "margin/"), "MetaTraderAPI margin response"),
+        };
+    },
+    async list_orders(input, context) {
+        const payload = await requestSession(input, context, "orders/");
+        return { orders: readArrayPayload(payload, "orders", "MetaTraderAPI pending orders response") };
+    },
+    async ping_session(input, context) {
+        return {
+            ping: requiredResponseRecord(await requestSession(input, context, "ping/"), "MetaTraderAPI ping response"),
+        };
+    },
+    async list_positions(input, context) {
+        const payload = await requestSession(input, context, "positions/");
+        return { positions: readArrayPayload(payload, "positions", "MetaTraderAPI positions response") };
+    },
+    async get_session_status(input, context) {
+        return {
+            status: requiredResponseRecord(await requestSession(input, context, "status/"), "MetaTraderAPI session status response"),
+        };
+    },
+    async list_symbols(input, context) {
+        const symbols = readArrayPayload(await requestSession(input, context, "symbols/"), "symbols", "MetaTraderAPI symbols response");
+        if (!symbols.every((value) => typeof value === "string")) {
+            throw providerResponseError("MetaTraderAPI symbols response must contain only strings");
+        }
+        return { symbols };
+    },
+    async get_symbol(input, context) {
+        const symbol = requiredInputString(input.symbol, "symbol");
+        return {
+            symbol: requiredResponseRecord(await requestSession(input, context, `symbols/${encodeURIComponent(symbol)}/`), "MetaTraderAPI symbol response"),
+        };
+    },
+};
+export async function validateMetaTraderApiCredential(apiKey, fetcher, signal) {
+    const payload = await requestMetaTrader({ apiKey, fetcher, signal, path: "sessions/", phase: "validate" });
+    const sessions = readArrayPayload(payload, "sessions", "MetaTraderAPI sessions response");
+    return {
+        profile: { displayName: "MetaTraderAPI API Key" },
+        grantedScopes: [],
+        metadata: {
+            apiBaseUrl: metatraderapiApiBaseUrl.slice(0, -1),
+            validationEndpoint: "/sessions/",
+            activeSessionCount: sessions.length,
+        },
+    };
+}
+async function requestSession(input, context, suffix, method = "GET") {
+    const sessionId = requiredInputString(input.sessionId, "sessionId");
+    return requestMetaTrader({
+        ...context,
+        path: `sessions/${encodeURIComponent(sessionId)}/${suffix}`,
+        method,
+        phase: "execute",
+    });
+}
+async function requestHistory(input, context, suffix) {
+    const sessionId = requiredInputString(input.sessionId, "sessionId");
+    return requestMetaTrader({
+        ...context,
+        path: `sessions/${encodeURIComponent(sessionId)}/${suffix}`,
+        query: compactObject({
+            date_from: optionalString(input.dateFrom),
+            date_to: optionalString(input.dateTo),
+            days_back: optionalInteger(input.daysBack),
+        }),
+        phase: "execute",
+    });
+}
+async function requestMetaTrader(input) {
+    try {
+        return await runProviderRequest({ label: "MetaTraderAPI", signal: input.signal }, async (signal) => {
+            const url = new URL(input.path, metatraderapiApiBaseUrl);
+            for (const [key, value] of Object.entries(input.query ?? {})) {
+                if (value !== undefined)
+                    url.searchParams.set(key, String(value));
+            }
+            const headers = new Headers({
+                accept: "application/json",
+                authorization: `Bearer ${input.apiKey}`,
+                "user-agent": providerUserAgent,
+            });
+            if (input.body !== undefined)
+                headers.set("content-type", "application/json");
+            const response = await input.fetcher(url, {
+                method: input.method ?? "GET",
+                headers,
+                body: input.body === undefined ? undefined : JSON.stringify(input.body),
+                signal,
+            });
+            const payload = await readPayload(response);
+            if (!response.ok)
+                throw createMetaTraderError(response.status, payload, input.phase);
+            return payload;
+        });
+    }
+    catch (error) {
+        if (input.phase === "execute" &&
+            input.method === "POST" &&
+            error instanceof ProviderRequestError &&
+            error.status >= 500) {
+            throw new ProviderRequestError(error.status, `${error.message}; the operation may have completed upstream. Check the current session or trading state before retrying.`, { retryable: false, upstreamCompleted: "unknown" });
+        }
+        throw error;
+    }
+}
+async function readPayload(response) {
+    const text = await readProviderTextBody(response, "MetaTraderAPI response", maxResponseBytes);
+    if (text.trim() === "")
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        if (!response.ok)
+            return text.trim();
+        throw new ProviderRequestError(502, "MetaTraderAPI returned invalid JSON", error);
+    }
+}
+function createMetaTraderError(status, payload, phase) {
+    const message = errorMessage(payload) ?? `MetaTraderAPI request failed with status ${status}`;
+    if (phase === "validate" && status >= 400 && status < 500) {
+        return providerInputError(message);
+    }
+    if (status === 400 || status === 404)
+        return providerInputError(message);
+    return new ProviderRequestError(status || 502, message);
+}
+function errorMessage(payload) {
+    if (typeof payload === "string" && payload.trim())
+        return payload.trim();
+    const record = optionalRecord(payload);
+    for (const key of ["detail", "message", "error"]) {
+        const value = optionalString(record?.[key])?.trim();
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+function readArrayPayload(payload, field, label) {
+    if (Array.isArray(payload))
+        return payload;
+    const record = optionalRecord(payload);
+    if (Array.isArray(record?.[field]))
+        return record[field];
+    throw providerResponseError(`${label} must contain an array`);
+}
+function requireMutationObject(payload, label) {
+    const record = optionalRecord(payload);
+    if (record)
+        return record;
+    throw new ProviderRequestError(502, `${label} returned an empty or invalid response; the operation may have completed upstream. Check the current session or trading state before retrying.`, { retryable: false, upstreamCompleted: "unknown" });
+}
+function requirePassword(value) {
+    if (typeof value !== "string" || value.length === 0)
+        throw providerInputError("password is required");
+    return value;
+}

package/src/providers/mktindex/actions-mmi.d.ts

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