@5ss/ai-tools 2.11.2 → 2.11.3

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

@@ -2,8 +2,8 @@ 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 { r as bytesToUtf8 } from "../../bytes-BxpimpQx.js";
+import { t as gunzipSync } from "../../esm-BDrCssjb.js";
 import { z } from "zod";
 import Decimal from "decimal.js";
 import Papa from "papaparse";
@@ -18,12 +18,14 @@ 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")
+	marketplace_ids: z.array(z.string().min(1)).min(1).optional().describe("Default marketplace ids when a tool call omits marketplace_ids"),
+	user_agent: z.string().min(1).describe("Application user agent sent with every SP-API request")
+});
+const amazonSpApiLwaTokenResponseSchema = z.object({
+	access_token: z.string().min(1),
+	token_type: z.string().min(1),
+	expires_in: z.number().int().positive()
 });
 const amazonSpApiListOrdersInputSchema = z.object({
 	marketplace_ids: z.array(z.string().min(1)).min(1).optional().describe("Marketplace ids; omit to use the configured defaults"),
@@ -89,6 +91,88 @@ const amazonSpApiSearchOrdersOutputSchema = z.object({
 	next_cursor: z.string().optional().describe("paginationToken for the next page when not fully drained"),
 	truncated: z.boolean()
 });
+const amazonInventoryDateTimeSchema = z.iso.datetime({ offset: true });
+function eighteenMonthsBeforeNow() {
+	const oldestAllowed = /* @__PURE__ */ new Date();
+	const currentDay = oldestAllowed.getUTCDate();
+	oldestAllowed.setUTCDate(1);
+	oldestAllowed.setUTCMonth(oldestAllowed.getUTCMonth() - 18);
+	const lastDayOfTargetMonth = new Date(Date.UTC(oldestAllowed.getUTCFullYear(), oldestAllowed.getUTCMonth() + 1, 0)).getUTCDate();
+	oldestAllowed.setUTCDate(Math.min(currentDay, lastDayOfTargetMonth));
+	return oldestAllowed.getTime();
+}
+const amazonInventoryFullPageInputSchema = z.strictObject({
+	mode: z.literal("full"),
+	marketplace_id: z.string().min(1),
+	next_token: z.string().min(1).optional()
+});
+const amazonInventoryIncrementalPageInputSchema = z.strictObject({
+	mode: z.literal("incremental"),
+	marketplace_id: z.string().min(1),
+	start_date_time: amazonInventoryDateTimeSchema,
+	next_token: z.string().min(1).optional()
+});
+const amazonSpApiInventoryPageInputSchema = z.discriminatedUnion("mode", [amazonInventoryFullPageInputSchema, amazonInventoryIncrementalPageInputSchema]).superRefine((input, context) => {
+	if (input.mode !== "incremental") return;
+	if (Date.parse(input.start_date_time) < eighteenMonthsBeforeNow()) context.addIssue({
+		code: "custom",
+		path: ["start_date_time"],
+		message: "start_date_time cannot be more than 18 months in the past"
+	});
+});
+const amazonInventoryReservedQuantityRawSchema = z.looseObject({
+	totalReservedQuantity: z.number().optional(),
+	pendingCustomerOrderQuantity: z.number().optional(),
+	pendingTransshipmentQuantity: z.number().optional(),
+	fcProcessingQuantity: z.number().optional()
+});
+const amazonInventoryResearchingQuantityBreakdownRawSchema = z.looseObject({
+	name: z.enum([
+		"researchingQuantityInShortTerm",
+		"researchingQuantityInMidTerm",
+		"researchingQuantityInLongTerm"
+	]),
+	quantity: z.int()
+});
+const amazonInventoryResearchingQuantityRawSchema = z.looseObject({
+	totalResearchingQuantity: z.number().optional(),
+	researchingQuantityBreakdown: z.array(amazonInventoryResearchingQuantityBreakdownRawSchema).optional()
+});
+const amazonInventoryUnfulfillableQuantityRawSchema = z.looseObject({
+	totalUnfulfillableQuantity: z.number().optional(),
+	customerDamagedQuantity: z.number().optional(),
+	warehouseDamagedQuantity: z.number().optional(),
+	distributorDamagedQuantity: z.number().optional(),
+	carrierDamagedQuantity: z.number().optional(),
+	defectiveQuantity: z.number().optional(),
+	expiredQuantity: z.number().optional()
+});
+const amazonInventoryDetailsRawSchema = z.looseObject({
+	fulfillableQuantity: z.number().optional(),
+	inboundWorkingQuantity: z.number().optional(),
+	inboundShippedQuantity: z.number().optional(),
+	inboundReceivingQuantity: z.number().optional(),
+	reservedQuantity: amazonInventoryReservedQuantityRawSchema.optional(),
+	researchingQuantity: amazonInventoryResearchingQuantityRawSchema.optional(),
+	unfulfillableQuantity: amazonInventoryUnfulfillableQuantityRawSchema.optional()
+});
+const amazonInventorySummaryRawSchema = z.looseObject({
+	asin: z.string().optional(),
+	fnSku: z.string().optional(),
+	sellerSku: z.string().optional(),
+	condition: z.string().optional(),
+	productName: z.string().optional(),
+	totalQuantity: z.number().optional(),
+	lastUpdatedTime: z.string().optional(),
+	stores: z.array(z.string()).optional(),
+	inventoryDetails: amazonInventoryDetailsRawSchema.optional()
+});
+const amazonSpApiInventoryPageOutputSchema = z.object({
+	items: z.array(amazonInventorySummaryRawSchema),
+	next_token: z.string().optional(),
+	rate_limit_per_second: z.number().optional(),
+	request_id: z.string().optional()
+});
 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)"),
@@ -128,14 +212,37 @@ const amazonSpApiReportSchema = z.object({
 	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)"),
+const amazonSpApiListReportsInitialFields = {
+	report_types: z.array(z.string().min(1)).min(1).max(10).describe("Filter by 1-10 report types"),
 	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")
+	created_since: z.iso.datetime({ offset: true }).optional().describe("ISO 8601; reports created after"),
+	created_until: z.iso.datetime({ offset: true }).optional().describe("ISO 8601; reports created before")
+};
+const amazonSpApiListReportsInitialInputSchema = z.strictObject(amazonSpApiListReportsInitialFields);
+const amazonSpApiListReportsCursorInputSchema = z.strictObject({ cursor: z.string().min(1).describe("nextToken from a prior page") });
+const amazonSpApiListReportsInputSchema = z.union([amazonSpApiListReportsInitialInputSchema, amazonSpApiListReportsCursorInputSchema]);
+const amazonReportRawSchema = z.looseObject({
+	reportId: z.string().min(1),
+	reportType: z.string().optional(),
+	processingStatus: z.string().optional(),
+	marketplaceIds: z.array(z.string()).optional(),
+	dataStartTime: z.string().optional(),
+	dataEndTime: z.string().optional(),
+	reportScheduleId: z.string().optional(),
+	createdTime: z.string().optional(),
+	processingStartTime: z.string().optional(),
+	processingEndTime: z.string().optional(),
+	reportDocumentId: z.string().optional()
+});
+const amazonSpApiListReportsContinuationInputSchema = z.strictObject({ next_token: z.string().min(1) });
+const amazonSpApiListReportsPageInputSchema = z.union([amazonSpApiListReportsInitialInputSchema, amazonSpApiListReportsContinuationInputSchema]);
+const amazonSpApiListReportsPageOutputSchema = z.object({
+	items: z.array(amazonReportRawSchema),
+	next_token: z.string().optional(),
+	rate_limit_per_second: z.number().optional(),
+	request_id: z.string().optional()
 });
 const amazonSpApiListReportsOutputSchema = z.object({
 	items: z.array(amazonSpApiReportSchema),
@@ -148,6 +255,18 @@ const amazonSpApiGetReportDocumentOutputSchema = z.object({
 	url: z.string(),
 	compression_algorithm: z.string().optional()
 });
+const amazonSpApiDownloadReportDocumentBytesInputSchema = z.strictObject({
+	report_document_id: z.string().min(1),
+	max_bytes: z.int().positive()
+});
+const amazonSpApiDownloadReportDocumentBytesOutputSchema = z.object({
+	bytes: z.custom((value) => value instanceof Uint8Array),
+	text: z.string(),
+	byte_length: z.int().nonnegative(),
+	content_type: z.string().optional(),
+	content_encoding: z.string().optional(),
+	compression_algorithm: z.enum(["GZIP"]).optional()
+});
 /**
 * Composite input: pick newest completed V2 settlement report in the retention
 * window (default 90d), download one document, return eight summary fields only.
@@ -194,6 +313,61 @@ const amazonSpApiSearchCatalogItemsOutputSchema = z.object({
 * Amazon SP-API: LWA body, order/inventory/report/catalog parse (no HTTP).
 */
 const LWA_TOKEN_URL = "https://api.amazon.com/auth/o2/token";
+const amazonMoneyRawSchema = z.looseObject({
+	Amount: z.string().optional(),
+	CurrencyCode: z.string().optional()
+});
+const amazonOrderRawSchema = z.looseObject({
+	AmazonOrderId: z.string().min(1),
+	OrderStatus: z.string().optional(),
+	PurchaseDate: z.string().optional(),
+	LastUpdateDate: z.string().optional(),
+	MarketplaceId: z.string().optional(),
+	OrderTotal: amazonMoneyRawSchema.optional(),
+	FulfillmentChannel: z.string().optional()
+});
+const amazonOrdersResponseSchema = z.looseObject({ payload: z.looseObject({
+	Orders: z.array(amazonOrderRawSchema),
+	NextToken: z.string().min(1).optional()
+}) });
+const amazonSearchOrderRawSchema = z.looseObject({
+	orderId: z.string().min(1),
+	createdTime: z.string().optional(),
+	fulfillment: z.looseObject({ fulfillmentStatus: z.string().optional() }).optional()
+});
+const amazonSearchOrdersRootSchema = z.looseObject({
+	orders: z.array(amazonSearchOrderRawSchema),
+	pagination: z.looseObject({ nextToken: z.string().min(1).optional() }).optional()
+});
+const amazonSearchOrdersWrappedResponseSchema = z.looseObject({ payload: amazonSearchOrdersRootSchema });
+const amazonOrderItemRawSchema = z.looseObject({
+	OrderItemId: z.string().min(1),
+	ASIN: z.string().optional(),
+	SellerSKU: z.string().optional(),
+	Title: z.string().optional(),
+	QuantityOrdered: z.number().optional(),
+	QuantityShipped: z.number().optional(),
+	ItemPrice: amazonMoneyRawSchema.optional()
+});
+const amazonOrderItemsResponseSchema = z.looseObject({ payload: z.looseObject({
+	AmazonOrderId: z.string().min(1),
+	OrderItems: z.array(amazonOrderItemRawSchema),
+	NextToken: z.string().min(1).optional()
+}) });
+const amazonCatalogItemRawSchema = z.looseObject({
+	asin: z.string().min(1),
+	summaries: z.array(z.looseObject({
+		itemName: z.string().optional(),
+		brandName: z.string().optional(),
+		marketplaceId: z.string().optional()
+	})).optional(),
+	productTypes: z.array(z.looseObject({ productType: z.string().optional() })).optional()
+});
+const amazonCatalogSearchResponseSchema = z.looseObject({
+	items: z.array(amazonCatalogItemRawSchema),
+	numberOfResults: z.number().optional(),
+	pagination: z.looseObject({ nextToken: z.string().min(1).optional() }).optional()
+});
 function lwaTokenBody(auth) {
 	return new URLSearchParams({
 		grant_type: "refresh_token",
@@ -202,201 +376,204 @@ function lwaTokenBody(auth) {
 		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 parseLwaTokenResponse(data) {
+	const parsed = amazonSpApiLwaTokenResponseSchema.safeParse(data);
+	if (!parsed.success) throw new ToolError("Amazon LWA returned an invalid token response", {
+		code: "bad_auth",
+		details: { issues: parsed.error.issues.map((issue) => issue.message) }
+	});
+	return parsed.data;
 }
 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;
+	const parsed = amazonOrderRawSchema.safeParse(value);
+	if (!parsed.success) throw new ToolError("Amazon SP-API returned an invalid order", { code: "upstream" });
 	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"] }
+		amazon_order_id: parsed.data.AmazonOrderId,
+		...parsed.data.OrderStatus && { order_status: parsed.data.OrderStatus },
+		...parsed.data.PurchaseDate && { purchase_date: parsed.data.PurchaseDate },
+		...parsed.data.LastUpdateDate && { last_update_date: parsed.data.LastUpdateDate },
+		...parsed.data.MarketplaceId && { marketplace_id: parsed.data.MarketplaceId },
+		...parsed.data.OrderTotal?.Amount && { order_total_amount: parsed.data.OrderTotal.Amount },
+		...parsed.data.OrderTotal?.CurrencyCode && { order_total_currency: parsed.data.OrderTotal.CurrencyCode },
+		...parsed.data.FulfillmentChannel && { fulfillment_channel: parsed.data.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;
+	const parsed = amazonOrdersResponseSchema.safeParse(data);
+	if (!parsed.success) throw new ToolError("Amazon SP-API orders payload invalid", { code: "upstream" });
 	return {
-		items: orders.map(parseOrder),
-		...nextToken && { nextToken }
+		items: parsed.data.payload.Orders.map(parseOrder),
+		...parsed.data.payload.NextToken && { nextToken: parsed.data.payload.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"]);
+	const parsed = z.looseObject({ payload: amazonOrderRawSchema }).safeParse(data);
+	if (!parsed.success) throw new ToolError("Amazon SP-API get order payload invalid", { code: "upstream" });
+	return parseOrder(parsed.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;
+	const parsed = amazonSearchOrderRawSchema.safeParse(value);
+	if (!parsed.success) throw new ToolError("Amazon SP-API searchOrders returned an invalid order", { code: "upstream" });
 	return {
-		order_id: value["orderId"],
-		...isString(value["createdTime"]) && { created_time: value["createdTime"] },
-		...fulfillmentStatus && { fulfillment_status: fulfillmentStatus }
+		order_id: parsed.data.orderId,
+		...parsed.data.createdTime && { created_time: parsed.data.createdTime },
+		...parsed.data.fulfillment?.fulfillmentStatus && { fulfillment_status: parsed.data.fulfillment.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;
+	const wrapped = amazonSearchOrdersWrappedResponseSchema.safeParse(data);
+	const direct = amazonSearchOrdersRootSchema.safeParse(data);
+	const root = wrapped.success ? wrapped.data.payload : direct.success ? direct.data : void 0;
+	if (!root) throw new ToolError("Amazon SP-API searchOrders payload invalid", { code: "upstream" });
 	return {
-		items: orders.map(parseSearchOrder),
-		...nextToken && { nextToken }
+		items: root.orders.map(parseSearchOrder),
+		...root.pagination?.nextToken && { nextToken: root.pagination.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;
+	const parsed = amazonOrderItemRawSchema.safeParse(value);
+	if (!parsed.success) throw new ToolError("Amazon SP-API returned an invalid order item", { code: "upstream" });
 	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 }
+		order_item_id: parsed.data.OrderItemId,
+		...parsed.data.ASIN && { asin: parsed.data.ASIN },
+		...parsed.data.SellerSKU && { seller_sku: parsed.data.SellerSKU },
+		...parsed.data.Title && { title: parsed.data.Title },
+		...parsed.data.QuantityOrdered !== void 0 && { quantity_ordered: parsed.data.QuantityOrdered },
+		...parsed.data.QuantityShipped !== void 0 && { quantity_shipped: parsed.data.QuantityShipped },
+		...parsed.data.ItemPrice?.Amount && { item_price_amount: parsed.data.ItemPrice.Amount },
+		...parsed.data.ItemPrice?.CurrencyCode && { item_price_currency: parsed.data.ItemPrice.CurrencyCode }
 	};
 }
 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;
+	const parsed = amazonOrderItemsResponseSchema.safeParse(data);
+	if (!parsed.success) throw new ToolError("Amazon SP-API order items payload invalid", { code: "upstream" });
 	return {
-		amazon_order_id: payload["AmazonOrderId"],
-		items: orderItems.map(parseOrderItem),
-		...nextToken && { nextToken }
+		amazon_order_id: parsed.data.payload.AmazonOrderId,
+		items: parsed.data.payload.OrderItems.map(parseOrderItem),
+		...parsed.data.payload.NextToken && { nextToken: parsed.data.payload.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"];
+	const parsed = amazonInventorySummaryRawSchema.safeParse(value);
+	if (!parsed.success) throw new ToolError("Amazon SP-API returned an invalid inventory summary", {
+		code: "upstream",
+		details: { issues: parsed.error.issues.map((issue) => issue.message) }
+	});
 	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"] }
+		...parsed.data.sellerSku && { seller_sku: parsed.data.sellerSku },
+		...parsed.data.asin && { asin: parsed.data.asin },
+		...parsed.data.fnSku && { fn_sku: parsed.data.fnSku },
+		...parsed.data.condition && { condition: parsed.data.condition },
+		...parsed.data.totalQuantity !== void 0 && { total_quantity: parsed.data.totalQuantity },
+		...parsed.data.productName && { product_name: parsed.data.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;
+const inventoryPageResponseSchema = z.looseObject({
+	payload: z.looseObject({ inventorySummaries: z.array(amazonInventorySummaryRawSchema) }),
+	pagination: z.looseObject({ nextToken: z.string().min(1).optional() }).optional()
+});
+const optionalAmazonRateLimitSchema = z.coerce.number().positive();
+function parseAmazonResponseMetadata(headers) {
+	const rawRateLimit = headers.get("x-amzn-ratelimit-limit");
+	let rateLimit;
+	if (rawRateLimit !== null) {
+		const parsedRateLimit = optionalAmazonRateLimitSchema.safeParse(rawRateLimit);
+		if (!parsedRateLimit.success) throw new ToolError("Amazon SP-API returned an invalid rate-limit header", { code: "upstream" });
+		rateLimit = parsedRateLimit.data;
+	}
+	const requestId = headers.get("x-amzn-requestid") ?? headers.get("x-amzn-request-id") ?? void 0;
 	return {
-		items: summaries.map(parseInventorySummary),
-		...nextToken && { nextToken }
+		...rateLimit !== void 0 && { rate_limit_per_second: rateLimit },
+		...requestId && { request_id: requestId }
+	};
+}
+function parseInventoryPagePayload(data, headers) {
+	const parsed = inventoryPageResponseSchema.safeParse(data);
+	if (!parsed.success) throw new ToolError("Amazon SP-API inventory page response invalid", {
+		code: "upstream",
+		details: { issues: parsed.error.issues.map((issue) => issue.message) }
+	});
+	return {
+		items: parsed.data.payload.inventorySummaries,
+		...parsed.data.pagination?.nextToken && { next_token: parsed.data.pagination.nextToken },
+		...parseAmazonResponseMetadata(headers)
 	};
 }
 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"] };
+	const parsed = z.looseObject({ reportId: z.string().min(1) }).safeParse(data);
+	if (!parsed.success) throw new ToolError("Amazon SP-API create report response invalid", { code: "upstream" });
+	return { report_id: parsed.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;
+	const parsed = amazonReportRawSchema.safeParse(value);
+	if (!parsed.success) throw new ToolError("Amazon SP-API returned an invalid report", {
+		code: "upstream",
+		details: { issues: parsed.error.issues.map((issue) => issue.message) }
+	});
 	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"] }
+		report_id: parsed.data.reportId,
+		...parsed.data.reportType && { report_type: parsed.data.reportType },
+		...parsed.data.processingStatus && { processing_status: parsed.data.processingStatus },
+		...parsed.data.marketplaceIds && parsed.data.marketplaceIds.length > 0 && { marketplace_ids: parsed.data.marketplaceIds },
+		...parsed.data.dataStartTime && { data_start_time: parsed.data.dataStartTime },
+		...parsed.data.dataEndTime && { data_end_time: parsed.data.dataEndTime },
+		...parsed.data.reportDocumentId && { report_document_id: parsed.data.reportDocumentId },
+		...parsed.data.createdTime && { created_time: parsed.data.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;
+const listReportsPageResponseSchema = z.looseObject({
+	reports: z.array(amazonReportRawSchema),
+	nextToken: z.string().min(1).optional()
+});
+function parseListReportsPagePayload(data, headers) {
+	const parsed = listReportsPageResponseSchema.safeParse(data);
+	if (!parsed.success) throw new ToolError("Amazon SP-API list reports page response invalid", {
+		code: "upstream",
+		details: { issues: parsed.error.issues.map((issue) => issue.message) }
+	});
 	return {
-		items: reports.map(parseReport),
-		...nextToken && { nextToken }
+		items: parsed.data.reports,
+		...parsed.data.nextToken && { next_token: parsed.data.nextToken },
+		...parseAmazonResponseMetadata(headers)
 	};
 }
 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" });
+	const parsed = z.looseObject({
+		reportDocumentId: z.string().min(1),
+		url: z.url(),
+		compressionAlgorithm: z.string().min(1).optional()
+	}).safeParse(data);
+	if (!parsed.success) 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"] }
+		document_id: parsed.data.reportDocumentId,
+		url: parsed.data.url,
+		...parsed.data.compressionAlgorithm && { compression_algorithm: parsed.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"];
-	}
+	const parsed = amazonCatalogItemRawSchema.safeParse(value);
+	if (!parsed.success) throw new ToolError("Amazon SP-API returned an invalid catalog item", { code: "upstream" });
+	const summary = parsed.data.summaries?.[0];
+	const productType = parsed.data.productTypes?.[0];
 	return {
-		asin: value["asin"],
-		...title && { title },
-		...brand && { brand },
-		...product_type && { product_type },
-		...marketplace_id && { marketplace_id }
+		asin: parsed.data.asin,
+		...summary?.itemName && { title: summary.itemName },
+		...summary?.brandName && { brand: summary.brandName },
+		...productType?.productType && { product_type: productType.productType },
+		...summary?.marketplaceId && { marketplace_id: summary.marketplaceId }
 	};
 }
 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;
+	const parsed = amazonCatalogSearchResponseSchema.safeParse(data);
+	if (!parsed.success) throw new ToolError("Amazon SP-API catalog search payload invalid", { code: "upstream" });
 	return {
-		items: items.map(parseCatalogItem),
-		...numberOfResults !== void 0 && { numberOfResults },
-		...nextToken && { nextToken }
+		items: parsed.data.items.map(parseCatalogItem),
+		...parsed.data.numberOfResults !== void 0 && { numberOfResults: parsed.data.numberOfResults },
+		...parsed.data.pagination?.nextToken && { nextToken: parsed.data.pagination.nextToken }
 	};
 }
 function requireMarketplaceIds(inputIds, authIds, label) {
@@ -405,6 +582,24 @@ function requireMarketplaceIds(inputIds, authIds, label) {
 	return ids;
 }
 //#endregion
+//#region src/vendors/amazon-sp-api/domain/report-document.ts
+function reportDocumentError(message, code) {
+	throw new ToolError(message, { code });
+}
+async function decompressReportDocumentBytes(bytes, compressionAlgorithm, maxBytes) {
+	if (bytes.byteLength > maxBytes) reportDocumentError("Amazon report document exceeds max_bytes", "too_large");
+	if (!compressionAlgorithm) return bytes;
+	if (compressionAlgorithm.toUpperCase() !== "GZIP") reportDocumentError(`Unsupported Amazon report compression: ${compressionAlgorithm}`, "unsupported");
+	try {
+		const output = gunzipSync(bytes, { out: new Uint8Array(maxBytes + 1) });
+		if (output.byteLength > maxBytes) reportDocumentError("Amazon report document exceeds max_bytes after decompression", "too_large");
+		return output.slice();
+	} catch (error) {
+		if (error instanceof ToolError) throw error;
+		reportDocumentError("Failed to decompress Amazon report document", "upstream");
+	}
+}
+//#endregion
 //#region src/vendors/amazon-sp-api/domain/settlement.ts
 /**
 * Amazon settlement report V2 (GET_V2_SETTLEMENT_REPORT_DATA_FLAT_FILE_V2).
@@ -414,6 +609,8 @@ function requireMarketplaceIds(inputIds, authIds, label) {
 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;
+/** Max decompressed TSV body (bytes). */
+const SETTLEMENT_MAX_DECOMPRESSED_BYTES = 64 * 1024 * 1024;
 /** Required V2 header names (order free after parse; extra trailing columns OK). */
 const SETTLEMENT_V2_REQUIRED_COLUMNS = [
 	"settlement-id",
@@ -451,26 +648,14 @@ function parseUsMoneyToSafeCents(raw) {
 	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). */
+/** Decompress GZIP when report document uses compressionAlgorithm GZIP. */
 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);
+		return await decompressReportDocumentBytes(bytes, compressionAlgorithm, SETTLEMENT_MAX_DECOMPRESSED_BYTES);
 	} catch (error) {
-		if (error instanceof ToolError) throw error;
+		if (error instanceof ToolError && error.code === "too_large") settlementError("Settlement report decompressed body exceeds limit", "too_large");
+		if (error instanceof ToolError && error.code === "unsupported") throw error;
 		settlementError("Failed to decompress settlement report", "upstream");
 	}
 }
@@ -561,8 +746,7 @@ function settlementCreatedSinceIso(now = /* @__PURE__ */ new Date(), retentionDa
 * 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.
+* LWA refresh provides the access token used by SP-API HTTP requests.
 */
 var AmazonSpApiClient = class AmazonSpApiClient {
 	#auth;
@@ -583,15 +767,11 @@ var AmazonSpApiClient = class AmazonSpApiClient {
 			...options,
 			label: "Amazon LWA"
 		});
-		this.#api = new AwsService({
+		this.#api = new HttpService({
 			...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 }
+			headers: { "user-agent": this.#auth.user_agent },
+			label: "Amazon SP-API"
 		});
 		this.#download = new HttpService({
 			...options,
@@ -607,15 +787,15 @@ var AmazonSpApiClient = class AmazonSpApiClient {
 	}
 	async #ensureAccessToken() {
 		const now = Date.now();
-		if (this.#accessToken && now < this.#accessTokenExpiresAt - 6e4) return this.#accessToken;
+		if (this.#accessToken && now < this.#accessTokenExpiresAt) 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;
+		const token = parseLwaTokenResponse(data);
+		this.#accessToken = token.access_token;
+		this.#accessTokenExpiresAt = now + Math.max(0, token.expires_in * 1e3 - 6e4);
+		return token.access_token;
 	}
 	async #spGet(path, label, query) {
 		const token = await this.#ensureAccessToken();
@@ -707,23 +887,59 @@ var AmazonSpApiClient = class AmazonSpApiClient {
 		};
 	}
 	/** 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", {
+	async getInventorySummariesPage(input) {
+		const parsedInput = amazonSpApiInventoryPageInputSchema.safeParse(input);
+		if (!parsedInput.success) throw new ToolError("Invalid Amazon SP-API inventory page input", {
+			code: "bad_input",
+			details: { issues: parsedInput.error.issues.map((issue) => issue.message) }
+		});
+		return await this.#requestInventorySummariesPage({
+			marketplace_id: parsedInput.data.marketplace_id,
+			...parsedInput.data.mode === "incremental" && { start_date_time: parsedInput.data.start_date_time },
+			...parsedInput.data.next_token && { next_token: parsedInput.data.next_token }
+		});
+	}
+	async #requestInventorySummariesPage(input) {
+		const result = await this.#spGet("/fba/inventory/v1/summaries", "Amazon SP-API getInventorySummariesPage", {
 			details: true,
 			granularityType: "Marketplace",
-			granularityId: marketplaceId,
-			marketplaceIds: marketplaceId,
-			...input.seller_skus && input.seller_skus.length > 0 && { sellerSkus: input.seller_skus.join(",") },
+			granularityId: input.marketplace_id,
+			marketplaceIds: input.marketplace_id,
 			...input.start_date_time && { startDateTime: input.start_date_time },
-			...input.cursor && { nextToken: input.cursor }
+			...input.next_token && { nextToken: input.next_token },
+			...input.seller_skus && input.seller_skus.length > 0 && { sellerSkus: input.seller_skus.join(",") }
+		});
+		return parseInventoryPagePayload(result.data, result.headers);
+	}
+	/** Existing slim agent-facing projection over one raw inventory page. */
+	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 pageInput = input.start_date_time ? {
+			mode: "incremental",
+			marketplace_id: marketplaceId,
+			start_date_time: input.start_date_time,
+			...input.cursor && { next_token: input.cursor }
+		} : {
+			mode: "full",
+			marketplace_id: marketplaceId,
+			...input.cursor && { next_token: input.cursor }
+		};
+		const parsedInput = amazonSpApiInventoryPageInputSchema.safeParse(pageInput);
+		if (!parsedInput.success) throw new ToolError("Invalid Amazon SP-API inventory page input", {
+			code: "bad_input",
+			details: { issues: parsedInput.error.issues.map((issue) => issue.message) }
+		});
+		const page = await this.#requestInventorySummariesPage({
+			marketplace_id: marketplaceId,
+			...input.start_date_time && { start_date_time: input.start_date_time },
+			...input.cursor && { next_token: input.cursor },
+			...input.seller_skus && input.seller_skus.length > 0 && { seller_skus: input.seller_skus }
 		});
-		const parsed = parseInventoryPayload(data);
 		return {
-			items: parsed.items,
-			truncated: Boolean(parsed.nextToken),
-			...parsed.nextToken && { next_cursor: parsed.nextToken }
+			items: page.items.map(parseInventorySummary),
+			truncated: Boolean(page.next_token),
+			...page.next_token && { next_cursor: page.next_token }
 		};
 	}
 	/** POST /reports/2021-06-30/reports */
@@ -745,29 +961,86 @@ var AmazonSpApiClient = class AmazonSpApiClient {
 		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 }
+	async listReports(input) {
+		const parsedInput = amazonSpApiListReportsInputSchema.safeParse(input);
+		if (!parsedInput.success) throw new ToolError("Invalid Amazon SP-API listReports input", {
+			code: "bad_input",
+			details: { issues: parsedInput.error.issues.map((issue) => issue.message) }
+		});
+		const page = "cursor" in parsedInput.data ? await this.listReportsPage({ next_token: parsedInput.data.cursor }) : await this.listReportsPage({
+			report_types: parsedInput.data.report_types,
+			...parsedInput.data.processing_statuses && { processing_statuses: parsedInput.data.processing_statuses },
+			...parsedInput.data.marketplace_ids && { marketplace_ids: parsedInput.data.marketplace_ids },
+			...parsedInput.data.page_size !== void 0 && { page_size: parsedInput.data.page_size },
+			...parsedInput.data.created_since && { created_since: parsedInput.data.created_since },
+			...parsedInput.data.created_until && { created_until: parsedInput.data.created_until }
 		});
-		const parsed = parseListReportsPayload(data);
 		return {
-			items: parsed.items,
-			truncated: Boolean(parsed.nextToken),
-			...parsed.nextToken && { next_cursor: parsed.nextToken }
+			items: page.items.map(parseReport),
+			truncated: Boolean(page.next_token),
+			...page.next_token && { next_cursor: page.next_token }
 		};
 	}
+	/** One GET /reports/2021-06-30/reports request. Continuations send only nextToken. */
+	async listReportsPage(input) {
+		const parsedInput = amazonSpApiListReportsPageInputSchema.safeParse(input);
+		if (!parsedInput.success) throw new ToolError("Invalid Amazon SP-API reports page input", {
+			code: "bad_input",
+			details: { issues: parsedInput.error.issues.map((issue) => issue.message) }
+		});
+		let query;
+		if ("next_token" in parsedInput.data) query = { nextToken: parsedInput.data.next_token };
+		else {
+			const marketplaceIds = parsedInput.data.marketplace_ids ?? this.#auth.marketplace_ids;
+			query = {
+				reportTypes: parsedInput.data.report_types.join(","),
+				...parsedInput.data.processing_statuses && { processingStatuses: parsedInput.data.processing_statuses.join(",") },
+				...marketplaceIds && { marketplaceIds: marketplaceIds.join(",") },
+				...parsedInput.data.page_size !== void 0 && { pageSize: parsedInput.data.page_size },
+				...parsedInput.data.created_since && { createdSince: parsedInput.data.created_since },
+				...parsedInput.data.created_until && { createdUntil: parsedInput.data.created_until }
+			};
+		}
+		const result = await this.#spGet("/reports/2021-06-30/reports", "Amazon SP-API listReportsPage", query);
+		return parseListReportsPagePayload(result.data, result.headers);
+	}
 	/** 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);
 	}
+	/** Resolve and privately download an Amazon report document by id. */
+	async downloadReportDocumentBytes(input) {
+		const parsedInput = amazonSpApiDownloadReportDocumentBytesInputSchema.safeParse(input);
+		if (!parsedInput.success) throw new ToolError("Invalid Amazon report document download input", {
+			code: "bad_input",
+			details: { issues: parsedInput.error.issues.map((issue) => issue.message) }
+		});
+		const document = await this.getReportDocument({ report_document_id: parsedInput.data.report_document_id });
+		return await this.#downloadReportDocumentDescriptor(document, parsedInput.data.max_bytes);
+	}
+	async #downloadReportDocumentDescriptor(document, maxBytes) {
+		let compressionAlgorithm;
+		if (document.compression_algorithm) {
+			if (document.compression_algorithm.toUpperCase() !== "GZIP") throw new ToolError(`Unsupported Amazon report compression: ${document.compression_algorithm}`, { code: "unsupported" });
+			compressionAlgorithm = "GZIP";
+		}
+		const result = await this.#download.bytes("GET", document.url, {
+			label: "Amazon SP-API report document",
+			maxBytes
+		});
+		const bytes = await decompressReportDocumentBytes(result.bytes, compressionAlgorithm, maxBytes);
+		const contentType = result.headers.get("content-type") ?? void 0;
+		const contentEncoding = result.headers.get("content-encoding") ?? void 0;
+		return {
+			bytes,
+			text: bytesToUtf8(bytes),
+			byte_length: bytes.byteLength,
+			...contentType && { content_type: contentType },
+			...contentEncoding && { content_encoding: contentEncoding },
+			...compressionAlgorithm && { compression_algorithm: compressionAlgorithm }
+		};
+	}
 	/**
 	* Composite: newest DONE Flat File V2 settlement report (or `report_id`) →
 	* one document download → eight summary fields in safe integer cents.
@@ -795,12 +1068,11 @@ var AmazonSpApiClient = class AmazonSpApiClient {
 		const createdSince = input.created_since ?? settlementCreatedSinceIso();
 		let cursor;
 		for (let page = 0; page < 5; page += 1) {
-			const listed = await this.listReports({
+			const listed = cursor ? await this.listReports({ cursor }) : await this.listReports({
 				report_types: [SETTLEMENT_REPORT_TYPE_V2],
 				processing_statuses: ["DONE"],
 				created_since: createdSince,
-				page_size: 100,
-				...cursor && { cursor }
+				page_size: 100
 			});
 			for (const report of listed.items) if (report.report_document_id) return report.report_document_id;
 			if (!listed.next_cursor) break;
@@ -902,7 +1174,7 @@ const amazonSpApiGetReportTool = defineTool({
 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.",
+	description: "List Amazon SP-API reports. Initial calls require report types and may use status, marketplace, and created-time filters. Continue with next_cursor.",
 	inputSchema: amazonSpApiListReportsInputSchema,
 	outputSchema: amazonSpApiListReportsOutputSchema,
 	sideEffect: "read",
@@ -970,6 +1242,6 @@ const amazonSpApiModule = defineModule({
 	]
 });
 //#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 };
+export { AmazonSpApiClient, amazonInventoryDetailsRawSchema, amazonInventoryResearchingQuantityBreakdownRawSchema, amazonInventoryResearchingQuantityRawSchema, amazonInventoryReservedQuantityRawSchema, amazonInventorySummaryRawSchema, amazonInventoryUnfulfillableQuantityRawSchema, amazonReportRawSchema, amazonSpApiAuthSchema, amazonSpApiCatalogItemSchema, amazonSpApiCreateReportInputSchema, amazonSpApiCreateReportOutputSchema, amazonSpApiCreateReportTool, amazonSpApiDownloadReportDocumentBytesInputSchema, amazonSpApiDownloadReportDocumentBytesOutputSchema, amazonSpApiEndpointSchema, amazonSpApiGetOrderInputSchema, amazonSpApiGetOrderItemsInputSchema, amazonSpApiGetOrderItemsOutputSchema, amazonSpApiGetOrderItemsTool, amazonSpApiGetOrderOutputSchema, amazonSpApiGetOrderTool, amazonSpApiGetReportDocumentInputSchema, amazonSpApiGetReportDocumentOutputSchema, amazonSpApiGetReportDocumentTool, amazonSpApiGetReportInputSchema, amazonSpApiGetReportOutputSchema, amazonSpApiGetReportTool, amazonSpApiGetSettlementSummaryInputSchema, amazonSpApiGetSettlementSummaryOutputSchema, amazonSpApiGetSettlementSummaryTool, amazonSpApiInventoryPageInputSchema, amazonSpApiInventoryPageOutputSchema, amazonSpApiInventorySummarySchema, amazonSpApiListInventorySummariesInputSchema, amazonSpApiListInventorySummariesOutputSchema, amazonSpApiListInventorySummariesTool, amazonSpApiListOrdersInputSchema, amazonSpApiListOrdersOutputSchema, amazonSpApiListOrdersTool, amazonSpApiListReportsContinuationInputSchema, amazonSpApiListReportsInitialInputSchema, amazonSpApiListReportsInputSchema, amazonSpApiListReportsOutputSchema, amazonSpApiListReportsPageInputSchema, amazonSpApiListReportsPageOutputSchema, amazonSpApiListReportsTool, amazonSpApiLwaTokenResponseSchema, amazonSpApiModule, amazonSpApiOrderItemSchema, amazonSpApiOrderSchema, amazonSpApiReportSchema, amazonSpApiSearchCatalogItemsInputSchema, amazonSpApiSearchCatalogItemsOutputSchema, amazonSpApiSearchCatalogItemsTool, amazonSpApiSearchOrderSchema, amazonSpApiSearchOrdersInputSchema, amazonSpApiSearchOrdersOutputSchema, amazonSpApiSearchOrdersTool, amazonSpApiSettlementSummarySchema };
 
 //# sourceMappingURL=index.js.map