@taiga-ai/mcp-server 0.18.0-dev.447 → 0.18.0-dev.448

package/src/server.integration.test.ts

@@ -267,7 +267,7 @@ function toolNames(tools: { name: string }[]) {
 }
 
 /** Extract parsed JSON from the first text content block of a tool call result. */
-function parseToolResult(result: Record<string, unknown>) {
+function parseToolResult(result: { content?: unknown }) {
   const content = result.content as { type: string; text: string }[];
   return JSON.parse(content[0]!.text);
 }
@@ -580,7 +580,7 @@ describe('MCP server integration', () => {
     it('should replace one section of the existing draft and keep the rest', async () => {
       const draft = policyDocument({ id: 'draft-1', version: null, isDraft: true });
       const saved = policyDocument({ id: 'draft-1', version: null, isDraft: true });
-      (saved.data.sections as Record<string, { content: string }>).summary!.content = 'New summary';
+      saved.data.sections.summary.content = 'New summary';
 
       const { client, fetchSpy } = await bootMcpPair({
         capabilities: ALL_CAPABILITIES,
@@ -750,9 +750,9 @@ describe('MCP server integration', () => {
       const { tools } = await client.listTools();
       const byName = Object.fromEntries(tools.map((t) => [t.name, t.annotations]));
 
-      expect(byName.taiga_publish_document).toMatchObject({ destructiveHint: true, idempotentHint: false });
-      expect(byName.taiga_publish_factory_document).toMatchObject({ destructiveHint: true, idempotentHint: false });
-      expect(byName.taiga_update_document).toMatchObject({ destructiveHint: false, idempotentHint: true });
+      expect(byName['taiga_publish_document']).toMatchObject({ destructiveHint: true, idempotentHint: false });
+      expect(byName['taiga_publish_factory_document']).toMatchObject({ destructiveHint: true, idempotentHint: false });
+      expect(byName['taiga_update_document']).toMatchObject({ destructiveHint: false, idempotentHint: true });
     });
 
     it('should hand the model the API message when the publish gate refuses the draft', async () => {
@@ -2904,8 +2904,9 @@ describe('MCP server integration', () => {
       }
       // A section id points at the read tool of its own scope, which lists the valid ids.
       const sectionHelp = (name: string) =>
-        (tools.find((t) => t.name === name)!.inputSchema.properties as Record<string, { description?: string }>)
-          .sectionId!.description;
+        (tools.find((t) => t.name === name)!.inputSchema.properties as Record<string, { description?: string }>)[
+          'sectionId'
+        ]!.description;
       expect(sectionHelp('taiga_update_document')).toContain('taiga_get_document,');
       expect(sectionHelp('taiga_update_factory_document')).toContain('taiga_get_factory_document');
       expect(sectionHelp('taiga_update_product_document')).toContain('taiga_get_product_document');
@@ -3323,7 +3324,7 @@ describe('MCP server integration', () => {
       const move = tools.find((t) => t.name === 'taiga_move_backlog_item')!;
       const props = move.inputSchema.properties as Record<string, { enum?: string[] }>;
       // The queue is the only way to start work: no "plan this now", nothing dropped into Build.
-      expect(props.state!.enum).toEqual(['backlog', 'todo', 'queue', 'done', 'canceled']);
+      expect(props['state']!.enum).toEqual(['backlog', 'todo', 'queue', 'done', 'canceled']);
 
       const before = fetchSpy.mock.calls.length;
       for (const state of ['build', 'plan']) {
@@ -6849,7 +6850,7 @@ describe('what the second agent review found (PRO-2778, PRO-2780)', () => {
     const { tools } = await client.listTools();
     const metrics = tools.find((t) => t.name === 'taiga_get_delivery_metrics')!;
     const properties = metrics.inputSchema.properties as Record<string, { enum?: unknown }>;
-    expect(properties.windowDays!.enum).toEqual([30, 60, 90]);
+    expect(properties['windowDays']!.enum).toEqual([30, 60, 90]);
   });
 
   it('opens every writing tool with what it does, and leaves the reads as they were', async () => {

package/src/tools/autonomy.ts

@@ -15,8 +15,6 @@ import { pickFields } from './summarize.js';
  * is taiga_set_auto_build.
  */
 
-type Row = Record<string, unknown>;
-
 export function registerAutonomyTools(server: McpServer, client: TaigaClient) {
   if (client.hasCapability('products:write')) {
     server.registerTool(
@@ -54,7 +52,7 @@ export function registerAutonomyTools(server: McpServer, client: TaigaClient) {
               ...(params.autoBuild !== undefined ? { autoBuild: params.autoBuild } : {}),
               ...(autoMerge !== undefined ? { autoMerge } : {}),
             })
-          ).data as Row;
+          ).data;
           return toolResult(pickFields([product], ['id', 'name', 'slug', 'autoBuild', 'autoMerge'])[0]);
         })
     );
@@ -82,7 +80,7 @@ export function registerAutonomyTools(server: McpServer, client: TaigaClient) {
       },
       (params) =>
         runTool(async () => {
-          const item = (await client.updateBacklogItem(params.itemId, { autoMerge: params.autoMerge })).data as Row;
+          const item = (await client.updateBacklogItem(params.itemId, { autoMerge: params.autoMerge })).data;
           return toolResult(pickFields([item], ['id', 'title', 'state', 'autoMerge', 'autoBuild'])[0]);
         })
     );

package/src/tools/backlogs.ts

@@ -1,6 +1,7 @@
 import type { McpServer } from '@modelcontextprotocol/server';
 import { z } from 'zod';
-import { TaigaApiError, type TaigaClient } from '../client.js';
+import type { ActivityEvent, ActivityActor, BacklogItem } from '@taiga/types';
+import { TaigaApiError, type TaigaClient, type WithoutTenant } from '../client.js';
 import { PLAN_REJECTION_COMMENT_MAX_CHARS, PR_CLOSING_STATES, USER_DROP_STATES, resolveAutoBuild } from '@taiga/types';
 import { OPERATE, OPERATE_SETTING, READ_ONLY } from './annotations.js';
 import { idInput, pagination, productId } from './inputs.js';
@@ -83,16 +84,16 @@ async function planFailureOf(
   itemId: string,
   itemCause: unknown
 ): Promise<Record<string, unknown> | null> {
-  let events: Record<string, unknown>[];
+  let events: WithoutTenant<ActivityEvent>[];
   try {
-    events = (await client.listBacklogItemActivity(itemId)).data as Record<string, unknown>[];
+    events = (await client.listBacklogItemActivity(itemId)).data;
   } catch (error) {
     if (error instanceof TaigaApiError || isNetworkFailure(error)) return null;
     throw error;
   }
   // Only a failure of the latest attempt: one before the last plan_started
   // belongs to an earlier attempt, even when it failed for the same reason.
-  let failed: Record<string, unknown> | undefined;
+  let failed: WithoutTenant<ActivityEvent> | undefined;
   for (const event of [...events].reverse()) {
     if (event.kind !== 'turn') continue;
     if (event.trigger === 'plan_started') break;
@@ -102,8 +103,8 @@ async function planFailureOf(
     }
   }
   if (!failed) return null;
-  const actor = (failed.actor ?? {}) as { type?: unknown; name?: unknown };
-  const data = (failed.data ?? {}) as { cause?: unknown };
+  const actor: Partial<ActivityActor> = failed.actor ?? {};
+  const data: { cause?: unknown } = failed.data ?? {};
   const cause = typeof data.cause === 'string' ? data.cause : null;
   // The event is recorded best effort: one that disagrees with the item's own
   // cause belongs to an earlier failure, and its who and when are not this one's.
@@ -140,13 +141,12 @@ const PLAN_STEP_SUMMARY_FIELDS = [
   'createsResources',
 ] as const;
 
+type Item = WithoutTenant<BacklogItem>;
+
 /** The outcome fields of an initiative, with how many of its criteria are met. */
-const outcomeOf = (item: unknown) => {
-  const row = item as Record<string, unknown>;
-  return { ...pickFields([row], ITEM_OUTCOME_FIELDS)[0], criteria: criteriaCounts(row) };
-};
+const outcomeOf = (item: Item) => ({ ...pickFields([item], ITEM_OUTCOME_FIELDS)[0], criteria: criteriaCounts(item) });
 
-const outcome = (item: unknown) => toolResult(outcomeOf(item));
+const outcome = (item: Item) => toolResult(outcomeOf(item));
 
 /**
  * Each tool is registered under the capability its route requires, so a
@@ -218,9 +218,7 @@ function registerBacklogReads(server: McpServer, client: TaigaClient) {
         const { query, ...filters } = params;
         if (query === undefined) {
           const result = await client.listBacklogItems(params.productId, filters);
-          return toolResult(
-            page(itemRows(result.data as Record<string, unknown>[], BACKLOG_SUMMARY_FIELDS), result.nextCursor)
-          );
+          return toolResult(page(itemRows(result.data, BACKLOG_SUMMARY_FIELDS), result.nextCursor));
         }
         if (params.cursor !== undefined) {
           return toolError('VALIDATION_ERROR', SEARCH_WITH_CURSOR);
@@ -255,9 +253,12 @@ function registerBacklogReads(server: McpServer, client: TaigaClient) {
     },
     (params) =>
       runTool(async () => {
-        const item = (await client.getBacklogItem(params.itemId)).data as Record<string, unknown>;
+        const item = (await client.getBacklogItem(params.itemId)).data;
         if (item.planningStatus !== 'failed') return toolResult(item);
-        const planFailure = await planFailureOf(client, params.itemId, item.planFailureCause);
+        // Always undefined: the API sends the cause only under `lifecycle`, so
+        // planFailureOf's cross-check never fires (PRO-2799). Kept as it was.
+        const ownCause = (item as { planFailureCause?: unknown }).planFailureCause;
+        const planFailure = await planFailureOf(client, params.itemId, ownCause);
         return toolResult(planFailure ? { ...item, planFailure } : item);
       })
   );
@@ -281,9 +282,9 @@ function registerBacklogReads(server: McpServer, client: TaigaClient) {
     },
     (params) =>
       runTool(async () => {
-        const plan = (await client.getActivePlan(params.itemId)).data as Record<string, unknown>;
+        const plan = (await client.getActivePlan(params.itemId)).data;
         if (params.full) return toolResult(plan);
-        const steps = Array.isArray(plan.steps) ? (plan.steps as Record<string, unknown>[]) : [];
+        const steps = Array.isArray(plan.steps) ? plan.steps : [];
         return toolResult({
           ...pickFields([plan], PLAN_SUMMARY_FIELDS)[0],
           steps: pickFields(steps, PLAN_STEP_SUMMARY_FIELDS),
@@ -331,7 +332,7 @@ function registerRequest(server: McpServer, client: TaigaClient) {
             targetId: params.productId,
             ...(userPrompt ? { metadata: { userPrompt } } : {}),
           })
-        ).data as Record<string, unknown>;
+        ).data;
         return toolResult(jobReport(job));
       })
   );
@@ -415,7 +416,7 @@ function registerPlanAgain(server: McpServer, client: TaigaClient) {
     },
     (params) =>
       runTool(async () => {
-        const item = (await client.getBacklogItem(params.itemId)).data as Record<string, unknown>;
+        const item = (await client.getBacklogItem(params.itemId)).data;
         if (!BUILD_STATION.has(String(item.state))) {
           return toolError(
             'CONFLICT',
@@ -437,12 +438,11 @@ const isApiFailure = (error: unknown) => error instanceof TaigaApiError || isNet
  * decided it: its own setting, or the product's default when it has none.
  * Null when the product cannot be read; the outcome then says so instead.
  */
-async function reviewGate(client: TaigaClient, item: Record<string, unknown>) {
+async function reviewGate(client: TaigaClient, item: Item) {
   const own = typeof item.autoBuild === 'boolean' ? item.autoBuild : null;
   try {
     // The product's default answers only when the initiative has no answer of its own.
-    const product =
-      own === null ? ((await client.getProduct(String(item.productId))).data as { autoBuild?: unknown }) : {};
+    const product: { autoBuild?: boolean | null } = own === null ? (await client.getProduct(item.productId)).data : {};
     // Absent on the product reads as its true default (@taiga/types).
     const productDefault = typeof product.autoBuild === 'boolean' ? product.autoBuild : true;
     const builds = resolveAutoBuild({ initiative: own, product: productDefault });
@@ -460,9 +460,9 @@ async function reviewGate(client: TaigaClient, item: Record<string, unknown>) {
 }
 
 /** Where a queued initiative stands in its product's line; null, and the outcome says so, when the queue cannot be read. */
-async function placeInQueue(client: TaigaClient, item: Record<string, unknown>) {
+async function placeInQueue(client: TaigaClient, item: Item) {
   try {
-    const view = await queueView(client, String(item.productId), { name: 'blocking' });
+    const view = await queueView(client, item.productId, { name: 'blocking' });
     const entry = view.entries.find((row) => row.backlogItemId === item.id);
     return { position: entry?.position ?? null, of: view.entries.length, waitingOn: view.waitingOn };
   } catch (error) {
@@ -519,10 +519,7 @@ function registerQueue(server: McpServer, client: TaigaClient) {
         if (autoBuild !== undefined) await client.setAutoBuild(id, autoBuild);
         // The move the web makes: one write that answers with the refreshed
         // item, rather than the queue route plus two reads around it.
-        const item = (await client.transitionInitiative(id, { state: 'queue', ...placement })).data as Record<
-          string,
-          unknown
-        >;
+        const item = (await client.transitionInitiative(id, { state: 'queue', ...placement })).data;
         const [gate, queue] = await Promise.all([reviewGate(client, item), placeInQueue(client, item)]);
         return toolResult({
           ...outcomeOf(item),
@@ -551,7 +548,7 @@ function registerReviewGate(server: McpServer, client: TaigaClient) {
     },
     (params) =>
       runTool(async () => {
-        const item = (await client.setAutoBuild(params.itemId, params.autoBuild)).data as Record<string, unknown>;
+        const item = (await client.setAutoBuild(params.itemId, params.autoBuild)).data;
         const gate = await reviewGate(client, item);
         return toolResult({
           ...outcomeOf(item),

package/src/tools/builds.ts

@@ -1,6 +1,7 @@
 import type { McpServer } from '@modelcontextprotocol/server';
 import { z } from 'zod';
-import type { TaigaClient } from '../client.js';
+import type { BuildRunStep, BuildRunWithContext } from '@taiga/types';
+import type { TaigaClient, WithoutTenant } from '../client.js';
 import { OPERATE, READ_ONLY } from './annotations.js';
 import { idInput, pagination, productId } from './inputs.js';
 import { isNetworkFailure, runTool, toolError, toolResult } from './errors.js';
@@ -54,7 +55,10 @@ const RUN_OUTCOME_FIELDS = [
  * stalled in the hardening pass after the steps and the retry continues it.
  * Null for a run still going or that finished.
  */
-export function stoppedIn(run: Record<string, unknown>, steps: Record<string, unknown>[]): string | null {
+export function stoppedIn(
+  run: Pick<WithoutTenant<BuildRunWithContext>, 'prMerged' | 'status' | 'hardeningResult'>,
+  steps: readonly Pick<WithoutTenant<BuildRunStep>, 'status' | 'stepOrder' | 'title'>[]
+): string | null {
   // A merged run is finished, whatever its status still says: the merge is
   // latched apart from the status, which can stay at a stale failed or stopped.
   if (run.prMerged === true || (run.status !== 'failed' && run.status !== 'stopped')) return null;
@@ -131,11 +135,11 @@ async function activityRows(
       throw error;
     }),
   ]);
-  const nameById = new Map<string, { name: unknown; slug: unknown }>();
-  for (const product of (products?.data ?? []) as Record<string, unknown>[]) {
-    nameById.set(String(product.id), { name: product.name, slug: product.slug });
+  const nameById = new Map<string, { name: string; slug: string }>();
+  for (const product of products?.data ?? []) {
+    nameById.set(product.id, { name: product.name, slug: product.slug });
   }
-  const rows = pickFields(runs.data as Record<string, unknown>[], BUILD_SUMMARY_FIELDS).map((row) => {
+  const rows = pickFields(runs.data, BUILD_SUMMARY_FIELDS).map((row) => {
     const product = nameById.get(String(row.productId));
     return product ? { ...row, product } : row;
   });
@@ -204,9 +208,7 @@ export function registerBuildTools(server: McpServer, client: TaigaClient) {
         }
         if (params.productId) {
           const result = await client.listBuildRuns(params.productId, params);
-          return toolResult(
-            page(pickFields(result.data as Record<string, unknown>[], BUILD_SUMMARY_FIELDS), result.nextCursor)
-          );
+          return toolResult(page(pickFields(result.data, BUILD_SUMMARY_FIELDS), result.nextCursor));
         }
         return toolResult(await activityRows(client, params));
       })
@@ -243,8 +245,8 @@ export function registerBuildTools(server: McpServer, client: TaigaClient) {
           client.getBuildRun(params.buildId),
           client.listBuildRunSteps(params.buildId),
         ]);
-        const runRow = run.data as Record<string, unknown>;
-        const rows = steps.data as Record<string, unknown>[];
+        const runRow = run.data;
+        const rows = steps.data;
         const where = stoppedIn(runRow, rows);
         const stop = where ? { stoppedIn: where } : {};
         if (params.full) return toolResult({ ...runRow, ...stop, steps: steps.data });
@@ -278,7 +280,7 @@ export function registerBuildTools(server: McpServer, client: TaigaClient) {
     (params) =>
       runTool(async () => {
         const result = await client.stopBuildRun(params.buildId);
-        return toolResult(pickFields([result.data as Record<string, unknown>], RUN_OUTCOME_FIELDS)[0]);
+        return toolResult(pickFields([result.data], RUN_OUTCOME_FIELDS)[0]);
       })
   );
 }

package/src/tools/catalogue.test.ts

@@ -104,7 +104,7 @@ describe('tool descriptions against the catalogue', () => {
     const tools = await allTools();
     const list = tools.find((t) => t.name === 'taiga_list_documents')!;
     const get = tools.find((t) => t.name === 'taiga_get_document')!;
-    const typeEnum = (get.inputSchema.properties as Record<string, { enum?: string[] }>).type!.enum;
+    const typeEnum = (get.inputSchema.properties as Record<string, { enum?: string[] }>)['type']!.enum;
 
     for (const type of POLICY_TYPES) {
       expect(list.description, type).toContain(type);
@@ -118,10 +118,10 @@ describe('tool descriptions against the catalogue', () => {
     const props = (name: string) =>
       tools.find((t) => t.name === name)!.inputSchema.properties as Record<string, { enum?: string[] }>;
 
-    expect(props('taiga_list_products').status!.enum).toEqual([...PRODUCT_STATUSES]);
-    expect(props('taiga_get_product_document').type!.enum).toEqual([...PRODUCT_DOCUMENT_TYPES]);
-    expect(props('taiga_get_product_document').origin!.enum).toEqual(['plan', 'reality']);
-    expect(props('taiga_get_factory_document').type!.enum).toEqual([...FACTORY_DOCUMENT_TYPES]);
+    expect(props('taiga_list_products')['status']!.enum).toEqual([...PRODUCT_STATUSES]);
+    expect(props('taiga_get_product_document')['type']!.enum).toEqual([...PRODUCT_DOCUMENT_TYPES]);
+    expect(props('taiga_get_product_document')['origin']!.enum).toEqual(['plan', 'reality']);
+    expect(props('taiga_get_factory_document')['type']!.enum).toEqual([...FACTORY_DOCUMENT_TYPES]);
   });
 
   it('has a display name for every product document type, the one the web uses', () => {

package/src/tools/context.ts

@@ -1,20 +1,24 @@
 import type { McpServer, CallToolResult } from '@modelcontextprotocol/server';
 import { isSettledOrArchived } from '@taiga/types';
+import type { BacklogItem, Product } from '@taiga/types';
 import { z } from 'zod';
-import { TaigaApiError, type TaigaClient } from '../client.js';
+import { TaigaApiError, type TaigaClient, type WithoutTenant } from '../client.js';
 import { READ_ONLY } from './annotations.js';
 import { BACKLOG_SUMMARY_FIELDS } from './backlogs.js';
-import {
-  POLICY_TYPES,
-  defaultOriginFor,
-  isImportedProduct,
-  setupNextStep,
-  type ProductSettingsView,
-} from './catalogue.js';
+import { POLICY_TYPES, defaultOriginFor, isImportedProduct, setupNextStep } from './catalogue.js';
 import { apiFailureText, isNetworkFailure, networkFailureDetail, runTool, toolError, toolResult } from './errors.js';
 import { productId, remoteUrl, slug } from './inputs.js';
 import { PRODUCT_SUMMARY_FIELDS, resolveProductRef } from './products.js';
-import { budgetSections, instructionsText, isRecord, sectionContent, sectionsOf, stripProvenance } from './sections.js';
+import {
+  budgetSections,
+  instructionsText,
+  isRecord,
+  sectionContent,
+  sectionsOf,
+  stripProvenance,
+  type DocumentData,
+  type StoredDocument,
+} from './sections.js';
 import { itemRows, pickFields } from './summarize.js';
 
 /**
@@ -72,7 +76,7 @@ export const DOCUMENT_BUDGET = 12_000;
  * which a session's opening read does not need. The full read keeps them.
  * Says whether any were dropped, so the bundle can tell the reader.
  */
-function withoutCitations(doc: Record<string, unknown>): { doc: Record<string, unknown>; dropped: boolean } {
+function withoutCitations(doc: StoredDocument): { doc: StoredDocument; dropped: boolean } {
   const sections = isRecord(doc.data) ? sectionsOf(doc.data) : null;
   if (!sections) return { doc, dropped: false };
   let dropped = false;
@@ -84,7 +88,7 @@ function withoutCitations(doc: Record<string, unknown>): { doc: Record<string, u
       return [id, rest];
     })
   );
-  return { doc: { ...doc, data: { ...(doc.data as Record<string, unknown>), sections: kept } }, dropped };
+  return { doc: { ...doc, data: { ...(doc.data as DocumentData), sections: kept } }, dropped };
 }
 
 /**
@@ -133,7 +137,7 @@ function isNotFound(reason: unknown): boolean {
 
 /** The factory's standing guidance in full; null, with a note, when none is published or it is not section-shaped. */
 async function factoryPart(client: TaigaClient, factoryId: string) {
-  const factory = (await client.getFactory(factoryId)).data as Record<string, unknown>;
+  const factory = (await client.getFactory(factoryId)).data;
   const base = { id: factory.id, name: factory.name, slug: factory.slug };
   try {
     const doc = (await client.getFactoryDocument(factoryId, 'factory_instructions')).data;
@@ -165,9 +169,9 @@ async function factoryPart(client: TaigaClient, factoryId: string) {
  * outline by default, the whole sections up to a budget or in full when
  * asked. Null, with a note, where unpublished.
  */
-async function documentsPart(client: TaigaClient, product: Record<string, unknown>, depth: DocumentDepth) {
-  const productId = String(product.id);
-  const origin = defaultOriginFor(product as ProductSettingsView);
+async function documentsPart(client: TaigaClient, product: WithoutTenant<Product>, depth: DocumentDepth) {
+  const productId = product.id;
+  const origin = defaultOriginFor(product);
   const reads = await Promise.allSettled(
     CONTEXT_DOCUMENT_TYPES.map((type) => client.getProductDocument(productId, type, origin))
   );
@@ -176,7 +180,7 @@ async function documentsPart(client: TaigaClient, product: Record<string, unknow
   CONTEXT_DOCUMENT_TYPES.forEach((type, index) => {
     const read = reads[index]!;
     if (read.status === 'fulfilled') {
-      const doc = stripProvenance(read.value.data as Record<string, unknown>);
+      const doc = stripProvenance(read.value.data);
       if (depth === 'full') out[type] = doc;
       else if (depth === 'budget') {
         const lean = withoutCitations(doc);
@@ -200,7 +204,7 @@ async function documentsPart(client: TaigaClient, product: Record<string, unknow
           );
         } else out[type] = cut.doc;
       } else {
-        const sections = sectionsOf((doc.data as Record<string, unknown>) ?? {});
+        const sections = sectionsOf(doc.data ?? {});
         if (sections) {
           // Each id with the length of its text, so the next read is sized before it is
           // made (a reality section's citations come on top).
@@ -224,14 +228,14 @@ async function documentsPart(client: TaigaClient, product: Record<string, unknow
 
 /** Every published policy as its section ids, so the model knows which one to read with taiga_get_document. */
 async function policiesPart(client: TaigaClient) {
-  const rows = (await client.listTenantDocuments({ limit: 100 })).data as Record<string, unknown>[];
+  const rows = (await client.listTenantDocuments({ limit: 100 })).data;
   return rows
     .filter((row) => (POLICY_TYPES as readonly string[]).includes(String(row.type)) && row.isDraft === false)
     .map((row) => ({
       type: row.type,
       name: row.name,
       version: row.version,
-      sections: Object.keys(sectionsOf((row.data as Record<string, unknown>) ?? {}) ?? {}),
+      sections: Object.keys(sectionsOf(row.data ?? {}) ?? {}),
     }));
 }
 
@@ -249,7 +253,7 @@ const OPEN_BACKLOG_STATUSES = ['backlog', 'in_progress'] as const;
 async function backlogPart(client: TaigaClient, productId: string) {
   // Keyed by id: an item that moves from backlog to in_progress between the
   // two reads would otherwise appear twice.
-  const open = new Map<string, Record<string, unknown>>();
+  const open = new Map<string, WithoutTenant<BacklogItem>>();
   let truncated = false;
   let pageCapped = false;
   for (const status of OPEN_BACKLOG_STATUSES) {
@@ -261,10 +265,8 @@ async function backlogPart(client: TaigaClient, productId: string) {
         break;
       }
       const result = await client.listBacklogItems(productId, { status, limit: 100, cursor });
-      for (const row of result.data as Record<string, unknown>[]) {
-        if (
-          !isSettledOrArchived({ status: String(row.status), archivedAt: (row.archivedAt as string | null) ?? null })
-        ) {
+      for (const row of result.data) {
+        if (!isSettledOrArchived({ status: String(row.status), archivedAt: row.archivedAt ?? null })) {
           open.set(String(row.id), row);
         }
       }
@@ -301,22 +303,22 @@ async function backlogPart(client: TaigaClient, productId: string) {
 async function repositoriesPart(client: TaigaClient, productId: string) {
   const result = await client.listProductRepositories(productId);
   return {
-    items: pickFields(result.data as Record<string, unknown>[], REPOSITORY_SUMMARY_FIELDS),
+    items: pickFields(result.data, REPOSITORY_SUMMARY_FIELDS),
     truncated: result.nextCursor !== null,
   };
 }
 
 async function buildsPart(client: TaigaClient, productId: string) {
-  const rows = (await client.listBuildRuns(productId, { limit: BUILDS_IN_CONTEXT })).data as Record<string, unknown>[];
+  const rows = (await client.listBuildRuns(productId, { limit: BUILDS_IN_CONTEXT })).data;
   return pickFields(rows, CONTEXT_BUILD_FIELDS);
 }
 
 export async function productContext(
   client: TaigaClient,
-  product: Record<string, unknown>,
+  product: WithoutTenant<Product>,
   options: { documents: DocumentDepth }
 ): Promise<CallToolResult> {
-  const productId = String(product.id);
+  const productId = product.id;
   const granted = (part: Part) => client.hasCapability(PARTS[part]);
   const notGranted = (Object.keys(PARTS) as Part[]).filter((part) => !granted(part));
 
@@ -335,8 +337,8 @@ export async function productContext(
   const bundle: Record<string, unknown> = {
     product: {
       ...pickFields([product], PRODUCT_SUMMARY_FIELDS)[0],
-      projectType: isImportedProduct(product as ProductSettingsView) ? 'brownfield' : 'greenfield',
-      defaultOrigin: defaultOriginFor(product as ProductSettingsView),
+      projectType: isImportedProduct(product) ? 'brownfield' : 'greenfield',
+      defaultOrigin: defaultOriginFor(product),
       // A product in setup says what it waits for: nothing else in the bundle does.
       ...(nextStep ? { nextStep } : {}),
     },

package/src/tools/documents.ts

@@ -1,6 +1,7 @@
 import type { McpServer } from '@modelcontextprotocol/server';
+import type { FactoryDocument, TenantDocument } from '@taiga/types';
 import { z } from 'zod';
-import { TaigaApiError, type TaigaClient, type TaigaDocument } from '../client.js';
+import { TaigaApiError, type TaigaClient, type TaigaDocument, type WithoutTenant } from '../client.js';
 import { READ_ONLY } from './annotations.js';
 import { idInput, pagination } from './inputs.js';
 import {
@@ -27,7 +28,10 @@ import { page, pickFields } from './summarize.js';
  */
 const DOCUMENT_SUMMARY_FIELDS = ['type', 'name', 'description', 'version', 'isDraft', 'hasDraft', 'updatedAt'] as const;
 
-const summaries = (rows: unknown[]) => pickFields(rows as Record<string, unknown>[], DOCUMENT_SUMMARY_FIELDS);
+/** A row of the company or factory document list; product documents list through their own tools. */
+type ListedDocument = WithoutTenant<TenantDocument | FactoryDocument>;
+
+const summaries = (rows: ListedDocument[]) => pickFields(rows, DOCUMENT_SUMMARY_FIELDS);
 
 /** What a lookup behind a miss said when it failed, so an unknown stays unknown. */
 function failedLookup(what: string, reason: unknown): string {
@@ -36,10 +40,10 @@ function failedLookup(what: string, reason: unknown): string {
 }
 
 /** `a (v3), b (v1)` for a not-found message. */
-function publishedList(rows: unknown[]): string {
+function publishedList(rows: ListedDocument[]): string {
   // The list routes return the latest draft rows beside the published ones,
   // and a draft named as published sends the model into a second miss.
-  return (rows as { type: string; version: unknown; isDraft: boolean }[])
+  return rows
     .filter((row) => row.isDraft === false)
     .map((row) => `${row.type} (v${String(row.version)})`)
     .join(', ');

package/src/tools/hints.ts

@@ -6,8 +6,11 @@ import { AsyncLocalStorage } from 'node:async_hooks';
  * hears only that guesses another ID, or a name. Each ID a tool takes names
  * the tool that lists the right ones; the tool's arguments say which apply.
  */
+const ITEM_ID_HINT =
+  "taiga_list_backlog_items lists a product's initiatives with their IDs; a run or plan ID is not one.";
+
 const BY_ARGUMENT: Record<string, string> = {
-  itemId: "taiga_list_backlog_items lists a product's initiatives with their IDs; a run or plan ID is not one.",
+  itemId: ITEM_ID_HINT,
   backlogItemId: "taiga_list_backlog_items lists a product's initiatives with their IDs.",
   buildId: 'taiga_list_builds lists the runs, of one product or of every product the key can see.',
   planId: "taiga_get_plan gives the initiative's active plan and its ID.",
@@ -40,7 +43,7 @@ const BY_TOOL: Record<string, Hint> = {
     /\bplan\b/i.test(said)
       ? 'taiga_get_backlog_item says whether one is being generated (planningStatus planning) or failed, and ' +
         'taiga_plan_again asks for a new one.'
-      : BY_ARGUMENT.itemId,
+      : ITEM_ID_HINT,
 };
 
 /** The hint for a 404 from one tool call: the tool's own, else one per ID it was given. */

package/src/tools/inbox.ts

@@ -14,8 +14,6 @@ import { page, pickFields } from './summarize.js';
  * everybody, so these tools say what they clear.
  */
 
-type Row = Record<string, unknown>;
-
 const ITEM_FIELDS = [
   'id',
   'productId',
@@ -95,7 +93,7 @@ export function registerInboxTools(server: McpServer, client: TaigaClient) {
         // one until its snooze ends, and so does this, so an agent does not
         // act on what the team put off.
         const now = Date.now();
-        const rows = result.data as Row[];
+        const rows = result.data;
         const due = rows.filter(
           (row) =>
             !(row.status === 'snoozed' && typeof row.snoozedUntil === 'string' && Date.parse(row.snoozedUntil) > now)
@@ -139,7 +137,7 @@ export function registerInboxTools(server: McpServer, client: TaigaClient) {
           ...(params.cursor === undefined ? { withTotal: true } : {}),
         });
         return toolResult({
-          ...page(pickFields(result.data as Row[], SETUP_TASK_FIELDS), result.nextCursor),
+          ...page(pickFields(result.data, SETUP_TASK_FIELDS), result.nextCursor),
           ...totalOf(result),
         });
       })
@@ -181,7 +179,7 @@ export function registerInboxTools(server: McpServer, client: TaigaClient) {
           ...(params.status !== undefined ? { status: params.status } : {}),
           ...(params.snoozedUntil !== undefined ? { snoozedUntil: params.snoozedUntil } : {}),
         });
-        return toolResult(pickFields([result.data as Row], ITEM_FIELDS)[0]);
+        return toolResult(pickFields([result.data], ITEM_FIELDS)[0]);
       })
   );
 }

package/src/tools/jobs.ts

@@ -1,8 +1,9 @@
 import type { McpServer } from '@modelcontextprotocol/server';
 import { createdInitiativeIdsOf, createdInitiativesOf, isBacklogGenerationEmptyResult } from '@taiga/types';
 import { z } from 'zod';
+import type { AgentJob } from '@taiga/types';
 import { idInput } from './inputs.js';
-import type { TaigaClient } from '../client.js';
+import type { TaigaClient, WithoutTenant } from '../client.js';
 import { READ_ONLY } from './annotations.js';
 import { runTool, toolResult } from './errors.js';
 import { pickFields } from './summarize.js';
@@ -13,7 +14,7 @@ import { pickFields } from './summarize.js';
  * it is, and what came of it.
  */
 
-type Row = Record<string, unknown>;
+type Job = WithoutTenant<AgentJob>;
 
 /** What a job says about itself: its kind, how far it got, and why it failed. */
 const JOB_FIELDS = [
@@ -43,7 +44,7 @@ export const SETTLED_JOB_STATUSES: ReadonlySet<string> = new Set(['completed', '
  * own words and the way to decide otherwise). Null while the job runs, and
  * for a job that is not an initiative request.
  */
-function requestOutcome(job: Row): Row | null {
+function requestOutcome(job: Job) {
   if (job.type !== 'generate_backlog' || job.status !== 'completed') return null;
   const created = createdInitiativesOf(job.result);
   if (created) return { outcome: 'created', initiatives: created };
@@ -63,7 +64,7 @@ function requestOutcome(job: Row): Row | null {
 }
 
 /** A job as the tools hand it over: its own fields, and for an initiative request, what came of it. */
-export function jobReport(job: Row): Row {
+export function jobReport(job: Job) {
   const outcome = requestOutcome(job);
   return { ...pickFields([job], JOB_FIELDS)[0], ...(outcome ? { outcome } : {}) };
 }
@@ -85,6 +86,6 @@ export function registerJobTools(server: McpServer, client: TaigaClient) {
       inputSchema: z.object({ jobId: idInput('job', 'the tool that started the job returned it') }),
       annotations: READ_ONLY,
     },
-    (params) => runTool(async () => toolResult(jobReport((await client.getAgentJob(params.jobId)).data as Row)))
+    (params) => runTool(async () => toolResult(jobReport((await client.getAgentJob(params.jobId)).data)))
   );
 }