@reactionary/feeds 0.10.41 → 0.10.43

package/cli.js

@@ -5,6 +5,7 @@ import { mkdir } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { finished } from "node:stream/promises";
 import { pathToFileURL } from "node:url";
+import { createACPFeedPublisherFromConfig } from "./lib/acp-feed-publisher.js";
 import { createDefaultFeedRegistry } from "./lib/default-registry.js";
 import { ReactionaryFeedGenerator } from "./lib/feed-generator.js";
 async function main() {
@@ -26,6 +27,17 @@ async function main() {
   ).option("--product-concurrency <count>", "Products to normalize in parallel. Defaults to config value or 10.").option("--testMode", "Limit source reads to at most 2 pages for smoke testing.").option("--no-progress", "Disable progress reporting on stderr.").action(async (options) => {
     await generateFeed(options);
   });
+  program.command("publish-acp").description("Push a feed to the agent-hosted ACP Feed API (PATCH /feeds/{id}/products). Run it from cron or a scheduled job.").requiredOption("-c, --config <path>", "Path to an ESM feed config module.").requiredOption("-f, --feed <id>", "Configured feed id to publish; its acp.feedId is the agent feed.").option("--batch-size <count>", "Products per upsert request. Defaults to 100.").option("--testMode", "Limit source reads to at most 2 pages for smoke testing.").option("--no-progress", "Disable progress reporting on stderr.").action(async (options) => {
+    const publisher = await createAcpPublisher(options);
+    const result = await publisher.publish(options.feed);
+    console.log(JSON.stringify(result));
+  });
+  program.command("create-acp-feed").description("Create a feed on the agent-hosted ACP Feed API (POST /feeds) and print its id, to put into the feed's acp.feedId. Only needed when the agent did not hand out a feed id.").requiredOption("-c, --config <path>", "Path to an ESM feed config module.").requiredOption("-f, --feed <id>", "Configured feed id to create an agent feed for.").action(async (options) => {
+    const publisher = await createAcpPublisher({ ...options, progress: false });
+    const metadata = await publisher.createFeed(options.feed);
+    console.log(JSON.stringify(metadata));
+    console.error(`Set acp.feedId to "${metadata.id}" on feed "${options.feed}" in ${options.config}.`);
+  });
   await program.parseAsync(process.argv);
 }
 async function generateFeed(options) {
@@ -51,6 +63,27 @@ async function generateFeed(options) {
     });
   }));
 }
