@sanity/workflow-mcp 0.5.1 → 0.6.0

package/dist/index.js

@@ -1,520 +1,3 @@
-import { extractDocumentId, actionVerdict, isTerminalStage, deniedGuardLabels, validateDefinition, WORKFLOW_INSTANCE_TYPE, tagScopeFilter } from "@sanity/workflow-engine";
-import { defineWorkflow } from "@sanity/workflow-engine/define";
-const minimalExample = {
-  name: "quick-approval",
-  title: "Quick approval",
-  description: "One review stage with a single approve action, then a terminal stage.",
-  initialStage: "review",
-  fields: [{ type: "doc.ref", name: "subject", title: "Document", initialValue: { type: "input" } }],
-  stages: [
-    {
-      name: "review",
-      title: "Review",
-      activities: [
-        {
-          name: "decide",
-          title: "Decide",
-          activation: "auto",
-          actions: [{ name: "approve", title: "Approve", status: "done" }]
-        }
-      ],
-      transitions: [{ name: "to-approved", title: "Approve and finish", to: "approved" }]
-    },
-    { name: "approved", title: "Approved", description: "Terminal \u2014 no transitions out." }
-  ]
-}, reviewLoopExample = {
-  name: "doc-review",
-  title: "Document review",
-  description: "Draft, then editorial review that approves or rejects back to drafting.",
-  initialStage: "drafting",
-  fields: [{ type: "doc.ref", name: "subject", title: "Document", initialValue: { type: "input" } }],
-  stages: [
-    {
-      name: "drafting",
-      title: "Drafting",
-      activities: [
-        {
-          name: "write",
-          title: "Write the draft",
-          activation: "auto",
-          actions: [{ name: "submit", title: "Submit for review", status: "done" }]
-        }
-      ],
-      transitions: [{ name: "to-review", title: "Send to review", to: "review" }]
-    },
-    {
-      name: "review",
-      title: "Editorial review",
-      // The decision is data: each action writes it, the transition filters
-      // read it. Stage-scoped so a later review round starts with a clean slate.
-      fields: [{ type: "string", name: "decision", title: "Review decision" }],
-      activities: [
-        {
-          name: "review",
-          title: "Review the draft",
-          activation: "auto",
-          actions: [
-            {
-              name: "approve",
-              title: "Approve",
-              status: "done",
-              ops: [
-                {
-                  type: "field.set",
-                  target: { field: "decision" },
-                  value: { type: "literal", value: "approve" }
-                }
-              ]
-            },
-            // Rejecting is the reviewer DOING their job — a decision, not a
-            // failure — so it resolves `done` and routes via the field.
-            {
-              name: "reject",
-              title: "Reject",
-              status: "done",
-              ops: [
-                {
-                  type: "field.set",
-                  target: { field: "decision" },
-                  value: { type: "literal", value: "reject" }
-                }
-              ]
-            }
-          ]
-        }
-      ],
-      transitions: [
-        {
-          name: "to-approved",
-          title: "Approve and finish",
-          to: "approved",
-          filter: "$allActivitiesDone && $fields.decision == 'approve'"
-        },
-        {
-          name: "to-drafting",
-          title: "Send back to drafting",
-          to: "drafting",
-          filter: "$allActivitiesDone && $fields.decision == 'reject'"
-        }
-      ]
-    },
-    { name: "approved", title: "Approved", description: "Terminal \u2014 no transitions out." }
-  ]
-}, ORIENTATION = "# Authoring a workflow definition\n\nA workflow definition is a plain JSON object. There is no code in it \u2014 every\ncondition (filters, predicates, guards) is a GROQ *string*. Generate the JSON,\nthen call `validate_workflow_definition` to check it; fix the reported errors\nand re-validate until it returns `valid: true`. The validator returns the\n*desugared* definition under `definition` \u2014 that is exactly what would deploy.\n\n## Shape\n\n- **Workflow**: `{ name, title, description?, initialStage, fields?, stages[], predicates? }`.\n  `initialStage` must be the `name` of a declared stage. Do NOT include a\n  `version` \u2014 definitions are immutable and content-addressed; deploy assigns\n  the version from the content, the author never writes one.\n- **Stage**: `{ name, title?, description?, activities?, transitions? }`. A stage with\n  no transitions is terminal. Reaching a terminal stage ends the workflow.\n- **Activity**: `{ name, title?, activation?, actions? }`. `activation` is `'auto'`\n  (starts when the stage is entered) or `'manual'` (default \u2014 a human starts it).\n- **Action**: `{ name, title?, status?, params?, ops? }`.\n  `status: 'done' | 'skipped' | 'failed'` is sugar that flips the *firing activity* to\n  that status when the action fires. Status is a health axis, not a decision:\n  a routine decision (reject, send back, decline, hold) resolves `'done'` and\n  writes the decision into a field the transition filters read \u2014 reserve\n  `'failed'` for work that genuinely could not complete (e.g. a missed\n  deadline via `failWhen`). `ops` are mutations applied when the action\n  fires (e.g. `{type:'field.set', target:{field:'x'}, value:{type:'param', param:'p'}}`).\n  `params` are values the action collects from the caller (referenced by\n  `{type:'param', param:'<name>'}` sources).\n- **Transition**: `{ name, title?, to, filter? }`. `to` must name a declared\n  stage. `filter` is a GROQ condition gating the exit; omit it and it defaults\n  to `$allActivitiesDone`.\n- **Field** (workflow- or stage-scoped persistent state): `{ type, name, title?, initialValue? }`.\n  Scalar `type`s mirror Sanity: `string`, `text` (multiline), `number`,\n  `boolean`, `date` (YYYY-MM-DD), `datetime` (ISO), `url`. Plus references\n  (`doc.ref`, `doc.refs`, `release.ref`), identities (`actor` \u2014 one concrete\n  principal; `assignee` / `assignees` \u2014 one or many user-or-role assignees), and\n  the compositional kinds `object` (`{ type:'object', name, fields: [...] }`) and\n  `array` (`{ type:'array', name, of: [...] }`) \u2014 `fields`/`of` are themselves\n  field shapes, so any structure composes. `initialValue` seeds the field once at\n  materialisation and is **optional** \u2014 omit it for op-filled working memory\n  (the common default). Arms: `{type:'input'}` (the caller supplies it when the\n  instance starts), `{type:'query', query:'<groq>'}` (computed from the lake),\n  `{type:'literal', value:<json>}`, or `{type:'fieldRead', field:'<name>'}`.\n  By convention a workflow has an `input`-sourced `doc.ref` named `subject` \u2014 the\n  headline document it is about.\n  Two list sugars desugar to `array`: `{type:'todoList', name}` (ad-hoc\n  status-tracked work \u2014 rows `{ label, status, assignee?, dueDate? }`) and\n  `{type:'notes', name}` (an append-only audit/comment log \u2014 rows\n  `{ body, actor, at }`; pairs with the `audit` op, which stamps `actor`/`at`).\n\n## GROQ in conditions\n\nBuilt-in variables available in filters/predicates (the engine's exported\n`CONDITION_VARS` inventory is the source of truth): `$allActivitiesDone`,\n`$anyActivityFailed` (booleans over the current stage's activities), `$activities` (the activity\nlist), `$fields` (field values), `$now`, `$self`/`$stage`/`$parent`/`$ancestors`\n(instance identity + position), `$effectStatus` (effect name \u2192 `'done'`/`'failed'`\nof the run queued during the CURRENT stage entry \u2014 the re-entry-safe way to gate\non an effect having drained, e.g.\n`completeWhen: \"defined($effectStatus['my.effect'])\"`), and the caller-scoped\nvars `$actor` (the acting user), `$assigned` (whether the caller is the\nactivity's assignee \u2014 the idiomatic permission gate, used as\n`filter: '$assigned'`), and `$can`. Define\nreusable named conditions under top-level `predicates: { name: '<groq>' }` and\nreference them as `$name` (e.g.\n`predicates: { ready: \"count($activities[status != 'done']) == 0\" }` \u2192 `$ready`).\n\nConditions evaluate against an in-memory snapshot (the instance + its subject +\nfield-declared docs) \u2014 **never** scan by `_type` (e.g. `*[_type==\"article\"]`);\nthat is a discovery query and the validator rejects it. To bring a document into\nscope, declare a `doc.ref` field for it.\n\n## Sugars worth knowing\n\n- Action `status: 'done' | 'skipped' | 'failed'` \u2014 flips the firing activity (shown above).\n- Omitted transition `filter` \u2014 defaults to `$allActivitiesDone`.\n- Omitted activity `activation` \u2014 defaults to `'manual'`.\n\n## Modeling defaults\n\nValid is not the same as good. Prefer these unless the request says otherwise:\n\n- **A decline/reject loops back.** Route a rejected / changes-requested\n  transition to an *earlier* stage for revision (e.g. `review \u2192 drafting` gated\n  on a `decision` field the reject action wrote), not to a terminal stage.\n  Reserve terminal stages for completion and for explicit\n  cancellation/abandonment \u2014 a workflow should not dead-end just because\n  something was declined.\n- **Decisions are fields, not failures.** When a stage branches on a human\n  decision, declare a stage-scoped `string` field (stage scope resets on\n  re-entry, so loop-backs start clean), have each deciding action `field.set`\n  it, and gate every outbound transition on its value (Example 2). Do not\n  encode a decision as `status: 'failed'` + `$anyActivityFailed` \u2014 reporting\n  would count healthy loops as failures.\n- **Prefer draft \u2192 review.** Model an author working in a drafting stage who\n  submits, then a review stage that gates. Don't add more review stages unless\n  the request asks for multiple approvers or rounds.\n- **When the shape is ambiguous, pick the conventional one and confirm** with the\n  user rather than inventing extra stages.\n\n## Rules the validator enforces\n\n- Stage names, activity names (per stage) and transition names are unique.\n- Every transition `to` and `initialStage` names a declared stage.\n- Custom `predicates` must not shadow a built-in (e.g. `allActivitiesDone`).\n- Every GROQ string must parse and must not be a `_type` discovery scan.", AUTHORING_GUIDE = `${ORIENTATION}
+import { WORKFLOW_TOOLS, registerWorkflowTools, toolInputJsonSchema, workflowAddressFromInput } from "./_chunks-es/index.js";
 
-## Examples
-
-### Example 1 \u2014 ${minimalExample.title} (minimal: one stage, one action)
-\`\`\`json
-${JSON.stringify(minimalExample, null, 2)}
-\`\`\`
-
-### Example 2 \u2014 ${reviewLoopExample.title} (review loop: reject routes back)
-\`\`\`json
-${JSON.stringify(reviewLoopExample, null, 2)}
-\`\`\`
-`, LIST_CAP = 25, TOOL_DESCRIPTORS = [
-  {
-    name: "list_workflow_instances",
-    description: "List workflow instances in the configured workspace. Use this when you need to find a workflow but don't already know its instance id, or to survey what's in flight. Returns a compact summary \u2014 id, `definition` (the workflow definition's `name`) and human-readable `workflowTitle`, current stage, whether the instance is done, and (when the workflow has a conventional subject document) a `subject` field with the subject doc's ref and title. Use `workflowTitle` when the user names the workflow by type (e.g. \"article reviews\") and `subject.title` when they name a specific in-flight instance by what it's about (e.g. \"the article-review about pricing\"). Capped at " + String(25) + " results. Do NOT use this to inspect a single known instance \u2014 use get_workflow_state for that, the response will be richer.",
-    input_schema: {
-      type: "object",
-      properties: {
-        definition: {
-          type: "string",
-          description: "Optional. Restrict to instances of this workflow definition, by its `name` (e.g. 'article-review')."
-        },
-        status: {
-          type: "string",
-          enum: ["in_flight", "done", "any"],
-          description: "Optional. 'in_flight' returns instances not in a terminal stage; 'done' returns completed/aborted; 'any' returns both. Defaults to 'in_flight'."
-        }
-      },
-      additionalProperties: !1
-    }
-  },
-  {
-    name: "get_workflow_state",
-    description: "Get the current state of a single workflow instance, projected for action. Returns the workflow's id and human-readable `workflowTitle`, the current stage, the subject document the workflow is about (when the workflow has a conventional subject \u2014 its ref and title), every activity on the current stage with its available actions (and whether each action is currently allowed), and the most recent history entries. Use this whenever you need to understand what's possible on an instance before deciding to act. This is a pure read \u2014 it does not change anything. If you only need to discover what instances exist, use list_workflow_instances instead; this tool requires you to know the instance id. list_workflow_instances also returns the same `workflowTitle` and `subject` fields, so prefer it for fan-out discovery rather than polling get_workflow_state per instance.",
-    input_schema: {
-      type: "object",
-      properties: {
-        instance_id: {
-          type: "string",
-          description: "The workflow instance id."
-        }
-      },
-      required: ["instance_id"],
-      additionalProperties: !1
-    }
-  },
-  {
-    name: "diagnose_workflow",
-    description: "Explain why a single workflow instance is or isn't progressing. Returns a verdict (`state`: progressing, waiting, blocked, completed, aborted, or stuck), a one-line `summary`, and \u2014 when stuck \u2014 a structured `cause` plus the `remediations` that would unstick it. Use this when an instance seems stalled or the user asks \"why isn't this moving?\": it distinguishes a healthy instance (waiting on a human, or will advance on its own) from a genuinely stuck one (a failed effect or activity, a dead-end transition). This is a pure read \u2014 it changes nothing, and the remediations it names are advisory: none can be executed through this server. To actually advance a healthy waiting instance use fire_action; for per-activity action detail use get_workflow_state.",
-    input_schema: {
-      type: "object",
-      properties: {
-        instance_id: {
-          type: "string",
-          description: "The workflow instance id."
-        }
-      },
-      required: ["instance_id"],
-      additionalProperties: !1
-    }
-  },
-  {
-    name: "fire_action",
-    description: "Advance a workflow instance by firing an action on one of its activities. This is the only way to advance workflow state from the outside \u2014 there is no separate 'complete activity' or 'transition stage' tool. To find the right (activity, action) pair, call get_workflow_state first and pick from the allowed actions listed on the current stage's activities. After firing, the engine cascades any auto-transitions that become eligible (so an 'approve' action on a review activity may transition the workflow to a terminal stage in one shot). Returns the resulting state, same shape as get_workflow_state. If the action is not currently allowed (e.g. the activity is already done, or a guard fails), this returns an error describing why.",
-    input_schema: {
-      type: "object",
-      properties: {
-        instance_id: {
-          type: "string",
-          description: "The workflow instance id."
-        },
-        activity: {
-          type: "string",
-          description: "The id of the activity on the current stage. Must be one of the activities returned by get_workflow_state."
-        },
-        action: {
-          type: "string",
-          description: "The id of the action on that activity. Must be one of the actions listed as allowed=true on the activity."
-        },
-        params: {
-          type: "object",
-          description: `Optional. Values for the action's declared params, keyed by param name (e.g. {"note": "Unsupported claim in paragraph 3."}). Required when the action declares a required param \u2014 get_workflow_state lists each action's params and whether they are required. The shape is per-action, so this is a free-form object; the engine validates the supplied values against the action's declared params and rejects the call if a required one is missing.`,
-          additionalProperties: !0
-        }
-      },
-      required: ["instance_id", "activity", "action"],
-      additionalProperties: !1
-    }
-  },
-  {
-    name: "get_workflow_authoring_guide",
-    description: "Get the guide for authoring a workflow definition: the DSL shape, the GROQ condition built-ins, the sugars, the rules the validator enforces, and two worked JSON examples. Call this BEFORE writing a definition from a description, then generate the JSON and check it with validate_workflow_definition. Pure read; takes no arguments.",
-    input_schema: {
-      type: "object",
-      properties: {},
-      additionalProperties: !1
-    }
-  },
-  {
-    name: "validate_workflow_definition",
-    description: "Validate a workflow definition you have authored. Runs the same checks as deploy \u2014 structural shape, cross-field invariants (e.g. every transition target is a declared stage), and GROQ syntax \u2014 without writing anything. Returns `{valid:true, definition}` where `definition` is the desugared form that would deploy, or `{valid:false, error}` with every problem listed and path-prefixed. This does NOT deploy \u2014 a human deploys the validated definition via the CLI. Call get_workflow_authoring_guide first for the shape; on `valid:false`, fix the reported problems and validate again.",
-    input_schema: {
-      type: "object",
-      properties: {
-        definition: {
-          type: "object",
-          description: "The workflow definition to validate, as a JSON object in authoring shape. See get_workflow_authoring_guide for the shape and examples."
-        }
-      },
-      required: ["definition"],
-      additionalProperties: !1
-    }
-  }
-], SUBJECT_ENTRY_NAME = "subject";
-function getSubjectGdr(instance) {
-  const entry = instance.fields.find((s) => s._type === "doc.ref" && s.name === SUBJECT_ENTRY_NAME);
-  if (!(entry === void 0 || entry._type !== "doc.ref"))
-    return entry.value?.id;
-}
-async function fetchSubjectTitles(engine, instances) {
-  const docIdToGdr = /* @__PURE__ */ new Map();
-  for (const inst of instances) {
-    const gdr = getSubjectGdr(inst);
-    if (gdr !== void 0)
-      try {
-        docIdToGdr.set(extractDocumentId(gdr), gdr);
-      } catch {
-      }
-  }
-  if (docIdToGdr.size === 0) return /* @__PURE__ */ new Map();
-  let docs;
-  try {
-    docs = await engine.client.fetch(
-      "*[_id in $docIds]{_id, title}",
-      { docIds: Array.from(docIdToGdr.keys()) }
-    );
-  } catch (err) {
-    return process.stderr.write(
-      `workflow-mcp: subject-title lookup failed; returning refs without titles: ${err instanceof Error ? err.message : String(err)}
-`
-    ), /* @__PURE__ */ new Map();
-  }
-  const out = /* @__PURE__ */ new Map();
-  for (const doc of docs) {
-    const gdr = docIdToGdr.get(doc._id);
-    gdr !== void 0 && typeof doc.title == "string" && doc.title !== "" && out.set(gdr, doc.title);
-  }
-  return out;
-}
-function buildSubject(instance, subjectTitles) {
-  const gdr = getSubjectGdr(instance);
-  if (gdr === void 0) return;
-  const title = subjectTitles.get(gdr);
-  return title !== void 0 ? { ref: gdr, title } : { ref: gdr };
-}
-function projectSummary(doc, subjectTitles) {
-  const definition = JSON.parse(doc.definitionSnapshot), stageTitle = definition.stages.find((s) => s.name === doc.currentStage)?.title, workflowTitle = definition.title, subject = buildSubject(doc, subjectTitles);
-  return {
-    instanceId: doc._id,
-    definition: doc.definition,
-    ...workflowTitle !== void 0 ? { workflowTitle } : {},
-    currentStage: doc.currentStage,
-    ...stageTitle !== void 0 ? { currentStageTitle: stageTitle } : {},
-    lastChangedAt: doc.lastChangedAt,
-    done: isInstanceDone(doc),
-    ...subject !== void 0 ? { subject } : {}
-  };
-}
-function projectState({
-  instance,
-  evaluation,
-  subjectTitles
-}) {
-  const workflowTitle = JSON.parse(instance.definitionSnapshot).title, stageTitle = evaluation.currentStage.stage.title, activities = evaluation.currentStage.activities.map((te) => {
-    const actions = te.actions.map((ae) => {
-      const verdict = actionVerdict(te, ae);
-      return {
-        action: verdict.action,
-        ...verdict.title !== void 0 ? { title: verdict.title } : {},
-        allowed: verdict.allowed,
-        ...verdict.allowed === !1 && verdict.disabledReason !== void 0 ? { disabledReason: formatDisabledReason(verdict.disabledReason) } : {}
-      };
-    });
-    return {
-      activity: te.activity.name,
-      ...te.activity.title !== void 0 ? { title: te.activity.title } : {},
-      ...te.activity.description !== void 0 ? { description: te.activity.description } : {},
-      status: te.status,
-      actions
-    };
-  }), recentHistory = instance.history.slice(-8).toReversed().map((entry) => ({
-    at: entry.at,
-    type: entry._type,
-    summary: summariseHistoryEntry(entry)
-  })), subject = buildSubject(instance, subjectTitles);
-  return {
-    instanceId: instance._id,
-    definition: instance.definition,
-    ...workflowTitle !== void 0 ? { workflowTitle } : {},
-    currentStage: instance.currentStage,
-    ...stageTitle !== void 0 ? { currentStageTitle: stageTitle } : {},
-    done: isInstanceDone(instance),
-    ...subject !== void 0 ? { subject } : {},
-    activities,
-    recentHistory
-  };
-}
-function isInstanceDone(instance) {
-  if (instance.completedAt !== void 0) return !0;
-  try {
-    const stage = JSON.parse(instance.definitionSnapshot).stages.find((s) => s.name === instance.currentStage);
-    return stage !== void 0 && isTerminalStage(stage);
-  } catch {
-    return !1;
-  }
-}
-function formatDisabledReason(reason) {
-  switch (reason.kind) {
-    case "filter-failed":
-      return "action's filter condition did not hold for this actor";
-    case "activity-not-active":
-      return "activity is not currently active";
-    case "stage-terminal":
-      return "stage is terminal \u2014 no further actions possible";
-    case "mutation-guard-denied":
-      return `blocked by mutation guard(s): ${deniedGuardLabels(reason.denied).join(", ")}`;
-    case "instance-completed":
-      return "instance has already completed";
-    case "requirements-unmet":
-      return "activity's declared requirements are not yet satisfied";
-  }
-}
-function summariseHistoryEntry(entry) {
-  switch (entry._type) {
-    case "stageEntered":
-      return `entered stage "${String(entry.stage)}"`;
-    case "stageExited":
-      return `exited stage "${String(entry.stage)}" \u2192 "${String(entry.toStage)}"`;
-    case "activityActivated":
-      return `activity "${String(entry.activity)}" activated`;
-    case "activityStatusChanged":
-      return `activity "${String(entry.activity)}" status: ${String(entry.from)} \u2192 ${String(entry.to)}`;
-    case "actionFired":
-      return `action "${String(entry.action)}" fired on activity "${String(entry.activity)}"`;
-    case "transitionFired":
-      return `transition fired: "${String(entry.fromStage)}" \u2192 "${String(entry.toStage)}"`;
-    case "effectQueued":
-      return `effect "${String(entry.effect)}" queued`;
-    case "effectCompleted":
-      return `effect "${String(entry.effect)}" completed (${String(entry.status)})`;
-    case "spawned":
-      return `spawned child workflow from activity "${String(entry.activity)}"`;
-    default:
-      return entry._type;
-  }
-}
-function diagnosisSummary(diagnosis) {
-  switch (diagnosis.state) {
-    case "progressing":
-      return "This instance will advance on its own.";
-    case "waiting":
-      return `Waiting for action on activity "${diagnosis.activity}": ${diagnosis.actions.join(" or ")}. This is the normal in-flight state \u2014 it advances when someone acts.`;
-    case "blocked":
-      return `Activity "${diagnosis.activity}" is visible but not yet executable \u2014 unmet requirement(s): ${diagnosis.requirements.join(", ")}. It will not advance until those are satisfied.`;
-    case "completed":
-      return `Completed at ${diagnosis.at}.`;
-    case "aborted":
-      return diagnosis.reason !== void 0 ? `Aborted at ${diagnosis.at}: ${diagnosis.reason}.` : `Aborted at ${diagnosis.at}.`;
-    case "stuck":
-      return stuckSummary(diagnosis.cause);
-  }
-}
-function stuckSummary(cause) {
-  switch (cause.kind) {
-    case "failed-effect":
-      return `Stuck: a failed effect "${cause.effect.name}" is blocking activity "${cause.effect.origin.name}", which can't complete until the effect succeeds.`;
-    case "hung-effect":
-      return `Stuck: effect "${cause.effect.name}" was claimed but never completed \u2014 the drainer likely died mid-dispatch, so it won't drain on its own.`;
-    case "failed-activity":
-      return `Stuck: activity "${cause.activity}" is in a terminal failed state, so any exit transition gated on it can never fire.`;
-    case "no-transition-fires":
-      return "Stuck: every activity is resolved but no exit transition's filter is satisfied \u2014 likely a routing state value a filter reads was never written.";
-    case "transition-unevaluable":
-      return `Stuck (recoverable): exit transition(s) ${cause.transitions.join(", ")} read an operand that is missing or unreadable (GROQ null). It advances on its own once that data becomes readable \u2014 no manual fix needed.`;
-  }
-}
-function buildTools(engine, options = {}) {
-  const accessOverride = options.access;
-  return { descriptors: TOOL_DESCRIPTORS, impls: {
-    list_workflow_instances: async (rawInput) => {
-      const input = parseListInput(rawInput);
-      return listInstances(engine, input);
-    },
-    get_workflow_state: async (rawInput) => {
-      const input = parseInstanceIdInput(rawInput, "get_workflow_state");
-      return getInstanceState({ engine, instanceId: input.instance_id, accessOverride });
-    },
-    diagnose_workflow: async (rawInput) => {
-      const input = parseInstanceIdInput(rawInput, "diagnose_workflow");
-      return getInstanceDiagnosis({ engine, instanceId: input.instance_id, accessOverride });
-    },
-    fire_action: async (rawInput) => {
-      const input = parseFireActionInput(rawInput);
-      return await engine.fireAction({
-        instanceId: input.instance_id,
-        activity: input.activity,
-        action: input.action,
-        ...input.params !== void 0 ? { params: input.params } : {},
-        ...accessOverride !== void 0 ? { access: accessOverride } : {}
-      }), getInstanceState({ engine, instanceId: input.instance_id, accessOverride });
-    },
-    // Authoring tools — engine-independent: they teach and check the DSL, they
-    // don't touch the lake or an instance.
-    get_workflow_authoring_guide: async () => AUTHORING_GUIDE,
-    validate_workflow_definition: async (rawInput) => {
-      const { definition } = parseValidateInput(rawInput);
-      try {
-        const stored = defineWorkflow(definition);
-        return validateDefinition(stored), { valid: !0, definition: stored };
-      } catch (err) {
-        return { valid: !1, error: err instanceof Error ? err.message : String(err) };
-      }
-    }
-  } };
-}
-function parseListInput(raw) {
-  if (raw === null || typeof raw != "object")
-    return { status: "in_flight" };
-  const obj = raw, status = obj.status === "done" || obj.status === "any" ? obj.status : "in_flight", definition = typeof obj.definition == "string" ? obj.definition : void 0;
-  return definition !== void 0 ? { definition, status } : { status };
-}
-function asObject(raw, tool) {
-  if (raw === null || typeof raw != "object")
-    throw new Error(`${tool}: input must be an object`);
-  return raw;
-}
-function requireString({
-  obj,
-  key,
-  tool
-}) {
-  const value = obj[key];
-  if (typeof value != "string" || value === "")
-    throw new Error(`${tool}: ${key} is required`);
-  return value;
-}
-function parseValidateInput(raw) {
-  const obj = asObject(raw, "validate_workflow_definition");
-  if (obj.definition === null || typeof obj.definition != "object")
-    throw new Error("validate_workflow_definition: `definition` is required and must be an object");
-  return { definition: obj.definition };
-}
-function parseInstanceIdInput(raw, tool) {
-  const obj = asObject(raw, tool);
-  return { instance_id: requireString({ obj, key: "instance_id", tool }) };
-}
-function parseFireActionInput(raw) {
-  const obj = asObject(raw, "fire_action");
-  let params;
-  if (obj.params !== void 0) {
-    if (obj.params === null || typeof obj.params != "object" || Array.isArray(obj.params))
-      throw new Error("fire_action: params must be an object");
-    params = obj.params;
-  }
-  return {
-    instance_id: requireString({ obj, key: "instance_id", tool: "fire_action" }),
-    activity: requireString({ obj, key: "activity", tool: "fire_action" }),
-    action: requireString({ obj, key: "action", tool: "fire_action" }),
-    ...params !== void 0 ? { params } : {}
-  };
-}
-async function listInstances(engine, input) {
-  const groqParts = [`_type == "${WORKFLOW_INSTANCE_TYPE}"`];
-  input.definition !== void 0 && groqParts.push("definition == $definition");
-  const groq = `*[${groqParts.join(" && ")} && ${tagScopeFilter()}] | order(lastChangedAt desc)[0...${LIST_CAP}]`, params = {};
-  input.definition !== void 0 && (params.definition = input.definition);
-  const filtered = (await engine.query({ groq, params })).filter((doc) => {
-    const done = isInstanceDone(doc);
-    return input.status === "done" ? done : input.status === "in_flight" ? !done : !0;
-  }), subjectTitles = await fetchSubjectTitles(engine, filtered);
-  return {
-    instances: filtered.map((doc) => projectSummary(doc, subjectTitles))
-  };
-}
-async function getInstanceState({
-  engine,
-  instanceId,
-  accessOverride
-}) {
-  const evaluation = await engine.evaluate({
-    instanceId,
-    ...accessOverride !== void 0 ? { access: accessOverride } : {}
-  }), instance = await engine.getInstance({ instanceId }), subjectTitles = await fetchSubjectTitles(engine, [instance]);
-  return projectState({ instance, evaluation, subjectTitles });
-}
-async function getInstanceDiagnosis({
-  engine,
-  instanceId,
-  accessOverride
-}) {
-  const { diagnosis, remediations } = await engine.diagnose({
-    instanceId,
-    ...accessOverride !== void 0 ? { access: accessOverride } : {}
-  });
-  return {
-    instanceId,
-    state: diagnosis.state,
-    summary: diagnosisSummary(diagnosis),
-    ...diagnosis.state === "stuck" ? { cause: diagnosis.cause.kind } : {},
-    remediations
-  };
-}
-export {
-  buildTools
-};
-//# sourceMappingURL=index.js.map
+export { WORKFLOW_TOOLS, registerWorkflowTools, toolInputJsonSchema, workflowAddressFromInput };

