@taiga-ai/mcp-server 0.14.0-dev.428 → 0.16.0-dev.430

package/src/tools/repositories.ts

@@ -0,0 +1,266 @@
+import type { McpServer } from '@modelcontextprotocol/server';
+import { z } from 'zod';
+import type { TaigaClient } from '../client.js';
+import { OPERATE, OPERATE_SETTING, READ_ONLY } from './annotations.js';
+import { runTool, toolError, toolResult } from './errors.js';
+import { pagination, productId } from './inputs.js';
+import { page, pickFields } from './summarize.js';
+
+/**
+ * A product's repository (docs.tai.ga, Administration: Integrations and
+ * environments, Source control). A linked repository is the prerequisite for
+ * most of what Taiga does: planning reads the code, runs work on a branch of
+ * it, sweeps scan it and the as-built documents are derived from it. GitHub is
+ * connected once for the organization, in the web; linking one of the
+ * repositories it can reach to a product is a separate act, per product.
+ */
+
+type Row = Record<string, unknown>;
+
+const LINK_FIELDS = [
+  'id',
+  'provider',
+  'repositoryName',
+  'repositoryUrl',
+  'repositoryDefaultBranch',
+  'baseBranch',
+  'effectiveBranch',
+  'label',
+  'buildable',
+  'isManaged',
+] as const;
+
+const INSTALLATION_FIELDS = [
+  'id',
+  'accountLogin',
+  'accountType',
+  'repositorySelection',
+  'suspendedAt',
+  'lastSyncError',
+] as const;
+
+const GITHUB_REPOSITORY_FIELDS = [
+  'id',
+  'fullName',
+  'private',
+  'archived',
+  'defaultBranch',
+  'description',
+  'language',
+] as const;
+
+const repositoryId = z
+  .string()
+  .uuid()
+  .describe("The product's repository link ID -- taiga_list_product_repositories gives it");
+
+export function registerRepositoryTools(server: McpServer, client: TaigaClient) {
+  if (client.hasCapability('products:read')) {
+    server.registerTool(
+      'taiga_list_product_repositories',
+      {
+        title: "List a product's repositories",
+        description:
+          'The repositories linked to a product, each with the branch Taiga works on (effectiveBranch: the ' +
+          "chosen branch, or the repository's default) and whether Taiga can plan and build in it (buildable).",
+        inputSchema: z.object({ productId }),
+        annotations: READ_ONLY,
+      },
+      (params) =>
+        runTool(async () => {
+          const result = await client.listProductRepositories(params.productId);
+          return toolResult(pickFields(result.data as Row[], LINK_FIELDS));
+        })
+    );
+
+    server.registerTool(
+      'taiga_list_repository_branches',
+      {
+        title: "List a repository's branches",
+        description:
+          "The branches of a product's linked repository, to choose the one Taiga branches from and opens pull " +
+          'requests against (taiga_set_repository_branch); each says whether it is protected. truncated: true ' +
+          'means the repository has more branches than this answer lists, and the rest were left out.',
+        inputSchema: z.object({ productId, repositoryId }),
+        annotations: READ_ONLY,
+      },
+      (params) =>
+        runTool(async () => {
+          const result = await client.listRepositoryBranches(params.productId, params.repositoryId);
+          return toolResult({ branches: result.data, truncated: result.truncated });
+        })
+    );
+  }
+
+  if (client.hasCapability('vcs:read')) {
+    server.registerTool(
+      'taiga_list_linkable_repositories',
+      {
+        title: 'Find a repository to link',
+        description:
+          "The repositories the organization's GitHub connection can reach, to link one to a product " +
+          '(taiga_link_repository takes its id). Searches by name with query; without installationId it reads ' +
+          'every connected GitHub account. No connection means GitHub is not connected yet: that is done once, ' +
+          'in the web, by someone who can install the app.',
+        inputSchema: z.object({
+          query: z.string().trim().min(1).max(256).optional().describe('Part of the repository name'),
+          installationId: z.string().uuid().optional().describe('One GitHub account -- this tool lists them'),
+          ...pagination,
+        }),
+        annotations: READ_ONLY,
+      },
+      (params) =>
+        runTool(async () => {
+          const installations = (await client.listGithubInstallations()).data as Row[];
+          const accounts = pickFields(installations, INSTALLATION_FIELDS);
+          if (installations.length === 0) {
+            return toolError(
+              'NOT_CONNECTED',
+              'GitHub is not connected for this organization. It is connected once, in the web; then link.'
+            );
+          }
+          const chosen = params.installationId
+            ? installations.filter((i) => i.id === params.installationId)
+            : installations;
+          if (chosen.length === 0) {
+            return toolError('NOT_FOUND', 'No such GitHub connection; these are the connected accounts.', { accounts });
+          }
+          // A cursor belongs to one account's pages, and a search answers one
+          // ranked page: either way a cursor would quietly start over.
+          if (params.cursor !== undefined && params.query !== undefined) {
+            return toolError('VALIDATION_FAILED', 'A search answers one page; narrow the query instead of paging it.');
+          }
+          if (chosen.length > 1 && params.cursor !== undefined) {
+            return toolError('VALIDATION_FAILED', 'A cursor pages one account: name its installationId.', { accounts });
+          }
+          // `limit` is the most rows the answer carries, however many accounts
+          // are read: a search answers its ranked matches whatever the page
+          // size, and several accounts add up.
+          const max = params.limit ?? 25;
+          const rows = (data: unknown[]) => pickFields(data as Row[], GITHUB_REPOSITORY_FIELDS);
+          if (chosen.length === 1) {
+            const result = await client.listInstallationRepositories(String(chosen[0]!.id), {
+              q: params.query,
+              limit: max,
+              cursor: params.cursor,
+            });
+            const found = rows(result.data);
+            return toolResult({
+              accounts,
+              repositories: page(found.slice(0, max), result.nextCursor),
+              ...(found.length > max
+                ? { more: 'More matched than the limit; narrow the query or raise the limit.' }
+                : {}),
+            });
+          }
+          // Several accounts are read once each, as the web's picker reads them;
+          // a cursor belongs to one account, so the page has none.
+          const pages = await Promise.all(
+            chosen.map((i) => client.listInstallationRepositories(String(i.id), { q: params.query, limit: max }))
+          );
+          const found = pages.flatMap((p) => rows(p.data));
+          const cut = found.length > max || pages.some((p) => p.nextCursor);
+          return toolResult({
+            accounts,
+            repositories: page(found.slice(0, max), null),
+            ...(cut
+              ? { more: 'More than the limit across accounts: name an installationId, or narrow the query.' }
+              : {}),
+          });
+        })
+    );
+  }
+
+  if (!client.hasCapability('vcs:manage')) return;
+
+  server.registerTool(
+    'taiga_link_repository',
+    {
+      title: 'Link a repository to a product',
+      description:
+        'Link a repository the GitHub connection can reach (taiga_list_linkable_repositories gives its id) to a ' +
+        'product, or with replacesRepositoryId swap the one linked now for it in one step (naming the same ' +
+        'repository there changes nothing; linking one already linked without it is refused). A link Taiga ' +
+        'manages (isManaged) cannot be replaced or unlinked. Once linked, planning reads its code, runs open pull requests in it, ' +
+        'sweeps scan it, and its deployment history is imported in the background. Ask the person first.',
+      inputSchema: z.object({
+        productId,
+        githubRepositoryId: z
+          .string()
+          .uuid()
+          .describe('The repository id -- taiga_list_linkable_repositories gives it'),
+        replacesRepositoryId: repositoryId.optional().describe('The link this one replaces'),
+      }),
+      annotations: OPERATE,
+    },
+    (params) =>
+      runTool(async () => {
+        const linked = await client.linkRepository(params.productId, {
+          githubRepositoryId: params.githubRepositoryId,
+          ...(params.replacesRepositoryId ? { replacesRepositoryId: params.replacesRepositoryId } : {}),
+        });
+        return toolResult(pickFields([linked.data as Row], LINK_FIELDS)[0]);
+      })
+  );
+
+  server.registerTool(
+    'taiga_set_repository_branch',
+    {
+      title: 'Choose the branch Taiga works on',
+      description:
+        "Choose the branch of a product's repository that Taiga branches from and opens its pull requests " +
+        "against (taiga_list_repository_branches lists them), or null to follow the repository's default " +
+        'again. A protected branch is not refused, but Taiga may not be able to merge into it: the answer says ' +
+        'when it is protected. Optionally a label for the link. Ask the person first.',
+      inputSchema: z.object({
+        productId,
+        repositoryId,
+        baseBranch: z
+          .string()
+          .trim()
+          .min(1)
+          .max(255)
+          .nullable()
+          .optional()
+          .describe('The branch; null for the default'),
+        label: z.string().trim().min(1).max(100).nullable().optional().describe('A label for the link; null clears it'),
+      }),
+      annotations: OPERATE_SETTING,
+    },
+    (params) =>
+      runTool(async () => {
+        if (params.baseBranch === undefined && params.label === undefined) {
+          return toolError('VALIDATION_FAILED', 'Set baseBranch, label or both.');
+        }
+        const updated = (
+          await client.updateRepository(params.productId, params.repositoryId, {
+            ...(params.baseBranch !== undefined ? { baseBranch: params.baseBranch } : {}),
+            ...(params.label !== undefined ? { label: params.label } : {}),
+          })
+        ).data as Row;
+        return toolResult({
+          ...pickFields([updated], LINK_FIELDS)[0],
+          baseBranchProtection: updated.baseBranchProtection ?? null,
+        });
+      })
+  );
+
+  server.registerTool(
+    'taiga_unlink_repository',
+    {
+      title: 'Unlink a repository from a product',
+      description:
+        'Unlink a repository from a product. Without one, the product can still have documents and initiatives ' +
+        'but no changes: nothing is planned against code, built or swept. The repository itself is untouched, ' +
+        'and a repository Taiga created for the product cannot be unlinked. ' +
+        'To swap it for another, use taiga_link_repository with replacesRepositoryId instead. Ask the person first.',
+      inputSchema: z.object({ productId, repositoryId }),
+      annotations: OPERATE,
+    },
+    (params) =>
+      runTool(async () => {
+        await client.unlinkRepository(params.productId, params.repositoryId);
+        return toolResult({ repositoryId: params.repositoryId, unlinked: true });
+      })
+  );
+}

