@5ss/ai-tools 2.11.1

package/dist/vendors/amazon-sp-api/index.js

@@ -0,0 +1,975 @@
+import { t as ToolError } from "../../errors-DoSpNHvs.js";
+import { n as defineModule, r as defineTool } from "../../define-CvpJ_pNP.js";
+import { n as requireAuth } from "../../provider-CgDAlg6K.js";
+import { t as HttpService } from "../../http-service-DDNCO1s4.js";
+import { t as AwsService } from "../../aws-service-msttbPrz.js";
+import { isPlainObject, isString } from "es-toolkit";
+import { z } from "zod";
+import Decimal from "decimal.js";
+import Papa from "papaparse";
+//#region src/vendors/amazon-sp-api/contracts.ts
+/** SP-API regional endpoints. */
+const amazonSpApiEndpointSchema = z.enum([
+	"https://sellingpartnerapi-na.amazon.com",
+	"https://sellingpartnerapi-eu.amazon.com",
+	"https://sellingpartnerapi-fe.amazon.com"
+]);
+const amazonSpApiAuthSchema = z.object({
+	client_id: z.string().min(1).describe("LWA client id"),
+	client_secret: z.string().min(1).describe("LWA client secret"),
+	refresh_token: z.string().min(1).describe("LWA refresh token for the selling partner"),
+	access_key_id: z.string().min(1).describe("AWS access key id for SP-API SigV4"),
+	secret_access_key: z.string().min(1).describe("AWS secret access key for SP-API SigV4"),
+	region: z.string().min(1).describe("AWS region used for SigV4 (typically us-east-1 for NA, eu-west-1 for EU, us-west-2 for FE)"),
+	endpoint: amazonSpApiEndpointSchema.describe("SP-API regional endpoint"),
+	session_token: z.string().min(1).optional().describe("Optional AWS session token"),
+	marketplace_ids: z.array(z.string().min(1)).min(1).optional().describe("Default marketplace ids when a tool call omits marketplace_ids")
+});
+const amazonSpApiListOrdersInputSchema = z.object({
+	marketplace_ids: z.array(z.string().min(1)).min(1).optional().describe("Marketplace ids; omit to use the configured defaults"),
+	created_after: z.string().min(1).optional().describe("ISO 8601; orders created after"),
+	created_before: z.string().min(1).optional().describe("ISO 8601; orders created before"),
+	last_updated_after: z.string().min(1).optional().describe("ISO 8601; orders updated after"),
+	order_statuses: z.array(z.string().min(1)).optional().describe("Order status filter list"),
+	cursor: z.string().min(1).optional().describe("NextToken from a prior page"),
+	max_results: z.int().min(1).max(100).optional().describe("Page size (1-100)")
+});
+const amazonSpApiOrderSchema = z.object({
+	amazon_order_id: z.string(),
+	order_status: z.string().optional(),
+	purchase_date: z.string().optional(),
+	last_update_date: z.string().optional(),
+	marketplace_id: z.string().optional(),
+	order_total_amount: z.string().optional(),
+	order_total_currency: z.string().optional(),
+	fulfillment_channel: z.string().optional()
+});
+const amazonSpApiListOrdersOutputSchema = z.object({
+	items: z.array(amazonSpApiOrderSchema),
+	next_cursor: z.string().optional(),
+	truncated: z.boolean()
+});
+const amazonSpApiGetOrderInputSchema = z.object({ amazon_order_id: z.string().min(1).describe("Amazon order id") });
+const amazonSpApiGetOrderOutputSchema = z.object({ order: amazonSpApiOrderSchema });
+const amazonSpApiGetOrderItemsInputSchema = z.object({
+	amazon_order_id: z.string().min(1).describe("Amazon order id"),
+	cursor: z.string().min(1).optional().describe("NextToken from a prior page")
+});
+const amazonSpApiOrderItemSchema = z.object({
+	order_item_id: z.string(),
+	asin: z.string().optional(),
+	seller_sku: z.string().optional(),
+	title: z.string().optional(),
+	quantity_ordered: z.number().optional(),
+	quantity_shipped: z.number().optional(),
+	item_price_amount: z.string().optional(),
+	item_price_currency: z.string().optional()
+});
+const amazonSpApiGetOrderItemsOutputSchema = z.object({
+	amazon_order_id: z.string(),
+	items: z.array(amazonSpApiOrderItemSchema),
+	next_cursor: z.string().optional(),
+	truncated: z.boolean()
+});
+const amazonSpApiSearchOrdersInputSchema = z.object({
+	created_after: z.string().min(1).describe("ISO 8601; orders created at or after this time (required for reconciliation)"),
+	created_before: z.string().min(1).optional().describe("ISO 8601; orders created at or before this time"),
+	marketplace_ids: z.array(z.string().min(1)).min(1).optional().describe("Marketplace ids; omit to use the configured defaults"),
+	max_results: z.int().min(1).max(100).optional().describe("Page size (1-100, default 100)"),
+	cursor: z.string().min(1).optional().describe("paginationToken from a prior page"),
+	max_pages: z.int().min(1).max(50).optional().describe("When set, drains up to this many pages and returns a combined list (default 1)")
+});
+const amazonSpApiSearchOrderSchema = z.object({
+	order_id: z.string().describe("Amazon order id"),
+	created_time: z.string().optional().describe("Order created time (ISO 8601)"),
+	fulfillment_status: z.string().optional().describe("Fulfillment status when FULFILLMENT data is included")
+});
+const amazonSpApiSearchOrdersOutputSchema = z.object({
+	items: z.array(amazonSpApiSearchOrderSchema),
+	next_cursor: z.string().optional().describe("paginationToken for the next page when not fully drained"),
+	truncated: z.boolean()
+});
+const amazonSpApiListInventorySummariesInputSchema = z.object({
+	marketplace_id: z.string().min(1).optional().describe("Marketplace id; omit to use the first configured default"),
+	seller_skus: z.array(z.string().min(1)).max(50).optional().describe("Optional seller SKU filter (max 50)"),
+	start_date_time: z.string().min(1).optional().describe("ISO 8601; summaries changed after"),
+	cursor: z.string().min(1).optional().describe("nextToken from a prior page")
+});
+const amazonSpApiInventorySummarySchema = z.object({
+	seller_sku: z.string().optional(),
+	asin: z.string().optional(),
+	fn_sku: z.string().optional(),
+	condition: z.string().optional(),
+	total_quantity: z.number().optional(),
+	product_name: z.string().optional()
+});
+const amazonSpApiListInventorySummariesOutputSchema = z.object({
+	items: z.array(amazonSpApiInventorySummarySchema),
+	next_cursor: z.string().optional(),
+	truncated: z.boolean()
+});
+const amazonSpApiCreateReportInputSchema = z.object({
+	report_type: z.string().min(1).describe("Report type (e.g. GET_FLAT_FILE_OPEN_LISTINGS_DATA)"),
+	marketplace_ids: z.array(z.string().min(1)).min(1).optional().describe("Marketplace ids; omit to use the configured defaults"),
+	data_start_time: z.string().min(1).optional().describe("ISO 8601 report data start"),
+	data_end_time: z.string().min(1).optional().describe("ISO 8601 report data end"),
+	report_options: z.record(z.string(), z.string()).optional().describe("Optional report-type-specific options map")
+});
+const amazonSpApiCreateReportOutputSchema = z.object({ report_id: z.string() });
+const amazonSpApiGetReportInputSchema = z.object({ report_id: z.string().min(1).describe("Report id from createReport or listReports") });
+const amazonSpApiReportSchema = z.object({
+	report_id: z.string(),
+	report_type: z.string().optional(),
+	processing_status: z.string().optional(),
+	marketplace_ids: z.array(z.string()).optional(),
+	data_start_time: z.string().optional(),
+	data_end_time: z.string().optional(),
+	report_document_id: z.string().optional(),
+	created_time: z.string().optional()
+});
+const amazonSpApiGetReportOutputSchema = z.object({ report: amazonSpApiReportSchema });
+const amazonSpApiListReportsInputSchema = z.object({
+	report_types: z.array(z.string().min(1)).optional().describe("Filter by report type(s)"),
+	processing_statuses: z.array(z.string().min(1)).optional().describe("Filter by processing status (e.g. DONE, IN_QUEUE, IN_PROGRESS, CANCELLED, FATAL)"),
+	marketplace_ids: z.array(z.string().min(1)).min(1).optional().describe("Marketplace ids filter; omit to use configured defaults when available"),
+	page_size: z.int().min(1).max(100).optional().describe("Page size (1-100)"),
+	created_since: z.string().min(1).optional().describe("ISO 8601; reports created after"),
+	created_until: z.string().min(1).optional().describe("ISO 8601; reports created before"),
+	cursor: z.string().min(1).optional().describe("nextToken from a prior page")
+});
+const amazonSpApiListReportsOutputSchema = z.object({
+	items: z.array(amazonSpApiReportSchema),
+	next_cursor: z.string().optional(),
+	truncated: z.boolean()
+});
+const amazonSpApiGetReportDocumentInputSchema = z.object({ report_document_id: z.string().min(1).describe("Report document id from a completed report") });
+const amazonSpApiGetReportDocumentOutputSchema = z.object({
+	document_id: z.string(),
+	url: z.string(),
+	compression_algorithm: z.string().optional()
+});
+/**
+* Composite input: pick newest completed V2 settlement report in the retention
+* window (default 90d), download one document, return eight summary fields only.
+*/
+const amazonSpApiGetSettlementSummaryInputSchema = z.object({
+	report_id: z.string().min(1).optional().describe("Optional report id; when set, uses this report instead of listing the newest DONE settlement report"),
+	created_since: z.string().min(1).optional().describe("ISO 8601 lower bound when listing reports (default: now minus 90 days)")
+});
+/** Eight summary fields only — never raw TSV rows. */
+const amazonSpApiSettlementSummarySchema = z.object({
+	settlement_id: z.string().describe("Amazon settlement id"),
+	settlement_start_date: z.string().describe("Settlement period start"),
+	settlement_end_date: z.string().describe("Settlement period end"),
+	deposit_date: z.string().describe("Deposit date when present; otherwise settlement end"),
+	currency: z.string().describe("ISO currency code from the report"),
+	total_amount_cents: z.number().int().describe("Report total-amount as safe integer cents (must equal amount_sum_cents)"),
+	amount_sum_cents: z.number().int().describe("Sum of amount column as safe integer cents"),
+	row_count: z.number().int().describe("Number of data rows in the TSV (excluding header)")
+});
+const amazonSpApiGetSettlementSummaryOutputSchema = amazonSpApiSettlementSummarySchema;
+const amazonSpApiSearchCatalogItemsInputSchema = z.object({
+	keywords: z.array(z.string().min(1)).min(1).describe("Search keywords"),
+	marketplace_ids: z.array(z.string().min(1)).min(1).optional().describe("Marketplace ids; omit to use the configured defaults"),
+	included_data: z.array(z.string().min(1)).optional().describe("Data sets to include (e.g. summaries, images, attributes)"),
+	page_size: z.int().min(1).max(20).optional().describe("Page size (1-20)"),
+	cursor: z.string().min(1).optional().describe("pageToken from a prior page")
+});
+const amazonSpApiCatalogItemSchema = z.object({
+	asin: z.string(),
+	title: z.string().optional(),
+	brand: z.string().optional(),
+	product_type: z.string().optional(),
+	marketplace_id: z.string().optional()
+});
+const amazonSpApiSearchCatalogItemsOutputSchema = z.object({
+	items: z.array(amazonSpApiCatalogItemSchema),
+	number_of_results: z.number().optional(),
+	next_cursor: z.string().optional(),
+	truncated: z.boolean()
+});
+//#endregion
+//#region src/vendors/amazon-sp-api/domain.ts
+/**
+* Amazon SP-API: LWA body, order/inventory/report/catalog parse (no HTTP).
+*/
+const LWA_TOKEN_URL = "https://api.amazon.com/auth/o2/token";
+function lwaTokenBody(auth) {
+	return new URLSearchParams({
+		grant_type: "refresh_token",
+		refresh_token: auth.refresh_token,
+		client_id: auth.client_id,
+		client_secret: auth.client_secret
+	}).toString();
+}
+function parseLwaAccessToken(data) {
+	if (!isPlainObject(data) || !isString(data["access_token"]) || data["access_token"].length === 0) throw new ToolError("Amazon LWA did not return an access_token", { code: "bad_auth" });
+	return data["access_token"];
+}
+function parseOrder(value) {
+	if (!isPlainObject(value) || !isString(value["AmazonOrderId"]) || value["AmazonOrderId"].length === 0) throw new ToolError("Amazon SP-API returned an invalid order", { code: "upstream" });
+	const total = value["OrderTotal"];
+	const amount = isPlainObject(total) && isString(total["Amount"]) ? total["Amount"] : void 0;
+	const currency = isPlainObject(total) && isString(total["CurrencyCode"]) ? total["CurrencyCode"] : void 0;
+	return {
+		amazon_order_id: value["AmazonOrderId"],
+		...isString(value["OrderStatus"]) && { order_status: value["OrderStatus"] },
+		...isString(value["PurchaseDate"]) && { purchase_date: value["PurchaseDate"] },
+		...isString(value["LastUpdateDate"]) && { last_update_date: value["LastUpdateDate"] },
+		...isString(value["MarketplaceId"]) && { marketplace_id: value["MarketplaceId"] },
+		...amount && { order_total_amount: amount },
+		...currency && { order_total_currency: currency },
+		...isString(value["FulfillmentChannel"]) && { fulfillment_channel: value["FulfillmentChannel"] }
+	};
+}
+function parseOrdersPayload(data) {
+	if (!isPlainObject(data)) throw new ToolError("Amazon SP-API orders payload invalid", { code: "upstream" });
+	const payload = data["payload"];
+	if (!isPlainObject(payload)) throw new ToolError("Amazon SP-API orders missing payload", { code: "upstream" });
+	const orders = payload["Orders"];
+	if (!Array.isArray(orders)) throw new ToolError("Amazon SP-API orders missing Orders array", { code: "upstream" });
+	const nextToken = isString(payload["NextToken"]) && payload["NextToken"].length > 0 ? payload["NextToken"] : void 0;
+	return {
+		items: orders.map(parseOrder),
+		...nextToken && { nextToken }
+	};
+}
+function parseOrderPayload(data) {
+	if (!isPlainObject(data) || !isPlainObject(data["payload"])) throw new ToolError("Amazon SP-API get order payload invalid", { code: "upstream" });
+	return parseOrder(data["payload"]);
+}
+/** Orders API v2026-01-01 SearchOrders — camelCase body, not v0 payload wrapper. */
+function parseSearchOrder(value) {
+	if (!isPlainObject(value) || !isString(value["orderId"]) || value["orderId"].length === 0) throw new ToolError("Amazon SP-API searchOrders returned an invalid order", { code: "upstream" });
+	const fulfillment = value["fulfillment"];
+	const fulfillmentStatus = isPlainObject(fulfillment) && isString(fulfillment["fulfillmentStatus"]) ? fulfillment["fulfillmentStatus"] : void 0;
+	return {
+		order_id: value["orderId"],
+		...isString(value["createdTime"]) && { created_time: value["createdTime"] },
+		...fulfillmentStatus && { fulfillment_status: fulfillmentStatus }
+	};
+}
+function parseSearchOrdersPayload(data) {
+	if (!isPlainObject(data)) throw new ToolError("Amazon SP-API searchOrders payload invalid", { code: "upstream" });
+	const root = isPlainObject(data["payload"]) ? data["payload"] : data;
+	if (!isPlainObject(root)) throw new ToolError("Amazon SP-API searchOrders missing body", { code: "upstream" });
+	const orders = root["orders"];
+	if (!Array.isArray(orders)) throw new ToolError("Amazon SP-API searchOrders missing orders array", { code: "upstream" });
+	const pagination = root["pagination"];
+	const nextToken = isPlainObject(pagination) && isString(pagination["nextToken"]) && pagination["nextToken"].length > 0 ? pagination["nextToken"] : void 0;
+	return {
+		items: orders.map(parseSearchOrder),
+		...nextToken && { nextToken }
+	};
+}
+function parseOrderItem(value) {
+	if (!isPlainObject(value) || !isString(value["OrderItemId"]) || value["OrderItemId"].length === 0) throw new ToolError("Amazon SP-API returned an invalid order item", { code: "upstream" });
+	const price = value["ItemPrice"];
+	const amount = isPlainObject(price) && isString(price["Amount"]) ? price["Amount"] : void 0;
+	const currency = isPlainObject(price) && isString(price["CurrencyCode"]) ? price["CurrencyCode"] : void 0;
+	return {
+		order_item_id: value["OrderItemId"],
+		...isString(value["ASIN"]) && { asin: value["ASIN"] },
+		...isString(value["SellerSKU"]) && { seller_sku: value["SellerSKU"] },
+		...isString(value["Title"]) && { title: value["Title"] },
+		...typeof value["QuantityOrdered"] === "number" && { quantity_ordered: value["QuantityOrdered"] },
+		...typeof value["QuantityShipped"] === "number" && { quantity_shipped: value["QuantityShipped"] },
+		...amount && { item_price_amount: amount },
+		...currency && { item_price_currency: currency }
+	};
+}
+function parseOrderItemsPayload(data) {
+	if (!isPlainObject(data)) throw new ToolError("Amazon SP-API order items payload invalid", { code: "upstream" });
+	const payload = data["payload"];
+	if (!isPlainObject(payload)) throw new ToolError("Amazon SP-API order items missing payload", { code: "upstream" });
+	if (!isString(payload["AmazonOrderId"]) || payload["AmazonOrderId"].length === 0) throw new ToolError("Amazon SP-API order items missing AmazonOrderId", { code: "upstream" });
+	const orderItems = payload["OrderItems"];
+	if (!Array.isArray(orderItems)) throw new ToolError("Amazon SP-API order items missing OrderItems array", { code: "upstream" });
+	const nextToken = isString(payload["NextToken"]) && payload["NextToken"].length > 0 ? payload["NextToken"] : void 0;
+	return {
+		amazon_order_id: payload["AmazonOrderId"],
+		items: orderItems.map(parseOrderItem),
+		...nextToken && { nextToken }
+	};
+}
+function parseInventorySummary(value) {
+	if (!isPlainObject(value)) throw new ToolError("Amazon SP-API returned an invalid inventory summary", { code: "upstream" });
+	const totals = value["inventoryDetails"];
+	let totalQuantity;
+	if (isPlainObject(totals) && typeof totals["fulfillableQuantity"] === "number") totalQuantity = totals["fulfillableQuantity"];
+	else if (typeof value["totalQuantity"] === "number") totalQuantity = value["totalQuantity"];
+	return {
+		...isString(value["sellerSku"]) && { seller_sku: value["sellerSku"] },
+		...isString(value["asin"]) && { asin: value["asin"] },
+		...isString(value["fnSku"]) && { fn_sku: value["fnSku"] },
+		...isString(value["condition"]) && { condition: value["condition"] },
+		...totalQuantity !== void 0 && { total_quantity: totalQuantity },
+		...isString(value["productName"]) && { product_name: value["productName"] }
+	};
+}
+function parseInventoryPayload(data) {
+	if (!isPlainObject(data)) throw new ToolError("Amazon SP-API inventory payload invalid", { code: "upstream" });
+	const payload = data["payload"];
+	if (!isPlainObject(payload)) throw new ToolError("Amazon SP-API inventory missing payload", { code: "upstream" });
+	const summaries = payload["inventorySummaries"];
+	if (!Array.isArray(summaries)) throw new ToolError("Amazon SP-API inventory missing inventorySummaries", { code: "upstream" });
+	const pagination = payload["pagination"];
+	const nextToken = isPlainObject(pagination) && isString(pagination["nextToken"]) && pagination["nextToken"].length > 0 ? pagination["nextToken"] : void 0;
+	return {
+		items: summaries.map(parseInventorySummary),
+		...nextToken && { nextToken }
+	};
+}
+function parseCreateReportPayload(data) {
+	if (!isPlainObject(data) || !isString(data["reportId"]) || data["reportId"].length === 0) throw new ToolError("Amazon SP-API create report response invalid", { code: "upstream" });
+	return { report_id: data["reportId"] };
+}
+function parseReport(value) {
+	if (!isPlainObject(value) || !isString(value["reportId"]) || value["reportId"].length === 0) throw new ToolError("Amazon SP-API returned an invalid report", { code: "upstream" });
+	const marketplaceIds = value["marketplaceIds"];
+	const marketplace_ids = Array.isArray(marketplaceIds) && marketplaceIds.every((id) => isString(id)) ? marketplaceIds.filter((id) => isString(id) && id.length > 0) : void 0;
+	return {
+		report_id: value["reportId"],
+		...isString(value["reportType"]) && { report_type: value["reportType"] },
+		...isString(value["processingStatus"]) && { processing_status: value["processingStatus"] },
+		...marketplace_ids && marketplace_ids.length > 0 && { marketplace_ids },
+		...isString(value["dataStartTime"]) && { data_start_time: value["dataStartTime"] },
+		...isString(value["dataEndTime"]) && { data_end_time: value["dataEndTime"] },
+		...isString(value["reportDocumentId"]) && { report_document_id: value["reportDocumentId"] },
+		...isString(value["createdTime"]) && { created_time: value["createdTime"] }
+	};
+}
+function parseGetReportPayload(data) {
+	return parseReport(data);
+}
+function parseListReportsPayload(data) {
+	if (!isPlainObject(data)) throw new ToolError("Amazon SP-API list reports payload invalid", { code: "upstream" });
+	const reports = data["reports"];
+	if (!Array.isArray(reports)) throw new ToolError("Amazon SP-API list reports missing reports array", { code: "upstream" });
+	const nextToken = isString(data["nextToken"]) && data["nextToken"].length > 0 ? data["nextToken"] : void 0;
+	return {
+		items: reports.map(parseReport),
+		...nextToken && { nextToken }
+	};
+}
+function parseReportDocumentPayload(data) {
+	if (!isPlainObject(data) || !isString(data["reportDocumentId"]) || data["reportDocumentId"].length === 0 || !isString(data["url"]) || data["url"].length === 0) throw new ToolError("Amazon SP-API report document response invalid", { code: "upstream" });
+	return {
+		document_id: data["reportDocumentId"],
+		url: data["url"],
+		...isString(data["compressionAlgorithm"]) && data["compressionAlgorithm"].length > 0 && { compression_algorithm: data["compressionAlgorithm"] }
+	};
+}
+function parseCatalogItem(value) {
+	if (!isPlainObject(value) || !isString(value["asin"]) || value["asin"].length === 0) throw new ToolError("Amazon SP-API returned an invalid catalog item", { code: "upstream" });
+	const summaries = value["summaries"];
+	let title;
+	let brand;
+	let marketplace_id;
+	if (Array.isArray(summaries) && summaries.length > 0 && isPlainObject(summaries[0])) {
+		const summary = summaries[0];
+		if (isString(summary["itemName"])) title = summary["itemName"];
+		if (isString(summary["brandName"])) brand = summary["brandName"];
+		if (isString(summary["marketplaceId"])) marketplace_id = summary["marketplaceId"];
+	}
+	const productTypes = value["productTypes"];
+	let product_type;
+	if (Array.isArray(productTypes) && productTypes.length > 0 && isPlainObject(productTypes[0])) {
+		const pt = productTypes[0];
+		if (isString(pt["productType"])) product_type = pt["productType"];
+	}
+	return {
+		asin: value["asin"],
+		...title && { title },
+		...brand && { brand },
+		...product_type && { product_type },
+		...marketplace_id && { marketplace_id }
+	};
+}
+function parseSearchCatalogItemsPayload(data) {
+	if (!isPlainObject(data)) throw new ToolError("Amazon SP-API catalog search payload invalid", { code: "upstream" });
+	const items = data["items"];
+	if (!Array.isArray(items)) throw new ToolError("Amazon SP-API catalog search missing items array", { code: "upstream" });
+	const pagination = data["pagination"];
+	const nextToken = isPlainObject(pagination) && isString(pagination["nextToken"]) && pagination["nextToken"].length > 0 ? pagination["nextToken"] : void 0;
+	const numberOfResults = typeof data["numberOfResults"] === "number" ? data["numberOfResults"] : void 0;
+	return {
+		items: items.map(parseCatalogItem),
+		...numberOfResults !== void 0 && { numberOfResults },
+		...nextToken && { nextToken }
+	};
+}
+function requireMarketplaceIds(inputIds, authIds, label) {
+	const ids = inputIds ?? authIds;
+	if (!ids || ids.length === 0) throw new ToolError(`${label} requires marketplace_ids on the call or auth`, { code: "bad_input" });
+	return ids;
+}
+//#endregion
+//#region src/vendors/amazon-sp-api/domain/settlement.ts
+/**
+* Amazon settlement report V2 (GET_V2_SETTLEMENT_REPORT_DATA_FLAT_FILE_V2).
+* TSV via papaparse; money via decimal.js. Never put raw row PII in errors/output.
+*/
+/** Report type for Flat File V2 Settlement (auto-scheduled by Amazon). */
+const SETTLEMENT_REPORT_TYPE_V2 = "GET_V2_SETTLEMENT_REPORT_DATA_FLAT_FILE_V2";
+/** Max compressed document body (bytes). */
+const SETTLEMENT_MAX_COMPRESSED_BYTES = 16 * 1024 * 1024;
+/** Required V2 header names (order free after parse; extra trailing columns OK). */
+const SETTLEMENT_V2_REQUIRED_COLUMNS = [
+	"settlement-id",
+	"settlement-start-date",
+	"settlement-end-date",
+	"deposit-date",
+	"total-amount",
+	"currency",
+	"amount"
+];
+function settlementError(message, code = "upstream") {
+	throw new ToolError(message, { code });
+}
+function cell(row, key) {
+	return (row[key] ?? "").trim();
+}
+/**
+* Parse Amazon settlement amount strings to safe integer cents via decimal.js.
+* Empty → 0. Strips US thousands commas only (`1,234.56` → `1234.56`).
+*/
+function parseUsMoneyToSafeCents(raw) {
+	const trimmed = raw.trim();
+	if (trimmed.length === 0) return 0;
+	const normalized = trimmed.replace(/,/g, "");
+	let value;
+	try {
+		value = new Decimal(normalized);
+	} catch {
+		settlementError("Settlement report has an invalid amount cell", "upstream");
+	}
+	if (!value.isFinite()) settlementError("Settlement report has a non-numeric amount", "upstream");
+	const cents = value.times(100).toDecimalPlaces(0, Decimal.ROUND_HALF_UP);
+	if (!cents.isInteger()) settlementError("Settlement report has a non-numeric amount", "upstream");
+	const n = cents.toNumber();
+	if (!Number.isSafeInteger(n)) settlementError("Settlement amount exceeds safe integer cents range", "upstream");
+	return n;
+}
+/** Copy into a fresh ArrayBuffer so Blob accepts it under exact DOM typings. */
+function toArrayBuffer(bytes) {
+	const copy = new Uint8Array(bytes.byteLength);
+	copy.set(bytes);
+	return copy.buffer;
+}
+/** Decompress GZIP when report document uses compressionAlgorithm GZIP (Web DecompressionStream). */
+async function maybeGunzipReportBytes(bytes, compressionAlgorithm) {
+	if (!compressionAlgorithm) return bytes;
+	const algo = compressionAlgorithm.toUpperCase();
+	if (algo !== "GZIP") settlementError(`Unsupported settlement report compression: ${algo}`, "upstream");
+	if (bytes.byteLength > 16777216) settlementError("Settlement report compressed body exceeds limit", "too_large");
+	if (typeof DecompressionStream === "undefined") settlementError("GZIP decompression is not available in this runtime", "unsupported");
+	try {
+		const stream = new Blob([toArrayBuffer(bytes)]).stream().pipeThrough(new DecompressionStream("gzip"));
+		const buffer = await new Response(stream).arrayBuffer();
+		if (buffer.byteLength > 67108864) settlementError("Settlement report decompressed body exceeds limit", "too_large");
+		return new Uint8Array(buffer);
+	} catch (error) {
+		if (error instanceof ToolError) throw error;
+		settlementError("Failed to decompress settlement report", "upstream");
+	}
+}
+/**
+* Parse Flat File V2 settlement TSV into the eight summary fields only.
+* Validates single settlement-id, currency, period, and amount sum vs total-amount.
+*/
+function parseSettlementV2Tsv(text) {
+	const result = Papa.parse(text, {
+		delimiter: "	",
+		header: true,
+		skipEmptyLines: "greedy",
+		transformHeader: (header) => header.trim().replace(/^\uFEFF/, "")
+	});
+	if (result.errors.length > 0) settlementError("Settlement report TSV could not be parsed", "upstream");
+	const fields = result.meta.fields ?? [];
+	for (const required of SETTLEMENT_V2_REQUIRED_COLUMNS) if (!fields.includes(required)) settlementError("Settlement report header columns do not match Flat File V2 schema", "upstream");
+	const rows = result.data;
+	if (rows.length === 0) settlementError("Settlement report is empty or missing data rows", "upstream");
+	if (rows.length > 25e4) settlementError("Settlement report exceeds max row limit", "too_large");
+	let settlementId;
+	let settlementStart;
+	let settlementEnd;
+	let depositDate;
+	let currency;
+	let totalAmountCents;
+	let amountSum = new Decimal(0);
+	for (const row of rows) {
+		const rowSettlementId = cell(row, "settlement-id");
+		const rowStart = cell(row, "settlement-start-date");
+		const rowEnd = cell(row, "settlement-end-date");
+		const rowDeposit = cell(row, "deposit-date");
+		const rowTotal = cell(row, "total-amount");
+		const rowCurrency = cell(row, "currency");
+		const rowAmount = cell(row, "amount");
+		if (rowSettlementId.length === 0) settlementError("Settlement report row missing settlement-id", "upstream");
+		const rowTotalCents = parseUsMoneyToSafeCents(rowTotal);
+		const rowAmountCents = parseUsMoneyToSafeCents(rowAmount);
+		if (settlementId === void 0) {
+			settlementId = rowSettlementId;
+			settlementStart = rowStart;
+			settlementEnd = rowEnd;
+			depositDate = rowDeposit;
+			currency = rowCurrency;
+			totalAmountCents = rowTotalCents;
+		} else {
+			if (rowSettlementId !== settlementId) settlementError("Settlement report contains multiple settlement ids", "upstream");
+			if (rowStart !== settlementStart || rowEnd !== settlementEnd) settlementError("Settlement report has inconsistent settlement period", "upstream");
+			if (rowCurrency !== currency) settlementError("Settlement report has inconsistent currency", "upstream");
+			if (rowTotalCents !== totalAmountCents) settlementError("Settlement report has inconsistent total-amount", "upstream");
+			if (rowDeposit.length > 0) {
+				if (depositDate && depositDate.length > 0 && rowDeposit !== depositDate) settlementError("Settlement report has inconsistent deposit-date", "upstream");
+				if (!depositDate || depositDate.length === 0) depositDate = rowDeposit;
+			}
+		}
+		amountSum = amountSum.plus(rowAmountCents);
+	}
+	if (settlementId === void 0 || settlementStart === void 0 || settlementEnd === void 0 || currency === void 0 || totalAmountCents === void 0) settlementError("Settlement report has no usable data rows", "upstream");
+	if (!amountSum.isInteger() || !Number.isSafeInteger(amountSum.toNumber())) settlementError("Settlement amount sum exceeds safe integer cents range", "upstream");
+	const amountSumCents = amountSum.toNumber();
+	if (amountSumCents !== totalAmountCents) settlementError("Settlement amount sum does not match total-amount", "upstream");
+	return {
+		settlement_id: settlementId,
+		settlement_start_date: settlementStart,
+		settlement_end_date: settlementEnd,
+		deposit_date: depositDate && depositDate.length > 0 ? depositDate : settlementEnd,
+		currency,
+		total_amount_cents: totalAmountCents,
+		amount_sum_cents: amountSumCents,
+		row_count: rows.length
+	};
+}
+/** Decode UTF-8 document bytes (after optional gunzip) and parse summary. */
+async function summarizeSettlementDocument(bytes, compressionAlgorithm) {
+	if (!compressionAlgorithm && bytes.byteLength > 67108864) settlementError("Settlement report body exceeds limit", "too_large");
+	const plain = await maybeGunzipReportBytes(bytes, compressionAlgorithm);
+	if (plain.byteLength > 67108864) settlementError("Settlement report body exceeds limit", "too_large");
+	return parseSettlementV2Tsv(new TextDecoder("utf-8", { fatal: false }).decode(plain));
+}
+/** ISO createdSince for listReports retention window. */
+function settlementCreatedSinceIso(now = /* @__PURE__ */ new Date(), retentionDays = 90) {
+	const ms = retentionDays * 24 * 60 * 60 * 1e3;
+	return new Date(now.getTime() - ms).toISOString();
+}
+//#endregion
+//#region src/vendors/amazon-sp-api/client.ts
+/**
+* Amazon Selling Partner API vendor client.
+* Host: `new AmazonSpApiClient(auth)`. Agent tools: `fromContext(ctx)`.
+*
+* LWA refresh → access token; SP-API calls use AwsService (SigV4 execute-api)
+* plus x-amz-access-token.
+*/
+var AmazonSpApiClient = class AmazonSpApiClient {
+	#auth;
+	#lwa;
+	#api;
+	/** Absolute URL document download (report document URLs). */
+	#download;
+	#accessToken;
+	#accessTokenExpiresAt = 0;
+	constructor(auth, options = {}) {
+		const parsed = amazonSpApiAuthSchema.safeParse(auth);
+		if (!parsed.success) throw new ToolError("Invalid Amazon SP-API auth credentials", {
+			code: "bad_auth",
+			details: { issues: parsed.error.issues.map((issue) => issue.message) }
+		});
+		this.#auth = parsed.data;
+		this.#lwa = new HttpService({
+			...options,
+			label: "Amazon LWA"
+		});
+		this.#api = new AwsService({
+			...options,
+			accessKeyId: this.#auth.access_key_id,
+			secretAccessKey: this.#auth.secret_access_key,
+			region: this.#auth.region,
+			service: "execute-api",
+			baseURL: this.#auth.endpoint,
+			label: "Amazon SP-API",
+			...this.#auth.session_token && { sessionToken: this.#auth.session_token }
+		});
+		this.#download = new HttpService({
+			...options,
+			label: "Amazon SP-API report download"
+		});
+	}
+	static fromContext(ctx) {
+		const auth = requireAuth(ctx, amazonSpApiAuthSchema);
+		return new AmazonSpApiClient(auth, {
+			...ctx.fetch && { fetch: ctx.fetch },
+			...ctx.signal && { signal: ctx.signal }
+		});
+	}
+	async #ensureAccessToken() {
+		const now = Date.now();
+		if (this.#accessToken && now < this.#accessTokenExpiresAt - 6e4) return this.#accessToken;
+		const { data } = await this.#lwa.post(LWA_TOKEN_URL, lwaTokenBody(this.#auth), {
+			label: "Amazon LWA token",
+			headers: { "Content-Type": "application/x-www-form-urlencoded" }
+		});
+		const token = parseLwaAccessToken(data);
+		this.#accessToken = token;
+		this.#accessTokenExpiresAt = now + 3e6;
+		return token;
+	}
+	async #spGet(path, label, query) {
+		const token = await this.#ensureAccessToken();
+		return this.#api.get(path, {
+			label,
+			headers: { "x-amz-access-token": token },
+			...query && { query }
+		});
+	}
+	async #spPost(path, label, body) {
+		const token = await this.#ensureAccessToken();
+		return this.#api.post(path, body, {
+			label,
+			headers: {
+				"x-amz-access-token": token,
+				"Content-Type": "application/json"
+			}
+		});
+	}
+	/** GET /orders/v0/orders */
+	async listOrders(input = {}) {
+		const marketplaceIds = requireMarketplaceIds(input.marketplace_ids, this.#auth.marketplace_ids, "Amazon SP-API listOrders");
+		const { data } = await this.#spGet("/orders/v0/orders", "Amazon SP-API listOrders", {
+			MarketplaceIds: marketplaceIds.join(","),
+			...input.created_after && { CreatedAfter: input.created_after },
+			...input.created_before && { CreatedBefore: input.created_before },
+			...input.last_updated_after && { LastUpdatedAfter: input.last_updated_after },
+			...input.order_statuses && input.order_statuses.length > 0 && { OrderStatuses: input.order_statuses.join(",") },
+			...input.cursor && { NextToken: input.cursor },
+			...input.max_results !== void 0 && { MaxResultsPerPage: input.max_results }
+		});
+		const parsed = parseOrdersPayload(data);
+		return {
+			items: parsed.items,
+			truncated: Boolean(parsed.nextToken),
+			...parsed.nextToken && { next_cursor: parsed.nextToken }
+		};
+	}
+	/** GET /orders/v0/orders/{orderId} */
+	async getOrder(input) {
+		const { data } = await this.#spGet(`/orders/v0/orders/${encodeURIComponent(input.amazon_order_id)}`, "Amazon SP-API getOrder");
+		return { order: parseOrderPayload(data) };
+	}
+	/** GET /orders/v0/orders/{orderId}/orderItems */
+	async getOrderItems(input) {
+		const query = input.cursor ? { NextToken: input.cursor } : void 0;
+		const { data } = await this.#spGet(`/orders/v0/orders/${encodeURIComponent(input.amazon_order_id)}/orderItems`, "Amazon SP-API getOrderItems", query);
+		const parsed = parseOrderItemsPayload(data);
+		return {
+			amazon_order_id: parsed.amazon_order_id,
+			items: parsed.items,
+			truncated: Boolean(parsed.nextToken),
+			...parsed.nextToken && { next_cursor: parsed.nextToken }
+		};
+	}
+	/**
+	* GET /orders/2026-01-01/orders (searchOrders).
+	* Always requests includedData=FULFILLMENT for fulfillmentStatus.
+	* Optional max_pages drains pages sequentially (bounded).
+	*/
+	async searchOrders(input) {
+		const marketplaceIds = requireMarketplaceIds(input.marketplace_ids, this.#auth.marketplace_ids, "Amazon SP-API searchOrders");
+		const maxPages = input.max_pages ?? 1;
+		const pageSize = input.max_results ?? 100;
+		const items = [];
+		let cursor = input.cursor;
+		let pages = 0;
+		let nextToken;
+		while (pages < maxPages) {
+			pages += 1;
+			const { data } = await this.#spGet("/orders/2026-01-01/orders", "Amazon SP-API searchOrders", {
+				createdAfter: input.created_after,
+				...input.created_before && { createdBefore: input.created_before },
+				marketplaceIds: marketplaceIds.join(","),
+				includedData: "FULFILLMENT",
+				maxResultsPerPage: pageSize,
+				...cursor && { paginationToken: cursor }
+			});
+			const parsed = parseSearchOrdersPayload(data);
+			items.push(...parsed.items);
+			nextToken = parsed.nextToken;
+			if (!nextToken) break;
+			cursor = nextToken;
+		}
+		return {
+			items,
+			truncated: Boolean(nextToken),
+			...nextToken && { next_cursor: nextToken }
+		};
+	}
+	/** GET /fba/inventory/v1/summaries */
+	async listInventorySummaries(input = {}) {
+		const marketplaceId = requireMarketplaceIds(input.marketplace_id ? [input.marketplace_id] : void 0, this.#auth.marketplace_ids, "Amazon SP-API listInventorySummaries")[0];
+		if (!marketplaceId) throw new ToolError("Amazon SP-API listInventorySummaries requires a marketplace_id", { code: "bad_input" });
+		const { data } = await this.#spGet("/fba/inventory/v1/summaries", "Amazon SP-API listInventorySummaries", {
+			details: true,
+			granularityType: "Marketplace",
+			granularityId: marketplaceId,
+			marketplaceIds: marketplaceId,
+			...input.seller_skus && input.seller_skus.length > 0 && { sellerSkus: input.seller_skus.join(",") },
+			...input.start_date_time && { startDateTime: input.start_date_time },
+			...input.cursor && { nextToken: input.cursor }
+		});
+		const parsed = parseInventoryPayload(data);
+		return {
+			items: parsed.items,
+			truncated: Boolean(parsed.nextToken),
+			...parsed.nextToken && { next_cursor: parsed.nextToken }
+		};
+	}
+	/** POST /reports/2021-06-30/reports */
+	async createReport(input) {
+		const marketplaceIds = requireMarketplaceIds(input.marketplace_ids, this.#auth.marketplace_ids, "Amazon SP-API createReport");
+		const body = {
+			reportType: input.report_type,
+			marketplaceIds,
+			...input.data_start_time && { dataStartTime: input.data_start_time },
+			...input.data_end_time && { dataEndTime: input.data_end_time },
+			...input.report_options && { reportOptions: input.report_options }
+		};
+		const { data } = await this.#spPost("/reports/2021-06-30/reports", "Amazon SP-API createReport", body);
+		return parseCreateReportPayload(data);
+	}
+	/** GET /reports/2021-06-30/reports/{reportId} */
+	async getReport(input) {
+		const { data } = await this.#spGet(`/reports/2021-06-30/reports/${encodeURIComponent(input.report_id)}`, "Amazon SP-API getReport");
+		return { report: parseGetReportPayload(data) };
+	}
+	/** GET /reports/2021-06-30/reports */
+	async listReports(input = {}) {
+		const marketplaceIds = input.marketplace_ids ?? this.#auth.marketplace_ids;
+		const { data } = await this.#spGet("/reports/2021-06-30/reports", "Amazon SP-API listReports", {
+			...input.report_types && input.report_types.length > 0 && { reportTypes: input.report_types.join(",") },
+			...input.processing_statuses && input.processing_statuses.length > 0 && { processingStatuses: input.processing_statuses.join(",") },
+			...marketplaceIds && marketplaceIds.length > 0 && { marketplaceIds: marketplaceIds.join(",") },
+			...input.page_size !== void 0 && { pageSize: input.page_size },
+			...input.created_since && { createdSince: input.created_since },
+			...input.created_until && { createdUntil: input.created_until },
+			...input.cursor && { nextToken: input.cursor }
+		});
+		const parsed = parseListReportsPayload(data);
+		return {
+			items: parsed.items,
+			truncated: Boolean(parsed.nextToken),
+			...parsed.nextToken && { next_cursor: parsed.nextToken }
+		};
+	}
+	/** GET /reports/2021-06-30/documents/{reportDocumentId} */
+	async getReportDocument(input) {
+		const { data } = await this.#spGet(`/reports/2021-06-30/documents/${encodeURIComponent(input.report_document_id)}`, "Amazon SP-API getReportDocument");
+		return parseReportDocumentPayload(data);
+	}
+	/**
+	* Composite: newest DONE Flat File V2 settlement report (or `report_id`) →
+	* one document download → eight summary fields in safe integer cents.
+	* Never returns raw TSV rows, order ids, skus, or document URLs.
+	*/
+	async getSettlementSummary(input = {}) {
+		const reportDocumentId = await this.#resolveSettlementReportDocumentId(input);
+		const doc = await this.getReportDocument({ report_document_id: reportDocumentId });
+		const { bytes } = await this.#download.bytes("GET", doc.url, {
+			label: "Amazon SP-API settlement document",
+			maxBytes: SETTLEMENT_MAX_COMPRESSED_BYTES
+		});
+		return await summarizeSettlementDocument(bytes, doc.compression_algorithm);
+	}
+	async #resolveSettlementReportDocumentId(input) {
+		if (input.report_id) {
+			const { report } = await this.getReport({ report_id: input.report_id });
+			if (report.processing_status && report.processing_status !== "DONE") throw new ToolError("Settlement report is not DONE", {
+				code: "bad_input",
+				details: { processing_status: report.processing_status }
+			});
+			if (!report.report_document_id) throw new ToolError("Settlement report has no document id", { code: "upstream" });
+			return report.report_document_id;
+		}
+		const createdSince = input.created_since ?? settlementCreatedSinceIso();
+		let cursor;
+		for (let page = 0; page < 5; page += 1) {
+			const listed = await this.listReports({
+				report_types: [SETTLEMENT_REPORT_TYPE_V2],
+				processing_statuses: ["DONE"],
+				created_since: createdSince,
+				page_size: 100,
+				...cursor && { cursor }
+			});
+			for (const report of listed.items) if (report.report_document_id) return report.report_document_id;
+			if (!listed.next_cursor) break;
+			cursor = listed.next_cursor;
+		}
+		throw new ToolError("No completed settlement report found in the retention window", { code: "not_found" });
+	}
+	/** GET /catalog/2022-04-01/items */
+	async searchCatalogItems(input) {
+		const marketplaceIds = requireMarketplaceIds(input.marketplace_ids, this.#auth.marketplace_ids, "Amazon SP-API searchCatalogItems");
+		const { data } = await this.#spGet("/catalog/2022-04-01/items", "Amazon SP-API searchCatalogItems", {
+			keywords: input.keywords.join(","),
+			marketplaceIds: marketplaceIds.join(","),
+			...input.included_data && input.included_data.length > 0 && { includedData: input.included_data.join(",") },
+			...input.page_size !== void 0 && { pageSize: input.page_size },
+			...input.cursor && { pageToken: input.cursor }
+		});
+		const parsed = parseSearchCatalogItemsPayload(data);
+		return {
+			items: parsed.items,
+			truncated: Boolean(parsed.nextToken),
+			...parsed.numberOfResults !== void 0 && { number_of_results: parsed.numberOfResults },
+			...parsed.nextToken && { next_cursor: parsed.nextToken }
+		};
+	}
+};
+//#endregion
+//#region src/vendors/amazon-sp-api/module.ts
+const amazonSpApiListOrdersTool = defineTool({
+	id: "amazon-sp-api-list-orders",
+	name: "amazonSpApiListOrders",
+	description: "List Amazon SP-API orders for one or more marketplaces. Optional date and status filters. Paginate with next_cursor (NextToken).",
+	inputSchema: amazonSpApiListOrdersInputSchema,
+	outputSchema: amazonSpApiListOrdersOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	execute: async (input, ctx) => AmazonSpApiClient.fromContext(ctx).listOrders(input)
+});
+const amazonSpApiGetOrderTool = defineTool({
+	id: "amazon-sp-api-get-order",
+	name: "amazonSpApiGetOrder",
+	description: "Get one Amazon SP-API order by AmazonOrderId.",
+	inputSchema: amazonSpApiGetOrderInputSchema,
+	outputSchema: amazonSpApiGetOrderOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	execute: async (input, ctx) => AmazonSpApiClient.fromContext(ctx).getOrder(input)
+});
+const amazonSpApiGetOrderItemsTool = defineTool({
+	id: "amazon-sp-api-get-order-items",
+	name: "amazonSpApiGetOrderItems",
+	description: "List line items for one Amazon SP-API order. Paginate with next_cursor (NextToken).",
+	inputSchema: amazonSpApiGetOrderItemsInputSchema,
+	outputSchema: amazonSpApiGetOrderItemsOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	execute: async (input, ctx) => AmazonSpApiClient.fromContext(ctx).getOrderItems(input)
+});
+const amazonSpApiSearchOrdersTool = defineTool({
+	id: "amazon-sp-api-search-orders",
+	name: "amazonSpApiSearchOrders",
+	description: "Search Amazon orders via Orders API v2026-01-01 (searchOrders). Filter by created_after (required) and optional created_before. Always includes FULFILLMENT data for fulfillment_status. Optional max_pages drains pages sequentially (max 50). Paginate with next_cursor when truncated.",
+	inputSchema: amazonSpApiSearchOrdersInputSchema,
+	outputSchema: amazonSpApiSearchOrdersOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	execute: async (input, ctx) => AmazonSpApiClient.fromContext(ctx).searchOrders(input)
+});
+const amazonSpApiListInventorySummariesTool = defineTool({
+	id: "amazon-sp-api-list-inventory-summaries",
+	name: "amazonSpApiListInventorySummaries",
+	description: "List FBA inventory summaries for a marketplace. Optional seller SKUs and start_date_time. Paginate with next_cursor.",
+	inputSchema: amazonSpApiListInventorySummariesInputSchema,
+	outputSchema: amazonSpApiListInventorySummariesOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	execute: async (input, ctx) => AmazonSpApiClient.fromContext(ctx).listInventorySummaries(input)
+});
+const amazonSpApiCreateReportTool = defineTool({
+	id: "amazon-sp-api-create-report",
+	name: "amazonSpApiCreateReport",
+	description: "Request an Amazon SP-API report for given marketplace(s) and optional date range. Returns report_id for later getReport polling.",
+	inputSchema: amazonSpApiCreateReportInputSchema,
+	outputSchema: amazonSpApiCreateReportOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	execute: async (input, ctx) => AmazonSpApiClient.fromContext(ctx).createReport(input)
+});
+const amazonSpApiGetReportTool = defineTool({
+	id: "amazon-sp-api-get-report",
+	name: "amazonSpApiGetReport",
+	description: "Get one Amazon SP-API report by report_id, including processing_status and report_document_id when DONE.",
+	inputSchema: amazonSpApiGetReportInputSchema,
+	outputSchema: amazonSpApiGetReportOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	execute: async (input, ctx) => AmazonSpApiClient.fromContext(ctx).getReport(input)
+});
+const amazonSpApiListReportsTool = defineTool({
+	id: "amazon-sp-api-list-reports",
+	name: "amazonSpApiListReports",
+	description: "List Amazon SP-API reports with optional type, status, marketplace, and created-time filters. Paginate with next_cursor.",
+	inputSchema: amazonSpApiListReportsInputSchema,
+	outputSchema: amazonSpApiListReportsOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	execute: async (input, ctx) => AmazonSpApiClient.fromContext(ctx).listReports(input)
+});
+const amazonSpApiGetReportDocumentTool = defineTool({
+	id: "amazon-sp-api-get-report-document",
+	name: "amazonSpApiGetReportDocument",
+	description: "Get a downloadable Amazon SP-API report document (document_id, url, optional compression_algorithm). Does not download the file body.",
+	inputSchema: amazonSpApiGetReportDocumentInputSchema,
+	outputSchema: amazonSpApiGetReportDocumentOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	execute: async (input, ctx) => AmazonSpApiClient.fromContext(ctx).getReportDocument(input)
+});
+const amazonSpApiSearchCatalogItemsTool = defineTool({
+	id: "amazon-sp-api-search-catalog-items",
+	name: "amazonSpApiSearchCatalogItems",
+	description: "Search Amazon catalog items by keywords for marketplace(s). Optional included_data and page_size. Paginate with next_cursor (pageToken).",
+	inputSchema: amazonSpApiSearchCatalogItemsInputSchema,
+	outputSchema: amazonSpApiSearchCatalogItemsOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	execute: async (input, ctx) => AmazonSpApiClient.fromContext(ctx).searchCatalogItems(input)
+});
+const amazonSpApiGetSettlementSummaryTool = defineTool({
+	id: "amazon-sp-api-get-settlement-summary",
+	name: "amazonSpApiGetSettlementSummary",
+	description: "Summarize the newest completed Amazon Flat File V2 settlement report (or a specific report_id): downloads one document, validates the TSV, and returns eight summary fields in integer cents (settlement id, period, deposit date, currency, total and amount sum, row count). Does not return line-level order or SKU data. Optional created_since (default last 90 days when listing).",
+	inputSchema: amazonSpApiGetSettlementSummaryInputSchema,
+	outputSchema: amazonSpApiGetSettlementSummaryOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	execute: async (input, ctx) => AmazonSpApiClient.fromContext(ctx).getSettlementSummary(input)
+});
+const amazonSpApiModule = defineModule({
+	id: "amazon-sp-api",
+	title: "Amazon SP-API",
+	description: "Amazon Selling Partner API vendor pack: orders v0 and SearchOrders v2026, order items, FBA inventory summaries, reports (create/get/list/document), settlement V2 summary, and catalog item search.",
+	runtime: "both",
+	auth: {
+		type: "custom",
+		schema: amazonSpApiAuthSchema
+	},
+	categories: ["commerce", "amazon"],
+	classification: "pii",
+	tags: [
+		"orders",
+		"fba",
+		"reports"
+	],
+	tools: [
+		amazonSpApiListOrdersTool,
+		amazonSpApiGetOrderTool,
+		amazonSpApiGetOrderItemsTool,
+		amazonSpApiSearchOrdersTool,
+		amazonSpApiListInventorySummariesTool,
+		amazonSpApiCreateReportTool,
+		amazonSpApiGetReportTool,
+		amazonSpApiListReportsTool,
+		amazonSpApiGetReportDocumentTool,
+		amazonSpApiGetSettlementSummaryTool,
+		amazonSpApiSearchCatalogItemsTool
+	]
+});
+//#endregion
+export { AmazonSpApiClient, amazonSpApiAuthSchema, amazonSpApiCatalogItemSchema, amazonSpApiCreateReportInputSchema, amazonSpApiCreateReportOutputSchema, amazonSpApiCreateReportTool, amazonSpApiEndpointSchema, amazonSpApiGetOrderInputSchema, amazonSpApiGetOrderItemsInputSchema, amazonSpApiGetOrderItemsOutputSchema, amazonSpApiGetOrderItemsTool, amazonSpApiGetOrderOutputSchema, amazonSpApiGetOrderTool, amazonSpApiGetReportDocumentInputSchema, amazonSpApiGetReportDocumentOutputSchema, amazonSpApiGetReportDocumentTool, amazonSpApiGetReportInputSchema, amazonSpApiGetReportOutputSchema, amazonSpApiGetReportTool, amazonSpApiGetSettlementSummaryInputSchema, amazonSpApiGetSettlementSummaryOutputSchema, amazonSpApiGetSettlementSummaryTool, amazonSpApiInventorySummarySchema, amazonSpApiListInventorySummariesInputSchema, amazonSpApiListInventorySummariesOutputSchema, amazonSpApiListInventorySummariesTool, amazonSpApiListOrdersInputSchema, amazonSpApiListOrdersOutputSchema, amazonSpApiListOrdersTool, amazonSpApiListReportsInputSchema, amazonSpApiListReportsOutputSchema, amazonSpApiListReportsTool, amazonSpApiModule, amazonSpApiOrderItemSchema, amazonSpApiOrderSchema, amazonSpApiReportSchema, amazonSpApiSearchCatalogItemsInputSchema, amazonSpApiSearchCatalogItemsOutputSchema, amazonSpApiSearchCatalogItemsTool, amazonSpApiSearchOrderSchema, amazonSpApiSearchOrdersInputSchema, amazonSpApiSearchOrdersOutputSchema, amazonSpApiSearchOrdersTool, amazonSpApiSettlementSummarySchema };
+
+//# sourceMappingURL=index.js.map