lb_feedback_submit

Instructions

Implementation Reference

• src/tools/feedback.tools.ts:19-33 (handler)

  The handler function that executes the lb_feedback_submit tool logic. It sends a POST request with the feedback text to /api/v1/feedback and formats the result or error.

    async (params) => {
      try {
        const res = await client.request<MessageResponse>(
          "POST",
          "/api/v1/feedback",
          { feedback: params.feedback },
          undefined,
          "lb_feedback_submit",
        );
        return formatResult(res.data);
      } catch (e) {
        return formatErrorResult(e);
      }
    },
  );

• src/tools/feedback.tools.ts:11-17 (schema)

  Input schema using Zod validation: feedback string between 10-5000 characters.

  {
    feedback: z
      .string()
      .min(10)
      .max(5000)
      .describe("Feedback text (10-5000 characters)"),
  },

• src/tools/feedback.tools.ts:7-33 (registration)

  Registration of the tool via server.tool() within registerFeedbackTools(), called from index.ts line 61.

  export function registerFeedbackTools(server: McpServer, client: LBClient) {
    server.tool(
      "lb_feedback_submit",
      "Submit feedback, feature requests, or suggestions (10-5000 characters)",
      {
        feedback: z
          .string()
          .min(10)
          .max(5000)
          .describe("Feedback text (10-5000 characters)"),
      },
      { idempotentHint: false },
      async (params) => {
        try {
          const res = await client.request<MessageResponse>(
            "POST",
            "/api/v1/feedback",
            { feedback: params.feedback },
            undefined,
            "lb_feedback_submit",
          );
          return formatResult(res.data);
        } catch (e) {
          return formatErrorResult(e);
        }
      },
    );

• src/client/lb-client.ts:188-222 (helper)

  The request() method on LBClient that handles authentication and sends the HTTP request. Used by the handler to POST feedback to the API.

  async request<T>(
    method: string,
    path: string,
    body?: Record<string, unknown>,
    query?: Record<string, string>,
    toolName?: string,
  ): Promise<ApiSuccessResponse<T>> {
    await this.ensureAuth();
    const response = await this.doRequest<T>(method, path, body, query, toolName);
  
    // Single retry on 401
    if (response.status === "error" && response._statusCode === 401) {
      this.jwt = null;
      await this.ensureAuth();
      const retry = await this.doRequest<T>(method, path, body, query, toolName);
      if (retry.status === "error") {
        throw new LBApiError(
          retry._statusCode ?? 500,
          retry.error.code,
          retry.error.message,
        );
      }
      return retry as ApiSuccessResponse<T>;
    }
  
    if (response.status === "error") {
      throw new LBApiError(
        response._statusCode ?? 500,
        response.error.code,
        response.error.message,
      );
    }
  
    return response as ApiSuccessResponse<T>;
  }

• src/utils/response.ts:10-86 (helper)

  formatResult helper that formats successful API responses as MCP CallToolResult content. Used by the handler to return feedback submission results.

  export function formatResult(data: unknown): CallToolResult {
    const warnings: string[] = [];
    let cleaned: Record<string, unknown> | unknown = data;
  
    if (data && typeof data === "object") {
      const obj = { ...(data as Record<string, unknown>) };
  
      // Top-level warning string
      if ("warning" in obj && typeof obj.warning === "string") {
        warnings.push(obj.warning);
        delete obj.warning;
      }
  
      // balance_warning object (independent of warning)
      if ("balance_warning" in obj && obj.balance_warning && typeof obj.balance_warning === "object") {
        const bw = obj.balance_warning as Record<string, unknown>;
        const parts: string[] = [];
        if (typeof bw.warning === "string" && bw.warning.trim()) parts.push(bw.warning);
        if (typeof bw.daily_cost_estimate === "number")
          parts.push(`Daily cost estimate: $${bw.daily_cost_estimate.toFixed(2)}`);
        if (typeof bw.balance === "number")
          parts.push(`Balance: $${bw.balance.toFixed(2)}`);
        if (typeof bw.days_remaining === "number")
          parts.push(`Days remaining: ${bw.days_remaining.toFixed(1)}`);
        if (parts.length > 0) warnings.push(parts.join(" | "));
        delete obj.balance_warning;
      }
  
      cleaned = obj;
    }
  
    let text = JSON.stringify(cleaned, null, 2);
    for (const w of warnings) {
      text += `\n\n⚠️ Warning: ${w}`;
    }
  
    const notice = getUpdateNotice();
    if (notice) {
      text += `\n\n${notice}`;
    }
  
    return {
      content: [{ type: "text", text }],
    };
  }
  
  /**
   * Format a paginated API response as an MCP tool result.
   * Includes pagination metadata.
   */
  export function formatPaginatedResult(
    data: unknown,
    meta: { page: number; per_page: number; total: number; total_pages: number },
  ): CallToolResult {
    const result = {
      data,
      pagination: meta,
    };
    let text = JSON.stringify(result, null, 2);
  
    const notice = getUpdateNotice();
    if (notice) {
      text += `\n\n${notice}`;
    }
  
    return {
      content: [{ type: "text", text }],
    };
  }
  
  /** Format an error as an MCP tool error result. */
  export function formatErrorResult(error: unknown): CallToolResult {
    return {
      content: [{ type: "text", text: formatError(error) }],
      isError: true,
    };
  }