package/src/tools/resources.ts

@@ -1,8 +1,12 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { ErrorCode, type ReadResourceResult } from '@modelcontextprotocol/sdk/types.js';
+import {
+  type McpServer,
+  ProtocolError,
+  ProtocolErrorCode,
+  type ReadResourceResult,
+  ResourceTemplate,
+} from '@modelcontextprotocol/server';
 import { TaigaApiError, type TaigaClient } from '../client.js';
-import { RequestError, apiFailureText, isMissOrRefusal } from './errors.js';
+import { apiFailureText, isMissOrRefusal } from './errors.js';
 import {
   FACTORY_DOCUMENT_TYPES,
   PRODUCT_DOCUMENT_ORIGINS,
@@ -38,7 +42,7 @@ function contents(uri: string, doc: Record<string, unknown>): ReadResourceResult
 }
 
 function invalid(message: string): never {
-  throw new RequestError(ErrorCode.InvalidParams, message);
+  throw new ProtocolError(ProtocolErrorCode.InvalidParams, message);
 }
 
 function requireOneOf<T extends string>(what: string, value: string, allowed: readonly T[]): T {

package/src/tools/setup.ts

@@ -0,0 +1,342 @@
+import type { McpServer } from '@modelcontextprotocol/server';
+import { DEPLOYMENT_NOTES_MAX_LENGTH, REALITY_DERIVED_DOCUMENT_TYPES } from '@taiga/types';
+import { z } from 'zod';
+import type { TaigaClient } from '../client.js';
+import { OPERATE, OPERATE_SETTING, READ_ONLY, WRITE } from './annotations.js';
+import { isImportedProduct, type ProductSettingsView } from './catalogue.js';
+import { runTool, toolError, toolResult } from './errors.js';
+import { productId } from './inputs.js';
+import { pickFields } from './summarize.js';
+
+/**
+ * Setting a product up (docs.tai.ga, Start: Your first product, Learn: Import
+ * an existing codebase, Organizations, factories and products): factories to
+ * put products in, a product started from scratch or from an imported
+ * codebase, what Taiga builds for it, the import, and finishing or reopening
+ * Discovery. Who may reach a factory (its members) and deleting a factory or
+ * a product stay in the web.
+ */
+
+type Row = Record<string, unknown>;
+
+const PRODUCT_FIELDS = [
+  'id',
+  'name',
+  'slug',
+  'status',
+  'factoryId',
+  'ownsInfrastructure',
+  'ownsDeployment',
+  'deploymentNotes',
+  'emitDesignStandards',
+  'settings',
+] as const;
+
+const FACTORY_FIELDS = ['id', 'name', 'slug', 'isDefault'] as const;
+
+const factoryId = z.string().uuid().describe('Factory ID -- taiga_list_factories gives it');
+
+const buildScope = {
+  ownsInfrastructure: z
+    .boolean()
+    .nullable()
+    .optional()
+    .describe('Whether Taiga writes the infrastructure code; null follows the organization'),
+  ownsDeployment: z
+    .boolean()
+    .nullable()
+    .optional()
+    .describe('Whether Taiga writes the CI/CD pipelines; null follows the organization'),
+};
+
+const deploymentNotes = z
+  .string()
+  .trim()
+  .min(1)
+  .max(DEPLOYMENT_NOTES_MAX_LENGTH)
+  .describe('When a half is off: a sentence on how it is done today, which Taiga designs and plans against');
+
+/** A product row the model can act on, saying how it started as the other product tools say it. */
+function productRow(product: Row): Row {
+  const { settings: _settings, ...rest } = pickFields([product], PRODUCT_FIELDS)[0]!;
+  return { ...rest, projectType: isImportedProduct(product as ProductSettingsView) ? 'brownfield' : 'greenfield' };
+}
+
+/**
+ * The sentence is for a half Taiga does not build; the web asks for it only
+ * then. When both halves are decided on here, a sentence has nothing to say.
+ */
+function notesWithNothingToDescribe(params: {
+  ownsInfrastructure?: boolean | null | undefined;
+  ownsDeployment?: boolean | null | undefined;
+  deploymentNotes?: string | null | undefined;
+}) {
+  return typeof params.deploymentNotes === 'string' &&
+    params.ownsInfrastructure === true &&
+    params.ownsDeployment === true
+    ? toolError(
+        'VALIDATION_FAILED',
+        'deploymentNotes describes a half Taiga does not build; both are on, so leave it out.'
+      )
+    : null;
+}
+
+export function registerSetupTools(server: McpServer, client: TaigaClient) {
+  if (client.hasCapability('factories:write')) {
+    server.registerTool(
+      'taiga_create_factory',
+      {
+        title: 'Create a factory',
+        description:
+          'Create a factory: a group of products that share a knowledge base, one instructions document and ' +
+          'their members, so products under it work from the same context. Members are added in the web. Then put ' +
+          'products in it with taiga_create_product, or move one there with taiga_move_product. Owners and admins ' +
+          'create factories.',
+        inputSchema: z.object({ name: z.string().trim().min(1).max(255).describe('The factory name') }),
+        annotations: WRITE,
+      },
+      (params) =>
+        runTool(async () =>
+          toolResult(pickFields([(await client.createFactory({ name: params.name })).data as Row], FACTORY_FIELDS)[0])
+        )
+    );
+
+    server.registerTool(
+      'taiga_rename_factory',
+      {
+        title: 'Rename a factory',
+        description:
+          'Rename a factory. Its products, members, knowledge and instructions stay as they are, but its slug ' +
+          'follows the new name, so links to the factory change. Ask the person first.',
+        inputSchema: z.object({ factoryId, name: z.string().trim().min(1).max(255).describe('The new name') }),
+        annotations: OPERATE_SETTING,
+      },
+      (params) =>
+        runTool(async () =>
+          toolResult(
+            pickFields(
+              [(await client.updateFactory(params.factoryId, { name: params.name })).data as Row],
+              FACTORY_FIELDS
+            )[0]
+          )
+        )
+    );
+
+    server.registerTool(
+      'taiga_preview_product_move',
+      {
+        title: 'Preview moving a product to another factory',
+        description:
+          'Who gains and who loses access if a product moves to another factory: people reach a product through ' +
+          "its factory, so the source factory's members lose it and the target's gain it. People on both, the " +
+          "product's own members, and owners and admins keep it, and are named with why. Read this, and show it " +
+          'to the person, before taiga_move_product.',
+        inputSchema: z.object({ productId, factoryId: factoryId.describe('The factory to move it to') }),
+        annotations: READ_ONLY,
+      },
+      (params) =>
+        runTool(async () => toolResult((await client.previewProductMove(params.productId, params.factoryId)).data))
+    );
+
+    server.registerTool(
+      'taiga_move_product',
+      {
+        title: 'Move a product to another factory',
+        description:
+          'Move a product to another factory. Access follows the factory, so this changes who can reach the ' +
+          "product (taiga_preview_product_move says who); the product's own knowledge files are re-filed onto " +
+          'the new factory, and factory knowledge and instructions stay with the factory that owns them. Refused ' +
+          '(CONFLICT) while a plan or build is in flight: stopLine: true stops the line first and then moves, which ' +
+          'interrupts that work. Ask the person first.',
+        inputSchema: z.object({
+          productId,
+          factoryId: factoryId.describe('The factory to move it to'),
+          stopLine: z
+            .boolean()
+            .optional()
+            .describe('Stop the line first, interrupting the plan or build in flight; only when the person says so'),
+        }),
+        annotations: OPERATE,
+      },
+      (params) =>
+        runTool(async () => {
+          const moved = await client.moveProduct(params.productId, {
+            factoryId: params.factoryId,
+            ...(params.stopLine ? { stopLine: true } : {}),
+          });
+          return toolResult({
+            product: productRow(moved.data as Row),
+            changed: moved.changed,
+            previousFactoryId: moved.previousFactoryId,
+            lineStopped: moved.lineStopped,
+            failedDocuments: moved.failedDocuments,
+          });
+        })
+    );
+  }
+
+  if (!client.hasCapability('products:write')) return;
+
+  server.registerTool(
+    'taiga_create_product',
+    {
+      title: 'Create a product',
+      description:
+        'Create a product in a factory, the way New product does. It starts one of two ways, chosen now and not ' +
+        'later: scratch, where Discovery is a conversation that writes the specification (held in the web), or ' +
+        'import (projectType brownfield), where Taiga reads an existing repository and drafts the documents from ' +
+        'the code: link the repository (taiga_link_repository; linking is for owners and admins, so a member ' +
+        'asks one), then taiga_start_import. Also what Taiga builds for it: its ' +
+        'infrastructure code and its CI/CD pipelines, each following the organization unless decided here; when ' +
+        'one is off, deploymentNotes says in a sentence how that half is done today. Material the product should ' +
+        'be built from is worth adding before Discovery starts (taiga_add_knowledge with the productId): what is ' +
+        'added first shapes the specification.',
+      inputSchema: z.object({
+        factoryId,
+        name: z.string().trim().min(1).max(255).describe('The product name'),
+        start: z.enum(['scratch', 'import']).describe('scratch: describe it in Discovery; import: from a repository'),
+        ...buildScope,
+        deploymentNotes: deploymentNotes.optional(),
+      }),
+      annotations: WRITE,
+    },
+    (params) =>
+      runTool(async () => {
+        const contradiction = notesWithNothingToDescribe(params);
+        if (contradiction) return contradiction;
+        const product = (
+          await client.createProduct({
+            name: params.name,
+            factoryId: params.factoryId,
+            ...(params.start === 'import' ? { projectType: 'brownfield' as const } : {}),
+            ...(params.ownsInfrastructure !== undefined ? { ownsInfrastructure: params.ownsInfrastructure } : {}),
+            ...(params.ownsDeployment !== undefined ? { ownsDeployment: params.ownsDeployment } : {}),
+            ...(params.deploymentNotes !== undefined ? { deploymentNotes: params.deploymentNotes } : {}),
+          })
+        ).data as Row;
+        return toolResult(productRow(product));
+      })
+  );
+
+  server.registerTool(
+    'taiga_update_product',
+    {
+      title: "Change a product's settings",
+      description:
+        "Change a product's name (its slug follows the name, so links to the product change) or what Taiga " +
+        'builds for it: its infrastructure code and CI/CD pipelines (null ' +
+        'returns one to the organization default), the sentence on how a half Taiga does not build is done today, ' +
+        "and whether it inherits the organization's design standards (null follows the default for how the " +
+        'product started). Later plans read the new answer; work already planned is not redone. Autonomy is ' +
+        'taiga_set_product_autonomy. Ask the person first.',
+      inputSchema: z.object({
+        productId,
+        name: z.string().trim().min(1).max(255).optional().describe('A new name'),
+        ...buildScope,
+        deploymentNotes: deploymentNotes.nullable().optional(),
+        emitDesignStandards: z
+          .boolean()
+          .nullable()
+          .optional()
+          .describe("Inherit the organization's design standards; null follows the default"),
+      }),
+      annotations: OPERATE_SETTING,
+    },
+    (params) =>
+      runTool(async () => {
+        const { productId: id, ...changes } = params;
+        if (Object.values(changes).every((value) => value === undefined)) {
+          return toolError('VALIDATION_FAILED', 'Change at least one setting.');
+        }
+        const contradiction = notesWithNothingToDescribe(params);
+        if (contradiction) return contradiction;
+        return toolResult(productRow((await client.updateProduct(id, changes)).data as Row));
+      })
+  );
+
+  server.registerTool(
+    'taiga_refresh_reality_documents',
+    {
+      title: "Refresh a product's documents from its code",
+      description:
+        "Derive the reality documents again from the code on the branch Taiga works on (the link's effectiveBranch: " +
+        "the chosen branch, or the repository's default): all of them, or the ones named (with " +
+        'what they are derived from). For a document the import misread, refresh it rather than importing ' +
+        'again; unchanged sections are not republished. Runs an agent in the background and returns the job; ' +
+        'taiga_wait_for_job says when it is done. Ask the person first.',
+      inputSchema: z.object({
+        productId,
+        docTypes: z
+          .array(z.enum(REALITY_DERIVED_DOCUMENT_TYPES))
+          .min(1)
+          .max(REALITY_DERIVED_DOCUMENT_TYPES.length)
+          .optional()
+          .describe('The documents to refresh; omit for all'),
+      }),
+      annotations: OPERATE,
+    },
+    (params) =>
+      runTool(async () => toolResult((await client.refreshRealityDocuments(params.productId, params.docTypes)).data))
+  );
+
+  server.registerTool(
+    'taiga_finish_discovery',
+    {
+      title: 'Finish Discovery',
+      description:
+        "Finish a product's Discovery. Refused (CONFLICT) with details.reason: documents_incomplete names the " +
+        'required documents still unpublished (details.missingDocuments); not_in_setup means it is already ' +
+        'finished; a required check left unstamped (stamped in the web) is refused with its details too. It ' +
+        'locks the document set ' +
+        'and opens the rest of the product; for an ' +
+        'imported product it is also when the first initiatives are planned. A locked document changes only ' +
+        'after taiga_reopen_discovery. Ask the person first: it is their decision that the documents are right.',
+      inputSchema: z.object({ productId }),
+      annotations: OPERATE,
+    },
+    (params) => runTool(async () => toolResult(productRow((await client.completeSetup(params.productId)).data as Row)))
+  );
+
+  server.registerTool(
+    'taiga_reopen_discovery',
+    {
+      title: 'Reopen Discovery',
+      description:
+        "Reopen a finished product's Discovery so its documents can be amended; finish it again afterwards. " +
+        'Nothing built from them is undone. Ask the person first.',
+      inputSchema: z.object({ productId }),
+      annotations: OPERATE,
+    },
+    (params) => runTool(async () => toolResult(productRow((await client.reopenSetup(params.productId)).data as Row)))
+  );
+
+  if (!client.hasCapability('products:read')) return;
+
+  server.registerTool(
+    'taiga_start_import',
+    {
+      title: 'Import a codebase into a product',
+      description:
+        'Start the import of a product created to import a codebase: Taiga reads its linked repository and ' +
+        'derives the full document set from the code, each document citing the files it came from. Importing ' +
+        'is one decision; the rest runs by itself. The scanners then sweep the repository, the documents are ' +
+        "assessed against the organization's policies, and the first initiatives are planned when Discovery is " +
+        'finished. Refused for a product started from scratch (the choice is made at creation), without a ' +
+        'linked repository, or while an import runs. Runs agents in the background and returns the job; ' +
+        'taiga_wait_for_job says when it is done (it takes a while). Ask the person first.',
+      inputSchema: z.object({ productId }),
+      annotations: OPERATE,
+    },
+    (params) =>
+      runTool(async () => {
+        const product = (await client.getProduct(params.productId)).data as Row;
+        if (!isImportedProduct(product as ProductSettingsView)) {
+          return toolError(
+            'CONFLICT',
+            'This product was started from scratch, so it has no import: the choice is made when a product is created.'
+          );
+        }
+        return toolResult((await client.startImport(params.productId)).data);
+      })
+  );
+}