@axonity-ai/mcp 0.7.0 → 0.9.0

package/dist/tools/company.js.map

@@ -1 +1 @@
-{"version":3,"file":"company.js","sourceRoot":"","sources":["../../src/tools/company.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"company.js","sourceRoot":"","sources":["../../src/tools/company.ts"],"names":[],"mappings":"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"}

package/dist/tools/conventions.js

@@ -257,6 +257,9 @@ made any time before you attach them.
     use rather than inventing one.
 - Complete check: the tool has the I/O schemas its callers need AND a non-empty
   implementation of the right shape for its type.
+- \`toolboxId\` files the tool in a toolbox on creation. Read \`list_toolboxes\`
+  BEFORE you create: a tool made without one is ungrouped, which is valid and
+  is also how nobody finds it. See Toolboxes below.
 
 ### agent  (\`create_agent\`, strict body)
 - Required: \`name\`. Enumerated fields, with their ONLY valid values:
@@ -321,6 +324,12 @@ made any time before you attach them.
   \`update_flow\` write draft state; runtime uses \`read_flow_published\` until
   approval. \`request_publish_flow\` to publish, \`discard_flow_draft\` to reset.
 
+### data_table
+- An authored table of rows: the tenant's own reference data, designed and
+  maintained by a person, read by agents and decisions. Same lifecycle as an
+  output schema — draft, version, request publish. See "Tables" below, which is
+  where the rules that are NOT the generic ones live.
+
 ### company
 - The tenant's single company document (mission, value streams, org structure).
   A SINGLETON — one per tenant, no id, so there is no list/create/delete:
@@ -515,6 +524,18 @@ the new tenant too, and a human fills the real value there.
   - An unknown or misspelled key is a 422 naming it, not a silent drop — so
     spelling matters and you are told when it is wrong.
 
+## Inputs and constants — the two lists that belong to the PROCESS
+A workflow declares two whole-list things of its own, both edited the same way
+(read the list, change it, write it back — there is no per-entry command,
+because the identity is the \`name\` and renaming is the common edit):
+- \`set_workflow_inputs\` — what the process NEEDS to start. Carried by every
+  start, and the list a caller fills in whichever trigger fired. A start's own
+  \`parameters\` are what that start declares on top; where a name is in both,
+  the process-level one wins.
+- \`set_workflow_constants\` — what the AUTHOR pins, described below.
+Read both back with \`read_workflow_trigger_parameters\`, which answers
+\`{ inputs, triggers, constants }\`.
+
 ## Constants — values the AUTHOR owns
 A constant is applied on EVERY run whichever trigger fired, and it OVERWRITES
 whatever a caller sent. That is deliberate: a field the operator's form does not
@@ -587,24 +608,71 @@ a document to find out what the platform did.
 - Trigger deletes are HARD deletes — no restore. Webhook tokens are shown once
   at create/rotate and are never retrievable; hand them straight to your human
   and never store one in an entity field.
+- **A schedule is a claim — check it.** \`run_cron_schedule_now\` fires one
+  immediately without moving \`nextFireAt\`, so you can prove a schedule starts
+  something instead of waiting until tomorrow to find out it does not. It runs
+  for real, with real cost and side effects.
+- **To PAUSE a schedule, disarm it** (\`set_cron_schedule_enabled\`), never
+  delete it. Deleting throws away the rules the author wrote and makes "stop
+  this for a week" indistinguishable from "we do not do this any more".
+- \`create_cron_schedule\` takes EITHER \`cronExpr\` OR \`rules\`, and the
+  trigger must exist in the PUBLISHED document. For the rule shapes, read
+  \`scheduleRuleKinds\` from \`get_workflow_authoring_spec\` — do not invent one.
+- \`list_all_cron_schedules\` answers "what runs tonight?" across the tenant;
+  \`reconcile_cron_schedules\` answers "is that actually what runs?". The second
+  reports rather than tidying silently and never arms something switched off.
 
 ## Evaluating what you built
 - There is no findings endpoint and no evaluator entity. To judge a run, read it:
   \`read_run\` (its \`validatorVerdicts\` and \`agentInvocations\`) and
   \`read_run_trace\` (the step-by-step tool calls).
+- **Start with \`read_run_outline\`, not \`read_run\`.** The outline is the run's
+  table of contents and carries no bodies, so it costs what the run's SHAPE
+  costs rather than its content — a fan-out over four thousand items reads about
+  as cheaply as one over four. Then open only what you need:
+  \`read_run_value\` for one large step value (by the digest in \`stepStates\`),
+  \`read_run_invocation_messages\` for one agent's transcript (by the id in
+  \`agentInvocations\`). Reading a whole run to find one message is the habit
+  this replaces.
+- \`itemCap\` on the outline bounds items listed per fan-out step; the remainder
+  is counted in \`counts.truncated\`, never dropped in silence.
+- **What an agent wrote to itself is readable.** \`list_run_session_memory\`
+  lists the files an agent left during a run (metadata only) and
+  \`read_run_session_memory_file\` opens one. When the trace shows a decision but
+  not what it was reading, this is usually where the reason is. Workflow-bound
+  reference material is NOT here — that lives in \`reference_docs\`.
+- **\`list_todo_steps\`** is every step in the tenant waiting on a human, across
+  all runs; \`read_run_waiting_on\` is the same question for one run you already
+  have. It is PAGED over the waiting RUNS, so \`items\` can be longer than
+  \`pageSize\` — one run may park several steps. Follow \`nextCursor\` until it
+  is null before concluding anything about how much is waiting.
 - Runs are the only thing with a real archive state — \`archive_run\` is
   reversible, \`bulk_delete_runs\` is not.
 
 ## Subworkflows — one workflow calling another
 Both halves live in the workflow DOCUMENT, so both are ordinary
 \`apply_workflow_mutations\` work. There is no separate "link" route.
-- **To make a workflow callable**, give it a trigger with
-  \`typeId: "subprocess-invocation"\` (\`add_trigger\`) whose \`parameters\` are
-  what a caller must pass. That list IS the signature — there is no other place
-  to declare it. \`parameters\` goes in the \`add_trigger\` call itself; you do
-  not need a follow-up \`update_trigger\`. For what a parameter may contain, ask
-  \`get_workflow_authoring_spec\` for \`add_trigger\`'s payload schema rather
-  than a shape written down here.
+- **To make a workflow callable**, it needs TWO things: a trigger with
+  \`typeId: "subprocess-invocation"\` (\`add_trigger\`), which is what makes it
+  callable at all, and a declared SIGNATURE.
+- **The signature belongs to the PROCESS, not to the trigger.** Declare it with
+  \`set_workflow_inputs\` — one list, carried by every start, and the same list
+  a caller of any kind fills in. A trigger's own \`parameters\` are what THAT
+  start declares on top; \`parameters\` goes in the \`add_trigger\` call itself,
+  so a start that does add fields needs no follow-up \`update_trigger\`.
+- Older documents declared everything on the invocation trigger instead, and
+  that still works: both are read, and where a name appears in both the
+  PROCESS-level one wins. When you are editing a workflow you did not author,
+  read \`read_workflow_trigger_parameters\` and see which list actually holds
+  its fields before adding to either.
+- \`set_workflow_inputs\` REPLACES the whole list, like
+  \`set_workflow_constants\`: read, edit, write back. An entry with no \`name\`
+  is refused rather than stored — the name is how a caller passes the value and
+  how the run payload keys it, so a nameless one would be skipped silently at
+  run time.
+- For what an input or a parameter may contain, ask
+  \`get_workflow_authoring_spec\` for the payload schema of the command you are
+  about to write, rather than a shape written down here.
 - **It must also be PUBLISHED.** The catalogue reads the published document, so
   a draft-only workflow comes back \`callable: false\` with "Never published".
   Authoring the caller first and publishing the callee later is a run-time
@@ -652,9 +720,127 @@ Both halves live in the workflow DOCUMENT, so both are ordinary
   \`metadataRedacted\`. If you need one of those values, a human reads it in
   Axonity — do not try another route to it.
 
+## Tables — the tenant's own reference data
+A table is an authored library element that HOLDS ROWS: the pricing bands, the
+region-to-owner map, the list of accepted reason codes. A person designs the
+columns and maintains the content; agents and decisions read it.
+
+**When a table is the right element.** Reach for one when the CONTENT is the
+point and it changes without the process changing.
+- Not an \`output_schema\`: that describes a SHAPE and holds no data. If you
+  find yourself putting example values in a schema, you wanted a table.
+- Not a workflow constant: a constant belongs to ONE workflow and is edited in
+  its document. A table is shared, and three workflows reading the same rows is
+  the case it exists for.
+- Not a function tool with a list inside it: that makes changing a row an act of
+  editing code, reviewing it and publishing a tool. A business user maintains a
+  table; nobody should need you to change a postcode.
+
+**Static or dynamic — who owns the rows.**
+- \`isDynamic: false\` (the default) is reference data the AUTHOR maintains. A
+  workflow reads it and cannot change it. \`allowedOperations\` must be empty:
+  a permission nothing honours is refused, not stored.
+- \`isDynamic: true\` lets a workflow change the rows, limited to
+  \`allowedOperations\` — any of \`add\` / \`update\` / \`delete\`. READING IS
+  NEVER LISTED there: it is what a table is for and is always allowed.
+- You edit rows through \`add_data_table_row\` / \`update_data_table_row\` /
+  \`delete_data_table_row\` whatever the table's mode says — those grants are
+  about what a RUN may do, not about authoring.
+
+**Never put rows in \`update_data_table\`.** \`rows\` and \`columns\` are
+whole-collection fields: sending one row REPLACES the table's content and
+deletes everything else. The row tools address a single row by a match
+(\`matchColumn\`/\`matchValue\`) and cannot touch the rest — use them. Reach for
+\`update_data_table({ fields: { rows } })\` only when you genuinely mean to
+replace the whole content, and never as a way to append.
+
+**The rule that bites hardest: derived tools follow the PUBLISHED table.** A
+published table mints its own CRUD tools, so granting an agent access to one is
+ordinary tool granting — take a \`toolId\` from \`list_data_table_tools\` and put
+it in the agent's \`toolIds\`. But those tools follow the table's PUBLISHED
+version. An author who ticked "may add rows" and has not published has granted
+nothing, and the tool that would let a run act on it does not exist yet.
+\`list_data_table_tools\` reports \`offered\` (what the draft would yield),
+\`toolId\` (whether a row exists) and \`isLive\` (whether a run can reach it)
+separately for exactly this reason. Read all three before concluding a grant
+landed. Same rule as everywhere else here — a draft changes nothing until it is
+published — and it is the first thing an agent gets wrong about tables.
+
+**Routing a decision on a table.** A decision can branch by looking a value up
+in one column and taking the branch named in another, with
+\`builtin: "evaluators.table_lookup"\`. The behaviour worth knowing, because no
+catalogue states it: THE CELL'S VALUE IS THE BRANCH'S OUTCOME KEY — not a new
+field, and not something you map afterwards. Every value in the result column
+must be the outcome key of an outgoing branch, or publishing the workflow is
+refused. The table must be PUBLISHED: a run reads the published snapshot, so a
+table that is only saved routes nothing. For the argument names it reads, and
+for every other selectable evaluator, read \`decisionEvaluators\` from
+\`get_workflow_authoring_spec\` — generated from the registry that dispatches
+them, so it cannot advertise one the platform would not run.
+
+**Column kinds** come from the same place: \`tableColumnKinds\` in
+\`get_workflow_authoring_spec\`. It is a FOURTH vocabulary beside the three for
+parameters, outputs and schema fields, with its own spellings — do not carry a
+value across from one of the others, and do not guess. Every column needs a
+\`description\`: an agent reads it to know what the column is for, and a save
+without one is refused.
+
+**\`list_data_tables\` is PAGED**, alone among the library lists — a tenant's
+reference data has no ceiling. Page one is not the library. Follow
+\`nextCursor\` while \`hasMore\` is true, or better, narrow in the query:
+\`name\` is exact and unique per workspace, so "does one called X already
+exist" is a single call rather than a walk. The page carries \`rowCount\`, never
+the rows; the rows come from \`read_data_table\`.
+
+## Toolboxes — where a tool is filed
+- A toolbox is a per-tenant grouping label over tools. Read \`list_toolboxes\`
+  before \`create_tool\` and pass the box's id as \`toolboxId\`; a tool created
+  without one is ungrouped. Move an existing tool with
+  \`assign_tool_toolbox\` (\`toolboxId: null\` takes it out of its box).
+- \`set_toolbox_tools\` DECLARES the membership — it does not add to it. A tool
+  in the box and absent from your list is evicted. To add one tool, read the
+  box's contents first, or use \`assign_tool_toolbox\`, which cannot evict
+  anything by accident. A tool is in at most one box.
+- A toolbox NEVER changes what an agent may call. An agent is linked to
+  individual tools (\`agent.toolIds\`), never to a box; there is no route that
+  grants a whole box, and "give this agent the Carerix toolbox" is a bulk write
+  of individual links. What the box decides is how a tool is ADVERTISED: a boxed
+  tool with \`surfacing: "inherit"\` is found via discover_tools instead of
+  riding in every prompt. Read \`effectiveSurfacing\` on the tool to answer "is
+  it in the prompt?"; \`surfacing\` is the raw stored choice.
+- Deleting a toolbox does NOT delete its tools — they survive, ungrouped. The
+  box itself has no restore.
+- Platform-shipped tools cannot be moved. The \`Axonity\`, \`Checks\` and
+  \`Branching\` boxes hold locked tools; the API refuses and NAMES the tool it
+  refused. Read that name to your human instead of bisecting the selection.
+- \`set_toolbox_auth\` sets the credential a box's tools SHARE — ten Microsoft
+  Mail tools, one mailbox, said once. A tool with its own auth keeps it; only a
+  tool with none inherits. Same rule as anywhere else: point \`secretId\` at a
+  stored secret, never a real value. Before you clear or replace it, or delete
+  the box, call \`list_toolbox_dependent_tools\` — it names the tools that would
+  start failing at run time with a bare 401.
+
 ## Tenant
 - Your token fixes the tenant. You cannot act across tenants; never send a
   tenant id in a body.
+- \`read_model_tier_map\` says what \`capabilityTier\` actually RESOLVES TO on
+  this tenant. The tier is the field you write; the model is what you are
+  choosing. Read it before you pick one.
+- When a run does not start, look outward before blaming the workflow:
+  \`read_concurrency_status\` (is the tenant at its cap?),
+  \`read_queue_overview\` (is dispatch alive?), \`list_task_queue\` (did
+  something fail in the layer beneath the run?). \`read_for_each_rate\` explains
+  a fan-out that is pacing itself rather than stalling.
+- You can READ those and not change them. Caps, rate ceilings and the tier map
+  are operator decisions — report what you found, and to whom, rather than
+  looking for another route to it.
+- \`read_deploy_contract\` says what THIS deploy speaks: build, environment and
+  the routes it mounts. Read it when a call fails in a way that suggests the
+  backend is older or newer than you expect.
+- \`list_users\` is where an \`ownerId\` comes from. Look one up instead of
+  asking a human to copy it out of the UI.
+- \`list_audit_events({ actorKind: "service_token" })\` reads back what external
+  agents — including you — actually changed.
 `;
 export function registerConventions(server) {
     server.tool("axonity_conventions", "Read the authoring conventions BEFORE creating or updating anything: the " +

package/dist/tools/conventions.js.map

@@ -1 +1 @@
-{"version":3,"file":"conventions.js","sourceRoot":"","sources":["../../src/tools/conventions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAIH,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAknBnB,CAAC;AAEF,MAAM,UAAU,mBAAmB,CAAC,MAAiB;IACnD,MAAM,CAAC,IAAI,CACT,qBAAqB,EACrB,2EAA2E;QACzE,2EAA2E;QAC3E,2EAA2E;QAC3E,4EAA4E;QAC5E,uEAAuE;QACvE,kBAAkB,EACpB,EAAE,EACF,KAAK,IAAI,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAe,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC,CAC1E,CAAC;AACJ,CAAC"}
+{"version":3,"file":"conventions.js","sourceRoot":"","sources":["../../src/tools/conventions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAIH,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4yBnB,CAAC;AAEF,MAAM,UAAU,mBAAmB,CAAC,MAAiB;IACnD,MAAM,CAAC,IAAI,CACT,qBAAqB,EACrB,2EAA2E;QACzE,2EAA2E;QAC3E,2EAA2E;QAC3E,4EAA4E;QAC5E,uEAAuE;QACvE,kBAAkB,EACpB,EAAE,EACF,KAAK,IAAI,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAe,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC,CAC1E,CAAC;AACJ,CAAC"}

package/dist/tools/dataTables.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The parts of a table that are NOT the generic entity family (axonity-mcp#63).
+ *
+ * A table is an authored, typed, versioned library element that holds ROWS
+ * (axonity-flow#1217), and its routes were deliberately written in the same
+ * order and spelling as an output schema's — so list/read/create/update/delete/
+ * restore/discard-draft/request-publish and the whole eleven-route version
+ * family come from `registerEntityTools` and `registerVersionTools` with no code
+ * here. Two things do not fit that shape, and both are here:
+ *
+ * **1. Row writes.** `PUT /data-tables/{id}` replaces the WHOLE `rows` array.
+ * `update_data_table` takes a blind `fields` bag by design — the connector stays
+ * thin and the backend validates — which means an agent that passes `rows`
+ * meaning "add this one" silently destroys the table's content. That is a
+ * destructive default reachable by accident, so the three row routes
+ * axonity-flow#1235 added get explicit tools that address ONE row and cannot
+ * touch the others. `update_data_table` carries the warning as well
+ * (`updateWarning` on its `EntityDef`); the tools are what make the warning
+ * actionable rather than merely a caution.
+ *
+ * The row tools take no `expectedVersion`. That is the backend's contract, not
+ * an omission: a row write is a single addressed operation the service applies
+ * under its own lock, and it RETURNS the table's new `version` for a later
+ * `update_data_table` to base itself on. Adding a version argument here would
+ * invent a check the route does not make.
+ *
+ * **2. Which tools a table yields.** A published table mints its own CRUD tools,
+ * so granting an agent access to a table is ordinary tool granting rather than a
+ * second permission vocabulary. Their names follow a convention, which used to
+ * mean the only way to find them was to fetch the whole tool library and match
+ * on it. `list_data_table_tools` asks the table instead — and, crucially,
+ * reports the operations that are OFFERED but not yet LIVE, which is the answer
+ * to the first thing an author gets wrong: a table's tools follow its PUBLISHED
+ * version, so ticking "may add rows" and not publishing has granted nothing.
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { AxonityClient } from "../client.js";
+export declare function registerDataTableTools(server: McpServer, client: AxonityClient): void;

package/dist/tools/dataTables.js

@@ -0,0 +1,129 @@
+/**
+ * The parts of a table that are NOT the generic entity family (axonity-mcp#63).
+ *
+ * A table is an authored, typed, versioned library element that holds ROWS
+ * (axonity-flow#1217), and its routes were deliberately written in the same
+ * order and spelling as an output schema's — so list/read/create/update/delete/
+ * restore/discard-draft/request-publish and the whole eleven-route version
+ * family come from `registerEntityTools` and `registerVersionTools` with no code
+ * here. Two things do not fit that shape, and both are here:
+ *
+ * **1. Row writes.** `PUT /data-tables/{id}` replaces the WHOLE `rows` array.
+ * `update_data_table` takes a blind `fields` bag by design — the connector stays
+ * thin and the backend validates — which means an agent that passes `rows`
+ * meaning "add this one" silently destroys the table's content. That is a
+ * destructive default reachable by accident, so the three row routes
+ * axonity-flow#1235 added get explicit tools that address ONE row and cannot
+ * touch the others. `update_data_table` carries the warning as well
+ * (`updateWarning` on its `EntityDef`); the tools are what make the warning
+ * actionable rather than merely a caution.
+ *
+ * The row tools take no `expectedVersion`. That is the backend's contract, not
+ * an omission: a row write is a single addressed operation the service applies
+ * under its own lock, and it RETURNS the table's new `version` for a later
+ * `update_data_table` to base itself on. Adding a version argument here would
+ * invent a check the route does not make.
+ *
+ * **2. Which tools a table yields.** A published table mints its own CRUD tools,
+ * so granting an agent access to a table is ordinary tool granting rather than a
+ * second permission vocabulary. Their names follow a convention, which used to
+ * mean the only way to find them was to fetch the whole tool library and match
+ * on it. `list_data_table_tools` asks the table instead — and, crucially,
+ * reports the operations that are OFFERED but not yet LIVE, which is the answer
+ * to the first thing an author gets wrong: a table's tools follow its PUBLISHED
+ * version, so ticking "may add rows" and not publishing has granted nothing.
+ */
+import { z } from "zod";
+import { guard, jsonResult } from "./result.js";
+const BASE = "/api/v1/data-tables";
+/**
+ * How the two addressed row writes name their row.
+ *
+ * Deliberately a MATCH rather than a row index: a table's rows have no stable
+ * position, so "row 4" is a different row after anyone inserts one. The backend
+ * refuses a match that hits zero rows (404) or more than one (with the count)
+ * rather than guessing, which is what makes this safe to hand an agent.
+ */
+const MATCH = {
+    matchColumn: z
+        .string()
+        .describe("The column that identifies the row. It must match EXACTLY ONE row: " +
+        "zero is a 404 and more than one is refused with the count, so a write " +
+        "never lands on a row you did not mean. Pick a column whose values are " +
+        "unique — read the table first if you are not sure."),
+    matchValue: z
+        .string()
+        .describe("The value that column must hold. Compared the way a decision compares " +
+        'it over the same table, so "5000" finds the number 5000 and ' +
+        '"benelux" finds the cell holding "Benelux".'),
+};
+export function registerDataTableTools(server, client) {
+    server.tool("add_data_table_row", "Append ONE row to a table, without resending the rows already there. " +
+        "\n\nUSE THIS RATHER THAN update_data_table TO ADD A ROW. `rows` on " +
+        "update_data_table is a whole-collection field: sending one row there " +
+        "replaces the table's entire content. This appends, and cannot touch the " +
+        "other rows. " +
+        "\n\nA key that is not a column is REFUSED and named — never dropped, " +
+        "because a silently discarded value is a lost value. Read the table first " +
+        "for its column names and what each one means. " +
+        "\n\nThe response carries the table's new `version`: base a later " +
+        "update_data_table on that number rather than re-reading. " +
+        "\n\nThis writes the DRAFT. A run reads the published table, so the row " +
+        "is not live until the table is published (request_publish_data_table).", {
+        id: z.string().describe("The table's id."),
+        values: z
+            .record(z.unknown())
+            .describe("The row's values, keyed by COLUMN NAME (the column's `name`, not " +
+            "its label). Required columns must be present."),
+    }, async ({ id, values }) => guard(async () => jsonResult(await client.post(`${BASE}/${id}/rows`, { values }))));
+    server.tool("update_data_table_row", "Change named columns on the ONE row a match addresses. Columns you do not " +
+        "name keep their values, so this is a partial edit of a row rather than a " +
+        "replacement of it. " +
+        "\n\nUSE THIS RATHER THAN update_data_table TO EDIT A ROW — `rows` there " +
+        "replaces the whole content. " +
+        "\n\nAn empty `changes` is refused: an update that changes nothing is a " +
+        "mistake dressed as a success. The response reports `changed` — which " +
+        "columns actually moved — plus the table's new `version`. " +
+        "\n\nThis writes the DRAFT; publish before a run can see it.", {
+        id: z.string().describe("The table's id."),
+        ...MATCH,
+        changes: z
+            .record(z.unknown())
+            .describe("The columns to change and what to change them to, keyed by column " +
+            "name. Columns not named here keep their values. Must not be empty."),
+    }, async ({ id, matchColumn, matchValue, changes }) => guard(async () => jsonResult(await client.patch(`${BASE}/${id}/rows`, { changes }, { match_column: matchColumn, match_value: matchValue }))));
+    server.tool("delete_data_table_row", "Remove the ONE row a match addresses. " +
+        "\n\nTHE REMOVED ROW RIDES BACK IN THE RESPONSE, on purpose: after this " +
+        "call it is the only copy left, so an operator who deleted the wrong one " +
+        "can put it back with add_data_table_row. Keep it. " +
+        "\n\nUnlike delete_data_table this is NOT soft-deleted and there is no " +
+        "restore_*: the row is gone from the draft. The published table still has " +
+        "it until the table is published again, which is the only undo. " +
+        "\n\nThe response also carries the table's new `version` and `total`.", {
+        id: z.string().describe("The table's id."),
+        ...MATCH,
+        confirm: z
+            .literal(true)
+            .describe("Must be true. Acknowledges you understand this removes a row from " +
+            "the draft and that only the response carries it afterwards."),
+    }, async ({ id, matchColumn, matchValue }) => guard(async () => jsonResult(await client.del(`${BASE}/${id}/rows`, {
+        match_column: matchColumn,
+        match_value: matchValue,
+    }))));
+    server.tool("list_data_table_tools", "Which tools this table yields, and which of them a RUN can actually " +
+        "reach. Read-only. " +
+        "\n\nA published table mints its own CRUD tools, so giving an agent " +
+        "access to a table is ordinary tool granting — put a `toolId` from here " +
+        "in the agent's `toolIds`. Their names follow a convention, so the " +
+        "alternative is fetching the whole tool library and matching on it. " +
+        "\n\nREAD THE THREE FLAGS SEPARATELY — collapsing them is how \"I ticked " +
+        "'may add rows' and there is no tool\" becomes a mystery: " +
+        "`offered` is what the current DRAFT would yield (what the author " +
+        "decided), `toolId` is whether a tool row exists today (what a grant " +
+        "names), and `isLive` is whether that row is PUBLISHED (what a run can " +
+        "reach). A table's tools follow its published version, so a grant that " +
+        "has been saved and not published has granted nothing yet. " +
+        "\n\n`publishedMajorVersion: null` means the table has never been " +
+        "published and nothing here is live.", { id: z.string().describe("The table's id.") }, async ({ id }) => guard(async () => jsonResult(await client.get(`${BASE}/${id}/tools`))));
+}
+//# sourceMappingURL=dataTables.js.map

package/dist/tools/dataTables.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataTables.js","sourceRoot":"","sources":["../../src/tools/dataTables.ts"],"names":[],"mappings":"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"}

package/dist/tools/extras.js

@@ -143,9 +143,14 @@ export function registerAttachTools(server, client) {
     // `detached: true` and not one link had ever existed.
     link("skill", "workflow", (workflowId, skillId) => `/api/v1/workflows/${workflowId}/skills-v2/${skillId}`, "workflowId", "skillId", "list_workflow_skills");
     link("policy", "agent", (agentId, policyId) => `/api/v1/agents/${agentId}/policies/${policyId}`, "agentId", "policyId", "list_agent_policies");
-    // Reference docs attach to agents only — there is no workflow-scoped
-    // reference-doc route on the backend, so no `*_to_workflow` pair here.
     link("reference", "agent", (agentId, refId) => `/api/v1/agents/${agentId}/reference-docs/${refId}`, "agentId", "refId", "list_agent_reference_docs");
+    // Reference docs used to attach to agents ONLY, and this file said so. That
+    // is no longer true: axonity-flow#1061 gave them the workflow-scoped trio,
+    // mirroring `workflow_skills_router` exactly. Until then the process panel
+    // "attached" a doc by rewriting its `scope`, which the runtime ignores — a
+    // link nothing read, which is the same failure the skill read-back exists to
+    // make visible.
+    link("reference", "workflow", (workflowId, refId) => `/api/v1/workflows/${workflowId}/reference-docs/${refId}`, "workflowId", "refId", "list_workflow_reference_docs");
     /**
      * The read side of the links above. `attach_*`/`detach_*` write a link but
      * return nothing you can list later, so these are how an agent verifies a
@@ -196,33 +201,52 @@ export function registerAttachTools(server, client) {
     listLinks("policy", "policies", (id) => `/api/v1/agents/${id}/policies`, "policies");
     listLinks("reference_doc", "reference_docs", (id) => `/api/v1/agents/${id}/reference-docs`, "references");
     /**
-     * The workflow-scoped read-back (axonity-flow#961 S8).
+     * The workflow-scoped read-backs (axonity-flow#961 S8, #1061).
      *
      * Deliberately without `linkSource`: unlike the agent view there is only one
-     * way a skill reaches a workflow — an explicit link — so a field that always
-     * says the same thing would train a reader to skip it. Live links only, for
-     * the reason `list_agent_skills` gives: detaching closes the interval rather
-     * than deleting the row, and a stale dependency list is worse than none.
+     * way a skill or a doc reaches a workflow — an explicit link — so a field
+     * that always says the same thing would train a reader to skip it. Live
+     * links only, for the reason `list_agent_skills` gives: detaching closes the
+     * interval rather than deleting the row, and a stale dependency list is
+     * worse than none.
      */
-    server.tool("list_workflow_skills", "List the skills currently scoped to a WORKFLOW — the read-back for " +
-        "attach_skill_to_workflow. A 200 from an attach does not prove the link " +
-        "resolved, and the link lives outside the workflow document, so " +
-        "read_workflow will never show it: this is the only way to tell an attach " +
-        "that landed from one that silently did nothing. Read-only. " +
-        "\n\nReturns IDENTITY by default; pass verbosity: \"full\" for whole " +
-        "bodies, which a skill's playbook makes expensive.", {
-        workflowId: z.string().describe("The workflow's id."),
-        verbosity: z
-            .enum(["identity", "full"])
-            .optional()
-            .describe('How much of each row to return. "identity" (default) is id, name, ' +
-            'description and status. "full" is the entire skill, body included.'),
-    }, async ({ workflowId, verbosity }) => guard(async () => {
-        const response = await client.get(`/api/v1/workflows/${workflowId}/skills-v2`);
-        if (verbosity === "full")
-            return jsonResult(response);
-        return jsonResult(projectLinkRows(response, "skills"));
-    }));
+    const listWorkflowLinks = (subject, plural, path, 
+    /** The key the backend nests the rows under (`skills` / `references`). */
+    rowsKey, 
+    /** Why "full" is expensive for this subject. */
+    fullCost, 
+    /**
+     * The noun the attach/detach pair is named with. It is NOT always the
+     * subject: the doc link is `attach_reference_to_workflow` while the
+     * read-back is `list_workflow_reference_docs`, an asymmetry inherited from
+     * the agent-scoped pair and kept so both halves of a family are spelled the
+     * same way. Pointing at the wrong name is worse than not pointing at all.
+     */
+    attachNoun) => {
+        server.tool(`list_workflow_${plural}`, `List the ${plural.replace("_", " ")} currently scoped to a WORKFLOW — ` +
+            `the read-back for attach_${attachNoun}_to_workflow. A 200 from an attach ` +
+            `does not prove the link resolved, and the link lives outside the ` +
+            `workflow document, so read_workflow will never show it: this is the ` +
+            `only way to tell an attach that landed from one that silently did ` +
+            `nothing. Read-only. ` +
+            `\n\nReturns IDENTITY by default; pass verbosity: "full" for whole ` +
+            `bodies, which ${fullCost}.`, {
+            workflowId: z.string().describe("The workflow's id."),
+            verbosity: z
+                .enum(["identity", "full"])
+                .optional()
+                .describe('How much of each row to return. "identity" (default) is id, name, ' +
+                `description and status. "full" is the entire ${subject}, body ` +
+                "included."),
+        }, async ({ workflowId, verbosity }) => guard(async () => {
+            const response = await client.get(path(workflowId));
+            if (verbosity === "full")
+                return jsonResult(response);
+            return jsonResult(projectLinkRows(response, rowsKey));
+        }));
+    };
+    listWorkflowLinks("skill", "skills", (id) => `/api/v1/workflows/${id}/skills-v2`, "skills", "a skill's playbook makes expensive", "skill");
+    listWorkflowLinks("reference_doc", "reference_docs", (id) => `/api/v1/workflows/${id}/reference-docs`, "references", "a reference doc's content makes expensive", "reference");
 }
 /**
  * "What breaks if I change this" — the reverse look-up, for both halves of the
@@ -274,11 +298,23 @@ export function registerDependencyTools(server, client) {
             .describe("Which library item you are about to change."),
         entityId: z.string().describe("That item's id."),
     }, async ({ entityKind, entityId }) => guard(async () => {
-        const base = {
+        const bases = {
             skill: "/api/v1/skills",
             policy: "/api/v1/policies",
             reference_doc: "/api/v1/reference-docs",
-        }[entityKind];
+        };
+        const base = bases[entityKind];
+        // A kind outside the enum cannot reach here through a real client — zod
+        // rejects it first. It CAN reach here through the route sweeps, which
+        // call handlers directly, and an unguarded lookup then built
+        // `undefined/{id}/dependent-agents` and reported it as a route this
+        // connector calls. A tool must not answer a question it was not asked.
+        if (!base) {
+            throw new Error(`list_dependent_agents has no route for entityKind "${entityKind}". ` +
+                `It covers ${Object.keys(bases).join(", ")}; for a tool, agent, ` +
+                `flow, output schema or workflow named by a workflow DOCUMENT, ` +
+                `use list_workflows_using.`);
+        }
         return jsonResult(await client.get(`${base}/${entityId}/dependent-agents`));
     }));
 }