+async function createAcpPublisher(options) {
+  const config = await loadConfig(options.config);
+  return createACPFeedPublisherFromConfig(config, await getClientFactory(config), {
+    ...options.batchSize ? { batchSize: parseBatchSize(options.batchSize) } : {},
+    testMode: Boolean(options.testMode),
+    ...options.progress === false ? {} : {
+      onProgress: createCliProgressReporter({
+        feedId: options.feed,
+        transformerId: "acp-feed-api",
+        stream: process.stderr
+      })
+    }
+  });
+}
+function parseBatchSize(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    throw new Error(`--batch-size must be a positive integer, got: ${value}`);
+  }
+  return parsed;
+}
 async function createFeedGenerationContext(options, labels) {
   const config = await loadConfig(options.config);
   const registry = createDefaultFeedRegistry();

package/index.js

@@ -11,3 +11,4 @@ export * from "./lib/transformers/acp-product-feed.transformer.js";
 export * from "./lib/transformers/google-merchant-feed.transformer.js";
 export * from "./lib/transformers/pricerunner-feed.transformer.js";
 export * from "./lib/transformers/sitemap-feed.transformer.js";
+export * from "./lib/acp-feed-publisher.js";

package/lib/acp-feed-publisher.js

@@ -0,0 +1,141 @@
+import { createInitialRequestContext } from "@reactionary/core";
+import { ReactionaryFeedGenerator } from "./feed-generator.js";
+import {
+  toACPFeedProduct
+} from "./transformers/acp-product-feed.transformer.js";
+import * as z from "zod";
+const ACP_FEED_API_VERSION = "2026-04-17";
+const DEFAULT_ACP_FEED_API_KEY_ENV = "ACP_FEED_API_KEY";
+const DEFAULT_BATCH_SIZE = 100;
+const REQUEST_TIMEOUT_MS = 3e4;
+const ACPFeedMetadataSchema = z.looseObject({
+  id: z.string(),
+  target_country: z.string().optional(),
+  updated_at: z.string().optional()
+});
+const ACPFeedUpsertResponseSchema = z.looseObject({
+  id: z.string().optional(),
+  accepted: z.boolean()
+});
+class ReactionaryACPFeedPublisher {
+  constructor(clientFactory, options) {
+    this.clientFactory = clientFactory;
+    this.options = options;
+    this.fetchImpl = options.fetch ?? fetch;
+  }
+  clientFactory;
+  options;
+  fetchImpl;
+  /** `POST /feeds`: creates a feed on the agent for the definition's market. */
+  async createFeed(feedKey) {
+    const feed = this.getFeed(feedKey);
+    const [, region] = feed.languageContext.locale.split("-");
+    const response = await this.request("POST", "/feeds", region ? { target_country: region.toUpperCase() } : {});
+    return ACPFeedMetadataSchema.parse(response);
+  }
+  /** `GET /feeds/{id}`: the agent's metadata for a feed. */
+  async getFeedMetadata(feedId) {
+    return ACPFeedMetadataSchema.parse(await this.request("GET", `/feeds/${encodeURIComponent(feedId)}`));
+  }
+  /**
+   * Generates the feed's products and upserts them, in batches, into the
+   * agent-hosted feed with `PATCH /feeds/{feedId}/products`. The feed id
+   * defaults to the definition's `acp.feedId`, as handed out by the agent's
+   * onboarding. Upserts never remove products; to drop products, replace
+   * the feed by file ingestion.
+   */
+  async publish(feedKey, feedId) {
+    const feed = this.getFeed(feedKey);
+    const targetFeedId = feedId ?? feed.acp?.feedId;
+    if (!targetFeedId) {
+      throw new Error(`ACP feed ${feedKey} has no feed id; configure acp.feedId (from the agent's onboarding) or create one with create-acp-feed.`);
+    }
+    const requestContext = createInitialRequestContext();
+    requestContext.languageContext = feed.languageContext;
+    const generator = new ReactionaryFeedGenerator(this.clientFactory(requestContext), {
+      defaultFulfillmentCenterKeys: this.options.defaultFulfillmentCenterKeys,
+      productConcurrency: this.options.productConcurrency,
+      onProgress: this.options.onProgress
+    });
+    const batchSize = Math.max(this.options.batchSize ?? DEFAULT_BATCH_SIZE, 1);
+    const path = `/feeds/${encodeURIComponent(targetFeedId)}/products`;
+    let batch = [];
+    let products = 0;
+    let batches = 0;
+    const flush = async () => {
+      if (batch.length === 0) {
+        return;
+      }
+      const response = ACPFeedUpsertResponseSchema.parse(await this.request("PATCH", path, { products: batch }));
+      if (!response.accepted) {
+        throw new Error(`ACP feed ${targetFeedId}: the agent did not accept the product upsert.`);
+      }
+      products += batch.length;
+      batches += 1;
+      batch = [];
+    };
+    for await (const product of generator.products(feed, requestContext)) {
+      const acpProduct = toACPFeedProduct(product, feed);
+      if (acpProduct) {
+        batch.push(acpProduct);
+      }
+      if (batch.length >= batchSize) {
+        await flush();
+      }
+    }
+    await flush();
+    return { feedId: targetFeedId, products, batches };
+  }
+  getFeed(feedKey) {
+    const feed = this.options.feeds[feedKey];
+    if (!feed) {
+      throw new Error(`ACP feed definition not found: ${feedKey}`);
+    }
+    return feed;
+  }
+  async request(method, path, body) {
+    const url = `${this.options.feedApiBaseUrl.replace(/\/+$/, "")}${path}`;
+    const response = await this.fetchImpl(url, {
+      method,
+      headers: {
+        authorization: `Bearer ${this.options.apiKey}`,
+        "api-version": ACP_FEED_API_VERSION,
+        accept: "application/json",
+        ...body === void 0 ? {} : { "content-type": "application/json", "idempotency-key": crypto.randomUUID() }
+      },
+      ...body === void 0 ? {} : { body: JSON.stringify(body) },
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+    });
+    const text = await response.text();
+    if (!response.ok) {
+      throw new Error(`ACP Feed API ${method} ${path} failed with HTTP ${response.status}: ${text.slice(0, 500)}`);
+    }
+    return text ? JSON.parse(text) : {};
+  }
+}
+function createACPFeedPublisherFromConfig(config, clientFactory, options = {}) {
+  if (!config.acpFeedApi?.baseUrl) {
+    throw new Error("The feeds config needs acpFeedApi.baseUrl: the agent's Feed API base URL from onboarding.");
+  }
+  const apiKeyEnv = config.acpFeedApi.apiKeyEnv ?? DEFAULT_ACP_FEED_API_KEY_ENV;
+  const apiKey = (options.env ?? process.env)[apiKeyEnv];
+  if (!apiKey) {
+    throw new Error(`The ACP Feed API key is missing; set the ${apiKeyEnv} environment variable.`);
+  }
+  const feeds = options.testMode ? Object.fromEntries(Object.entries(config.feeds).map(([key, feed]) => [key, { ...feed, maxPages: Math.min(feed.maxPages ?? 2, 2) }])) : config.feeds;
+  return new ReactionaryACPFeedPublisher(clientFactory, {
+    feedApiBaseUrl: config.acpFeedApi.baseUrl,
+    apiKey,
+    feeds,
+    defaultFulfillmentCenterKeys: config.defaultFulfillmentCenterKeys,
+    productConcurrency: config.productConcurrency,
+    ...options.batchSize ? { batchSize: options.batchSize } : {},
+    ...options.fetch ? { fetch: options.fetch } : {},
+    ...options.onProgress ? { onProgress: options.onProgress } : {}
+  });
+}
+export {
+  DEFAULT_ACP_FEED_API_KEY_ENV,
+  ReactionaryACPFeedPublisher,
+  createACPFeedPublisherFromConfig
+};

package/lib/default-registry.js

@@ -1,13 +1,14 @@
 import {
   ReactionaryFeedTransformerRegistry
 } from "./feed-transformer.js";
-import { acpProductFeedTransformer } from "./transformers/acp-product-feed.transformer.js";
+import { acpFeedMetadataTransformer, acpProductFeedTransformer } from "./transformers/acp-product-feed.transformer.js";
 import { googleMerchantFeedTransformer } from "./transformers/google-merchant-feed.transformer.js";
 import { pricerunnerFeedTransformer } from "./transformers/pricerunner-feed.transformer.js";
 import { sitemapFeedTransformer } from "./transformers/sitemap-feed.transformer.js";
 function createDefaultFeedRegistry() {
   const registry = new ReactionaryFeedTransformerRegistry();
   registry.register(acpProductFeedTransformer);
+  registry.register(acpFeedMetadataTransformer);
   registry.register(googleMerchantFeedTransformer);
   registry.register(sitemapFeedTransformer);
   registry.register(pricerunnerFeedTransformer);

package/lib/transformers/acp-product-feed.transformer.js

@@ -1,15 +1,10 @@
 import {
   getTargetCountry
 } from "../feed-generator.js";
-import {
-  formatMoney,
-  primaryImage,
-  productDescription
-} from "./shared.js";
 const acpProductFeedTransformer = {
   id: "acp-product-feed",
   title: "ACP Product Feed",
-  description: "Agentic Commerce Protocol product feed output.",
+  description: "Agentic Commerce Protocol Feed API products (2026-04-17).",
   output: {
     contentType: "application/x-ndjson; charset=utf-8",
     fileExtension: "jsonl"
@@ -21,108 +16,125 @@ const acpProductFeedTransformer = {
     if (context.options.format === "json") {
       const collected = [];
       for await (const product of products) {
-        collected.push(...toACPRows(product, context.feed));
+        const acpProduct = toACPFeedProduct(product, context.feed);
+        if (acpProduct) {
+          collected.push(acpProduct);
+        }
       }
-      yield JSON.stringify({
-        ...getTargetCountry(context.feed.languageContext) ? { target_country: getTargetCountry(context.feed.languageContext) } : {},
-        products: collected
-      });
+      yield JSON.stringify({ products: collected });
       return;
     }
     for await (const product of products) {
-      for (const row of toACPRows(product, context.feed)) {
-        yield `${JSON.stringify(row)}
+      const acpProduct = toACPFeedProduct(product, context.feed);
+      if (acpProduct) {
+        yield `${JSON.stringify(acpProduct)}
 `;
       }
     }
   }
 };
-function toACPRows(product, feed) {
-  return product.variants.map(
-    (variant) => toACPRow(product, variant, feed)
-  );
-}
-function toACPRow(product, variant, feed) {
-  const primaryImageUrl = primaryImage(product, variant);
-  const additionalImageUrls = getAdditionalImageUrls(product, variant, primaryImageUrl);
-  const variation = getVariationFields(product, variant);
-  const priceFields = getPriceFields(variant);
-  const gtin = variant.gtin || variant.ean || variant.upc || void 0;
+const acpFeedMetadataTransformer = {
+  id: "acp-feed-metadata",
+  title: "ACP Feed Metadata",
+  description: "Agentic Commerce Protocol Feed API metadata.json (2026-04-17).",
+  output: {
+    contentType: "application/json; charset=utf-8",
+    fileExtension: "json"
+  },
+  async *transform(_products, context) {
+    yield JSON.stringify(toACPFeedMetadata(context.feedId, context.feed));
+  }
+};
+function toACPFeedMetadata(feedId, feed, updatedAt = /* @__PURE__ */ new Date()) {
+  const targetCountry = getTargetCountry(feed.languageContext);
   return {
-    item_id: variant.id,
-    ...variation,
-    title: variant.title || product.title,
-    description: variant.description ?? productDescription(product),
-    ...variant.url ?? product.url ? { url: variant.url ?? product.url } : {},
-    ...product.brand ? { brand: product.brand } : {},
-    is_eligible_search: true,
-    ...feed.sellerName ? { seller_name: feed.sellerName } : {},
-    ...product.manufacturer ? { manufacturer: product.manufacturer } : {},
-    ...product.categoryPath?.length ? {
-      product_category: product.categoryPath.map((category) => category.name).join(" > ")
-    } : {},
-    ...product.ratingSummary ? {
-      ...product.ratingSummary.totalRatings !== void 0 ? { review_count: product.ratingSummary.totalRatings } : {},
-      ...product.ratingSummary.totalRatings ? { star_rating: product.ratingSummary.averageRating.toFixed(2) } : {}
-    } : {},
-    ...primaryImageUrl ? { image_url: primaryImageUrl } : {},
-    ...additionalImageUrls.length > 0 ? { additional_image_urls: additionalImageUrls } : {},
-    availability: toACPAvailability(variant.availability?.status),
-    ...priceFields,
-    ...gtin ? { gtin } : {},
-    ...variant.manufacturerPartNumber ? { mpn: variant.manufacturerPartNumber } : {}
+    id: feedId,
+    ...targetCountry ? { target_country: targetCountry } : {},
+    updated_at: updatedAt.toISOString()
   };
 }
-function getVariationFields(product, variant) {
-  if (product.variants.length <= 1 || product.id === variant.id || variant.options.length === 0) {
-    return {};
+function toACPFeedProduct(product, feed) {
+  if (product.variants.length === 0) {
+    return void 0;
   }
-  const variantDict = Object.fromEntries(
-    variant.options.map((option) => [option.name, option.value])
-  );
+  const media = toMedia(product.images);
+  const categoryPath = product.categoryPath?.map((category) => category.name).join(" > ");
   return {
-    group_id: product.id,
-    listing_has_variations: true,
-    variant_dict: variantDict
+    id: product.id,
+    title: product.title,
+    ...product.description ? { description: { plain: product.description } } : {},
+    ...product.url ? { url: product.url } : {},
+    ...media.length > 0 ? { media } : {},
+    variants: product.variants.map((variant) => toACPFeedVariant(variant, categoryPath, feed.sellerName))
   };
 }
-function getPriceFields(variant) {
-  if (variant.price && variant.listPrice && variant.price.currency.toUpperCase() === variant.listPrice.currency.toUpperCase() && variant.price.value > 0 && variant.listPrice.value > variant.price.value) {
-    return {
-      price: formatMoney(variant.listPrice),
-      sale_price: formatMoney(variant.price)
-    };
-  }
+function toACPFeedVariant(variant, categoryPath, sellerName) {
+  const media = toMedia(variant.images);
+  const price = toFeedPrice(variant.price ?? variant.listPrice);
+  const listPrice = variant.price ? toFeedPrice(variant.listPrice) : void 0;
   return {
-    ...variant.price ?? variant.listPrice ? { price: formatMoney(variant.price ?? variant.listPrice) } : {}
+    id: variant.id,
+    title: variant.title,
+    ...variant.description ? { description: { plain: variant.description } } : {},
+    ...variant.url ? { url: variant.url } : {},
+    ...variant.barcodes.length > 0 ? { barcodes: variant.barcodes.map((barcode) => ({ type: barcode.type, value: barcode.value })) } : {},
+    ...price ? { price } : {},
+    // The regular price, reported when the selling price is below it.
+    ...listPrice && price && listPrice.currency === price.currency && listPrice.amount > price.amount ? { list_price: listPrice } : {},
+    ...variant.availability ? { availability: { available: variant.availability.available, status: variant.availability.status } } : {},
+    ...categoryPath ? { categories: [{ value: categoryPath }] } : {},
+    ...variant.options.length > 0 ? { variant_options: variant.options.map((option) => ({ name: option.name, value: option.value })) } : {},
+    ...media.length > 0 ? { media } : {},
+    ...sellerName ? { seller: { name: sellerName } } : {}
   };
 }
-function toACPAvailability(status) {
-  switch (status) {
-    case "in_stock":
-    case "out_of_stock":
-    case "backorder":
-      return status;
-    case "preorder":
-      return "pre_order";
-    default:
-      return "unknown";
-  }
+function toMedia(images) {
+  return images.filter((image) => image.url.length > 0).map((image) => ({
+    type: "image",
+    url: image.url,
+    ...image.altText ? { alt_text: image.altText } : {}
+  }));
 }
-function getAdditionalImageUrls(product, variant, primaryImageUrl) {
-  const urls = [
-    ...variant.images.map((image) => image.url),
-    ...product.images.map((image) => image.url)
-  ];
-  const unique = /* @__PURE__ */ new Set();
-  return urls.filter((url) => {
-    if (url === primaryImageUrl || unique.has(url)) {
-      return false;
-    }
-    unique.add(url);
-    return true;
-  });
+const CURRENCY_EXPONENTS = {
+  BIF: 0,
+  CLP: 0,
+  DJF: 0,
+  GNF: 0,
+  ISK: 0,
+  JPY: 0,
+  KMF: 0,
+  KRW: 0,
+  PYG: 0,
+  RWF: 0,
+  UGX: 0,
+  UYI: 0,
+  VND: 0,
+  VUV: 0,
+  XAF: 0,
+  XOF: 0,
+  XPF: 0,
+  BHD: 3,
+  IQD: 3,
+  JOD: 3,
+  KWD: 3,
+  LYD: 3,
+  OMR: 3,
+  TND: 3
+};
+function toFeedPrice(money) {
+  if (!money) {
+    return void 0;
+  }
+  const currency = money.currency.toUpperCase();
+  const exponent = CURRENCY_EXPONENTS[currency] ?? 2;
+  return {
+    amount: Math.max(Math.round(money.value * 10 ** exponent), 0),
+    currency
+  };
 }
 export {
-  acpProductFeedTransformer
+  acpFeedMetadataTransformer,
+  acpProductFeedTransformer,
+  toACPFeedMetadata,
+  toACPFeedProduct
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactionary/feeds",
-  "version": "0.10.41",
+  "version": "0.10.43",
   "type": "module",
   "main": "./index.js",
   "types": "./src/index.d.ts",
@@ -12,14 +12,14 @@
     "url": "git+https://github.com/Solteq/reactionary.git"
   },
   "dependencies": {
-    "@reactionary/algolia": "0.10.41",
-    "@reactionary/commercetools": "0.10.41",
-    "@reactionary/core": "0.10.41",
-    "@reactionary/fake": "0.10.41",
-    "@reactionary/magento": "0.10.41",
-    "@reactionary/medusa": "0.10.41",
-    "@reactionary/meilisearch": "0.10.41",
-    "@reactionary/unomi": "0.10.41",
+    "@reactionary/algolia": "0.10.43",
+    "@reactionary/commercetools": "0.10.43",
+    "@reactionary/core": "0.10.43",
+    "@reactionary/fake": "0.10.43",
+    "@reactionary/magento": "0.10.43",
+    "@reactionary/medusa": "0.10.43",
+    "@reactionary/meilisearch": "0.10.43",
+    "@reactionary/unomi": "0.10.43",
     "commander": "^15.0.0",
     "dotenv": "^17.2.2",
     "sitemap": "^9.0.1",

package/src/index.d.ts

@@ -11,3 +11,4 @@ export * from './lib/transformers/acp-product-feed.transformer.js';
 export * from './lib/transformers/google-merchant-feed.transformer.js';
 export * from './lib/transformers/pricerunner-feed.transformer.js';
 export * from './lib/transformers/sitemap-feed.transformer.js';
+export * from './lib/acp-feed-publisher.js';

package/src/lib/acp-feed-publisher.d.ts

@@ -0,0 +1,73 @@
+import type { ReactionaryFeedClient, ReactionaryFeedClientFactory, ReactionaryFeedDefinition, ReactionaryFeedInventoryOptions, ReactionaryFeedProcessingOptions, ReactionaryFeedProgress } from './feed-types.js';
+import { type ACPFeedMetadata } from './transformers/acp-product-feed.transformer.js';
+/** The environment variable holding the Feed API key, unless configured otherwise. */
+export declare const DEFAULT_ACP_FEED_API_KEY_ENV = "ACP_FEED_API_KEY";
+export interface ReactionaryACPFeedPublisherOptions extends ReactionaryFeedInventoryOptions, ReactionaryFeedProcessingOptions {
+    /** Base URL of the agent's Feed API, e.g. `https://agent.example/api`. */
+    feedApiBaseUrl: string;
+    /** The bearer token the agent issued to this merchant. */
+    apiKey: string;
+    /** Feed definitions by key: what to search, in which language context. */
+    feeds: Record<string, ReactionaryFeedDefinition>;
+    /** Products per `PATCH /feeds/{id}/products` request. Defaults to 100. */
+    batchSize?: number;
+    /** Fetch implementation; defaults to the global fetch. */
+    fetch?: typeof fetch;
+    /** Generation progress, e.g. for a CLI progress line. */
+    onProgress?: (progress: ReactionaryFeedProgress) => void;
+}
+export interface ACPFeedPublishResult {
+    feedId: string;
+    products: number;
+    batches: number;
+}
+/**
+ * Publishes product feeds to an agent's Feed API (ACP 2026-04-17). Feeds are
+ * agent-hosted and pushed by merchants: create the feed once, then upsert
+ * its products. For file ingestion instead, generate `products.jsonl` and
+ * `metadata.json` with the `@reactionary/feeds` CLI (`acp-product-feed`,
+ * `acp-feed-metadata`).
+ */
+export declare class ReactionaryACPFeedPublisher<TClient extends ReactionaryFeedClient = ReactionaryFeedClient> {
+    private readonly clientFactory;
+    private readonly options;
+    private readonly fetchImpl;
+    constructor(clientFactory: ReactionaryFeedClientFactory<TClient>, options: ReactionaryACPFeedPublisherOptions);
+    /** `POST /feeds`: creates a feed on the agent for the definition's market. */
+    createFeed(feedKey: string): Promise<ACPFeedMetadata>;
+    /** `GET /feeds/{id}`: the agent's metadata for a feed. */
+    getFeedMetadata(feedId: string): Promise<ACPFeedMetadata>;
+    /**
+     * Generates the feed's products and upserts them, in batches, into the
+     * agent-hosted feed with `PATCH /feeds/{feedId}/products`. The feed id
+     * defaults to the definition's `acp.feedId`, as handed out by the agent's
+     * onboarding. Upserts never remove products; to drop products, replace
+     * the feed by file ingestion.
+     */
+    publish(feedKey: string, feedId?: string): Promise<ACPFeedPublishResult>;
+    private getFeed;
+    private request;
+}
+/** Where the agent's Feed API is, as handed out by the agent's onboarding. */
+export interface ACPFeedApiConfig {
+    /** Base URL of the agent-hosted Feed API. */
+    baseUrl: string;
+    /** Environment variable holding the API key; defaults to `ACP_FEED_API_KEY`. */
+    apiKeyEnv?: string;
+}
+export interface ACPFeedPublishingConfig extends ReactionaryFeedInventoryOptions, ReactionaryFeedProcessingOptions {
+    acpFeedApi?: ACPFeedApiConfig;
+    feeds: Record<string, ReactionaryFeedDefinition>;
+}
+/**
+ * A publisher from a feeds config module, reading the API key from the
+ * environment so it never lives in configuration. `testMode` limits each
+ * feed to two search pages.
+ */
+export declare function createACPFeedPublisherFromConfig<TClient extends ReactionaryFeedClient>(config: ACPFeedPublishingConfig, clientFactory: ReactionaryFeedClientFactory<TClient>, options?: {
+    env?: Record<string, string | undefined>;
+    batchSize?: number;
+    testMode?: boolean;
+    fetch?: typeof fetch;
+    onProgress?: (progress: ReactionaryFeedProgress) => void;
+}): ReactionaryACPFeedPublisher<TClient>;

package/src/lib/feed-types.d.ts

@@ -61,6 +61,11 @@ export interface ReactionaryFeedDefinition {
     productUrlBase?: string;
     sellerName?: string;
     metadata?: Record<string, unknown>;
+    /** ACP: the agent-hosted feed this definition is published to. */
+    acp?: {
+        /** Feed id from the agent's onboarding (or from `create-acp-feed`). */
+        feedId: string;
+    };
 }
 export type ReactionarySitemapChangeFrequency = 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never';
 export interface ReactionarySitemapEntry {

package/src/lib/transformers/acp-product-feed.transformer.d.ts

@@ -1,4 +1,81 @@
 import type { ReactionaryFeedTransformer } from '../feed-transformer.js';
+import type { ReactionaryFeedDefinition, ReactionaryFeedProduct } from '../feed-types.js';
+/** ACP Feed API `Price`: minor units and an upper-case ISO 4217 code. */
+export interface ACPFeedPrice {
+    amount: number;
+    currency: string;
+}
+export interface ACPFeedDescription {
+    plain?: string;
+    html?: string;
+    markdown?: string;
+}
+export interface ACPFeedMedia {
+    type: string;
+    url: string;
+    alt_text?: string;
+}
+export interface ACPFeedAvailability {
+    available?: boolean;
+    status?: string;
+}
+export interface ACPFeedVariant {
+    id: string;
+    title: string;
+    description?: ACPFeedDescription;
+    url?: string;
+    barcodes?: Array<{
+        type: string;
+        value: string;
+    }>;
+    price?: ACPFeedPrice;
+    list_price?: ACPFeedPrice;
+    availability?: ACPFeedAvailability;
+    categories?: Array<{
+        value: string;
+        taxonomy?: string;
+    }>;
+    variant_options?: Array<{
+        name: string;
+        value: string;
+    }>;
+    media?: ACPFeedMedia[];
+    seller?: {
+        name?: string;
+    };
+}
+/** ACP Feed API `Product` (2026-04-17), one line of `products.jsonl`. */
+export interface ACPFeedProduct {
+    id: string;
+    title?: string;
+    description?: ACPFeedDescription;
+    url?: string;
+    media?: ACPFeedMedia[];
+    variants: ACPFeedVariant[];
+}
+/** ACP Feed API `FeedMetadata`, the content of `metadata.json`. */
+export interface ACPFeedMetadata {
+    id: string;
+    target_country?: string;
+    updated_at?: string;
+}
+/**
+ * The ACP product feed (Feed API 2026-04-17): `jsonl` writes
+ * `products.jsonl` for file ingestion, one `Product` per line; `json` writes
+ * `{ "products": [...] }`, the body of `PATCH /feeds/{id}/products`.
+ */
 export declare const acpProductFeedTransformer: ReactionaryFeedTransformer<{
     format?: 'jsonl' | 'json';
 }>;
+/**
+ * The ACP feed's `metadata.json` for file ingestion, alongside the
+ * `acp-product-feed` products.jsonl. Products are not read.
+ */
+export declare const acpFeedMetadataTransformer: ReactionaryFeedTransformer;
+/** The feed's `metadata.json`: its id, target country and generation time. */
+export declare function toACPFeedMetadata(feedId: string, feed: ReactionaryFeedDefinition, updatedAt?: Date): ACPFeedMetadata;
+/**
+ * A feed product as an ACP `Product`. Products need at least one variant,
+ * so a product without variants is left out (undefined).
+ */
+export declare function toACPFeedProduct(product: ReactionaryFeedProduct, feed: Pick<ReactionaryFeedDefinition, 'sellerName'>): ACPFeedProduct | undefined;