@elizaos/plugin-shopify 2.0.0-beta.1

package/dist/index.js

@@ -0,0 +1,1802 @@
+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