list_subscription_rate_plans

Instructions

Implementation Reference

• src/tools/subscriptions/listSubscriptionRatePlans.ts:59-68 (handler)

  Handler function for list_subscription_rate_plans: parses args with Zod schema, extracts subscriptionId, calls subscriptionService.listSubscriptionRatePlans(client, subscriptionId, params), wrapped in handleToolCall for error handling.

  async function handler(client: Client, args: Record<string, unknown> | undefined) {
    const parsed = schema.safeParse(args);
    if (!parsed.success) {
      return errorResult(parsed.error.errors.map((e) => e.message).join("; "));
    }
    const { subscriptionId, ...params } = parsed.data;
    return handleToolCall(() =>
      subscriptionService.listSubscriptionRatePlans(client, subscriptionId, params)
    );
  }

• src/tools/subscriptions/listSubscriptionRatePlans.ts:70-73 (handler)

  Exported Tool object pairing the definition with the handler function.

  export const listSubscriptionRatePlansTool: Tool = {
    definition,
    handler,
  };

• src/tools/subscriptions/listSubscriptionRatePlans.ts:31-57 (schema)

  Tool definition/inputSchema for list_subscription_rate_plans: name, description, and JSON Schema input properties (subscriptionId required; include, pageNo, itemPerPage, orderBy, sortBy, status, type optional).

  const definition = {
    name: "list_subscription_rate_plans",
    description:
      "List rate plans on a subscription. GET /subscriptions/{subscriptionId}/rateplans. Returns paginated rate plans (product rate plan ref, name, type, effectiveStartDate, charges when included). Optional: include, pageNo, itemPerPage, orderBy, sortBy, status (active|pause|cancel|archived), type (ongoing|prepaid|contract). status/type filters are case-insensitive.",
    inputSchema: {
      type: "object" as const,
      properties: {
        subscriptionId: { type: "string", description: "Subscription ID (required)" },
        include: { type: "string", description: "Attributes to include (e.g. rateplanCharge)" },
        pageNo: { type: "number", description: "Page number" },
        itemPerPage: { type: "number", description: "Items per page" },
        orderBy: { type: "string", description: "Sort column" },
        sortBy: { type: "string", description: "Sort direction" },
        status: {
          type: "string",
          enum: ["active", "pause", "cancel", "archived"],
          description: "Filter by rate plan status (case-insensitive)",
        },
        type: {
          type: "string",
          enum: ["ongoing", "prepaid", "contract"],
          description: "Filter by rate plan type (case-insensitive)",
        },
      },
      required: ["subscriptionId"],
    },
  };

• src/tools/subscriptions/listSubscriptionRatePlans.ts:10-29 (schema)

  Zod validation schema for list_subscription_rate_plans inputs: validates subscriptionId, include, pageNo, itemPerPage, orderBy, sortBy, status (case-insensitive enum), type (case-insensitive enum).

  const schema = z.object({
    subscriptionId: z.string().min(1, "subscriptionId is required"),
    include: z.string().optional(),
    pageNo: z.number().int().min(1).optional(),
    itemPerPage: z.number().int().min(1).optional(),
    orderBy: z.string().optional(),
    sortBy: z.string().optional(),
    status: z
      .preprocess(
        (value) => (typeof value === "string" ? value.toLowerCase() : value),
        z.enum(ratePlanStatuses)
      )
      .optional(),
    type: z
      .preprocess(
        (value) => (typeof value === "string" ? value.toLowerCase() : value),
        z.enum(ratePlanTypes)
      )
      .optional(),
  });

• src/services/subscriptionServices.ts:298-326 (helper)

  ListSubscriptionRatePlansParams interface and listSubscriptionRatePlans service function: builds query params from optional filters (include, pageNo, itemPerPage, orderBy, sortBy, status, type) and makes GET /subscriptions/{subscriptionId}/rateplans API call.

  export interface ListSubscriptionRatePlansParams {
    include?: string;
    pageNo?: number;
    itemPerPage?: number;
    orderBy?: string;
    sortBy?: string;
    status?: "active" | "pause" | "cancel" | "archived";
    type?: "ongoing" | "prepaid" | "contract";
  }
  
  /** List rate plans on a subscription. GET /subscriptions/{id}/rateplans */
  export async function listSubscriptionRatePlans(
    client: Client,
    subscriptionId: string,
    params?: ListSubscriptionRatePlansParams
  ): Promise<PaginatedResponse<unknown>> {
    const search = new URLSearchParams();
    if (params?.include) search.append("include", params.include);
    if (params?.pageNo != null) search.append("pageNo", String(params.pageNo));
    if (params?.itemPerPage != null) search.append("itemPerPage", String(params.itemPerPage));
    if (params?.orderBy) search.append("orderBy", params.orderBy ?? "");
    if (params?.sortBy) search.append("sortBy", params.sortBy ?? "");
    if (params?.status) search.append("status", params.status);
    if (params?.type) search.append("type", params.type);
    const q = search.toString();
    return client.get<PaginatedResponse<unknown>>(
      `/subscriptions/${subscriptionId}/rateplans${q ? `?${q}` : ""}`
    );
  }