@stratta/mcp 0.10.0 → 0.12.1

package/dist/tools/dossier.d.ts

@@ -11,6 +11,8 @@ export declare const openQuestion: import("./define.js").ToolDef<{
     options: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }>;
 export declare const saveFinding: import("./define.js").ToolDef<{
+    attachmentId: z.ZodOptional<z.ZodString>;
+    attachmentPage: z.ZodOptional<z.ZodNumber>;
     title: z.ZodString;
     detail: z.ZodOptional<z.ZodString>;
     value: z.ZodOptional<z.ZodString>;
@@ -32,6 +34,7 @@ export declare const saveFinding: import("./define.js").ToolDef<{
     }>;
 }>;
 export declare const recordDecision: import("./define.js").ToolDef<{
+    confirmed: z.ZodOptional<z.ZodBoolean>;
     title: z.ZodString;
     detail: z.ZodOptional<z.ZodString>;
     value: z.ZodOptional<z.ZodString>;
@@ -54,6 +57,30 @@ export declare const loadDossier: import("./define.js").ToolDef<{
 export declare const resolveQuestion: import("./define.js").ToolDef<{
     questionId: z.ZodString;
     resolved: z.ZodOptional<z.ZodBoolean>;
+    confirmed: z.ZodOptional<z.ZodBoolean>;
+}>;
+export declare const listAttachments: import("./define.js").ToolDef<{
+    dossierId: z.ZodString;
+}>;
+export declare const readAttachment: import("./define.js").ToolDef<{
+    attachmentId: z.ZodString;
+    from: z.ZodOptional<z.ZodNumber>;
+    to: z.ZodOptional<z.ZodNumber>;
+    maxChars: z.ZodOptional<z.ZodNumber>;
+}>;
+export declare const searchInDossier: import("./define.js").ToolDef<{
+    dossierId: z.ZodString;
+    keyword: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+}>;
+export declare const addAttachment: import("./define.js").ToolDef<{
+    dossierId: z.ZodString;
+    filePath: z.ZodString;
+}>;
+export declare const listTemplates: import("./define.js").ToolDef<{}>;
+export declare const applyTemplate: import("./define.js").ToolDef<{
+    dossierId: z.ZodString;
+    templateId: z.ZodString;
 }>;
 export declare const dossierTools: (import("./define.js").ToolDef<{}> | import("./define.js").ToolDef<{
     name: z.ZodString;
@@ -64,6 +91,8 @@ export declare const dossierTools: (import("./define.js").ToolDef<{}> | import("
     body: z.ZodOptional<z.ZodString>;
     options: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }> | import("./define.js").ToolDef<{
+    attachmentId: z.ZodOptional<z.ZodString>;
+    attachmentPage: z.ZodOptional<z.ZodNumber>;
     title: z.ZodString;
     detail: z.ZodOptional<z.ZodString>;
     value: z.ZodOptional<z.ZodString>;
@@ -84,6 +113,7 @@ export declare const dossierTools: (import("./define.js").ToolDef<{}> | import("
         observation: "observation";
     }>;
 }> | import("./define.js").ToolDef<{
+    confirmed: z.ZodOptional<z.ZodBoolean>;
     title: z.ZodString;
     detail: z.ZodOptional<z.ZodString>;
     value: z.ZodOptional<z.ZodString>;
@@ -104,4 +134,22 @@ export declare const dossierTools: (import("./define.js").ToolDef<{}> | import("
 }> | import("./define.js").ToolDef<{
     questionId: z.ZodString;
     resolved: z.ZodOptional<z.ZodBoolean>;
+    confirmed: z.ZodOptional<z.ZodBoolean>;
+}> | import("./define.js").ToolDef<{
+    dossierId: z.ZodString;
+}> | import("./define.js").ToolDef<{
+    attachmentId: z.ZodString;
+    from: z.ZodOptional<z.ZodNumber>;
+    to: z.ZodOptional<z.ZodNumber>;
+    maxChars: z.ZodOptional<z.ZodNumber>;
+}> | import("./define.js").ToolDef<{
+    dossierId: z.ZodString;
+    keyword: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+}> | import("./define.js").ToolDef<{
+    dossierId: z.ZodString;
+    filePath: z.ZodString;
+}> | import("./define.js").ToolDef<{
+    dossierId: z.ZodString;
+    templateId: z.ZodString;
 }>)[];

package/dist/tools/dossier.js

@@ -1,86 +1,58 @@
+import { readFileSync } from 'node:fs';
+import { basename, extname } from 'node:path';
 import { z } from 'zod';
 import { api } from '../client.js';
 import { requireApiKey } from '../auth.js';
+import { catalogEntry, param } from './catalog.gen.js';
 import { defineTool } from './define.js';
 /**
  * The seven dossier tools: how the work survives the conversation.
  *
- * Everything else here reads a norm. These write down what was decided with
- * it, so the next conversation starts where the last one stopped and a human
- * can review it in the app.
- *
- * A dossier is a set of QUESTIONS. Each question holds the evidence gathered
+ * A dossier is a set of questions. Each question holds the evidence gathered
  * for it, the options on the table and, once the engineer has confirmed it, a
  * decision. The question is the unit of work: it is what gets assigned,
- * reviewed and closed. The first model was a flat journal, and the one real
- * dossier it produced held a single "question" with eight sub-questions in its
- * body — unassignable, unanswerable one at a time, unreadable.
+ * reviewed and closed.
  *
- * The descriptions carry more instruction than the read tools do, on purpose.
- * An agent left to guess will either record nothing — and the feature is dead
- * — or record every sentence it produces, which buries the three decisions
- * that mattered. `get_methodology` tells it when to open a dossier; these tell
- * it what is worth putting in one, and in what shape.
+ * Names, descriptions and annotations come from the generated catalogue,
+ * shared with the remote transport. `get_methodology` tells the agent when to
+ * open a dossier; the descriptions tell it what is worth putting in one.
  */
-const write = { readOnlyHint: false, openWorldHint: false };
-const readOnly = { readOnlyHint: true, openWorldHint: false };
-const dossierId = z
-    .string()
-    .min(1)
-    .describe('Dossier id returned by open_dossier or list_dossiers.');
-const questionId = z
-    .string()
-    .min(1)
-    .describe('Question id returned by open_question or load_dossier.');
+const headOf = (name) => {
+    const entry = catalogEntry(name);
+    return {
+        name,
+        title: entry.title,
+        description: entry.description,
+        annotations: entry.annotations,
+    };
+};
+const dossierId = (tool) => z.string().min(1).describe(param(tool, 'dossierId'));
+const questionId = (tool) => z.string().min(1).describe(param(tool, 'questionId'));
 /** The fields a piece of evidence or a decision carries. */
-const entryFields = {
-    title: z
-        .string()
-        .min(1)
-        .max(200)
-        .describe('The fact in one line, as an engineer would write it in a report. One clause, one value or one observation; not a theme.'),
-    detail: z
-        .string()
-        .max(4000)
-        .optional()
-        .describe('The reasoning, in one or two sentences: why this value, what it rests on, what disagreed. Required in practice for a hypothesis.'),
-    value: z
-        .string()
-        .max(120)
-        .optional()
-        .describe('The retained value WITH its unit, e.g. "30°", "1,25 kN/m²".'),
+const entryFields = (tool) => ({
+    title: z.string().min(1).max(200).describe(param(tool, 'title')),
+    detail: z.string().max(4000).optional().describe(param(tool, 'detail')),
+    value: z.string().max(120).optional().describe(param(tool, 'value')),
     confidence: z
         .enum(['established', 'judgement', 'to_confirm'])
         .optional()
-        .describe('How firm the value is. See the tool description.'),
-    normCode: z
-        .string()
-        .max(40)
-        .optional()
-        .describe('Norm this comes from, e.g. "SIA 267".'),
+        .describe(param(tool, 'confidence')),
+    normCode: z.string().max(40).optional().describe(param(tool, 'normCode')),
     sectionPath: z
         .string()
         .max(60)
         .optional()
-        .describe('Exact section path, e.g. "9.5.2.1".'),
-    page: z
-        .number()
-        .int()
-        .positive()
-        .optional()
-        .describe('Page in the norm, so a human can verify it in their PDF.'),
+        .describe(param(tool, 'sectionPath')),
+    page: z.number().int().positive().optional().describe(param(tool, 'page')),
     normEdition: z
         .string()
         .max(40)
         .optional()
-        .describe('The edition cited, e.g. "2013" or "2020 + rect. 2022", when list_norms gives it.'),
-};
+        .describe(param(tool, 'normEdition')),
+});
 export const listDossiers = defineTool({
-    name: 'list_dossiers',
-    title: 'List dossiers',
-    description: 'List the dossiers of YOUR organisation, most recently touched first. A dossier is a project record: the questions to settle, what was decided, what it rests on. Call this when the user mentions a project by name, or asks what they were working on. Each row carries the count of entries and of OPEN questions — a dossier with open questions is the one to resume.',
+    ...headOf('list_dossiers'),
     inputSchema: {},
-    annotations: readOnly,
     run: async (client) => ({
         dossiers: await client.action(api.dossiersApi.listDossiers, {
             apiKey: requireApiKey(),
@@ -88,22 +60,15 @@ export const listDossiers = defineTool({
     }),
 });
 export const openDossier = defineTool({
-    name: 'open_dossier',
-    title: 'Open a dossier',
-    description: "Open the dossier for a project, creating it if it does not exist yet. IDEMPOTENT on the name: calling it twice with the same name returns the same dossier rather than splitting a project's history in two. Call this when the user starts working on a named project and there is something worth keeping — a question to settle, a retained value, an assumption, a site observation. Do not open one for a passing lookup. Returns { dossierId, created }.",
+    ...headOf('open_dossier'),
     inputSchema: {
-        name: z
-            .string()
-            .min(1)
-            .max(120)
-            .describe('How the user refers to the project, e.g. "Villa Morges — toiture". Reuse their words: this is the name they will search for.'),
+        name: z.string().min(1).max(120).describe(param('open_dossier', 'name')),
         reference: z
             .string()
             .max(60)
             .optional()
-            .describe("The bureau's own project number, if the user gave one."),
+            .describe(param('open_dossier', 'reference')),
     },
-    annotations: { ...write, idempotentHint: true },
     run: (client, args) => client.action(api.dossiersApi.openDossier, {
         apiKey: requireApiKey(),
         name: args.name,
@@ -111,32 +76,21 @@ export const openDossier = defineTool({
     }),
 });
 export const openQuestion = defineTool({
-    name: 'open_question',
-    title: 'Open a question',
-    description: `Open ONE question to settle in a dossier, BEFORE gathering evidence for it. A question is the unit of work: "Can pile P38 be kept?", "Which φ'k do we retain for the fill?", "Is kinematic interaction to be checked?". Evidence saved with save_finding and the eventual record_decision hang off it.
-
-ONE QUESTION PER THING TO SETTLE. Never put a list of sub-questions in the body: a question that bundles eight cannot be assigned, answered or closed one at a time. Open eight questions.
-
-IDEMPOTENT on the title: reopening the same wording returns the question already open, with its evidence. Name the options on the table in \`options\` when the user or the norm puts several forward ("abandon the pile", "recover it by re-concreting plus integrity tests", "redistribute onto P37/P39"). Returns { questionId, created }.`,
+    ...headOf('open_question'),
     inputSchema: {
-        dossierId,
-        title: z
-            .string()
-            .min(1)
-            .max(200)
-            .describe('The question in one line, phrased as a question.'),
+        dossierId: dossierId('open_question'),
+        title: z.string().min(1).max(200).describe(param('open_question', 'title')),
         body: z
             .string()
             .max(4000)
             .optional()
-            .describe('What is at stake and why it is not settled, in two or three sentences. Not a list of sub-questions.'),
+            .describe(param('open_question', 'body')),
         options: z
             .array(z.string().min(1).max(120))
             .max(10)
             .optional()
-            .describe('The ways this could be settled, one short name each.'),
+            .describe(param('open_question', 'options')),
     },
-    annotations: { ...write, idempotentHint: true },
     run: (client, args) => client.action(api.dossiersApi.openQuestion, {
         apiKey: requireApiKey(),
         dossierId: args.dossierId,
@@ -146,75 +100,66 @@ IDEMPOTENT on the title: reopening the same wording returns the question already
     }),
 });
 export const saveFinding = defineTool({
-    name: 'save_finding',
-    title: 'Record evidence in a dossier',
-    description: `Record ONE piece of evidence in a dossier. Call it as you work, not in a batch at the end — a finding saved when it is made carries the reasoning that produced it.
-
-WHAT TO RECORD, by kind:
-- reference: what a norm says, that the project relies on. ALWAYS fill normCode + sectionPath (+ page). If you cannot cite it, it is not a reference.
-- hypothesis: a value the engineer RETAINS, and why. This is the one that matters most in geotechnics, where a retained value is a judgement between disagreeing measurements rather than the output of a formula. Put the number in \`value\` and the reasoning in \`detail\`.
-- observation: what the site, a borehole, or a survey showed. Include the date in \`detail\` when known.
-
-KEEP IT SHORT: one clause, one value or one fact per call, in one or two sentences. Three short entries beat one paragraph that mixes the citation, the reasoning and the consequence. A question is NOT recorded here: call open_question. A decision is NOT recorded here: call record_decision.
-
-FILE IT: pass \`questionId\` so the entry lands under the question it serves. If you do not yet know which question it serves, save it anyway without one — the engineer files it later.
-
-Set \`confidence\` whenever the entry is a value: established (computed or read directly), judgement (the engineer chose it), to_confirm (provisional, needs a test or a check). Confusing those three is the professional fault this field exists to prevent.`,
+    ...headOf('save_finding'),
     inputSchema: {
-        dossierId,
-        questionId: questionId
-            .optional()
-            .describe('The question this evidence serves, from open_question or load_dossier. Omit only when you do not know yet.'),
+        dossierId: dossierId('save_finding'),
+        questionId: questionId('save_finding').optional(),
         kind: z
             .enum(['reference', 'hypothesis', 'observation'])
-            .describe('See the tool description: pick by what the entry IS.'),
-        ...entryFields,
+            .describe(param('save_finding', 'kind')),
+        ...entryFields('save_finding'),
+        attachmentId: z
+            .string()
+            .optional()
+            .describe(param('save_finding', 'attachmentId')),
+        attachmentPage: z
+            .number()
+            .int()
+            .min(1)
+            .optional()
+            .describe(param('save_finding', 'attachmentPage')),
     },
-    annotations: write,
     run: (client, args) => client.action(api.dossiersApi.saveFinding, {
         apiKey: requireApiKey(),
         ...args,
     }),
 });
 export const recordDecision = defineTool({
-    name: 'record_decision',
-    title: 'Record a decision',
-    description: `Settle a question with a decision the engineer has CONFIRMED: what was decided, why, and the clause it rests on. The question leaves the open items and keeps its evidence; the decision becomes the entry a reviewer reads first.
-
-Only call this once the user has confirmed the decision, never on your own reasoning. Name the retained option in \`retainedOption\` when the question listed some (the name as it was given; an option not listed yet is created). Put the number in \`value\` when the decision is a value, and set \`confidence\`. Returns { entryId }.`,
+    ...headOf('record_decision'),
     inputSchema: {
-        questionId,
+        questionId: questionId('record_decision'),
         retainedOption: z
             .string()
             .max(120)
             .optional()
-            .describe('The option that was retained, by name.'),
-        ...entryFields,
+            .describe(param('record_decision', 'retainedOption')),
+        ...entryFields('record_decision'),
+        confirmed: z
+            .boolean()
+            .optional()
+            .describe(param('record_decision', 'confirmed')),
     },
-    annotations: write,
-    run: (client, args) => client.action(api.dossiersApi.recordDecision, {
+    // `confirmed` is read by the confirmation gate in `index.ts`, never sent.
+    run: (client, { confirmed: _confirmed, ...args }) => client.action(api.dossiersApi.recordDecision, {
         apiKey: requireApiKey(),
         ...args,
     }),
 });
 export const loadDossier = defineTool({
-    name: 'load_dossier',
-    title: 'Load a dossier',
-    description: 'Reload everything a dossier holds: its questions with their evidence, options and decisions, then the evidence not yet filed under a question, then the comments a colleague left. OPEN QUESTIONS COME FIRST — read them before anything else and tell the user what is still open. Call this whenever the user returns to a project ("reprends le dossier X", "on en était où sur Y") BEFORE answering anything about it, so you build on what was decided instead of deciding it again. Accepts either the id or the name the user uses.',
+    ...headOf('load_dossier'),
     inputSchema: {
         dossierId: z
             .string()
             .min(1)
             .optional()
-            .describe('Preferred when you have it.'),
+            .describe(param('load_dossier', 'dossierId')),
         name: z
             .string()
             .min(1)
             .max(120)
             .optional()
-            .describe('The project name, when the user names it rather than giving an id. Matched exactly; call list_dossiers first if unsure.'),
+            .describe(param('load_dossier', 'name')),
     },
-    annotations: readOnly,
     run: (client, args) => client.action(api.dossiersApi.loadDossier, {
         apiKey: requireApiKey(),
         dossierId: args.dossierId,
@@ -222,17 +167,18 @@ export const loadDossier = defineTool({
     }),
 });
 export const resolveQuestion = defineTool({
-    name: 'resolve_question',
-    title: 'Close a question',
-    description: 'Close a question that stopped mattering WITHOUT a decision: the variant was abandoned, the client withdrew the request, the point became moot. The question stays in the dossier, marked closed, with its evidence. To settle a question with an answer, call record_decision instead. Pass resolved: false to reopen a question. Only call this when the user says so, never on your own reasoning.',
+    ...headOf('resolve_question'),
     inputSchema: {
-        questionId,
+        questionId: questionId('resolve_question'),
         resolved: z
             .boolean()
             .optional()
-            .describe('Defaults to true (close). Pass false to reopen.'),
+            .describe(param('resolve_question', 'resolved')),
+        confirmed: z
+            .boolean()
+            .optional()
+            .describe(param('resolve_question', 'confirmed')),
     },
-    annotations: { ...write, idempotentHint: true },
     run: async (client, args) => {
         await client.action(api.dossiersApi.resolveQuestion, {
             apiKey: requireApiKey(),
@@ -242,6 +188,176 @@ export const resolveQuestion = defineTool({
         return { ok: true };
     },
 });
+const MIME_BY_EXT = {
+    '.pdf': 'application/pdf',
+    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.txt': 'text/plain',
+    '.md': 'text/markdown',
+    '.csv': 'text/csv',
+};
+export const listAttachments = defineTool({
+    ...headOf('list_attachments'),
+    inputSchema: {
+        dossierId: z.string().describe(param('list_attachments', 'dossierId')),
+    },
+    run: async (client, args) => {
+        const attachments = await client.action(api.dossiersApi.listAttachments, {
+            apiKey: requireApiKey(),
+            dossierId: args.dossierId,
+        });
+        if (attachments === null)
+            return { error: 'Dossier not found in your workspace.' };
+        return { dossierId: args.dossierId, attachments };
+    },
+});
+export const readAttachment = defineTool({
+    ...headOf('read_attachment'),
+    inputSchema: {
+        attachmentId: z.string().describe(param('read_attachment', 'attachmentId')),
+        from: z
+            .number()
+            .int()
+            .min(1)
+            .optional()
+            .describe(param('read_attachment', 'from')),
+        to: z
+            .number()
+            .int()
+            .min(1)
+            .optional()
+            .describe(param('read_attachment', 'to')),
+        maxChars: z
+            .number()
+            .int()
+            .min(500)
+            .max(40_000)
+            .optional()
+            .describe(param('read_attachment', 'maxChars')),
+    },
+    run: async (client, args) => {
+        const read = (await client.action(api.dossiersApi.readAttachment, {
+            apiKey: requireApiKey(),
+            attachmentId: args.attachmentId,
+            from: args.from,
+            to: args.to,
+            maxChars: args.maxChars,
+        }));
+        if (read === null) {
+            return {
+                error: 'Attachment not found in your workspace. Call list_attachments on the dossier.',
+            };
+        }
+        return read;
+    },
+    toContent: (result) => {
+        const r = result;
+        if (r.error || !r.markdown) {
+            return {
+                content: [{ type: 'text', text: r.error ?? 'Attachment unavailable.' }],
+                isError: true,
+            };
+        }
+        const { markdown, ...structured } = r;
+        return {
+            content: [{ type: 'text', text: markdown }],
+            structuredContent: { ...structured, markdown },
+        };
+    },
+});
+export const searchInDossier = defineTool({
+    ...headOf('search_in_dossier'),
+    inputSchema: {
+        dossierId: z.string().describe(param('search_in_dossier', 'dossierId')),
+        keyword: z
+            .string()
+            .min(1)
+            .max(200)
+            .describe(param('search_in_dossier', 'keyword')),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(30)
+            .optional()
+            .describe(param('search_in_dossier', 'limit')),
+    },
+    run: async (client, args) => {
+        const hits = await client.action(api.dossiersApi.searchInDossier, {
+            apiKey: requireApiKey(),
+            dossierId: args.dossierId,
+            keyword: args.keyword,
+            limit: args.limit,
+        });
+        if (hits === null)
+            return { error: 'Dossier not found in your workspace.' };
+        return { keyword: args.keyword, hits };
+    },
+});
+export const addAttachment = defineTool({
+    ...headOf('add_attachment'),
+    inputSchema: {
+        dossierId: z.string().describe(param('add_attachment', 'dossierId')),
+        filePath: z.string().min(1).describe(param('add_attachment', 'filePath')),
+    },
+    run: async (client, args) => {
+        const mimeType = MIME_BY_EXT[extname(args.filePath).toLowerCase()];
+        if (!mimeType) {
+            return {
+                error: `Unsupported file type "${extname(args.filePath)}". Allowed: ${Object.keys(MIME_BY_EXT).join(', ')}.`,
+            };
+        }
+        let bytes;
+        try {
+            bytes = readFileSync(args.filePath);
+        }
+        catch {
+            return {
+                error: `Cannot read ${args.filePath}. Check the path with the user.`,
+            };
+        }
+        if (bytes.byteLength > 25 * 1024 * 1024) {
+            return { error: 'A file is limited to 25 MB.' };
+        }
+        const { attachmentId } = await client.action(api.dossiersApi.uploadAttachment, {
+            apiKey: requireApiKey(),
+            dossierId: args.dossierId,
+            name: basename(args.filePath),
+            mimeType,
+            base64: bytes.toString('base64'),
+        });
+        return {
+            attachmentId,
+            name: basename(args.filePath),
+            bytes: bytes.byteLength,
+            note: 'Text extraction runs in the background; list_attachments shows when it is ready.',
+        };
+    },
+});
+export const listTemplates = defineTool({
+    ...headOf('list_templates'),
+    inputSchema: {},
+    run: async (client) => ({
+        templates: await client.action(api.dossiersApi.listTemplates, {
+            apiKey: requireApiKey(),
+        }),
+    }),
+});
+export const applyTemplate = defineTool({
+    ...headOf('apply_template'),
+    inputSchema: {
+        dossierId: z.string().describe(param('apply_template', 'dossierId')),
+        templateId: z.string().describe(param('apply_template', 'templateId')),
+    },
+    run: (client, args) => client.action(api.dossiersApi.applyTemplate, {
+        apiKey: requireApiKey(),
+        dossierId: args.dossierId,
+        templateId: args.templateId,
+    }),
+});
 export const dossierTools = [
     listDossiers,
     openDossier,
@@ -250,4 +366,10 @@ export const dossierTools = [
     recordDecision,
     loadDossier,
     resolveQuestion,
+    listAttachments,
+    readAttachment,
+    searchInDossier,
+    addAttachment,
+    listTemplates,
+    applyTemplate,
 ];

package/dist/tools/ingest.d.ts

@@ -13,6 +13,8 @@ export declare const ingestCreateDocument: import("./define.js").ToolDef<{
         en: "en";
     }>;
     totalPages: z.ZodNumber;
+    scope: z.ZodOptional<z.ZodString>;
+    edition: z.ZodOptional<z.ZodString>;
 }>;
 export declare const ingestCreateSections: import("./define.js").ToolDef<{
     documentId: z.ZodString;
@@ -71,6 +73,7 @@ export declare const ingestNormalizeCrossRefs: import("./define.js").ToolDef<{
 }>;
 export declare const ingestPublish: import("./define.js").ToolDef<{
     documentId: z.ZodString;
+    force: z.ZodOptional<z.ZodBoolean>;
 }>;
 export declare const ingestDelete: import("./define.js").ToolDef<{
     documentId: z.ZodString;
@@ -88,6 +91,8 @@ export declare const ingestTools: (import("./define.js").ToolDef<{
         en: "en";
     }>;
     totalPages: z.ZodNumber;
+    scope: z.ZodOptional<z.ZodString>;
+    edition: z.ZodOptional<z.ZodString>;
 }> | import("./define.js").ToolDef<{
     documentId: z.ZodString;
     sections: z.ZodArray<z.ZodObject<{
@@ -137,4 +142,7 @@ export declare const ingestTools: (import("./define.js").ToolDef<{
     figureNumber: z.ZodString;
 }> | import("./define.js").ToolDef<{
     documentId: z.ZodString;
+}> | import("./define.js").ToolDef<{
+    documentId: z.ZodString;
+    force: z.ZodOptional<z.ZodBoolean>;
 }>)[];