@stratta/mcp 0.9.8 → 0.12.0

package/dist/tools/dossier.d.ts

@@ -4,14 +4,37 @@ export declare const openDossier: import("./define.js").ToolDef<{
     name: z.ZodString;
     reference: z.ZodOptional<z.ZodString>;
 }>;
+export declare const openQuestion: import("./define.js").ToolDef<{
+    dossierId: z.ZodString;
+    title: z.ZodString;
+    body: z.ZodOptional<z.ZodString>;
+    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>;
+    confidence: z.ZodOptional<z.ZodEnum<{
+        established: "established";
+        judgement: "judgement";
+        to_confirm: "to_confirm";
+    }>>;
+    normCode: z.ZodOptional<z.ZodString>;
+    sectionPath: z.ZodOptional<z.ZodString>;
+    page: z.ZodOptional<z.ZodNumber>;
+    normEdition: z.ZodOptional<z.ZodString>;
     dossierId: z.ZodString;
+    questionId: z.ZodOptional<z.ZodString>;
     kind: z.ZodEnum<{
         reference: "reference";
         hypothesis: "hypothesis";
         observation: "observation";
-        question: "question";
     }>;
+}>;
+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>;
@@ -23,26 +46,74 @@ export declare const saveFinding: import("./define.js").ToolDef<{
     normCode: z.ZodOptional<z.ZodString>;
     sectionPath: z.ZodOptional<z.ZodString>;
     page: z.ZodOptional<z.ZodNumber>;
+    normEdition: z.ZodOptional<z.ZodString>;
+    questionId: z.ZodString;
+    retainedOption: z.ZodOptional<z.ZodString>;
 }>;
 export declare const loadDossier: import("./define.js").ToolDef<{
     dossierId: z.ZodOptional<z.ZodString>;
     name: z.ZodOptional<z.ZodString>;
 }>;
 export declare const resolveQuestion: import("./define.js").ToolDef<{
-    entryId: z.ZodString;
+    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;
     reference: z.ZodOptional<z.ZodString>;
 }> | import("./define.js").ToolDef<{
     dossierId: z.ZodString;
+    title: z.ZodString;
+    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>;
+    confidence: z.ZodOptional<z.ZodEnum<{
+        established: "established";
+        judgement: "judgement";
+        to_confirm: "to_confirm";
+    }>>;
+    normCode: z.ZodOptional<z.ZodString>;
+    sectionPath: z.ZodOptional<z.ZodString>;
+    page: z.ZodOptional<z.ZodNumber>;
+    normEdition: z.ZodOptional<z.ZodString>;
+    dossierId: z.ZodString;
+    questionId: z.ZodOptional<z.ZodString>;
     kind: z.ZodEnum<{
         reference: "reference";
         hypothesis: "hypothesis";
         observation: "observation";
-        question: "question";
     }>;
+}> | import("./define.js").ToolDef<{
+    confirmed: z.ZodOptional<z.ZodBoolean>;
     title: z.ZodString;
     detail: z.ZodOptional<z.ZodString>;
     value: z.ZodOptional<z.ZodString>;
@@ -54,10 +125,31 @@ export declare const dossierTools: (import("./define.js").ToolDef<{}> | import("
     normCode: z.ZodOptional<z.ZodString>;
     sectionPath: z.ZodOptional<z.ZodString>;
     page: z.ZodOptional<z.ZodNumber>;
+    normEdition: z.ZodOptional<z.ZodString>;
+    questionId: z.ZodString;
+    retainedOption: z.ZodOptional<z.ZodString>;
 }> | import("./define.js").ToolDef<{
     dossierId: z.ZodOptional<z.ZodString>;
     name: z.ZodOptional<z.ZodString>;
 }> | import("./define.js").ToolDef<{
-    entryId: z.ZodString;
+    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,32 +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 five dossier tools: how the work survives the conversation.
+ * 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
+ * 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 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.
+ * 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 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 = (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(param(tool, 'confidence')),
+    normCode: z.string().max(40).optional().describe(param(tool, 'normCode')),
+    sectionPath: z
+        .string()
+        .max(60)
+        .optional()
+        .describe(param(tool, 'sectionPath')),
+    page: z.number().int().positive().optional().describe(param(tool, 'page')),
+    normEdition: z
+        .string()
+        .max(40)
+        .optional()
+        .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: what was decided, what it rests on, and what is still open. 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 UNRESOLVED 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(),
@@ -34,107 +60,106 @@ 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 retained value, an assumption, a site observation, an unanswered question. 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,
         reference: args.reference,
     }),
 });
