@hanhnd/agent-kit 1.0.43 → 1.0.44

package/README.md

@@ -27,6 +27,29 @@ Claude Code and Codex plugin manifests already use this package:
 }
 ```
 
+## API Token Scopes
+
+Integration tools call the Atlassian REST APIs with scoped API tokens. Create each token at [id.atlassian.com/manage-profile/security/api-tokens](https://id.atlassian.com/manage-profile/security/api-tokens) ("Create API token with scopes") and grant the scopes below.
+
+| Token                  | Scopes                                                                                                                         |
+| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
+| `BITBUCKET_API_TOKEN`  | `read:pullrequest:bitbucket`, `write:pullrequest:bitbucket`, `read:repository:bitbucket`, `read:workspace:bitbucket`, `read:user:bitbucket` |
+| `JIRA_API_TOKEN`       | `read:jira-work`                                                                                                               |
+| `CONFLUENCE_API_TOKEN` | `read:page:confluence`                                                                                                         |
+
+Per tool:
+
+| Tool                            | Scopes                                                                                                                        |
+| ------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
+| `kit_get_bitbucket_pr`          | `read:pullrequest:bitbucket`; `read:repository:bitbucket` for the diff (the PR diff redirects to the repository diff)         |
+| `kit_get_bitbucket_pr_comments` | `read:pullrequest:bitbucket`                                                                                                  |
+| `kit_create_bitbucket_pr`       | `read:pullrequest:bitbucket`, `write:pullrequest:bitbucket`; `read:workspace:bitbucket` for reviewers given by name; `read:user:bitbucket` to skip the PR author |
+| `kit_find_bitbucket_reviewers`  | `read:workspace:bitbucket`; `read:user:bitbucket` to flag the PR author                                                       |
+| `kit_jira_get_ticket`           | `read:jira-work`                                                                                                              |
+| `kit_confluence_get_page`       | `read:page:confluence`                                                                                                        |
+
+A missing scope surfaces as a 401/403; the error message lists the scopes the tool needs.
+
 ## Development
 
 From the repository root:

package/dist/mcp/bitbucket.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mcp/bitbucket.test.js

@@ -0,0 +1,335 @@
+import * as assert from 'node:assert/strict';
+import { afterEach, describe, mock, test } from 'node:test';
+import { MAX_PAGES, handleCreateBitbucketPr, handleFindBitbucketReviewers, handleGetBitbucketPrComments, matchReviewers, normalizeName, resolveBitbucketPr, resolveBitbucketRepo, } from './integration.js';
+const API = 'https://api.bitbucket.org/2.0';
+const PR_URL = 'https://bitbucket.org/acme/web-app/pull-requests/42';
+process.env.BITBUCKET_USER_EMAIL = 'dev@acme.test';
+process.env.BITBUCKET_API_TOKEN = 'bb-token';
+process.env.BITBUCKET_DEFAULT_WORKSPACE = 'acme';
+/** Replace the global fetch for one test with a queue of responses; `afterEach` restores it. */
+function stubFetch(responses) {
+    const calls = [];
+    mock.method(globalThis, 'fetch', async (input, init) => {
+        calls.push({
+            url: String(input),
+            method: init?.method ?? 'GET',
+            body: init?.body ? JSON.parse(String(init.body)) : undefined,
+        });
+        const next = responses[Math.min(calls.length - 1, responses.length - 1)];
+        return new Response(typeof next.body === 'string' ? next.body : JSON.stringify(next.body), {
+            status: next.status,
+            headers: { 'content-type': 'application/json' },
+        });
+    });
+    return calls;
+}
+afterEach(() => mock.restoreAll());
+describe('resolveBitbucketPr / resolveBitbucketRepo', () => {
+    test('B1: PR URL resolves to workspace, repo and id', () => {
+        assert.deepEqual(resolveBitbucketPr(PR_URL), { ok: true, ws: 'acme', repo: 'web-app', prId: 42 });
+    });
+    test('B2: numeric PR id uses the default workspace', () => {
+        assert.deepEqual(resolveBitbucketPr('7', undefined, 'api'), { ok: true, ws: 'acme', repo: 'api', prId: 7 });
+    });
+    test('B3: numeric PR id without repoSlug is rejected', () => {
+        assert.equal(resolveBitbucketPr('7').ok, false);
+    });
+    test('B4: repo accepts URL, workspace/repo pair, clone URL and bare slug', () => {
+        const expected = { ok: true, ws: 'acme', repo: 'web-app' };
+        assert.deepEqual(resolveBitbucketRepo('https://bitbucket.org/acme/web-app/src/main/'), expected);
+        assert.deepEqual(resolveBitbucketRepo('acme/web-app'), expected);
+        assert.deepEqual(resolveBitbucketRepo('git@bitbucket.org:acme/web-app.git'), expected);
+        assert.deepEqual(resolveBitbucketRepo('web-app'), expected);
+        assert.deepEqual(resolveBitbucketRepo('web-app', 'other'), { ok: true, ws: 'other', repo: 'web-app' });
+    });
+    test('B5: slugs with URL-breaking characters are rejected', () => {
+        assert.equal(resolveBitbucketRepo('acme/web app').ok, false);
+        assert.equal(resolveBitbucketRepo('../evil').ok, false);
+    });
+});
+const SELF_UUID = '{11111111-1111-1111-1111-111111111111}';
+const MEMBERS = [
+    { uuid: '{aaaaaaaa-0000-0000-0000-000000000001}', display_name: 'Trần Văn Điền', nickname: 'dientv' },
+    { uuid: '{aaaaaaaa-0000-0000-0000-000000000002}', display_name: 'Nguyễn Tiến Dũng', nickname: 'dungnt' },
+    { uuid: '{aaaaaaaa-0000-0000-0000-000000000003}', display_name: 'Lê Dũng', nickname: 'dungle' },
+    { uuid: SELF_UUID, display_name: 'Ngô Hạnh', nickname: 'hanhnd' },
+];
+const member = (i) => ({
+    uuid: MEMBERS[i].uuid,
+    displayName: MEMBERS[i].display_name,
+    nickname: MEMBERS[i].nickname,
+});
+/** Route requests by URL (lookups run concurrently, so order is not stable); unrouted → 500. */
+function stubRoutes(route) {
+    const calls = [];
+    mock.method(globalThis, 'fetch', async (input, init) => {
+        const url = String(input);
+        const method = init?.method ?? 'GET';
+        calls.push({ url, method, body: init?.body ? JSON.parse(String(init.body)) : undefined });
+        const res = route(url, method) ?? { status: 500, body: `unrouted ${method} ${url}` };
+        return new Response(typeof res.body === 'string' ? res.body : JSON.stringify(res.body), {
+            status: res.status,
+            headers: { 'content-type': 'application/json' },
+        });
+    });
+    return calls;
+}
+/** Workspace members split over two pages, the current user, and a 201 for PR creation. */
+function bitbucketRoutes(overrides = () => undefined) {
+    return (url, method) => {
+        const hit = overrides(url, method);
+        if (hit)
+            return hit;
+        if (url === `${API}/workspaces/acme/members?pagelen=100`) {
+            return {
+                status: 200,
+                body: { values: MEMBERS.slice(0, 2).map((user) => ({ user })), next: `${API}/workspaces/acme/members?page=2` },
+            };
+        }
+        if (url === `${API}/workspaces/acme/members?page=2`) {
+            return { status: 200, body: { values: MEMBERS.slice(2).map((user) => ({ user })) } };
+        }
+        if (url === `${API}/user`)
+            return { status: 200, body: { uuid: SELF_UUID } };
+        if (method === 'POST')
+            return { status: 201, body: created };
+        return undefined;
+    };
+}
+const created = {
+    id: 101,
+    title: 'Add login',
+    state: 'OPEN',
+    draft: true,
+    source: { branch: { name: 'feature/login' } },
+    destination: { branch: { name: 'develop' } },
+    reviewers: [{ display_name: 'Bob' }],
+    links: { html: { href: 'https://bitbucket.org/acme/web-app/pull-requests/101' } },
+};
+const postOf = (calls) => calls.find((c) => c.method === 'POST');
+describe('matchReviewers / normalizeName', () => {
+    const members = MEMBERS.map((_, i) => member(i));
+    test('N1: normalizeName strips Vietnamese diacritics including đ', () => {
+        assert.equal(normalizeName('  Trần Văn Điền '), 'tran van dien');
+    });
+    test('N2: a single word matches a whole word of the display name, accent-insensitive', () => {
+        const r = matchReviewers(['Dien'], members);
+        assert.deepEqual(r.resolved, [{ query: 'Dien', member: member(0) }]);
+    });
+    test('N3: a word shared by several members is ambiguous, never guessed', () => {
+        const r = matchReviewers(['Dung'], members);
+        assert.equal(r.resolved.length, 0);
+        assert.deepEqual(r.ambiguous[0].candidates.map((c) => c.uuid), [member(1).uuid, member(2).uuid]);
+    });
+    test('N4: full name, nickname and multi-word queries disambiguate', () => {
+        const r = matchReviewers(['nguyen tien dung', 'dungle', 'Le Dung'], members);
+        assert.deepEqual(r.resolved.map((x) => x.member.uuid), [member(1).uuid, member(2).uuid, member(2).uuid]);
+    });
+    test('N5: partial words do not match', () => {
+        assert.deepEqual(matchReviewers(['Die'], members).unmatched, ['Die']);
+    });
+});
+describe('handleCreateBitbucketPr', () => {
+    test('C1: POSTs the documented body and renders id + URL', async () => {
+        const calls = stubRoutes(bitbucketRoutes());
+        const text = (await handleCreateBitbucketPr({
+            repository: 'acme/web-app',
+            title: ' Add login ',
+            sourceBranch: 'feature/login',
+            destinationBranch: 'develop',
+            description: 'Body',
+            closeSourceBranch: true,
+            draft: true,
+            reviewers: ['504c3b62-8120-4f0c-a7bc-87800b9d6f70'],
+        })).content[0].text;
+        const post = postOf(calls);
+        assert.ok(post);
+        assert.equal(post.url, `${API}/repositories/acme/web-app/pullrequests`);
+        assert.deepEqual(post.body, {
+            title: 'Add login',
+            source: { branch: { name: 'feature/login' } },
+            destination: { branch: { name: 'develop' } },
+            description: 'Body',
+            close_source_branch: true,
+            draft: true,
+            reviewers: [{ uuid: '{504c3b62-8120-4f0c-a7bc-87800b9d6f70}' }],
+        });
+        assert.ok(!calls.some((c) => c.url.includes('/members')), 'UUID-only reviewers need no member lookup');
+        assert.match(text, /Created PR #101: Add login/);
+        assert.match(text, /pull-requests\/101/);
+        assert.match(text, /feature\/login → develop/);
+        assert.match(text, /\(draft\)/);
+        assert.match(text, /Reviewers:\*\* Bob/);
+    });
+    test('C2: omits destination so Bitbucket defaults to the main branch; no lookups without reviewers', async () => {
+        const calls = stubRoutes(bitbucketRoutes());
+        await handleCreateBitbucketPr({ repository: 'web-app', title: 'T', sourceBranch: 'feat' });
+        assert.equal(calls.length, 1);
+        assert.deepEqual(postOf(calls)?.body, { title: 'T', source: { branch: { name: 'feat' } } });
+    });
+    test('C3: names resolve across member pages, dedupe, and drop the PR author', async () => {
+        const calls = stubRoutes(bitbucketRoutes());
+        const text = (await handleCreateBitbucketPr({
+            repository: 'acme/web-app',
+            title: 'T',
+            sourceBranch: 'f',
+            reviewers: ['Dien', 'dientv', 'Le Dung', 'Hanh'],
+        })).content[0].text;
+        assert.deepEqual(postOf(calls)?.body, {
+            title: 'T',
+            source: { branch: { name: 'f' } },
+            reviewers: [{ uuid: member(0).uuid }, { uuid: member(2).uuid }],
+        });
+        assert.match(text, /PR author\) were named as a reviewer — skipped/);
+    });
+    test('C4: ambiguous or unknown names abort before any PR is created', async () => {
+        const calls = stubRoutes(bitbucketRoutes());
+        const text = (await handleCreateBitbucketPr({
+            repository: 'acme/web-app',
+            title: 'T',
+            sourceBranch: 'f',
+            reviewers: ['Dung', 'Zed'],
+        })).content[0].text;
+        assert.equal(postOf(calls), undefined);
+        assert.match(text, /PR not created/);
+        assert.match(text, /"Dung" matches 2 members/);
+        assert.match(text, /Nguyễn Tiến Dũng \(@dungnt\)/);
+        assert.match(text, /"Zed" matches no workspace member/);
+    });
+    test('C5: a 403 on the member list names the missing scope', async () => {
+        stubRoutes(bitbucketRoutes((url) => (url.includes('/members') ? { status: 403, body: {} } : undefined)));
+        const text = (await handleCreateBitbucketPr({ repository: 'acme/web-app', title: 'T', sourceBranch: 'f', reviewers: ['Dien'] })).content[0].text;
+        assert.match(text, /read:workspace:bitbucket/);
+    });
+    test('C5b: the member-list scope hint is not repeated by the generic scope hint', async () => {
+        stubRoutes(bitbucketRoutes((url) => (url.includes('/members') ? { status: 403, body: {} } : undefined)));
+        const text = (await handleCreateBitbucketPr({ repository: 'acme/web-app', title: 'T', sourceBranch: 'f', reviewers: ['Dien'] })).content[0].text;
+        assert.doesNotMatch(text, /Check the API token has these scopes/);
+    });
+    test('C6: without read:user scope the author is not filtered, but creation proceeds', async () => {
+        const calls = stubRoutes(bitbucketRoutes((url) => (url.endsWith('/user') ? { status: 403, body: {} } : undefined)));
+        await handleCreateBitbucketPr({ repository: 'acme/web-app', title: 'T', sourceBranch: 'f', reviewers: ['Dien'] });
+        assert.deepEqual((postOf(calls)?.body).reviewers, [{ uuid: member(0).uuid }]);
+    });
+    test('C7: 400 surfaces the Bitbucket error message', async () => {
+        stubRoutes(() => ({
+            status: 400,
+            body: { type: 'error', error: { message: 'There are no changes to be pulled' } },
+        }));
+        const text = (await handleCreateBitbucketPr({ repository: 'acme/web-app', title: 'T', sourceBranch: 'f' }))
+            .content[0].text;
+        assert.match(text, /API error 400: There are no changes to be pulled/);
+    });
+});
+describe('handleFindBitbucketReviewers', () => {
+    test('F1: reports matched, skipped-self, ambiguous and unknown names', async () => {
+        stubRoutes(bitbucketRoutes());
+        const text = (await handleFindBitbucketReviewers({ names: ['Dien', 'Hanh', 'Dung', 'Zed'] })).content[0].text;
+        assert.match(text, /## Reviewer lookup \(acme\)/);
+        assert.match(text, /✅ Trần Văn Điền \(@dientv\) \{aaaaaaaa-0000-0000-0000-000000000001\}/);
+        assert.match(text, /PR author\) were named — skipped/);
+        assert.match(text, /"Dung" matches 2 members/);
+        assert.match(text, /"Zed" matches no workspace member/);
+    });
+    test('F2: an invalid workspace slug is rejected before any request', async () => {
+        const calls = stubRoutes(bitbucketRoutes());
+        const text = (await handleFindBitbucketReviewers({ names: ['Dien'], workspace: '../x' })).content[0].text;
+        assert.equal(calls.length, 0);
+        assert.match(text, /Invalid workspace slug/);
+    });
+});
+function comment(id, extra = {}) {
+    return {
+        id,
+        created_on: '2026-10-01T10:00:00Z',
+        content: { raw: `body ${id}` },
+        user: { display_name: `user${id}` },
+        deleted: false,
+        ...extra,
+    };
+}
+describe('handleGetBitbucketPrComments', () => {
+    test('M1: follows next links and threads general + inline comments', async () => {
+        const calls = stubFetch([
+            {
+                status: 200,
+                body: {
+                    values: [comment(1), comment(2, { inline: { path: 'src/a.ts', to: 12 } })],
+                    next: `${API}/repositories/acme/web-app/pullrequests/42/comments?pagelen=100&page=2`,
+                },
+            },
+            {
+                status: 200,
+                body: {
+                    values: [
+                        comment(3, { parent: { id: 2 }, inline: { path: 'src/a.ts', to: 12 } }),
+                        comment(4, {
+                            inline: { path: 'src/b.ts', from: 5 },
+                            resolution: { type: 'comment_resolution', user: { display_name: 'Ann' } },
+                        }),
+                    ],
+                },
+            },
+        ]);
+        const text = (await handleGetBitbucketPrComments({ input: PR_URL })).content[0].text;
+        assert.equal(calls.length, 2);
+        assert.equal(calls[0].url, `${API}/repositories/acme/web-app/pullrequests/42/comments?pagelen=100`);
+        assert.match(text, /4 comments in 3 threads · 2 open · 1 resolved/);
+        assert.match(text, /### General\n- \*\*#1 · user1 · 2026-10-01 · 🟡 open\*\*\n  > body 1/);
+        assert.match(text, /#### `src\/a.ts`\n- \*\*#2 · user2 · 2026-10-01 · line 12 · 🟡 open\*\*/);
+        assert.match(text, /  ↳ \*\*#3 · user3 · 2026-10-01\*\*\n    > body 3/);
+        assert.match(text, /#4 · user4 · 2026-10-01 · old line 5 · ✅ resolved by Ann/);
+    });
+    test('M2: includeResolved=false hides resolved threads', async () => {
+        stubFetch([
+            {
+                status: 200,
+                body: { values: [comment(1), comment(2, { resolution: { type: 'comment_resolution' } })] },
+            },
+        ]);
+        const text = (await handleGetBitbucketPrComments({ input: PR_URL, includeResolved: false })).content[0].text;
+        assert.match(text, /#1 /);
+        assert.doesNotMatch(text, /#2 /);
+    });
+    test('M3: deleted comments are hidden unless they carry replies', async () => {
+        stubFetch([
+            {
+                status: 200,
+                body: {
+                    values: [comment(1, { deleted: true }), comment(2, { deleted: true }), comment(3, { parent: { id: 2 } })],
+                },
+            },
+        ]);
+        const text = (await handleGetBitbucketPrComments({ input: PR_URL })).content[0].text;
+        assert.doesNotMatch(text, /#1 /);
+        assert.match(text, /#2 [^\n]*\n  > _\(deleted\)_/);
+        assert.match(text, /↳ \*\*#3 /);
+    });
+    test('M4: a next link to another host is never followed', async () => {
+        const calls = stubFetch([{ status: 200, body: { values: [comment(1)], next: 'https://evil.example/steal' } }]);
+        await handleGetBitbucketPrComments({ input: PR_URL });
+        assert.equal(calls.length, 1);
+    });
+    test('M5: stops at the page cap and says so', async () => {
+        const calls = stubFetch([
+            {
+                status: 200,
+                body: { values: [comment(1)], next: `${API}/repositories/acme/web-app/pullrequests/42/comments?page=n` },
+            },
+        ]);
+        const text = (await handleGetBitbucketPrComments({ input: PR_URL })).content[0].text;
+        assert.equal(calls.length, MAX_PAGES);
+        assert.match(text, /Stopped after 20 pages/);
+    });
+    test('M7: a 403 appends the scopes the tool needs', async () => {
+        stubFetch([{ status: 403, body: {} }]);
+        const text = (await handleGetBitbucketPrComments({ input: PR_URL })).content[0].text;
+        assert.match(text, /Access denied \(403\)/);
+        assert.match(text, /Check the API token has these scopes: read:pullrequest:bitbucket\./);
+    });
+    test('M6: 404 maps to a not-found message', async () => {
+        stubFetch([{ status: 404, body: { type: 'error', error: { message: 'nope' } } }]);
+        const text = (await handleGetBitbucketPrComments({ input: PR_URL })).content[0].text;
+        assert.match(text, /Not found/);
+    });
+});

package/dist/mcp/integration.d.ts

@@ -1,6 +1,6 @@
 /**
  * Integration Tools - Bitbucket, Jira, Confluence
- * Tools: kit_get_bitbucket_pr, kit_jira_get_ticket, kit_confluence_get_page
+ * Tools: kit_get_bitbucket_pr, kit_create_bitbucket_pr, kit_find_bitbucket_reviewers, kit_get_bitbucket_pr_comments, kit_jira_get_ticket, kit_confluence_get_page
  */
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 /**
@@ -22,6 +22,18 @@ export interface AtlassianContext {
     auth: string;
     cloudId: string;
 }
+/**
+ * API token scopes each tool needs, from Atlassian's OpenAPI specs (`x-atlassian-oauth2-scopes`).
+ * Used for 401/403 hints; mcp/README.md lists the same scopes for setup.
+ */
+export declare const REQUIRED_SCOPES: {
+    readonly kit_get_bitbucket_pr: readonly ["read:pullrequest:bitbucket", "read:repository:bitbucket"];
+    readonly kit_get_bitbucket_pr_comments: readonly ["read:pullrequest:bitbucket"];
+    readonly kit_create_bitbucket_pr: readonly ["read:pullrequest:bitbucket", "write:pullrequest:bitbucket", "read:workspace:bitbucket", "read:user:bitbucket"];
+    readonly kit_find_bitbucket_reviewers: readonly ["read:workspace:bitbucket", "read:user:bitbucket"];
+    readonly kit_jira_get_ticket: readonly ["read:jira-work"];
+    readonly kit_confluence_get_page: readonly ["read:page:confluence"];
+};
 /** Resolve the shared cloud id plus the product's basic-auth header (shared email, own token). */
 export declare function buildAtlassianContext(product: 'jira' | 'confluence'): AtlassianContext;
 /**
@@ -45,4 +57,102 @@ export declare function handleConfluenceGetPage(args: {
         text: string;
     }];
 }>;
+/** Safety cap on followed pagination pages (100 items each). */
+export declare const MAX_PAGES = 20;
+export type BitbucketRef<T> = ({
+    ok: true;
+} & T) | {
+    ok: false;
+    error: string;
+};
+/** Resolve a PR URL, or a numeric PR id plus workspace/repoSlug, to its coordinates. */
+export declare function resolveBitbucketPr(input: string, workspace?: string, repoSlug?: string): BitbucketRef<{
+    ws: string;
+    repo: string;
+    prId: number;
+}>;
+/** Resolve a repo URL, `workspace/repo`, or a bare repo slug (plus workspace or default) to its coordinates. */
+export declare function resolveBitbucketRepo(repository: string, workspace?: string): BitbucketRef<{
+    ws: string;
+    repo: string;
+}>;
+export interface BitbucketMember {
+    uuid: string;
+    displayName: string;
+    nickname?: string;
+}
+export interface ReviewerResolution {
+    resolved: Array<{
+        query: string;
+        member: BitbucketMember;
+    }>;
+    ambiguous: Array<{
+        query: string;
+        candidates: BitbucketMember[];
+    }>;
+    unmatched: string[];
+}
+/** Lowercase and strip diacritics so "Dũng" matches "Dung" and "Đức" matches "Duc". */
+export declare function normalizeName(value: string): string;
+/**
+ * Match reviewer queries against workspace members. A query matches a member by exact
+ * display name / nickname first; failing that, when every word of the query is a whole
+ * word of the member's name ("Dung" → "Nguyen Tien Dung"). More than one hit is ambiguous —
+ * never guessed. UUID queries must be resolved by the caller before this runs.
+ */
+export declare function matchReviewers(queries: string[], members: BitbucketMember[]): ReviewerResolution;
+export interface FindBitbucketReviewersArgs {
+    names: string[];
+    workspace?: string;
+}
+/**
+ * Handler for kit_find_bitbucket_reviewers: dry-run of the reviewer resolution that
+ * kit_create_bitbucket_pr performs, so callers can verify names before pushing anything.
+ * Never rejects — every failure path resolves to an actionable mcpText message.
+ */
+export declare function handleFindBitbucketReviewers(args: FindBitbucketReviewersArgs): Promise<{
+    content: [{
+        type: 'text';
+        text: string;
+    }];
+}>;
+export interface CreateBitbucketPrArgs {
+    repository: string;
+    workspace?: string;
+    title: string;
+    sourceBranch: string;
+    destinationBranch?: string;
+    description?: string;
+    closeSourceBranch?: boolean;
+    draft?: boolean;
+    reviewers?: string[];
+}
+/**
+ * Handler for kit_create_bitbucket_pr. Exported so it is unit testable without a transport.
+ * Never rejects — every failure path resolves to an actionable mcpText message.
+ */
+export declare function handleCreateBitbucketPr(args: CreateBitbucketPrArgs): Promise<{
+    content: [{
+        type: 'text';
+        text: string;
+    }];
+}>;
+export interface GetBitbucketPrCommentsArgs {
+    input: string;
+    workspace?: string;
+    repoSlug?: string;
+    includeResolved?: boolean;
+    includeDeleted?: boolean;
+}
+/**
+ * Handler for kit_get_bitbucket_pr_comments. Follows `next` links (pagelen=100) up to
+ * MAX_PAGES, then renders threads: general comments first, inline ones grouped by file.
+ * Never rejects — every failure path resolves to an actionable mcpText message.
+ */
+export declare function handleGetBitbucketPrComments(args: GetBitbucketPrCommentsArgs): Promise<{
+    content: [{
+        type: 'text';
+        text: string;
+    }];
+}>;
 export declare function registerIntegrationTools(server: McpServer): void;