@elizaos/plugin-shopify 2.0.0-beta.1 → 2.0.11-beta.7

package/dist/index.js

@@ -1,1802 +0,0 @@
-import { ModelType, Service, getConnectorAccountManager, logger, promoteSubactionsToActions } from "@elizaos/core";
-//#region src/accounts.ts
-const DEFAULT_SHOPIFY_ACCOUNT_ID = "default";
-const DEFAULT_SHOPIFY_ACCOUNT_ROLE = "OWNER";
-function nonEmptyString$1(value) {
-	return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
-}
-function readSetting$1(runtime, key) {
-	return nonEmptyString$1(runtime.getSetting(key));
-}
-function normalizeShopifyAccountId(value) {
-	return nonEmptyString$1(value) ?? "default";
-}
-function resolveShopifyAccountId(runtime, options) {
-	const requested = nonEmptyString$1(options?.accountId) ?? nonEmptyString$1(options?.shopifyAccountId);
-	if (requested) return requested;
-	const configuredDefault = readSetting$1(runtime, "SHOPIFY_DEFAULT_ACCOUNT_ID") ?? readSetting$1(runtime, "SHOPIFY_ACCOUNT_ID");
-	return resolveShopifyDefaultAccount(readShopifyAccounts(runtime), configuredDefault)?.accountId ?? normalizeShopifyAccountId(configuredDefault);
-}
-function parseAccountsJson(raw) {
-	if (!raw) return [];
-	try {
-		const parsed = JSON.parse(raw);
-		if (Array.isArray(parsed)) return parsed.filter((item) => Boolean(item) && typeof item === "object" && !Array.isArray(item));
-		if (parsed && typeof parsed === "object") return Object.entries(parsed).filter(([, value]) => value && typeof value === "object").map(([id, value]) => ({
-			...value,
-			accountId: value.accountId ?? id
-		}));
-	} catch {
-		return [];
-	}
-	return [];
-}
-function readRawField(record, keys) {
-	const credentials = record.credentials && typeof record.credentials === "object" ? record.credentials : {};
-	const metadata = record.metadata && typeof record.metadata === "object" ? record.metadata : {};
-	const settings = record.settings && typeof record.settings === "object" ? record.settings : {};
-	for (const source of [
-		record,
-		credentials,
-		metadata,
-		settings
-	]) for (const key of keys) {
-		const value = nonEmptyString$1(source[key]);
-		if (value) return value;
-	}
-}
-function accountFromRecord(record) {
-	const accountId = normalizeShopifyAccountId(record.accountId ?? record.id ?? record.name);
-	const storeDomain = readRawField(record, [
-		"SHOPIFY_STORE_DOMAIN",
-		"storeDomain",
-		"domain"
-	]);
-	const accessToken = readRawField(record, [
-		"SHOPIFY_ACCESS_TOKEN",
-		"accessToken",
-		"token",
-		"access"
-	]);
-	if (!storeDomain || !accessToken) return null;
-	return {
-		accountId,
-		role: DEFAULT_SHOPIFY_ACCOUNT_ROLE,
-		storeDomain,
-		accessToken,
-		label: nonEmptyString$1(record.label ?? record.displayName)
-	};
-}
-function addAccount(accounts, account) {
-	if (account) accounts.set(account.accountId, account);
-}
-function readShopifyAccounts(runtime) {
-	const accounts = /* @__PURE__ */ new Map();
-	const characterAccounts = (runtime.character?.settings?.shopify)?.accounts;
-	if (Array.isArray(characterAccounts)) {
-		for (const item of characterAccounts) if (item && typeof item === "object") addAccount(accounts, accountFromRecord(item));
-	} else if (characterAccounts && typeof characterAccounts === "object") {
-		for (const [id, value] of Object.entries(characterAccounts)) if (value && typeof value === "object") addAccount(accounts, accountFromRecord({
-			...value,
-			accountId: value.accountId ?? id
-		}));
-	}
-	for (const record of parseAccountsJson(readSetting$1(runtime, "SHOPIFY_ACCOUNTS"))) addAccount(accounts, accountFromRecord(record));
-	const storeDomain = readSetting$1(runtime, "SHOPIFY_STORE_DOMAIN");
-	const accessToken = readSetting$1(runtime, "SHOPIFY_ACCESS_TOKEN");
-	if (storeDomain && accessToken) addAccount(accounts, {
-		accountId: normalizeShopifyAccountId(readSetting$1(runtime, "SHOPIFY_ACCOUNT_ID") ?? readSetting$1(runtime, "SHOPIFY_DEFAULT_ACCOUNT_ID")),
-		role: DEFAULT_SHOPIFY_ACCOUNT_ROLE,
-		storeDomain,
-		accessToken
-	});
-	return Array.from(accounts.values());
-}
-function resolveShopifyAccount(accounts, accountId) {
-	return accounts.find((account) => account.accountId === accountId) ?? null;
-}
-function resolveShopifyDefaultAccount(accounts, accountId) {
-	return resolveShopifyAccount(accounts, normalizeShopifyAccountId(accountId)) ?? resolveShopifyAccount(accounts, "default") ?? accounts.find((account) => account.role === "OWNER") ?? accounts[0] ?? null;
-}
-function hasShopifyAccountConfig(runtime, options) {
-	const accountId = resolveShopifyAccountId(runtime, options);
-	return Boolean(resolveShopifyAccount(readShopifyAccounts(runtime), accountId));
-}
-//#endregion
-//#region src/actions/account-options.ts
-function getShopifyActionOptions(options) {
-	const direct = options ?? {};
-	const parameters = direct.parameters && typeof direct.parameters === "object" ? direct.parameters : {};
-	return {
-		...direct,
-		...parameters
-	};
-}
-function getShopifyAccountId(runtime, options) {
-	return resolveShopifyAccountId(runtime, getShopifyActionOptions(options));
-}
-function hasShopifyConfig(runtime, options) {
-	return hasShopifyAccountConfig(runtime, getShopifyActionOptions(options));
-}
-const shopifyAccountIdParameter = {
-	name: "accountId",
-	description: "Optional Shopify account id from SHOPIFY_ACCOUNTS. Defaults to SHOPIFY_DEFAULT_ACCOUNT_ID or the legacy single store token.",
-	required: false,
-	schema: { type: "string" }
-};
-//#endregion
-//#region src/shopify-client.ts
-const API_VERSION = "2025-04";
-/**
-* Lightweight Shopify Admin GraphQL API client.
-* Uses native fetch -- no external dependencies.
-*/
-var ShopifyClient = class {
-	baseUrl;
-	accessToken;
-	constructor(storeDomain, accessToken) {
-		const domain = storeDomain.replace(/^https?:\/\//, "").replace(/\/$/, "");
-		this.baseUrl = `https://${domain}/admin/api/${API_VERSION}/graphql.json`;
-		this.accessToken = accessToken;
-	}
-	/**
-	* Execute a GraphQL query or mutation against the Shopify Admin API.
-	* Throws on HTTP errors and on GraphQL-level errors.
-	*/
-	async query(graphql, variables) {
-		const resp = await fetch(this.baseUrl, {
-			method: "POST",
-			headers: {
-				"Content-Type": "application/json",
-				"X-Shopify-Access-Token": this.accessToken
-			},
-			body: JSON.stringify({
-				query: graphql,
-				variables
-			})
-		});
-		if (!resp.ok) {
-			const body = await resp.text().catch(() => "");
-			throw new Error(`Shopify API error: ${resp.status} ${resp.statusText}${body ? ` -- ${body.slice(0, 200)}` : ""}`);
-		}
-		const json = await resp.json();
-		if (json.errors?.length) throw new Error(`Shopify GraphQL error: ${json.errors.map((e) => e.message).join(", ")}`);
-		return json.data;
-	}
-};
-//#endregion
-//#region src/services/ShopifyService.ts
-const SHOPIFY_SERVICE_TYPE = "shopify";
-const PRODUCT_FIELDS = `
-  id
-  title
-  handle
-  status
-  descriptionHtml
-  productType
-  vendor
-  totalInventory
-  featuredImage { url altText }
-  variants(first: 5) {
-    edges { node { id title price sku inventoryQuantity } }
-  }
-`;
-const ORDER_FIELDS = `
-  id
-  name
-  createdAt
-  displayFinancialStatus
-  displayFulfillmentStatus
-  totalPriceSet { shopMoney { amount currencyCode } }
-  customer { id displayName }
-  lineItems(first: 10) {
-    edges { node { title quantity originalUnitPriceSet { shopMoney { amount currencyCode } } } }
-  }
-`;
-const CUSTOMER_FIELDS = `
-  id
-  displayName
-  email
-  phone
-  ordersCount
-  totalSpentV2 { amount currencyCode }
-  createdAt
-`;
-function formatUserErrors(errors) {
-	return errors.map((e) => `${e.field?.join(".") ?? "?"}: ${e.message}`).join("; ");
-}
-var ShopifyService = class ShopifyService extends Service {
-	static serviceType = SHOPIFY_SERVICE_TYPE;
-	capabilityDescription = "Connects the agent to a Shopify store for managing products, orders, inventory, and customers through the Admin GraphQL API.";
-	clients = /* @__PURE__ */ new Map();
-	defaultAccountId = DEFAULT_SHOPIFY_ACCOUNT_ID;
-	constructor(runtime) {
-		super(runtime);
-	}
-	async stop() {
-		this.clients.clear();
-	}
-	static async start(runtime) {
-		const svc = new ShopifyService(runtime);
-		const accounts = readShopifyAccounts(runtime);
-		const defaultAccount = resolveShopifyDefaultAccount(accounts, normalizeShopifyAccountId(runtime.getSetting("SHOPIFY_DEFAULT_ACCOUNT_ID") ?? runtime.getSetting("SHOPIFY_ACCOUNT_ID")));
-		if (!defaultAccount) {
-			logger.warn({
-				src: "plugin:shopify",
-				agentId: runtime.agentId
-			}, "No Shopify account configured -- Shopify service inactive");
-			return svc;
-		}
-		svc.defaultAccountId = defaultAccount.accountId;
-		for (const account of accounts) svc.clients.set(account.accountId, {
-			accountId: account.accountId,
-			config: account,
-			client: new ShopifyClient(account.storeDomain, account.accessToken)
-		});
-		try {
-			const shop = await svc.getShop();
-			logger.info({
-				src: "plugin:shopify",
-				agentId: runtime.agentId,
-				accountId: defaultAccount.accountId,
-				store: shop.name
-			}, `Shopify connected to "${shop.name}" (${shop.myshopifyDomain})`);
-		} catch (err) {
-			logger.error({
-				src: "plugin:shopify",
-				agentId: runtime.agentId,
-				error: err instanceof Error ? err.message : String(err)
-			}, "Failed to connect to Shopify store");
-			svc.clients.delete(defaultAccount.accountId);
-		}
-		return svc;
-	}
-	isConnected(accountId) {
-		return Boolean(this.getClientState(accountId, false));
-	}
-	getClientState(accountId, throwOnMissing = true) {
-		const normalized = normalizeShopifyAccountId(accountId);
-		const state = accountId ? this.clients.get(normalized) ?? null : this.clients.get(this.defaultAccountId) ?? Array.from(this.clients.values())[0] ?? null;
-		if (!state && throwOnMissing) throw new Error("Shopify client is not initialised. Check SHOPIFY_STORE_DOMAIN and SHOPIFY_ACCESS_TOKEN.");
-		return state;
-	}
-	requireClient(accountId) {
-		return this.getClientState(accountId)?.client;
-	}
-	async getShop(accountId) {
-		return (await this.requireClient(accountId).query(`{
-      shop {
-        name
-        email
-        myshopifyDomain
-        plan { displayName }
-        currencyCode
-        primaryDomain { url }
-      }
-    }`)).shop;
-	}
-	async listProducts(opts = {}, accountId) {
-		const variables = { first: Math.min(opts.first ?? 10, 50) };
-		if (opts.after) variables.after = opts.after;
-		if (opts.query) variables.query = opts.query;
-		const gql = `query ListProducts($first: Int!, $after: String, $query: String) {
-      products(first: $first, after: $after, query: $query, sortKey: TITLE) {
-        edges { node { ${PRODUCT_FIELDS} } }
-        pageInfo { hasNextPage endCursor }
-      }
-    }`;
-		const data = await this.requireClient(accountId).query(gql, variables);
-		return {
-			products: data.products.edges.map((e) => e.node),
-			hasNextPage: data.products.pageInfo.hasNextPage,
-			endCursor: data.products.pageInfo.endCursor
-		};
-	}
-	async createProduct(input, accountId) {
-		const gql = `mutation CreateProduct($input: ProductInput!) {
-      productCreate(input: $input) {
-        product { ${PRODUCT_FIELDS} }
-        userErrors { field message }
-      }
-    }`;
-		const data = await this.requireClient(accountId).query(gql, { input: {
-			title: input.title,
-			descriptionHtml: input.descriptionHtml ?? "",
-			productType: input.productType ?? "",
-			vendor: input.vendor ?? "",
-			status: (input.status ?? "DRAFT").toUpperCase()
-		} });
-		if (data.productCreate.userErrors.length > 0) throw new Error(`Product create failed: ${formatUserErrors(data.productCreate.userErrors)}`);
-		if (!data.productCreate.product) throw new Error("Product create returned no product");
-		return data.productCreate.product;
-	}
-	async updateProduct(id, input, accountId) {
-		const gql = `mutation UpdateProduct($input: ProductInput!) {
-      productUpdate(input: $input) {
-        product { ${PRODUCT_FIELDS} }
-        userErrors { field message }
-      }
-    }`;
-		const data = await this.requireClient(accountId).query(gql, { input: {
-			id,
-			...input
-		} });
-		if (data.productUpdate.userErrors.length > 0) throw new Error(`Product update failed: ${formatUserErrors(data.productUpdate.userErrors)}`);
-		if (!data.productUpdate.product) throw new Error("Product update returned no product");
-		return data.productUpdate.product;
-	}
-	async listOrders(opts = {}, accountId) {
-		const variables = { first: Math.min(opts.first ?? 10, 50) };
-		if (opts.after) variables.after = opts.after;
-		if (opts.query) variables.query = opts.query;
-		const gql = `query ListOrders($first: Int!, $after: String, $query: String) {
-      orders(first: $first, after: $after, query: $query, sortKey: CREATED_AT, reverse: true) {
-        edges { node { ${ORDER_FIELDS} } }
-        pageInfo { hasNextPage endCursor }
-      }
-    }`;
-		const data = await this.requireClient(accountId).query(gql, variables);
-		return {
-			orders: data.orders.edges.map((e) => e.node),
-			hasNextPage: data.orders.pageInfo.hasNextPage,
-			endCursor: data.orders.pageInfo.endCursor
-		};
-	}
-	async getOrder(id, accountId) {
-		const gql = `query GetOrder($id: ID!) {
-      order(id: $id) { ${ORDER_FIELDS} }
-    }`;
-		return (await this.requireClient(accountId).query(gql, { id })).order;
-	}
-	async fulfillOrder(orderId, accountId) {
-		const foData = await this.requireClient(accountId).query(`query FulfillmentOrders($id: ID!) {
-      order(id: $id) {
-        fulfillmentOrders(first: 5) {
-          edges {
-            node {
-              id
-              status
-              lineItems(first: 50) {
-                edges { node { id totalQuantity } }
-              }
-            }
-          }
-        }
-      }
-    }`, { id: orderId });
-		if (!foData.order) throw new Error(`Order ${orderId} not found`);
-		const openFOs = foData.order.fulfillmentOrders.edges.map((e) => e.node).filter((fo) => fo.status === "OPEN" || fo.status === "IN_PROGRESS");
-		if (openFOs.length === 0) throw new Error("No open fulfillment orders found for this order");
-		const fulfillGql = `mutation FulfillOrder($fulfillment: FulfillmentV2Input!) {
-      fulfillmentCreateV2(fulfillment: $fulfillment) {
-        fulfillment { id status }
-        userErrors { field message }
-      }
-    }`;
-		const lineItems = openFOs[0].lineItems.edges.map((e) => ({
-			fulfillmentOrderLineItemId: e.node.id,
-			quantity: e.node.totalQuantity
-		}));
-		const data = await this.requireClient(accountId).query(fulfillGql, { fulfillment: {
-			fulfillmentOrderId: openFOs[0].id,
-			lineItemsByFulfillmentOrder: [{
-				fulfillmentOrderId: openFOs[0].id,
-				fulfillmentOrderLineItems: lineItems
-			}]
-		} });
-		if (data.fulfillmentCreateV2.userErrors.length > 0) throw new Error(`Fulfillment failed: ${formatUserErrors(data.fulfillmentCreateV2.userErrors)}`);
-		if (!data.fulfillmentCreateV2.fulfillment) throw new Error("Fulfillment returned no result");
-		return data.fulfillmentCreateV2.fulfillment;
-	}
-	async listCustomers(opts = {}, accountId) {
-		const variables = { first: Math.min(opts.first ?? 10, 50) };
-		if (opts.after) variables.after = opts.after;
-		if (opts.query) variables.query = opts.query;
-		const gql = `query ListCustomers($first: Int!, $after: String, $query: String) {
-      customers(first: $first, after: $after, query: $query) {
-        edges { node { ${CUSTOMER_FIELDS} } }
-        pageInfo { hasNextPage endCursor }
-      }
-    }`;
-		const data = await this.requireClient(accountId).query(gql, variables);
-		return {
-			customers: data.customers.edges.map((e) => e.node),
-			hasNextPage: data.customers.pageInfo.hasNextPage,
-			endCursor: data.customers.pageInfo.endCursor
-		};
-	}
-	async checkInventory(inventoryItemId, accountId) {
-		const data = await this.requireClient(accountId).query(`query CheckInventory($id: ID!) {
-      inventoryItem(id: $id) {
-        id
-        tracked
-        inventoryLevels(first: 10) {
-          edges { node { id available location { id name } } }
-        }
-      }
-    }`, { id: inventoryItemId });
-		if (!data.inventoryItem) throw new Error(`Inventory item ${inventoryItemId} not found`);
-		return data.inventoryItem.inventoryLevels.edges.map((e) => e.node);
-	}
-	async adjustInventory(opts, accountId) {
-		const data = await this.requireClient(accountId).query(`mutation AdjustInventory($input: InventoryAdjustQuantitiesInput!) {
-      inventoryAdjustQuantities(input: $input) {
-        inventoryAdjustmentGroup { reason }
-        userErrors { field message }
-      }
-    }`, { input: {
-			reason: opts.reason ?? "correction",
-			name: "available",
-			changes: [{
-				inventoryItemId: opts.inventoryItemId,
-				locationId: opts.locationId,
-				delta: opts.delta
-			}]
-		} });
-		if (data.inventoryAdjustQuantities.userErrors.length > 0) throw new Error(`Inventory adjust failed: ${formatUserErrors(data.inventoryAdjustQuantities.userErrors)}`);
-	}
-	async listLocations(accountId) {
-		return (await this.requireClient(accountId).query(`{
-      locations(first: 20) {
-        edges { node { id name isActive } }
-      }
-    }`)).locations.edges.map((e) => e.node);
-	}
-	async getProductCount(accountId) {
-		return (await this.requireClient(accountId).query(`{
-      productsCount { count }
-    }`)).productsCount.count;
-	}
-	async getOrderCount(accountId) {
-		return (await this.requireClient(accountId).query(`{
-      ordersCount { count }
-    }`)).ordersCount.count;
-	}
-};
-//#endregion
-//#region src/actions/confirmation.ts
-function mergedOptions(options) {
-	const direct = options ?? {};
-	const parameters = direct.parameters && typeof direct.parameters === "object" ? direct.parameters : {};
-	return {
-		...direct,
-		...parameters
-	};
-}
-function getActionOptions(options) {
-	return mergedOptions(options);
-}
-function isConfirmed(options) {
-	const raw = mergedOptions(options).confirmed;
-	return raw === true || raw === "true";
-}
-function confirmationRequired(preview, data) {
-	return {
-		success: false,
-		text: preview,
-		data: {
-			requiresConfirmation: true,
-			preview,
-			...data
-		}
-	};
-}
-//#endregion
-//#region src/actions/json.ts
-function parseJsonObject(value) {
-	try {
-		const parsed = JSON.parse(value.trim());
-		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
-	} catch {
-		return null;
-	}
-}
-//#endregion
-//#region src/actions/manage-customers.ts
-function formatCustomer(c) {
-	const email = c.email ?? "no email";
-	const spent = `${c.totalSpentV2.amount} ${c.totalSpentV2.currencyCode}`;
-	return `- **${c.displayName}** | ${email} | Orders: ${c.ordersCount} | Total spent: ${spent}`;
-}
-function readNullableString$3(value) {
-	return typeof value === "string" && value.trim().length > 0 && value.trim().toLowerCase() !== "null" ? value.trim() : null;
-}
-function readCustomerIntent(options) {
-	const params = getActionOptions(options);
-	const candidate = params.intent && typeof params.intent === "object" ? params.intent : params;
-	const action = candidate.action;
-	const query = readNullableString$3(candidate.query);
-	if (action === "list") return {
-		action,
-		query
-	};
-	if (action === "search" && query) return {
-		action,
-		query
-	};
-	return null;
-}
-async function classifyIntent$4(runtime, text) {
-	const prompt = `Analyze the user message and determine what customer action they want.
-Respond with JSON only in one of these shapes:
-{"action":"list","query":null}
-
-{"action":"search","query":"customer name, email, or other search term"}
-
-User message: "${text}"
-`;
-	for (let i = 0; i < 2; i++) {
-		const parsed = parseJsonObject(await runtime.useModel(ModelType.TEXT_SMALL, { prompt }));
-		if (parsed?.action) return readCustomerIntent(parsed);
-	}
-	return null;
-}
-async function manageCustomersHandler(runtime, message, _state, options, callback) {
-	const svc = runtime.getService(SHOPIFY_SERVICE_TYPE);
-	if (!svc?.isConnected()) {
-		await callback?.({ text: "Shopify is not connected. Please check SHOPIFY_STORE_DOMAIN and SHOPIFY_ACCESS_TOKEN." });
-		return {
-			success: false,
-			error: "Shopify not connected"
-		};
-	}
-	const text = typeof message.content?.text === "string" ? message.content.text : "";
-	const intent = readCustomerIntent(options) ?? await classifyIntent$4(runtime, text);
-	if (!intent) {
-		await callback?.({ text: "I couldn't determine what customer action you want. Try: list customers or search for a specific customer." });
-		return {
-			success: false,
-			error: "Could not classify intent"
-		};
-	}
-	try {
-		const queryStr = intent.action === "search" ? intent.query : intent.query ?? void 0;
-		const result = await svc.listCustomers({
-			query: queryStr,
-			first: 15
-		});
-		if (result.customers.length === 0) {
-			const msg = queryStr ? `No customers found matching "${queryStr}".` : "No customers found in the store.";
-			await callback?.({ text: msg });
-			return {
-				success: true,
-				text: "No customers found"
-			};
-		}
-		const lines = result.customers.map(formatCustomer);
-		const more = result.hasNextPage ? "\n\n(More customers available)" : "";
-		if (intent.action === "search" && result.customers.length === 1) {
-			const c = result.customers[0];
-			const detail = [
-				`**${c.displayName}**`,
-				`Email: ${c.email ?? "not set"}`,
-				`Phone: ${c.phone ?? "not set"}`,
-				`Orders: ${c.ordersCount}`,
-				`Total spent: ${c.totalSpentV2.amount} ${c.totalSpentV2.currencyCode}`,
-				`Customer since: ${c.createdAt.slice(0, 10)}`
-			].join("\n");
-			await callback?.({ text: detail });
-		} else await callback?.({ text: `Customers (${result.customers.length}):\n\n${lines.join("\n")}${more}` });
-		return {
-			success: true,
-			data: { customers: result.customers }
-		};
-	} catch (err) {
-		const msg = err instanceof Error ? err.message : String(err);
-		logger.error({
-			src: "plugin:shopify:manage-customers",
-			error: msg
-		}, "Customer action failed");
-		await callback?.({ text: `Shopify customer operation failed: ${msg}` });
-		return {
-			success: false,
-			error: msg
-		};
-	}
-}
-//#endregion
-//#region src/actions/manage-inventory.ts
-function formatInventoryLevel(level) {
-	const qty = level.available !== null ? String(level.available) : "untracked";
-	return `- ${level.location.name}: ${qty} available`;
-}
-function formatLocation(loc) {
-	return `- ${loc.name} (${loc.isActive ? "active" : "inactive"})`;
-}
-function readNullableString$2(value) {
-	return typeof value === "string" && value.trim().length > 0 && value.trim().toLowerCase() !== "null" ? value.trim() : null;
-}
-function readInventoryIntent(options) {
-	const params = getActionOptions(options);
-	const candidate = params.intent && typeof params.intent === "object" ? params.intent : params;
-	const action = candidate.action;
-	if (action === "locations") return { action };
-	if (action === "check") {
-		const productQuery = readNullableString$2(candidate.productQuery);
-		return productQuery ? {
-			action,
-			productQuery
-		} : null;
-	}
-	if (action === "adjust") {
-		const productQuery = readNullableString$2(candidate.productQuery);
-		const delta = typeof candidate.delta === "number" ? candidate.delta : Number.parseInt(String(candidate.delta ?? ""), 10);
-		if (!productQuery || !Number.isFinite(delta)) return null;
-		return {
-			action,
-			productQuery,
-			delta,
-			reason: readNullableString$2(candidate.reason)
-		};
-	}
-	return null;
-}
-async function classifyIntent$3(runtime, text) {
-	const prompt = `Analyze the user message and determine what inventory action they want.
-Respond with JSON only in one of these shapes:
-{"action":"check","productQuery":"product name or SKU to check"}
-
-{"action":"adjust","productQuery":"product name","delta":5,"reason":"reason"}
-
-{"action":"locations"}
-
-For adjust, delta is positive to add stock and negative to remove stock.
-
-User message: "${text}"
-`;
-	for (let i = 0; i < 2; i++) {
-		const parsed = parseJsonObject(await runtime.useModel(ModelType.TEXT_SMALL, { prompt }));
-		if (parsed?.action) return readInventoryIntent(parsed);
-	}
-	return null;
-}
-async function manageInventoryHandler(runtime, message, _state, options, callback) {
-	const svc = runtime.getService(SHOPIFY_SERVICE_TYPE);
-	if (!svc?.isConnected()) {
-		await callback?.({ text: "Shopify is not connected. Please check SHOPIFY_STORE_DOMAIN and SHOPIFY_ACCESS_TOKEN." });
-		return {
-			success: false,
-			error: "Shopify not connected"
-		};
-	}
-	const text = typeof message.content?.text === "string" ? message.content.text : "";
-	const intent = readInventoryIntent(options) ?? await classifyIntent$3(runtime, text);
-	if (!intent) {
-		await callback?.({ text: "I couldn't determine what inventory action you want. Try: check stock, adjust inventory, or list locations." });
-		return {
-			success: false,
-			error: "Could not classify intent"
-		};
-	}
-	try {
-		if (intent.action === "locations") {
-			const locations = await svc.listLocations();
-			if (locations.length === 0) {
-				await callback?.({ text: "No locations found in the store." });
-				return {
-					success: true,
-					text: "No locations"
-				};
-			}
-			await callback?.({ text: `Store locations:\n\n${locations.map(formatLocation).join("\n")}` });
-			return {
-				success: true,
-				data: { locations }
-			};
-		}
-		if (intent.action === "check") {
-			const result = await svc.listProducts({
-				query: intent.productQuery,
-				first: 3
-			});
-			if (result.products.length === 0) {
-				await callback?.({ text: `No product found matching "${intent.productQuery}".` });
-				return {
-					success: false,
-					error: "Product not found"
-				};
-			}
-			const product = result.products[0];
-			const firstVariant = product.variants.edges[0]?.node;
-			if (!firstVariant) {
-				await callback?.({ text: `Product "${product.title}" has no variants.` });
-				return {
-					success: false,
-					error: "No variants"
-				};
-			}
-			const inventoryItemId = `gid://shopify/InventoryItem/${firstVariant.id.split("/").pop()}`;
-			const levels = await svc.checkInventory(inventoryItemId);
-			if (levels.length === 0) {
-				await callback?.({ text: `No inventory tracking found for "${product.title}".` });
-				return {
-					success: true,
-					text: "No inventory tracking"
-				};
-			}
-			await callback?.({ text: `Inventory for **${product.title}** (${firstVariant.title}):\n\n${levels.map(formatInventoryLevel).join("\n")}` });
-			return {
-				success: true,
-				data: {
-					product: product.title,
-					levels
-				}
-			};
-		}
-		if (intent.action === "adjust") {
-			const result = await svc.listProducts({
-				query: intent.productQuery,
-				first: 3
-			});
-			if (result.products.length === 0) {
-				await callback?.({ text: `No product found matching "${intent.productQuery}".` });
-				return {
-					success: false,
-					error: "Product not found"
-				};
-			}
-			const product = result.products[0];
-			const firstVariant = product.variants.edges[0]?.node;
-			if (!firstVariant) {
-				await callback?.({ text: `Product "${product.title}" has no variants.` });
-				return {
-					success: false,
-					error: "No variants"
-				};
-			}
-			const inventoryItemId = `gid://shopify/InventoryItem/${firstVariant.id.split("/").pop()}`;
-			const levels = await svc.checkInventory(inventoryItemId);
-			const locationId = levels[0]?.location.id ?? (await svc.listLocations())[0]?.id;
-			const locationName = levels[0]?.location.name ?? "first active location";
-			if (!locationId) {
-				await callback?.({ text: "No locations found in the store to adjust inventory against." });
-				return {
-					success: false,
-					error: "No locations"
-				};
-			}
-			const sign = intent.delta >= 0 ? "+" : "";
-			const preview = [
-				"Confirmation required before adjusting Shopify inventory:",
-				`Product: ${product.title}`,
-				`Variant: ${firstVariant.title}`,
-				`Location: ${locationName}`,
-				`Adjustment: ${sign}${intent.delta} units`,
-				`Reason: ${intent.reason ?? "correction"}`
-			].join("\n");
-			if (!isConfirmed(options)) {
-				await callback?.({ text: preview });
-				return confirmationRequired(preview, {
-					intent,
-					productId: product.id,
-					inventoryItemId,
-					locationId
-				});
-			}
-			await svc.adjustInventory({
-				inventoryItemId,
-				locationId,
-				delta: intent.delta,
-				reason: intent.reason ?? "correction"
-			});
-			await callback?.({ text: `Inventory adjusted for **${product.title}**: ${sign}${intent.delta} units.` });
-			return {
-				success: true,
-				data: {
-					product: product.title,
-					delta: intent.delta
-				}
-			};
-		}
-		await callback?.({ text: "Unsupported inventory action." });
-		return {
-			success: false,
-			error: "Unknown action"
-		};
-	} catch (err) {
-		const msg = err instanceof Error ? err.message : String(err);
-		logger.error({
-			src: "plugin:shopify:manage-inventory",
-			error: msg
-		}, "Inventory action failed");
-		await callback?.({ text: `Shopify inventory operation failed: ${msg}` });
-		return {
-			success: false,
-			error: msg
-		};
-	}
-}
-//#endregion
-//#region src/actions/manage-orders.ts
-function formatOrder(o) {
-	const total = o.totalPriceSet.shopMoney;
-	const items = o.lineItems.edges.map((e) => `${e.node.title} x${e.node.quantity}`).join(", ");
-	const customer = o.customer?.displayName ?? "Guest";
-	return `- **${o.name}** | ${total.amount} ${total.currencyCode} | ${o.displayFulfillmentStatus} | ${customer} | Items: ${items} | ${o.createdAt.slice(0, 10)}`;
-}
-function readNullableString$1(value) {
-	return typeof value === "string" && value.trim().length > 0 && value.trim().toLowerCase() !== "null" ? value.trim() : null;
-}
-function readOrderIntent(options) {
-	const params = getActionOptions(options);
-	const candidate = params.intent && typeof params.intent === "object" ? params.intent : params;
-	const action = candidate.action;
-	if (action === "list") return {
-		action,
-		query: readNullableString$1(candidate.query)
-	};
-	if (action === "get" || action === "fulfill") {
-		const orderName = readNullableString$1(candidate.orderName);
-		return orderName ? {
-			action,
-			orderName
-		} : null;
-	}
-	return null;
-}
-async function classifyIntent$2(runtime, text) {
-	const prompt = `Analyze the user message and determine what order action they want.
-Respond with JSON only in one of these shapes:
-{"action":"list","query":"optional filter like unfulfilled or last week"}
-
-{"action":"get","orderName":"order number like #1001 or 1001"}
-
-{"action":"fulfill","orderName":"order number to fulfill"}
-
-User message: "${text}"
-`;
-	for (let i = 0; i < 2; i++) {
-		const parsed = parseJsonObject(await runtime.useModel(ModelType.TEXT_SMALL, { prompt }));
-		if (parsed?.action) return readOrderIntent(parsed);
-	}
-	return null;
-}
-async function manageOrdersHandler(runtime, message, _state, options, callback) {
-	const svc = runtime.getService(SHOPIFY_SERVICE_TYPE);
-	if (!svc?.isConnected()) {
-		await callback?.({ text: "Shopify is not connected. Please check SHOPIFY_STORE_DOMAIN and SHOPIFY_ACCESS_TOKEN." });
-		return {
-			success: false,
-			error: "Shopify not connected"
-		};
-	}
-	const text = typeof message.content?.text === "string" ? message.content.text : "";
-	const intent = readOrderIntent(options) ?? await classifyIntent$2(runtime, text);
-	if (!intent) {
-		await callback?.({ text: "I couldn't determine what order action you want. Try: list orders, check order status, or fulfill an order." });
-		return {
-			success: false,
-			error: "Could not classify intent"
-		};
-	}
-	try {
-		if (intent.action === "list") {
-			const queryStr = intent.query ?? void 0;
-			const result = await svc.listOrders({
-				query: queryStr,
-				first: 10
-			});
-			if (result.orders.length === 0) {
-				await callback?.({ text: queryStr ? `No orders found matching "${queryStr}".` : "No orders found." });
-				return {
-					success: true,
-					text: "No orders found"
-				};
-			}
-			const lines = result.orders.map(formatOrder);
-			const more = result.hasNextPage ? "\n\n(More orders available)" : "";
-			await callback?.({ text: `Recent orders (${result.orders.length}):\n\n${lines.join("\n")}${more}` });
-			return {
-				success: true,
-				data: { orders: result.orders }
-			};
-		}
-		if (intent.action === "get") {
-			const cleanName = intent.orderName.replace(/^#/, "").trim();
-			const result = await svc.listOrders({
-				query: `name:#${cleanName}`,
-				first: 1
-			});
-			if (result.orders.length === 0) {
-				await callback?.({ text: `Order #${cleanName} not found.` });
-				return {
-					success: false,
-					error: "Order not found"
-				};
-			}
-			const order = result.orders[0];
-			const total = order.totalPriceSet.shopMoney;
-			const lineItems = order.lineItems.edges.map((e) => `  - ${e.node.title} x${e.node.quantity} (${e.node.originalUnitPriceSet.shopMoney.amount} ${e.node.originalUnitPriceSet.shopMoney.currencyCode})`);
-			const detail = [
-				`**Order ${order.name}**`,
-				`Status: ${order.displayFulfillmentStatus} | Payment: ${order.displayFinancialStatus ?? "n/a"}`,
-				`Total: ${total.amount} ${total.currencyCode}`,
-				`Customer: ${order.customer?.displayName ?? "Guest"}`,
-				`Created: ${order.createdAt.slice(0, 10)}`,
-				`Items:`,
-				...lineItems
-			].join("\n");
-			await callback?.({ text: detail });
-			return {
-				success: true,
-				data: { order }
-			};
-		}
-		if (intent.action === "fulfill") {
-			const cleanName = intent.orderName.replace(/^#/, "").trim();
-			const result = await svc.listOrders({
-				query: `name:#${cleanName}`,
-				first: 1
-			});
-			if (result.orders.length === 0) {
-				await callback?.({ text: `Order #${cleanName} not found.` });
-				return {
-					success: false,
-					error: "Order not found"
-				};
-			}
-			const order = result.orders[0];
-			const preview = [
-				"Confirmation required before fulfilling Shopify order:",
-				`Order: ${order.name}`,
-				`Status: ${order.displayFulfillmentStatus}`,
-				`Customer: ${order.customer?.displayName ?? "Guest"}`
-			].join("\n");
-			if (!isConfirmed(options)) {
-				await callback?.({ text: preview });
-				return confirmationRequired(preview, {
-					intent,
-					orderId: order.id
-				});
-			}
-			const fulfillment = await svc.fulfillOrder(order.id);
-			await callback?.({ text: `Order ${order.name} fulfilled (status: ${fulfillment.status}).` });
-			return {
-				success: true,
-				data: {
-					order: order.name,
-					fulfillment
-				}
-			};
-		}
-		await callback?.({ text: "Unsupported order action." });
-		return {
-			success: false,
-			error: "Unknown action"
-		};
-	} catch (err) {
-		const msg = err instanceof Error ? err.message : String(err);
-		logger.error({
-			src: "plugin:shopify:manage-orders",
-			error: msg
-		}, "Order action failed");
-		await callback?.({ text: `Shopify order operation failed: ${msg}` });
-		return {
-			success: false,
-			error: msg
-		};
-	}
-}
-//#endregion
-//#region src/actions/manage-products.ts
-function formatProduct(p) {
-	const variants = p.variants.edges.map((e) => e.node);
-	const priceRange = variants.length > 0 ? variants.map((v) => v.price).join(", ") : "n/a";
-	const inventory = p.totalInventory !== null ? String(p.totalInventory) : "untracked";
-	return `- **${p.title}** (${p.status}) | Price: ${priceRange} | Inventory: ${inventory} | Handle: ${p.handle}`;
-}
-function readNullableString(value) {
-	return typeof value === "string" && value.trim().length > 0 && value.trim().toLowerCase() !== "null" ? value.trim() : null;
-}
-function readProductIntent(options) {
-	const params = getActionOptions(options);
-	const candidate = params.intent && typeof params.intent === "object" ? params.intent : params;
-	const action = candidate.action;
-	if (action === "list") return {
-		action,
-		query: readNullableString(candidate.query)
-	};
-	if (action === "create") {
-		const title = readNullableString(candidate.title);
-		if (!title) return null;
-		return {
-			action,
-			title,
-			description: readNullableString(candidate.description),
-			productType: readNullableString(candidate.productType),
-			vendor: readNullableString(candidate.vendor),
-			status: readNullableString(candidate.status)
-		};
-	}
-	if (action === "update") {
-		const identifier = readNullableString(candidate.identifier);
-		if (!identifier) return null;
-		return {
-			action,
-			identifier,
-			title: readNullableString(candidate.title),
-			description: readNullableString(candidate.description),
-			status: readNullableString(candidate.status)
-		};
-	}
-	return null;
-}
-async function classifyIntent$1(runtime, text) {
-	const prompt = `Analyze the user message and determine what product action they want.
-Respond with JSON only in one of these shapes:
-{"action":"list","query":"search term"}
-
-{"action":"create","title":"product title","description":"description","productType":"type","vendor":"vendor","status":"ACTIVE"}
-
-{"action":"update","identifier":"product title or handle to find","title":"new title","description":"new description","status":"ACTIVE"}
-
-User message: "${text}"
-`;
-	for (let i = 0; i < 2; i++) {
-		const parsed = parseJsonObject(await runtime.useModel(ModelType.TEXT_SMALL, { prompt }));
-		if (parsed?.action) return readProductIntent(parsed);
-	}
-	return null;
-}
-async function manageProductsHandler(runtime, message, _state, options, callback) {
-	const svc = runtime.getService(SHOPIFY_SERVICE_TYPE);
-	if (!svc?.isConnected()) {
-		await callback?.({ text: "Shopify is not connected. Please check SHOPIFY_STORE_DOMAIN and SHOPIFY_ACCESS_TOKEN." });
-		return {
-			success: false,
-			error: "Shopify not connected"
-		};
-	}
-	const text = typeof message.content?.text === "string" ? message.content.text : "";
-	const intent = readProductIntent(options) ?? await classifyIntent$1(runtime, text);
-	if (!intent) {
-		await callback?.({ text: "I couldn't determine what product action you want. You can ask me to list, create, or update products." });
-		return {
-			success: false,
-			error: "Could not classify intent"
-		};
-	}
-	try {
-		if (intent.action === "list") {
-			const result = await svc.listProducts({
-				query: intent.query,
-				first: 10
-			});
-			if (result.products.length === 0) {
-				await callback?.({ text: intent.query ? `No products found matching "${intent.query}".` : "The store has no products yet." });
-				return {
-					success: true,
-					text: "No products found"
-				};
-			}
-			const lines = result.products.map(formatProduct);
-			const more = result.hasNextPage ? "\n\n(More products available -- ask to see more)" : "";
-			await callback?.({ text: `Found ${result.products.length} product(s):\n\n${lines.join("\n")}${more}` });
-			return {
-				success: true,
-				data: { products: result.products }
-			};
-		}
-		if (intent.action === "create") {
-			const status = intent.status ?? "DRAFT";
-			const preview = [
-				"Confirmation required before creating Shopify product:",
-				`Title: ${intent.title}`,
-				`Status: ${status}`,
-				intent.vendor ? `Vendor: ${intent.vendor}` : null,
-				intent.productType ? `Type: ${intent.productType}` : null
-			].filter((line) => line !== null).join("\n");
-			if (!isConfirmed(options)) {
-				await callback?.({ text: preview });
-				return confirmationRequired(preview, { intent });
-			}
-			const product = await svc.createProduct({
-				title: intent.title,
-				descriptionHtml: intent.description ?? void 0,
-				productType: intent.productType ?? void 0,
-				vendor: intent.vendor ?? void 0,
-				status
-			});
-			await callback?.({ text: `Product created: ${product.title} (${product.status}).` });
-			return {
-				success: true,
-				data: { product }
-			};
-		}
-		if (intent.action === "update") {
-			const searchResult = await svc.listProducts({
-				query: intent.identifier,
-				first: 5
-			});
-			if (searchResult.products.length === 0) {
-				await callback?.({ text: `Could not find a product matching "${intent.identifier}".` });
-				return {
-					success: false,
-					error: "Product not found"
-				};
-			}
-			const target = searchResult.products[0];
-			const updateInput = {};
-			if (intent.title) updateInput.title = intent.title;
-			if (intent.description) updateInput.descriptionHtml = intent.description;
-			if (intent.status) updateInput.status = intent.status.toUpperCase();
-			const changeLines = [
-				intent.title ? `Title: ${intent.title}` : null,
-				intent.description ? "Description: updated" : null,
-				intent.status ? `Status: ${intent.status.toUpperCase()}` : null
-			].filter((line) => line !== null);
-			const preview = [
-				"Confirmation required before updating Shopify product:",
-				`Product: ${target.title}`,
-				...changeLines
-			].join("\n");
-			if (!isConfirmed(options)) {
-				await callback?.({ text: preview });
-				return confirmationRequired(preview, {
-					intent,
-					productId: target.id
-				});
-			}
-			const updated = await svc.updateProduct(target.id, updateInput);
-			await callback?.({ text: `Product updated: ${updated.title} (${updated.status}).` });
-			return {
-				success: true,
-				data: { product: updated }
-			};
-		}
-		await callback?.({ text: "Unsupported product action." });
-		return {
-			success: false,
-			error: "Unknown action"
-		};
-	} catch (err) {
-		const msg = err instanceof Error ? err.message : String(err);
-		logger.error({
-			src: "plugin:shopify:manage-products",
-			error: msg
-		}, "Product action failed");
-		await callback?.({ text: `Shopify product operation failed: ${msg}` });
-		return {
-			success: false,
-			error: msg
-		};
-	}
-}
-//#endregion
-//#region src/actions/search-store.ts
-function formatProductBrief(p) {
-	const price = p.variants.edges[0]?.node.price ?? "n/a";
-	return `[Product] **${p.title}** -- ${p.status} -- ${price}`;
-}
-function formatOrderBrief(o) {
-	const total = o.totalPriceSet.shopMoney;
-	return `[Order] **${o.name}** -- ${total.amount} ${total.currencyCode} -- ${o.displayFulfillmentStatus}`;
-}
-function formatCustomerBrief(c) {
-	return `[Customer] **${c.displayName}** -- ${c.email ?? "no email"} -- ${c.ordersCount} orders`;
-}
-function readSearchStoreParams(options) {
-	const params = options?.parameters ?? {};
-	const query = typeof params.query === "string" && params.query.trim().length > 0 ? params.query.trim() : null;
-	const scope = params.scope === "products" || params.scope === "orders" || params.scope === "customers" || params.scope === "all" ? params.scope : "all";
-	const limit = typeof params.limit === "number" && Number.isFinite(params.limit) ? Math.max(1, Math.floor(params.limit)) : 5;
-	return {
-		intent: query ? {
-			query,
-			scope
-		} : null,
-		limit
-	};
-}
-async function classifyIntent(runtime, text) {
-	const prompt = `Analyze the user message and determine what they want to search for in a Shopify store.
-Respond with JSON only:
-{"query":"the search term","scope":"all"}
-
-Use "all" when the user does not specify a specific category, or mentions multiple.
-
-User message: "${text}"
-`;
-	for (let i = 0; i < 2; i++) {
-		const parsed = parseJsonObject(await runtime.useModel(ModelType.TEXT_SMALL, { prompt }));
-		const query = typeof parsed?.query === "string" && parsed.query.trim().length > 0 ? parsed.query.trim() : null;
-		const scope = parsed?.scope === "products" || parsed?.scope === "orders" || parsed?.scope === "customers" || parsed?.scope === "all" ? parsed.scope : "all";
-		if (query) return {
-			query,
-			scope
-		};
-	}
-	return null;
-}
-async function searchStoreHandler(runtime, message, _state, _options, callback) {
-	const svc = runtime.getService(SHOPIFY_SERVICE_TYPE);
-	const accountId = getShopifyAccountId(runtime, _options);
-	if (!svc?.isConnected(accountId)) {
-		await callback?.({ text: "Shopify is not connected. Please check SHOPIFY_STORE_DOMAIN and SHOPIFY_ACCESS_TOKEN." });
-		return {
-			success: false,
-			error: "Shopify not connected"
-		};
-	}
-	const text = typeof message.content?.text === "string" ? message.content.text : "";
-	const structured = readSearchStoreParams(_options);
-	const intent = structured.intent ?? await classifyIntent(runtime, text);
-	if (!intent) {
-		await callback?.({ text: "I couldn't determine what to search for. Please provide a search term." });
-		return {
-			success: false,
-			error: "Could not classify intent"
-		};
-	}
-	try {
-		const sections = [];
-		const data = {};
-		if (intent.scope === "all" || intent.scope === "products") {
-			const result = await svc.listProducts({
-				query: intent.query,
-				first: structured.limit
-			}, accountId);
-			if (result.products.length > 0) {
-				sections.push(`**Products** (${result.products.length}):\n${result.products.map(formatProductBrief).join("\n")}`);
-				data.products = result.products;
-			}
-		}
-		if (intent.scope === "all" || intent.scope === "orders") {
-			const result = await svc.listOrders({
-				query: intent.query,
-				first: structured.limit
-			}, accountId);
-			if (result.orders.length > 0) {
-				sections.push(`**Orders** (${result.orders.length}):\n${result.orders.map(formatOrderBrief).join("\n")}`);
-				data.orders = result.orders;
-			}
-		}
-		if (intent.scope === "all" || intent.scope === "customers") {
-			const result = await svc.listCustomers({
-				query: intent.query,
-				first: structured.limit
-			}, accountId);
-			if (result.customers.length > 0) {
-				sections.push(`**Customers** (${result.customers.length}):\n${result.customers.map(formatCustomerBrief).join("\n")}`);
-				data.customers = result.customers;
-			}
-		}
-		if (sections.length === 0) {
-			await callback?.({ text: `No results found for "${intent.query}" in the store.` });
-			return {
-				success: true,
-				text: "No results"
-			};
-		}
-		await callback?.({ text: `Search results for "${intent.query}":\n\n${sections.join("\n\n")}` });
-		return {
-			success: true,
-			data
-		};
-	} catch (err) {
-		const msg = err instanceof Error ? err.message : String(err);
-		logger.error({
-			src: "plugin:shopify:search-store",
-			error: msg
-		}, "Store search failed");
-		await callback?.({ text: `Shopify search failed: ${msg}` });
-		return {
-			success: false,
-			error: msg
-		};
-	}
-}
-//#endregion
-//#region src/actions/shopify.ts
-const ALL_OPS = [
-	"search",
-	"products",
-	"inventory",
-	"orders",
-	"customers"
-];
-const ROUTES = [
-	{
-		op: "search",
-		handler: searchStoreHandler,
-		match: /\b(search|find|browse|look\s+up|catalog|store search)\b/i
-	},
-	{
-		op: "inventory",
-		handler: manageInventoryHandler,
-		match: /\b(inventory|stock|quantity|on hand|in stock|out of stock|restock)\b/i
-	},
-	{
-		op: "customers",
-		handler: manageCustomersHandler,
-		match: /\b(customer|buyer|shopper|client)s?\b/i
-	},
-	{
-		op: "orders",
-		handler: manageOrdersHandler,
-		match: /\b(order|fulfill|ship|refund|return)s?\b/i
-	},
-	{
-		op: "products",
-		handler: manageProductsHandler,
-		match: /\b(product|sku|variant|listing|item)s?\b/i
-	}
-];
-function readOptions(options) {
-	const direct = options ?? {};
-	const parameters = direct.parameters && typeof direct.parameters === "object" ? direct.parameters : {};
-	return {
-		...direct,
-		...parameters
-	};
-}
-function normalizeOp(value) {
-	if (typeof value !== "string") return null;
-	const trimmed = value.trim().toLowerCase();
-	return ALL_OPS.includes(trimmed) ? trimmed : null;
-}
-function selectRoute(message, options) {
-	const opts = readOptions(options);
-	const requested = normalizeOp(opts.action ?? opts.op ?? opts.entity ?? opts.subaction);
-	if (requested) {
-		const route = ROUTES.find((candidate) => candidate.op === requested);
-		if (route) return route;
-	}
-	const text = typeof message.content?.text === "string" ? message.content.text : "";
-	return ROUTES.find((route) => route.match.test(text)) ?? null;
-}
-const shopifyAction = {
-	name: "SHOPIFY",
-	description: "Manage a Shopify store. Actions: search (read-only catalog browsing across products, orders, and customers), products (CRUD on products), inventory (stock adjustments), orders (list/update orders), customers (CRUD on customers). Action is inferred from the message text when not explicitly provided.",
-	descriptionCompressed: "Shopify: search, products, inventory, orders, customers.",
-	similes: [
-		"MANAGE_SHOPIFY_PRODUCTS",
-		"MANAGE_SHOPIFY_INVENTORY",
-		"MANAGE_SHOPIFY_ORDERS",
-		"MANAGE_SHOPIFY_CUSTOMERS",
-		"LIST_PRODUCTS",
-		"CREATE_PRODUCT",
-		"UPDATE_PRODUCT",
-		"SEARCH_PRODUCTS",
-		"CHECK_INVENTORY",
-		"ADJUST_INVENTORY",
-		"CHECK_STOCK",
-		"UPDATE_STOCK",
-		"LIST_ORDERS",
-		"CHECK_ORDERS",
-		"FULFILL_ORDER",
-		"ORDER_STATUS",
-		"LIST_CUSTOMERS",
-		"FIND_CUSTOMER",
-		"SEARCH_CUSTOMERS"
-	],
-	contexts: [
-		"payments",
-		"connectors",
-		"automation",
-		"knowledge"
-	],
-	contextGate: { anyOf: [
-		"payments",
-		"connectors",
-		"automation",
-		"knowledge"
-	] },
-	roleGate: { minRole: "USER" },
-	parameters: [
-		{
-			name: "action",
-			description: "Operation to perform. One of: search, products, inventory, orders, customers. Inferred from message text when omitted.",
-			required: false,
-			schema: {
-				type: "string",
-				enum: [...ALL_OPS]
-			}
-		},
-		{
-			name: "subaction",
-			description: "Legacy alias for action.",
-			required: false,
-			schema: { type: "string" }
-		},
-		{
-			name: "query",
-			description: "Search term for action=search.",
-			required: false,
-			schema: { type: "string" }
-		},
-		{
-			name: "scope",
-			description: "Search scope for action=search: all, products, orders, or customers.",
-			required: false,
-			schema: {
-				type: "string",
-				enum: [
-					"all",
-					"products",
-					"orders",
-					"customers"
-				]
-			}
-		},
-		{
-			name: "limit",
-			description: "Maximum results per searched Shopify category.",
-			required: false,
-			schema: { type: "number" }
-		},
-		shopifyAccountIdParameter
-	],
-	validate: async (runtime) => {
-		if (!hasShopifyConfig(runtime)) return false;
-		return true;
-	},
-	handler: async (runtime, message, state, options, callback) => {
-		const route = selectRoute(message, options);
-		if (!route) {
-			const ops = ALL_OPS.join(", ");
-			const text = `SHOPIFY could not determine the operation. Specify one of: ${ops}.`;
-			await callback?.({
-				text,
-				source: message.content?.source
-			});
-			return {
-				success: false,
-				text,
-				values: { error: "MISSING" },
-				data: {
-					actionName: "SHOPIFY",
-					availableOps: ops
-				}
-			};
-		}
-		const result = await route.handler(runtime, message, state, options, callback) ?? { success: true };
-		return {
-			...result,
-			data: {
-				...typeof result.data === "object" && result.data ? result.data : {},
-				actionName: "SHOPIFY",
-				action: route.op,
-				op: route.op
-			}
-		};
-	},
-	examples: [
-		[{
-			name: "{{user1}}",
-			content: { text: "Show me my Shopify orders from this week" }
-		}, {
-			name: "{{agentName}}",
-			content: {
-				text: "Pulling recent Shopify orders.",
-				actions: ["SHOPIFY"]
-			}
-		}],
-		[{
-			name: "{{user1}}",
-			content: { text: "Search my Shopify store for hat" }
-		}, {
-			name: "{{agentName}}",
-			content: {
-				text: "Searching the Shopify store.",
-				actions: ["SHOPIFY"]
-			}
-		}],
-		[{
-			name: "{{user1}}",
-			content: { text: "Adjust inventory for SKU ABC-123 to 50 units" }
-		}, {
-			name: "{{agentName}}",
-			content: {
-				text: "Updating inventory.",
-				actions: ["SHOPIFY"]
-			}
-		}],
-		[{
-			name: "{{user1}}",
-			content: { text: "Create a new product: red t-shirt, $25" }
-		}, {
-			name: "{{agentName}}",
-			content: {
-				text: "Creating that product.",
-				actions: ["SHOPIFY"]
-			}
-		}]
-	]
-};
-//#endregion
-//#region src/connector-account-provider.ts
-/**
-* Shopify ConnectorAccountManager provider.
-*
-* Bridges plugin-shopify to the @elizaos/core ConnectorAccountManager so the
-* generic HTTP CRUD + OAuth surface can list, create, patch, delete, and run
-* the OAuth flow for Shopify stores.
-*
-* Account model:
-*   - role "OWNER" — store admin (Shopify Admin API access token)
-*   - accountKey  — store domain (e.g. mystore.myshopify.com)
-*   - purpose     — ["admin"]
-*/
-const SHOPIFY_PROVIDER_NAME = "shopify";
-const DEFAULT_PURPOSES = ["admin"];
-function nonEmptyString(value) {
-	if (typeof value !== "string") return void 0;
-	const trimmed = value.trim();
-	return trimmed.length > 0 ? trimmed : void 0;
-}
-function readSetting(runtime, key) {
-	return nonEmptyString(runtime.getSetting?.(key));
-}
-function readClientConfig(runtime) {
-	const clientId = readSetting(runtime, "SHOPIFY_OAUTH_CLIENT_ID");
-	const clientSecret = readSetting(runtime, "SHOPIFY_OAUTH_CLIENT_SECRET");
-	const redirectUri = readSetting(runtime, "SHOPIFY_OAUTH_REDIRECT_URI");
-	if (!clientId || !clientSecret || !redirectUri) throw new Error("Shopify OAuth requires SHOPIFY_OAUTH_CLIENT_ID, SHOPIFY_OAUTH_CLIENT_SECRET, and SHOPIFY_OAUTH_REDIRECT_URI to be configured.");
-	return {
-		clientId,
-		clientSecret,
-		redirectUri
-	};
-}
-function parseScopes(value) {
-	if (!value) return [];
-	return value.split(/[,\s]+/).map((scope) => scope.trim()).filter(Boolean);
-}
-function normalizeStoreDomain(value) {
-	const trimmed = value.trim().toLowerCase();
-	if (trimmed.endsWith(".myshopify.com")) return trimmed;
-	if (trimmed.includes(".")) return trimmed;
-	return `${trimmed}.myshopify.com`;
-}
-async function exchangeCodeForToken(args) {
-	const url = `https://${args.storeDomain}/admin/oauth/access_token`;
-	const response = await fetch(url, {
-		method: "POST",
-		headers: {
-			"Content-Type": "application/json",
-			Accept: "application/json"
-		},
-		body: JSON.stringify({
-			client_id: args.clientId,
-			client_secret: args.clientSecret,
-			code: args.code
-		})
-	});
-	if (!response.ok) {
-		const body = await response.text();
-		throw new Error(`Shopify token exchange failed with ${response.status}: ${body}`);
-	}
-	const parsed = await response.json();
-	if (parsed.error) throw new Error(`Shopify token exchange returned error ${parsed.error}: ${parsed.error_description ?? "no description"}`);
-	if (!parsed.access_token) throw new Error("Shopify token exchange returned no access_token.");
-	return parsed;
-}
-async function fetchShopInfo(storeDomain, accessToken) {
-	const url = `https://${storeDomain}/admin/api/2024-10/shop.json`;
-	const response = await fetch(url, { headers: {
-		"X-Shopify-Access-Token": accessToken,
-		Accept: "application/json"
-	} });
-	if (!response.ok) throw new Error(`Shopify shop.json query failed with ${response.status}`);
-	return await response.json();
-}
-function synthesizeEnvAccounts(runtime) {
-	const now = Date.now();
-	return readShopifyAccounts(runtime).map((account) => ({
-		id: account.accountId,
-		provider: SHOPIFY_PROVIDER_NAME,
-		label: account.label ?? `Shopify (${account.storeDomain})`,
-		role: "OWNER",
-		purpose: DEFAULT_PURPOSES,
-		accessGate: "open",
-		status: "connected",
-		externalId: account.storeDomain,
-		displayHandle: account.storeDomain,
-		createdAt: now,
-		updatedAt: now,
-		metadata: {
-			authMethod: "access_token",
-			source: "env",
-			storeDomain: account.storeDomain
-		}
-	}));
-}
-/**
-* Build the Shopify ConnectorAccountManager provider.
-*/
-function createShopifyConnectorAccountProvider(runtime) {
-	return {
-		provider: SHOPIFY_PROVIDER_NAME,
-		label: "Shopify",
-		listAccounts: async (manager) => {
-			const stored = await manager.getStorage().listAccounts(SHOPIFY_PROVIDER_NAME);
-			if (stored.length > 0) return stored;
-			return synthesizeEnvAccounts(runtime);
-		},
-		createAccount: async (input, _manager) => {
-			return {
-				...input,
-				provider: SHOPIFY_PROVIDER_NAME,
-				role: input.role ?? "OWNER",
-				purpose: input.purpose ?? DEFAULT_PURPOSES,
-				accessGate: input.accessGate ?? "open",
-				status: input.status ?? "pending"
-			};
-		},
-		patchAccount: async (_accountId, patch, _manager) => {
-			return {
-				...patch,
-				provider: SHOPIFY_PROVIDER_NAME
-			};
-		},
-		deleteAccount: async (_accountId, _manager) => {},
-		startOAuth: async (request, _manager) => {
-			const config = readClientConfig(runtime);
-			const redirectUri = request.redirectUri ?? config.redirectUri;
-			const metadataInput = request.metadata ?? {};
-			const storeDomainRaw = nonEmptyString(metadataInput.storeDomain) ?? nonEmptyString(metadataInput.shopDomain) ?? nonEmptyString(metadataInput.shop);
-			if (!storeDomainRaw) throw new Error("Shopify OAuth requires a storeDomain (e.g. mystore.myshopify.com) in startOAuth metadata.");
-			const storeDomain = normalizeStoreDomain(storeDomainRaw);
-			const scopes = request.scopes && request.scopes.length > 0 ? request.scopes : [
-				"read_products",
-				"write_products",
-				"read_orders",
-				"write_orders",
-				"read_customers",
-				"read_inventory",
-				"write_inventory",
-				"read_locations"
-			];
-			return {
-				authUrl: `https://${storeDomain}/admin/oauth/authorize?${new URLSearchParams({
-					client_id: config.clientId,
-					scope: scopes.join(","),
-					redirect_uri: redirectUri,
-					state: request.flow.state
-				}).toString()}`,
-				metadata: {
-					...request.metadata,
-					requestedScopes: scopes,
-					redirectUri,
-					storeDomain
-				}
-			};
-		},
-		completeOAuth: async (request, _manager) => {
-			const code = nonEmptyString(request.code);
-			if (!code) throw new Error("Shopify OAuth callback is missing an authorization code.");
-			const storeDomainRaw = nonEmptyString((request.flow.metadata ?? {}).storeDomain) ?? nonEmptyString(request.query.shop);
-			if (!storeDomainRaw) throw new Error("Shopify OAuth callback could not resolve a storeDomain.");
-			const storeDomain = normalizeStoreDomain(storeDomainRaw);
-			const config = readClientConfig(runtime);
-			const tokens = await exchangeCodeForToken({
-				storeDomain,
-				clientId: config.clientId,
-				clientSecret: config.clientSecret,
-				code
-			});
-			if (!tokens.access_token) throw new Error("Shopify token exchange returned no access_token.");
-			const shop = (await fetchShopInfo(storeDomain, tokens.access_token)).shop;
-			const externalId = nonEmptyString(shop?.myshopify_domain ?? shop?.domain ?? storeDomain);
-			if (!externalId) throw new Error("Shopify shop payload did not include a usable domain.");
-			const accountPatch = {
-				provider: SHOPIFY_PROVIDER_NAME,
-				role: "OWNER",
-				purpose: DEFAULT_PURPOSES,
-				accessGate: "open",
-				status: "connected",
-				externalId,
-				displayHandle: externalId,
-				label: nonEmptyString(shop?.name) ?? externalId,
-				metadata: {
-					authMethod: "oauth",
-					storeDomain,
-					shopId: shop?.id ?? null,
-					shopName: nonEmptyString(shop?.name) ?? null,
-					shopEmail: nonEmptyString(shop?.email) ?? null,
-					planName: nonEmptyString(shop?.plan_name) ?? null,
-					currency: nonEmptyString(shop?.currency) ?? null,
-					countryCode: nonEmptyString(shop?.country_code) ?? null,
-					grantedScopes: parseScopes(tokens.scope)
-				}
-			};
-			logger.info({
-				src: "plugin:shopify:connector",
-				storeDomain
-			}, "Shopify OAuth completed");
-			return {
-				account: accountPatch,
-				flow: { status: "completed" }
-			};
-		}
-	};
-}
-//#endregion
-//#region src/providers/store-context.ts
-const MAX_SHOPIFY_DOMAIN_CHARS = 200;
-const storeContextProvider = {
-	name: "shopifyStoreContext",
-	description: "Provides context about the connected Shopify store -- name, domain, plan, product count, and order count.",
-	descriptionCompressed: "Shopify store: name, domain, plan, product/order counts.",
-	dynamic: true,
-	contexts: ["connectors", "finance"],
-	contextGate: { anyOf: ["connectors", "finance"] },
-	cacheStable: false,
-	cacheScope: "turn",
-	get: async (runtime, _message, _state) => {
-		const svc = runtime.getService(SHOPIFY_SERVICE_TYPE);
-		if (!svc?.isConnected()) return {
-			text: "",
-			values: { shopifyConnected: false },
-			data: { shopifyConnected: false }
-		};
-		try {
-			const [shop, productCount, orderCount] = await Promise.all([
-				svc.getShop(),
-				svc.getProductCount().catch(() => null),
-				svc.getOrderCount().catch(() => null)
-			]);
-			return {
-				text: [
-					`Connected Shopify store: ${shop.name}`,
-					`Domain: ${shop.primaryDomain.url}`,
-					`Plan: ${shop.plan.displayName}`,
-					`Currency: ${shop.currencyCode}`,
-					productCount !== null ? `Products: ${productCount}` : null,
-					orderCount !== null ? `Orders: ${orderCount}` : null
-				].filter(Boolean).join("\n"),
-				values: {
-					shopifyConnected: true,
-					shopifyStoreName: shop.name,
-					shopifyDomain: shop.myshopifyDomain.slice(0, MAX_SHOPIFY_DOMAIN_CHARS),
-					shopifyPlan: shop.plan.displayName,
-					shopifyCurrency: shop.currencyCode,
-					shopifyProductCount: productCount ?? 0,
-					shopifyOrderCount: orderCount ?? 0
-				},
-				data: {
-					shopifyConnected: true,
-					shop,
-					productCount: productCount ?? 0,
-					orderCount: orderCount ?? 0,
-					truncated: false
-				}
-			};
-		} catch (err) {
-			logger.error({
-				src: "plugin:shopify:store-context",
-				error: err instanceof Error ? err.message : String(err)
-			}, "Failed to fetch Shopify store context");
-			return {
-				text: "Shopify store context unavailable.",
-				values: { shopifyConnected: false },
-				data: { shopifyConnected: false }
-			};
-		}
-	}
-};
-//#endregion
-//#region src/index.ts
-const shopifyPlugin = {
-	name: "shopify",
-	description: "Manage Shopify stores -- products, orders, inventory, customers",
-	actions: [...promoteSubactionsToActions(shopifyAction)],
-	providers: [storeContextProvider],
-	services: [ShopifyService],
-	autoEnable: { envKeys: ["SHOPIFY_ACCESS_TOKEN", "SHOPIFY_ACCOUNTS"] },
-	init: async (_config, runtime) => {
-		try {
-			getConnectorAccountManager(runtime).registerProvider(createShopifyConnectorAccountProvider(runtime));
-		} catch (err) {
-			logger.warn({
-				src: "plugin:shopify",
-				err: err instanceof Error ? err.message : String(err)
-			}, "Failed to register Shopify provider with ConnectorAccountManager");
-		}
-	}
-};
-//#endregion
-export { DEFAULT_SHOPIFY_ACCOUNT_ID, DEFAULT_SHOPIFY_ACCOUNT_ROLE, ShopifyService, createShopifyConnectorAccountProvider, shopifyPlugin as default, hasShopifyAccountConfig, normalizeShopifyAccountId, readShopifyAccounts, resolveShopifyAccount, resolveShopifyAccountId, resolveShopifyDefaultAccount };
-
-//# sourceMappingURL=index.js.map