-export const saveFinding = defineTool({
-    name: 'save_finding',
-    title: 'Save a finding to a dossier',
-    description: `Record ONE decision 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.
-- question: something not settled. These surface FIRST when the dossier is reloaded, so record them even when you cannot answer — especially then.
-
-WHAT NOT TO RECORD: your own prose, intermediate steps, anything the user did not treat as a decision. A dossier of forty entries where three mattered is worse than a dossier of three.
-
-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.`,
+export const openQuestion = defineTool({
+    ...headOf('open_question'),
     inputSchema: {
-        dossierId,
-        kind: z
-            .enum(['reference', 'hypothesis', 'observation', 'question'])
-            .describe('See the tool description: pick by what the entry IS.'),
-        title: z
-            .string()
-            .min(1)
-            .max(200)
-            .describe('The decision in one line, as an engineer would write it in a report.'),
-        detail: z
+        dossierId: dossierId('open_question'),
+        title: z.string().min(1).max(200).describe(param('open_question', 'title')),
+        body: z
             .string()
             .max(4000)
             .optional()
-            .describe('The reasoning: why this value, what it rests on, what disagreed. Required in practice for a hypothesis — without it the entry cannot be reviewed.'),
-        value: z
-            .string()
-            .max(120)
-            .optional()
-            .describe('The retained value WITH its unit, e.g. "30°", "1,25 kN/m²".'),
-        confidence: z
-            .enum(['established', 'judgement', 'to_confirm'])
+            .describe(param('open_question', 'body')),
+        options: z
+            .array(z.string().min(1).max(120))
+            .max(10)
             .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 261".'),
-        sectionPath: z
+            .describe(param('open_question', 'options')),
+    },
+    run: (client, args) => client.action(api.dossiersApi.openQuestion, {
+        apiKey: requireApiKey(),
+        dossierId: args.dossierId,
+        title: args.title,
+        body: args.body,
+        options: args.options,
+    }),
+});
+export const saveFinding = defineTool({
+    ...headOf('save_finding'),
+    inputSchema: {
+        dossierId: dossierId('save_finding'),
+        questionId: questionId('save_finding').optional(),
+        kind: z
+            .enum(['reference', 'hypothesis', 'observation'])
+            .describe(param('save_finding', 'kind')),
+        ...entryFields('save_finding'),
+        attachmentId: z
             .string()
-            .max(60)
             .optional()
-            .describe('Exact section path, e.g. "14.2".'),
-        page: z
+            .describe(param('save_finding', 'attachmentId')),
+        attachmentPage: z
             .number()
             .int()
-            .positive()
+            .min(1)
             .optional()
-            .describe('Page in the norm, so a human can verify it in their PDF.'),
+            .describe(param('save_finding', 'attachmentPage')),
     },
-    annotations: write,
     run: (client, args) => client.action(api.dossiersApi.saveFinding, {
         apiKey: requireApiKey(),
         ...args,
     }),
 });
+export const recordDecision = defineTool({
+    ...headOf('record_decision'),
+    inputSchema: {
+        questionId: questionId('record_decision'),
+        retainedOption: z
+            .string()
+            .max(120)
+            .optional()
+            .describe(param('record_decision', 'retainedOption')),
+        ...entryFields('record_decision'),
+        confirmed: z
+            .boolean()
+            .optional()
+            .describe(param('record_decision', 'confirmed')),
+    },
+    // `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: retained values, what they rest on, site observations, open questions and the comments a colleague left. UNRESOLVED 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,
@@ -142,33 +167,209 @@ export const loadDossier = defineTool({
     }),
 });
 export const resolveQuestion = defineTool({
-    name: 'resolve_question',
-    title: 'Close an open question',
-    description: 'Mark a question entry as settled, once it actually is. The entry stays in the dossier — the trail of what was once uncertain is part of the record — but it stops surfacing at the top on reload. Only call this when the user has confirmed the answer, never on your own reasoning.',
+    ...headOf('resolve_question'),
     inputSchema: {
-        entryId: z
-            .string()
-            .min(1)
-            .describe('Entry id of the question, from load_dossier.'),
+        questionId: questionId('resolve_question'),
         resolved: z
             .boolean()
             .optional()
-            .describe('Defaults to true. Pass false to reopen a question.'),
+            .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(),
-            entryId: args.entryId,
+            questionId: args.questionId,
             resolved: args.resolved,
         });
         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,
+    openQuestion,
     saveFinding,
+    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>;
 }>)[];