package/dist/stdio.d.ts

@@ -1,12 +1,16 @@
 /**
- * stdio MCP host — boots a {@link Server} from `@modelcontextprotocol/sdk`,
- * binds the workflow tools to an engine built from environment variables,
- * and listens on stdio.
+ * stdio MCP host — boots an {@link McpServer} from
+ * `@modelcontextprotocol/sdk`, binds the workflow tools, and listens on
+ * stdio.
  *
- * This is one of two thin hosts over the shared {@link buildTools} core:
- * the stdio host (here) is the early-access self-host (one env-built
- * engine, BYO scoped token, system-actor attribution); the production
- * host embeds {@link buildTools} with per-request identity elsewhere.
+ * The server is org-authed: boot config is the org-level
+ * `SANITY_AUTH_TOKEN` (plus an optional `SANITY_API_HOST`) and nothing
+ * else — no project, dataset, resource, or tag. Every instance-operating
+ * tool call names its own workflow environment (`workflow_resource` +
+ * `tag`, see `./address.ts`), and the host builds one engine per
+ * distinct environment, cached for the life of the process (see
+ * `./engine-cache.ts`). Same model as the Sanity MCP: auth says who may
+ * act, the call says where.
  *
  * Kept as its own package entry (not inline in `bin/`) so it can be
  * compiled to `dist/stdio.js` by pkg-utils and re-used by both the
@@ -15,9 +19,9 @@
  * keeps the MCP transport deps out of the library import graph.
  */
 /**
- * Read the environment, build the engine, register the tools, and serve
- * on stdio. Resolves when the transport is connected (the process then
- * stays alive on the open stdio streams).
+ * Read the org token, register the tools, and serve on stdio. Resolves
+ * when the transport is connected (the process then stays alive on the
+ * open stdio streams).
  */
 export declare function runStdioServer(): Promise<void>;