@elizaos/plugin-shopify 2.0.3-beta.5 → 2.0.3-beta.7

package/dist/index.js

@@ -0,0 +1,1966 @@
+// src/index.ts
+import {
+  getConnectorAccountManager,
+  logger as logger9,
+  promoteSubactionsToActions
+} from "@elizaos/core";
+
+// src/accounts.ts
+var DEFAULT_SHOPIFY_ACCOUNT_ID = "default";
+var DEFAULT_SHOPIFY_ACCOUNT_ROLE = "OWNER";
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function readSetting(runtime, key) {
+  return nonEmptyString(runtime.getSetting(key));
+}
+function normalizeShopifyAccountId(value) {
+  return nonEmptyString(value) ?? DEFAULT_SHOPIFY_ACCOUNT_ID;
+}
+function resolveShopifyAccountId(runtime, options) {
+  const requested = nonEmptyString(options?.accountId) ?? nonEmptyString(options?.shopifyAccountId);
+  if (requested) return requested;
+  const configuredDefault = readSetting(runtime, "SHOPIFY_DEFAULT_ACCOUNT_ID") ?? readSetting(runtime, "SHOPIFY_ACCOUNT_ID");
+  const accounts = readShopifyAccounts(runtime);
+  const defaultAccount = resolveShopifyDefaultAccount(
+    accounts,
+    configuredDefault
+  );
+  return defaultAccount?.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(source[key]);
+      if (value) return value;
+    }
+  }
+  return void 0;
+}
+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(record.label ?? record.displayName)
+  };
+}
+function addAccount(accounts, account) {
+  if (account) {
+    accounts.set(account.accountId, account);
+  }
+}
+function readShopifyAccounts(runtime) {
+  const accounts = /* @__PURE__ */ new Map();
+  const characterConfig = runtime.character?.settings?.shopify;
+  const characterAccounts = characterConfig?.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(runtime, "SHOPIFY_ACCOUNTS")
+  )) {
+    addAccount(accounts, accountFromRecord(record));
+  }
+  const storeDomain = readSetting(runtime, "SHOPIFY_STORE_DOMAIN");
+  const accessToken = readSetting(runtime, "SHOPIFY_ACCESS_TOKEN");
+  if (storeDomain && accessToken) {
+    addAccount(accounts, {
+      accountId: normalizeShopifyAccountId(
+        readSetting(runtime, "SHOPIFY_ACCOUNT_ID") ?? readSetting(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) {
+  const normalized = normalizeShopifyAccountId(accountId);
+  return resolveShopifyAccount(accounts, normalized) ?? resolveShopifyAccount(accounts, DEFAULT_SHOPIFY_ACCOUNT_ID) ?? accounts.find((account) => account.role === DEFAULT_SHOPIFY_ACCOUNT_ROLE) ?? accounts[0] ?? null;
+}
+function hasShopifyAccountConfig(runtime, options) {
+  const accountId = resolveShopifyAccountId(runtime, options);
+  return Boolean(
+    resolveShopifyAccount(readShopifyAccounts(runtime), accountId)
+  );
+}
+
+// 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));
+}
+var 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" }
+};
+
+// src/actions/manage-customers.ts
+import { logger as logger2, ModelType } from "@elizaos/core";
+
+// src/services/ShopifyService.ts
+import { logger, Service } from "@elizaos/core";
+
+// src/shopify-client.ts
+var API_VERSION = "2025-04";
+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;
+  }
+};
+
+// src/services/ShopifyService.ts
+var SHOPIFY_SERVICE_TYPE = "shopify";
+var PRODUCT_FIELDS = `
+  id
+  title
+  handle
+  status
+  descriptionHtml
+  productType
+  vendor
+  totalInventory
+  featuredImage { url altText }
+  variants(first: 5) {
+    edges { node { id title price sku inventoryQuantity } }
+  }
+`;
+var 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 } } } }
+  }
+`;
+var CUSTOMER_FIELDS = `
+  id
+  displayName
+  email
+  phone
+  ordersCount: numberOfOrders
+  totalSpentV2: amountSpent { 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;
+  async stop() {
+    this.clients.clear();
+  }
+  static async start(runtime) {
+    const svc = new _ShopifyService(runtime);
+    const accounts = readShopifyAccounts(runtime);
+    const requestedDefault = normalizeShopifyAccountId(
+      runtime.getSetting("SHOPIFY_DEFAULT_ACCOUNT_ID") ?? runtime.getSetting("SHOPIFY_ACCOUNT_ID")
+    );
+    const defaultAccount = resolveShopifyDefaultAccount(
+      accounts,
+      requestedDefault
+    );
+    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;
+  }
+  // -----------------------------------------------------------------------
+  // Helpers
+  // -----------------------------------------------------------------------
+  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;
+  }
+  // -----------------------------------------------------------------------
+  // Shop
+  // -----------------------------------------------------------------------
+  async getShop(accountId) {
+    const data = await this.requireClient(accountId).query(`{
+      shop {
+        name
+        email
+        myshopifyDomain
+        plan { displayName }
+        currencyCode
+        primaryDomain { url }
+      }
+    }`);
+    return data.shop;
+  }
+  // -----------------------------------------------------------------------
+  // Products
+  // -----------------------------------------------------------------------
+  async listProducts(opts = {}, accountId) {
+    const first = Math.min(opts.first ?? 10, 50);
+    const variables = { first };
+    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;
+  }
+  // -----------------------------------------------------------------------
+  // Orders
+  // -----------------------------------------------------------------------
+  async listOrders(opts = {}, accountId) {
+    const first = Math.min(opts.first ?? 10, 50);
+    const variables = { first };
+    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} }
+    }`;
+    const data = await this.requireClient(accountId).query(gql, {
+      id
+    });
+    return data.order;
+  }
+  async fulfillOrder(orderId, accountId) {
+    const foGql = `query FulfillmentOrders($id: ID!) {
+      order(id: $id) {
+        fulfillmentOrders(first: 5) {
+          edges {
+            node {
+              id
+              status
+              lineItems(first: 50) {
+                edges { node { id totalQuantity } }
+              }
+            }
+          }
+        }
+      }
+    }`;
+    const foData = await this.requireClient(
+      accountId
+    ).query(foGql, { 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;
+  }
+  // -----------------------------------------------------------------------
+  // Customers
+  // -----------------------------------------------------------------------
+  async listCustomers(opts = {}, accountId) {
+    const first = Math.min(opts.first ?? 10, 50);
+    const variables = { first };
+    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
+    };
+  }
+  // -----------------------------------------------------------------------
+  // Inventory
+  // -----------------------------------------------------------------------
+  async checkInventory(inventoryItemId, accountId) {
+    const gql = `query CheckInventory($id: ID!) {
+      inventoryItem(id: $id) {
+        id
+        tracked
+        inventoryLevels(first: 10) {
+          edges { node { id available location { id name } } }
+        }
+      }
+    }`;
+    const data = await this.requireClient(
+      accountId
+    ).query(gql, { 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 gql = `mutation AdjustInventory($input: InventoryAdjustQuantitiesInput!) {
+      inventoryAdjustQuantities(input: $input) {
+        inventoryAdjustmentGroup { reason }
+        userErrors { field message }
+      }
+    }`;
+    const data = await this.requireClient(
+      accountId
+    ).query(gql, {
+      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) {
+    const gql = `{
+      locations(first: 20) {
+        edges { node { id name isActive } }
+      }
+    }`;
+    const data = await this.requireClient(accountId).query(gql);
+    return data.locations.edges.map((e) => e.node);
+  }
+  // -----------------------------------------------------------------------
+  // Counts (for provider context)
+  // -----------------------------------------------------------------------
+  async getProductCount(accountId) {
+    const data = await this.requireClient(
+      accountId
+    ).query(`{
+      productsCount { count }
+    }`);
+    return data.productsCount.count;
+  }
+  async getOrderCount(accountId) {
+    const data = await this.requireClient(
+      accountId
+    ).query(`{
+      ordersCount { count }
+    }`);
+    return data.ordersCount.count;
+  }
+};
+
+// src/actions/confirmation.ts
+import { gateDestructiveConfirmation } from "@elizaos/core";
+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);
+}
+async function requireShopifyConfirmation(args) {
+  const gate = await gateDestructiveConfirmation({
+    runtime: args.runtime,
+    message: args.message,
+    actionName: args.actionName,
+    pendingKey: args.pendingKey,
+    prompt: `${args.preview} Reply yes to confirm or no to cancel.`,
+    callback: args.callback
+  });
+  if (gate.status === "confirmed") return null;
+  if (gate.status === "pending") {
+    return {
+      success: true,
+      text: `${args.preview} Reply yes to confirm or no to cancel.`,
+      data: { requiresConfirmation: true, preview: args.preview, awaitingUserInput: true }
+    };
+  }
+  return { success: true, text: "Cancelled.", data: { cancelled: true } };
+}
+
+// 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;
+  }
+}
+
+// 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(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(candidate.query);
+  if (action === "list") {
+    return { action, query };
+  }
+  if (action === "search" && query) {
+    return { action, query };
+  }
+  return null;
+}
+async function classifyIntent(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 response = await runtime.useModel(ModelType.TEXT_SMALL, { prompt });
+    const parsed = parseJsonObject(response);
+    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(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}):
+
+${lines.join("\n")}${more}`
+      });
+    }
+    return { success: true, data: { customers: result.customers } };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger2.error(
+      { src: "plugin:shopify:manage-customers", error: msg },
+      "Customer action failed"
+    );
+    await callback?.({ text: `Shopify customer operation failed: ${msg}` });
+    return { success: false, error: msg };
+  }
+}
+
+// src/actions/manage-inventory.ts
+import { logger as logger3, ModelType as ModelType2 } from "@elizaos/core";
+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 readNullableString2(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 = readNullableString2(candidate.productQuery);
+    return productQuery ? { action, productQuery } : null;
+  }
+  if (action === "adjust") {
+    const productQuery = readNullableString2(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: readNullableString2(candidate.reason)
+    };
+  }
+  return null;
+}
+async function classifyIntent2(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 response = await runtime.useModel(ModelType2.TEXT_SMALL, { prompt });
+    const parsed = parseJsonObject(response);
+    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 classifyIntent2(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:
+
+${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 variantNumericId = firstVariant.id.split("/").pop();
+      const inventoryItemId = `gid://shopify/InventoryItem/${variantNumericId}`;
+      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}):
+
+${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 variantNumericId = firstVariant.id.split("/").pop();
+      const inventoryItemId = `gid://shopify/InventoryItem/${variantNumericId}`;
+      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");
+      const confirmBlock = await requireShopifyConfirmation({
+        runtime,
+        message,
+        actionName: "SHOPIFY_MANAGE_INVENTORY",
+        pendingKey: `inventory:${product.id}:${intent.delta}`,
+        preview,
+        callback
+      });
+      if (confirmBlock) return confirmBlock;
+      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);
+    logger3.error(
+      { src: "plugin:shopify:manage-inventory", error: msg },
+      "Inventory action failed"
+    );
+    await callback?.({ text: `Shopify inventory operation failed: ${msg}` });
+    return { success: false, error: msg };
+  }
+}
+
+// src/actions/manage-orders.ts
+import { logger as logger4, ModelType as ModelType3 } from "@elizaos/core";
+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 readNullableString3(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: readNullableString3(candidate.query) };
+  }
+  if (action === "get" || action === "fulfill") {
+    const orderName = readNullableString3(candidate.orderName);
+    return orderName ? { action, orderName } : null;
+  }
+  return null;
+}
+async function classifyIntent3(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 response = await runtime.useModel(ModelType3.TEXT_SMALL, { prompt });
+    const parsed = parseJsonObject(response);
+    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 classifyIntent3(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}):
+
+${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");
+      const confirmBlock = await requireShopifyConfirmation({
+        runtime,
+        message,
+        actionName: "SHOPIFY_FULFILL_ORDER",
+        pendingKey: `fulfill:${order.id}`,
+        preview,
+        callback
+      });
+      if (confirmBlock) return confirmBlock;
+      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);
+    logger4.error(
+      { src: "plugin:shopify:manage-orders", error: msg },
+      "Order action failed"
+    );
+    await callback?.({ text: `Shopify order operation failed: ${msg}` });
+    return { success: false, error: msg };
+  }
+}
+
+// src/actions/manage-products.ts
+import { logger as logger5, ModelType as ModelType4 } from "@elizaos/core";
+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 readNullableString4(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: readNullableString4(candidate.query) };
+  }
+  if (action === "create") {
+    const title = readNullableString4(candidate.title);
+    if (!title) return null;
+    return {
+      action,
+      title,
+      description: readNullableString4(candidate.description),
+      productType: readNullableString4(candidate.productType),
+      vendor: readNullableString4(candidate.vendor),
+      status: readNullableString4(candidate.status)
+    };
+  }
+  if (action === "update") {
+    const identifier = readNullableString4(candidate.identifier);
+    if (!identifier) return null;
+    return {
+      action,
+      identifier,
+      title: readNullableString4(candidate.title),
+      description: readNullableString4(candidate.description),
+      status: readNullableString4(candidate.status)
+    };
+  }
+  return null;
+}
+async function classifyIntent4(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 response = await runtime.useModel(ModelType4.TEXT_SMALL, { prompt });
+    const parsed = parseJsonObject(response);
+    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 classifyIntent4(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):
+
+${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");
+      const confirmBlock = await requireShopifyConfirmation({
+        runtime,
+        message,
+        actionName: "SHOPIFY_CREATE_PRODUCT",
+        pendingKey: `create:${intent.title}`,
+        preview,
+        callback
+      });
+      if (confirmBlock) return confirmBlock;
+      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");
+      const confirmBlock = await requireShopifyConfirmation({
+        runtime,
+        message,
+        actionName: "SHOPIFY_UPDATE_PRODUCT",
+        pendingKey: `update:${target.id}`,
+        preview,
+        callback
+      });
+      if (confirmBlock) return confirmBlock;
+      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);
+    logger5.error(
+      { src: "plugin:shopify:manage-products", error: msg },
+      "Product action failed"
+    );
+    await callback?.({ text: `Shopify product operation failed: ${msg}` });
+    return { success: false, error: msg };
+  }
+}
+
+// src/actions/search-store.ts
+import { logger as logger6, ModelType as ModelType5 } from "@elizaos/core";
+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 classifyIntent5(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 response = await runtime.useModel(ModelType5.TEXT_SMALL, { prompt });
+    const parsed = parseJsonObject(response);
+    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 classifyIntent5(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}):
+${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}):
+${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}):
+${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}":
+
+${sections.join("\n\n")}`
+    });
+    return { success: true, data };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger6.error(
+      { src: "plugin:shopify:search-store", error: msg },
+      "Store search failed"
+    );
+    await callback?.({ text: `Shopify search failed: ${msg}` });
+    return { success: false, error: msg };
+  }
+}
+
+// src/actions/shopify.ts
+var ALL_OPS = [
+  "search",
+  "products",
+  "inventory",
+  "orders",
+  "customers"
+];
+var 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);
+  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;
+}
+var 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: [
+    // Legacy per-op action names — kept as similes so older callers still resolve.
+    "MANAGE_SHOPIFY_PRODUCTS",
+    "MANAGE_SHOPIFY_INVENTORY",
+    "MANAGE_SHOPIFY_ORDERS",
+    "MANAGE_SHOPIFY_CUSTOMERS",
+    // Common shorthands the planner might emit.
+    "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: "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"] }
+      }
+    ]
+  ]
+};
+
+// src/connector-account-provider.ts
+import {
+  logger as logger7,
+  readRequestedConnectorRole
+} from "@elizaos/core";
+var SHOPIFY_PROVIDER_NAME = "shopify";
+var DEFAULT_PURPOSES = [
+  "admin"
+];
+function nonEmptyString2(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function readSetting2(runtime, key) {
+  return nonEmptyString2(runtime.getSetting?.(key));
+}
+function readClientConfig(runtime) {
+  const clientId = readSetting2(runtime, "SHOPIFY_OAUTH_CLIENT_ID");
+  const clientSecret = readSetting2(runtime, "SHOPIFY_OAUTH_CLIENT_SECRET");
+  const redirectUri = readSetting2(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
+    }
+  }));
+}
+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 = nonEmptyString2(metadataInput.storeDomain) ?? nonEmptyString2(metadataInput.shopDomain) ?? nonEmptyString2(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"
+      ];
+      const params = new URLSearchParams({
+        client_id: config.clientId,
+        scope: scopes.join(","),
+        redirect_uri: redirectUri,
+        state: request.flow.state
+      });
+      return {
+        authUrl: `https://${storeDomain}/admin/oauth/authorize?${params.toString()}`,
+        metadata: {
+          ...request.metadata,
+          requestedScopes: scopes,
+          redirectUri,
+          storeDomain
+        }
+      };
+    },
+    completeOAuth: async (request, _manager) => {
+      const code = nonEmptyString2(request.code);
+      if (!code) {
+        throw new Error(
+          "Shopify OAuth callback is missing an authorization code."
+        );
+      }
+      const flowMetadata = request.flow.metadata ?? {};
+      const storeDomainRaw = nonEmptyString2(flowMetadata.storeDomain) ?? nonEmptyString2(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 shopPayload = await fetchShopInfo(storeDomain, tokens.access_token);
+      const shop = shopPayload.shop;
+      const externalId = nonEmptyString2(
+        shop?.myshopify_domain ?? shop?.domain ?? storeDomain
+      );
+      if (!externalId) {
+        throw new Error(
+          "Shopify shop payload did not include a usable domain."
+        );
+      }
+      const role = readRequestedConnectorRole(
+        flowMetadata,
+        "plugin:shopify:connector"
+      );
+      const accountPatch = {
+        provider: SHOPIFY_PROVIDER_NAME,
+        role,
+        purpose: DEFAULT_PURPOSES,
+        accessGate: "open",
+        status: "connected",
+        externalId,
+        displayHandle: externalId,
+        label: nonEmptyString2(shop?.name) ?? externalId,
+        metadata: {
+          authMethod: "oauth",
+          storeDomain,
+          shopId: shop?.id ?? null,
+          shopName: nonEmptyString2(shop?.name) ?? null,
+          shopEmail: nonEmptyString2(shop?.email) ?? null,
+          planName: nonEmptyString2(shop?.plan_name) ?? null,
+          currency: nonEmptyString2(shop?.currency) ?? null,
+          countryCode: nonEmptyString2(shop?.country_code) ?? null,
+          grantedScopes: parseScopes(tokens.scope)
+        }
+      };
+      logger7.info(
+        {
+          src: "plugin:shopify:connector",
+          storeDomain
+        },
+        "Shopify OAuth completed"
+      );
+      return {
+        account: accountPatch,
+        flow: { status: "completed" }
+      };
+    }
+  };
+}
+
+// src/providers/store-context.ts
+import { logger as logger8 } from "@elizaos/core";
+var MAX_SHOPIFY_DOMAIN_CHARS = 200;
+var 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)
+      ]);
+      const contextText = [
+        `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");
+      return {
+        text: contextText,
+        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) {
+      logger8.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 }
+      };
+    }
+  }
+};
+
+// src/index.ts
+var shopifyPlugin = {
+  name: "shopify",
+  description: "Manage Shopify stores -- products, orders, inventory, customers",
+  actions: [...promoteSubactionsToActions(shopifyAction)],
+  providers: [storeContextProvider],
+  services: [ShopifyService],
+  // Self-declared auto-enable: activate when the SHOPIFY_ACCESS_TOKEN env var
+  // is set. (Manifest-only auto-enable — see ./auto-enable.ts.)
+  autoEnable: {
+    envKeys: ["SHOPIFY_ACCESS_TOKEN", "SHOPIFY_ACCOUNTS"]
+  },
+  init: async (_config, runtime) => {
+    try {
+      const manager = getConnectorAccountManager(runtime);
+      manager.registerProvider(createShopifyConnectorAccountProvider(runtime));
+    } catch (err) {
+      logger9.warn(
+        {
+          src: "plugin:shopify",
+          err: err instanceof Error ? err.message : String(err)
+        },
+        "Failed to register Shopify provider with ConnectorAccountManager"
+      );
+    }
+  },
+  async dispose(runtime) {
+    await runtime.getService(ShopifyService.serviceType)?.stop();
+  }
+};
+var index_default = shopifyPlugin;
+export {
+  DEFAULT_SHOPIFY_ACCOUNT_ID,
+  DEFAULT_SHOPIFY_ACCOUNT_ROLE,
+  ShopifyService,
+  createShopifyConnectorAccountProvider,
+  index_default as default,
+  hasShopifyAccountConfig,
+  normalizeShopifyAccountId,
+  readShopifyAccounts,
+  resolveShopifyAccount,
+  resolveShopifyAccountId,
+  resolveShopifyDefaultAccount
+};
+//# sourceMappingURL=index.js.map