@pipefy/pipefy-process-coder 0.1.1 → 0.1.3

package/dist/commands/misc.js

@@ -13,7 +13,7 @@ import { RECONSTRUCTION_GAPS } from "../pipefy/reconstruct.js";
 import { readTree } from "../workspace/read.js";
 import { registryRows } from "../apply/registry.js";
 import { validateTree, renderFindings, blockingErrors } from "../validate/index.js";
-import { connect, openWorkspace } from "./context.js";
+import { connect, openWorkspace, readLive } from "./context.js";
 // ── login ────────────────────────────────────────────────────────────────────
 export const loginHelp = `pipe login [options]
 
@@ -36,11 +36,14 @@ export const login = async (p) => {
     const token = str(p, 'token');
     // ── the intended path: delegate to the toolkit's OAuth flow ───────────────
     if (!token) {
-        const { inspectToolkit, runToolkitLogin, INSTALL_HINT } = await import("../pipefy/toolkit.js");
+        const { inspectToolkit, runToolkitLogin, INSTALL_HINT, UPGRADE_HINT } = await import("../pipefy/toolkit.js");
         const toolkit = await inspectToolkit();
         if (!toolkit.installed) {
             throw new UserError('the Pipefy AI toolkit is not installed, so there is no browser login to run', `${INSTALL_HINT} — or use \`pipe login --token <token>\` for a personal API token`);
         }
+        if (!toolkit.usable) {
+            throw new UserError(`the Pipefy AI toolkit is installed but this tool cannot use it: ${toolkit.error}`, `${UPGRADE_HINT} — or use \`pipe login --token <token>\` for a personal API token`);
+        }
         step('running `pipefy auth login` (browser sign-in)');
         const code = await runToolkitLogin(bool(p, 'device') ? ['--device'] : []);
         if (code !== 0) {
@@ -91,7 +94,7 @@ export const doctorHelp = `pipe doctor [--repo <pipeId>]
   With --repo it also probes that pipe's read paths.`;
 export const doctor = async (p) => {
     const { resolveCredential } = await import("../config.js");
-    const { inspectToolkit, toolkitAuthStatus, INSTALL_HINT } = await import("../pipefy/toolkit.js");
+    const { inspectToolkit, toolkitAuthStatus, INSTALL_HINT, UPGRADE_HINT } = await import("../pipefy/toolkit.js");
     out(bold('endpoints'));
     out(`  graphql   ${ENDPOINTS.graphql}`);
     out(`  internal  ${ENDPOINTS.internal}`);
@@ -99,9 +102,18 @@ export const doctor = async (p) => {
     out(bold('credential'));
     const toolkit = await inspectToolkit();
     const credential = await resolveCredential();
-    out(`  toolkit   ${toolkit.installed ? green('installed') : red('not installed')}` +
-        (toolkit.installed ? dim(`  ${toolkit.cliPath ?? toolkit.interpreter}`) : dim(`  ${INSTALL_HINT}`)));
-    if (toolkit.installed) {
+    if (!toolkit.installed) {
+        out(`  toolkit   ${red('not installed')}${dim(`  ${INSTALL_HINT}`)}`);
+    }
+    else if (!toolkit.usable) {
+        out(`  toolkit   ${yellow('installed, unusable')}${dim(`  ${toolkit.cliPath ?? toolkit.interpreter}`)}`);
+        out(`            ${dim(toolkit.error)}`);
+        out(`            ${dim(UPGRADE_HINT)}`);
+    }
+    else {
+        out(`  toolkit   ${green('installed')}${dim(`  ${toolkit.cliPath ?? toolkit.interpreter}`)}`);
+    }
+    if (toolkit.installed && toolkit.usable) {
         const status = await toolkitAuthStatus();
         if (status) {
             const identity = status['identity'];
@@ -118,7 +130,11 @@ export const doctor = async (p) => {
         dim(credential?.detail ? `  ${credential.detail}` : ''));
     if (!credential) {
         info('');
-        throw new UserError('no credential', toolkit.installed ? 'run `pipe login` for the browser flow' : `${INSTALL_HINT}, or \`pipe login --token <token>\``);
+        throw new UserError('no credential', !toolkit.installed
+            ? `${INSTALL_HINT}, or \`pipe login --token <token>\``
+            : !toolkit.usable
+                ? `${UPGRADE_HINT}, or \`pipe login --token <token>\``
+                : 'run `pipe login` for the browser flow');
     }
     const net = await connect(p);
     const caps = await net.capabilities();
@@ -151,14 +167,35 @@ export const doctor = async (p) => {
     if (repoId) {
         out('');
         out(bold(`probing repo ${repoId}`));
-        const jumps = await net.internal.getPhaseSettings(await firstPhaseId(net, repoId));
+        const repo = await probeRepo(net, repoId);
+        const jumps = await net.internal.getPhaseSettings(repo.firstPhaseId);
         out(`  internal settings endpoint  ${jumps ? green('answers') : red('no answer')}`);
-        const autos = net.organizationId ? await net.internal.listAutomations(net.organizationId, repoId) : null;
-        out(`  internal automations query   ${autos ? green(`answers (${autos.length} automations)`) : net.organizationId ? red('no answer') : yellow('needs --org')}`);
+        // The repo's own organization, as a pull uses — not the saved default.
+        const orgId = repo.organizationId ?? net.organizationId;
+        const autos = orgId ? await net.internal.listAutomations(orgId, repoId) : null;
+        out(`  internal automations query   ${autos ? green(`answers (${autos.length} automations)`) : orgId ? red('no answer') : yellow('needs --org')}`);
     }
     out('');
     out(bold('internal API'));
-    out(`  status ${net.internal.status === 'ok' ? green('ok') : net.internal.status === 'unavailable' ? red('unavailable') : dim('unknown')}`);
+    // Validates the query documents themselves, with ids that match nothing —
+    // "status unknown" used to be all this said, while every automation read in
+    // a pull was failing on a query the schema had stopped accepting.
+    const checks = await net.internal.checkQueries();
+    if (!checks)
+        out(`  queries   ${red('no answer')}${dim('  the endpoint could not be reached')}`);
+    else {
+        for (const c of checks) {
+            out(`  ${c.ok ? green('ok  ') : red('FAIL')}  ${c.label.padEnd(18)}${c.ok ? '' : ` ${dim(c.message ?? '')}`}`);
+        }
+    }
+    const status = net.internal.status;
+    out(`  status ${status === 'ok'
+        ? green('ok')
+        : status === 'incompatible'
+            ? red('incompatible') + dim('  a query this version of pipe sends is refused — a bug in pipe, worth reporting')
+            : status === 'unavailable'
+                ? red('unavailable')
+                : dim('unknown')}`);
     info(dim('  Unversioned, no compatibility contract (PLAN.md §2.1). When it breaks, automation\n' +
         '  detail and phase-jump editing degrade to unknown rather than failing an apply.'));
     if (!caps.snapshots) {
@@ -169,9 +206,12 @@ export const doctor = async (p) => {
     }
     return 0;
 };
-const firstPhaseId = async (net, repoId) => {
-    const data = await net.client.tryRaw('query($id: ID!) { pipe(id: $id) { phases { id } } }', { id: repoId }, 'first phase');
-    return data?.pipe?.phases?.[0]?.id ?? '0';
+const probeRepo = async (net, repoId) => {
+    const data = await net.client.tryRaw('query($id: ID!) { pipe(id: $id) { organizationId phases { id } } }', { id: repoId }, 'probe repo');
+    return {
+        firstPhaseId: data?.pipe?.phases?.[0]?.id ?? '0',
+        organizationId: data?.pipe?.organizationId ? String(data.pipe.organizationId) : null,
+    };
 };
 // ── export ───────────────────────────────────────────────────────────────────
 export const exportHelp = `pipe export <pipeId> [options]
@@ -191,26 +231,7 @@ export const exportCmd = async (p) => {
     const net = await connect(p);
     const caps = await net.capabilities();
     const useSnapshot = caps.snapshots && !bool(p, 'no-snapshot');
-    let env;
-    if (useSnapshot) {
-        const { payload, versionId } = await net.snapshots.pull(repoId);
-        const { fullCoverage } = await import("../model/payload.js");
-        env = {
-            source: 'snapshot',
-            versionId,
-            readAt: new Date().toISOString(),
-            repoKind: 'pipe',
-            coverage: fullCoverage('complete'),
-            notes: [],
-            payload,
-        };
-    }
-    else {
-        env = await net.reconstructor.reconstruct(repoId, {
-            organizationId: net.organizationId,
-            noInternal: bool(p, 'no-internal'),
-        });
-    }
+    const env = await readLive(net, p, repoId, { preferSnapshot: useSnapshot, noInternal: bool(p, 'no-internal') });
     /**
      * A bare payload has no provenance, and for a reconstructed read that matters.
      *

package/dist/commands/plan.js

@@ -10,7 +10,7 @@ import { compile } from "../apply/compile.js";
 import { readAutomationCatalogue } from "../pipefy/automations.js";
 import { validateTree, renderFindings, blockingErrors } from "../validate/index.js";
 import { connect, openWorkspace } from "./context.js";
-import { loadBaseline, writeHtml, openViewer } from "./diff.js";
+import { loadBaseline, writeHtml, openViewer, refuseSuppressedEdits } from "./diff.js";
 export const help = `pipe plan [workspace] [options]
 
   --repo <id>            which repo in the workspace (default: the root pipe)
@@ -115,6 +115,8 @@ export const run = async (p) => {
         throw new UserError(`${blocking.length} validation error${blocking.length === 1 ? '' : 's'} — fix these before planning`);
     }
     const changeSet = diffTrees(baseline, edited);
+    // Before the empty check: edits that were all left out are not "nothing to do".
+    refuseSuppressedEdits(changeSet, bool(p, 'force'));
     if (!changeSet.changes.length) {
         /**
          * The pipe half is clean, which is not the same as nothing to do: a flow-only

package/dist/commands/pull.js

@@ -19,6 +19,7 @@ import { baselineFile, paths } from "../workspace/layout.js";
 import { connect } from "./context.js";
 import { RunRecorder, invocation } from "../report/run.js";
 import { pullAndWriteFlows } from "./flows.js";
+import { TOOL } from "../version.js";
 /**
  * `pipe pull <pipeId>` — the read path.
  *
@@ -39,6 +40,7 @@ export const help = `pipe pull <pipeId> [options]
   --org <id>           organization id, for the internal automations query
   --reuse-snapshot     use the newest complete snapshot instead of creating one
   --no-snapshot        force GraphQL reconstruction even if snapshots exist
+  --no-fallback        if a snapshot read fails, fail rather than reconstruct over GraphQL
   --no-internal        skip the internal API (automations and jumps become unknown)
   --label <text>       label the snapshot this pull creates
   --skip-roundtrip     do not run the codec self-check (not recommended)
@@ -57,6 +59,7 @@ export const run = async (p) => {
     const noInternal = bool(p, 'no-internal');
     const reuseSnapshot = bool(p, 'reuse-snapshot');
     const skipRoundTrip = bool(p, 'skip-roundtrip');
+    const noFallback = bool(p, 'no-fallback');
     const label = str(p, 'label');
     const startedAt = new Date();
     const net = await connect(p);
@@ -114,7 +117,28 @@ export const run = async (p) => {
              * relation arrays a pipe's does (VALIDATION.md §3g).
              */
             if (useSnapshots) {
-                env = await readViaSnapshot(net, ref, { reuseSnapshot, label });
+                try {
+                    env = await readViaSnapshot(net, ref, { reuseSnapshot, label });
+                }
+                catch (e) {
+                    /**
+                     * A failed snapshot read falls back to reconstruction rather than
+                     * leaving the repo out. Found live: Pipefy's storage answered every
+                     * signed snapshot URL with HTTP 500 — the creation succeeded, the
+                     * download did not, on every pipe tried — and the pull wrote a
+                     * workspace with no pipe in it. Reconstruction is less complete, and
+                     * says so per group: what it cannot see is `unknown`, never empty, so
+                     * the fallback cannot license a delete.
+                     */
+                    if (noFallback)
+                        throw e;
+                    warn(`snapshot read failed for ${ref.kind} ${ref.id} (${ref.name ?? '?'}): ${e.message} — ` +
+                        'reading it over GraphQL instead (--no-fallback to stop here)');
+                    env = await net.reconstructor.reconstruct(ref.id, {
+                        organizationId: net.organizationId,
+                        noInternal,
+                    });
+                }
             }
             else {
                 env = await net.reconstructor.reconstruct(ref.id, {
@@ -164,8 +188,31 @@ export const run = async (p) => {
     });
     const rootRef = discovery.repos.find((r) => r.id === rootRepoId);
     const outDir = resolve(str(p, 'out') ?? `${slugName(rootRef.name ?? String(rootRepoId))}-workspace`);
+    /**
+     * The root repo is the workspace. Without it there is nothing to validate,
+     * diff or plan against — and writing lock.json and workspace.json anyway
+     * did worse than produce an empty directory: re-pulling into an existing
+     * workspace replaced its lock with one that no longer listed the pipe, so
+     * the next diff had no baseline. This used to finish with exit code 0 and a
+     * "next: pipe validate", which scripts and agents believed.
+     */
+    const rootEnvelope = await readRepo(rootRef);
+    if (!rootEnvelope) {
+        ui.stop();
+        throw new UserError(`could not read the root repo ${rootRepoId}${rootRef.name ? ` (${rootRef.name})` : ''} — nothing was written to ${outDir}`, useSnapshots && noFallback
+            ? 'drop --no-fallback to read it over GraphQL, or run with --verbose for the cause'
+            : 'run with --verbose for the cause');
+    }
     await mkdirp(outDir);
-    const lock = emptyLock(rootRepoId, net.organizationId, depth);
+    /**
+     * The workspace's organization is the root pipe's, not the credential's
+     * default: `plan` hands this to the compiler, and a token can belong to
+     * several organizations. The default is only the fallback for a payload
+     * that does not say.
+     */
+    const rootOrg = rootEnvelope.payload['organization_id'];
+    const organizationId = rootOrg ? String(rootOrg) : net.organizationId;
+    const lock = emptyLock(rootRepoId, organizationId, depth);
     lock.edges = discovery.edges;
     const trees = [];
     const sources = new Set();
@@ -270,7 +317,8 @@ export const run = async (p) => {
         const detail = ref.kind === 'table'
             ? `${fieldCount} fields, ${Math.max(0, tree.phases.length - 1)} record statuses, ${written.length} files`
             : `${tree.phases.length} phases, ${fieldCount} fields, ` +
-                `${tree.automations.length} automations, ${written.length} files`;
+                // "0 automations" beside an unknown group read as "this pipe has none".
+                `${env.coverage.automations === 'unknown' ? 'automations unknown' : `${tree.automations.length} automations`}, ${written.length} files`;
         ui.update(task, {
             state: 'done',
             detail: detail + (gaps.length ? `, ${gaps.length} groups partial or unknown` : ''),
@@ -281,10 +329,10 @@ export const run = async (p) => {
         name: rootRef.name ?? String(rootRepoId),
         createdAt: new Date().toISOString(),
         rootRepoId,
-        organizationId: net.organizationId,
+        organizationId,
         depth,
         lastPullSource: sources.size > 1 ? 'mixed' : (sources.values().next().value ?? 'reconstructed'),
-        tool: { name: 'pipefy-process-coder', version: '0.1.0' },
+        tool: { ...TOOL },
     });
     /**
      * Read the closed sets while the client is open. Two queries, and it is what
@@ -492,7 +540,7 @@ const pullFromFile = async (p, fromFile) => {
         organizationId: str(p, 'org') ?? null,
         depth: 0,
         lastPullSource: env.source,
-        tool: { name: 'pipefy-process-coder', version: '0.1.0' },
+        tool: { ...TOOL },
     });
     await writeDocs(outDir, lock, [tree], null, await loadReference(outDir));
     ok(`${rootRef.kind} ${repoIdNum} ${green(rootRef.name ?? '')} — ${tree.phases.length} phases, ` +

package/dist/commands/verify.js

@@ -1,13 +1,12 @@
 import { bool } from "../cli/args.js";
 import { writeJson } from "../util/fsx.js";
 import { dim, info, ok, out, stripAnsi, warn } from "../util/log.js";
-import { fullCoverage } from "../model/payload.js";
 import { unpack } from "../codec/unpack.js";
 import { readTree } from "../workspace/read.js";
 import { baselineFile } from "../workspace/layout.js";
 import { diffTrees } from "../diff/diff.js";
 import { renderChangeSet } from "../diff/render.js";
-import { connect, openWorkspace } from "./context.js";
+import { connect, openWorkspace, readLive } from "./context.js";
 import { RunRecorder, invocation } from "../report/run.js";
 export const help = `pipe verify [workspace] [options]
 
@@ -40,20 +39,7 @@ export const run = async (p) => {
         const { writeTree } = await import("../workspace/write.js");
         const caps = await net.capabilities();
         info(dim(`reading pipe ${repo.id} to match against (${caps.snapshots ? 'snapshot' : 'GraphQL reconstruction'})`));
-        const envelope = caps.snapshots
-            ? await (async () => {
-                const { payload, versionId } = await net.snapshots.pull(repo.id);
-                return {
-                    source: 'snapshot',
-                    versionId,
-                    readAt: new Date().toISOString(),
-                    repoKind: repo.kind,
-                    coverage: fullCoverage('complete'),
-                    notes: [],
-                    payload,
-                };
-            })()
-            : await net.reconstructor.reconstruct(repo.id, { organizationId: lock.organizationId });
+        const envelope = await readLive(net, p, repo.id, { kind: repo.kind, organizationId: lock.organizationId });
         const authored = await readTree(dir);
         const { loadBaselineEnvelope } = await import("./diff.js");
         const previous = await loadBaselineEnvelope(root, repo.id);
@@ -88,7 +74,7 @@ export const run = async (p) => {
         return 0;
     }
     const rec = recorderFor(p, root, repo, 'verify');
-    const result = await verifyRepo({ net, root, lock, repo, expectedTreeDir: dir });
+    const result = await verifyRepo({ net, parsed: p, root, lock, repo, expectedTreeDir: dir });
     rec?.after(result.envelope);
     rec?.verified(result.ok, result.ok ? undefined : `${result.changeCount} difference(s) remain`);
     if (bool(p, 'json')) {
@@ -143,6 +129,8 @@ const write = async (rec, outcome, summary) => {
     else if (res)
         info(dim(`   run recorded in runs/${rec.id}/`));
 };
+/** No flags: a caller that passes none gets the defaults, fallback included. */
+const EMPTY_ARGS = { command: 'verify', positionals: [], flags: {} };
 export const verifyRepo = async (args) => {
     const { net, lock, repo, expectedTreeDir, idMap, preferReconstruct } = args;
     const caps = await net.capabilities();
@@ -159,21 +147,12 @@ export const verifyRepo = async (args) => {
      * comparison and a verified-clean apply proves less than it appears to.
      * `preferReconstruct` trades that away deliberately — see its doc comment.
      */
-    if (useSnapshot) {
-        const { payload, versionId } = await net.snapshots.pull(repo.id, `post-apply/${new Date().toISOString()}`);
-        envelope = {
-            source: 'snapshot',
-            versionId,
-            readAt: new Date().toISOString(),
-            repoKind: repo.kind,
-            coverage: fullCoverage('complete'),
-            notes: [],
-            payload,
-        };
-    }
-    else {
-        envelope = await net.reconstructor.reconstruct(repo.id, { organizationId: lock.organizationId });
-    }
+    envelope = await readLive(net, args.parsed ?? EMPTY_ARGS, repo.id, {
+        kind: repo.kind,
+        label: `post-apply/${new Date().toISOString()}`,
+        organizationId: lock.organizationId,
+        preferSnapshot: useSnapshot,
+    });
     const live = unpack(envelope);
     /**
      * Direction matters: live -> expected. A change in this diff means "the pipe

package/dist/diff/diff.js

@@ -378,8 +378,19 @@ export const diffTrees = (before, after, opts = {}) => {
      * second would be catastrophic.
      */
     const skipSet = new Set(opts.skipEntities ?? []);
-    /** Which sides read this group only partially. See deltasOf. */
+    /**
+     * Which sides read this group's *columns* only partially. See deltasOf.
+     * `meta.columns` when the read recorded it, otherwise the group's coverage —
+     * what a snapshot, and every workspace pulled before the two were split,
+     * carry.
+     */
+    const columnCoverage = (tree, entity) => tree.meta.columns?.[entity] ?? tree.meta.coverage?.[entity] ?? 'unknown';
     const partialSides = (entity) => ({
+        before: columnCoverage(before, entity) === 'partial',
+        after: columnCoverage(after, entity) === 'partial',
+    });
+    /** Which sides read this group's *rows* only partially — the row rule below. */
+    const partialRows = (entity) => ({
         before: (before.meta.coverage?.[entity] ?? 'unknown') === 'partial',
         after: (after.meta.coverage?.[entity] ?? 'unknown') === 'partial',
     });
@@ -392,12 +403,14 @@ export const diffTrees = (before, after, opts = {}) => {
      * "deletes" — and an apply would have deleted two live automations because one
      * read path could not see them.
      *
-     * So on a partial side, absence means unseen: a delete is suppressed when the
-     * *after* side is partial, and a create when the *before* side is partial.
+     * So on a side whose *rows* are partial, absence means unseen: a delete is
+     * suppressed when the *after* side is partial, and a create when the *before*
+     * side is partial. Missing columns say nothing about rows, so they do not
+     * enter into this (see Coverage on TreeMeta.columns).
      */
     const suppressed = [];
     const rowAbsenceIsUnknown = (entity, op, label) => {
-        const sides = partialSides(entity);
+        const sides = partialRows(entity);
         const unknown = op === 'delete' ? sides.after : sides.before;
         if (unknown)
             suppressed.push({ entity, op, label });
@@ -963,6 +976,7 @@ export const diffTrees = (before, after, opts = {}) => {
             entity: s.entity,
             reason: `"${s.label}" would read as a ${s.op}, but that side's coverage is partial — ` +
                 `absence there is unseen, not gone. Re-read from a snapshot to decide.`,
+            suppressed: { op: s.op, label: s.label },
         });
     }
     return {
@@ -975,6 +989,16 @@ export const diffTrees = (before, after, opts = {}) => {
     };
 };
 export const isEmpty = (cs) => cs.changes.length === 0;
+/**
+ * The creates and deletes this change set had to leave out.
+ *
+ * Between a workspace and its own baseline every one of these is an edit
+ * someone made, and planning the rest without them is applying half of what
+ * was asked for. Found in a field run: 20 updates would have gone through and
+ * the 2 phase creates they pointed at would not, leaving a pipe with no final
+ * phase. `plan` and `apply` refuse on these unless told otherwise.
+ */
+export const suppressedEdits = (cs) => cs.skipped.flatMap((s) => (s.suppressed ? [{ entity: s.entity, ...s.suppressed }] : []));
 export const countByOp = (cs) => {
     const out = { create: 0, update: 0, delete: 0, reorder: 0, archive: 0, unarchive: 0 };
     for (const c of cs.changes)

package/dist/pipefy/agents.js

@@ -1,4 +1,39 @@
 import { debug } from "../util/log.js";
+/**
+ * The selection under `aiBehaviorParams`, aliased to the snake_case the files
+ * use. Shared with `internal.ts`'s `loadAutomation`, because `AiBehaviorParams`
+ * is the same object type on both endpoints — and the internal query once
+ * selected it bare, as though it were a scalar. GraphQL rejects that before
+ * resolving anything, so every automation in the pipe failed to load, not only
+ * the AI ones. One selection, two call sites, so the two cannot drift apart.
+ */
+export const AI_BEHAVIOR_PARAMS_SELECTION = `{
+  data_source_ids: dataSourceIds
+  instruction
+  referenced_field_ids: referencedFieldIds
+  provider_id: providerId
+  system_provider_id: systemProviderId
+  actions_attributes: actionsAttributes {
+    id
+    name
+    action_type: actionType
+    reference_id: referenceId
+    metadata {
+      destination_phase_id: destinationPhaseId
+      pipe_id: pipeId
+      table_id: tableId
+      email_template_id: emailTemplateId
+      allow_template_modifications: allowTemplateModifications
+      mcp_server_id: mcpServerId
+      tool_name: toolName
+      title
+      emails
+      tool_inputs: toolInputs { name source value field_id: fieldId }
+      fields_attributes: fieldsAttributes { field_id: fieldId input_mode: inputMode value }
+    }
+  }
+  capabilities_attributes: capabilitiesAttributes { capability_type: capabilityType enabled }
+}`;
 const QUERY = `
   query($repoUuid: ID!, $after: String) {
     aiAgents(repoUuid: $repoUuid, first: 50, after: $after) {
@@ -34,33 +69,7 @@ const QUERY = `
               expressions { id field_address operation value structure_id }
             }
             action_params {
-              ai_behavior_params: aiBehaviorParams {
-                data_source_ids: dataSourceIds
-                instruction
-                referenced_field_ids: referencedFieldIds
-                provider_id: providerId
-                system_provider_id: systemProviderId
-                actions_attributes: actionsAttributes {
-                  id
-                  name
-                  action_type: actionType
-                  reference_id: referenceId
-                  metadata {
-                    destination_phase_id: destinationPhaseId
-                    pipe_id: pipeId
-                    table_id: tableId
-                    email_template_id: emailTemplateId
-                    allow_template_modifications: allowTemplateModifications
-                    mcp_server_id: mcpServerId
-                    tool_name: toolName
-                    title
-                    emails
-                    tool_inputs: toolInputs { name source value field_id: fieldId }
-                    fields_attributes: fieldsAttributes { field_id: fieldId input_mode: inputMode value }
-                  }
-                }
-                capabilities_attributes: capabilitiesAttributes { capability_type: capabilityType enabled }
-              }
+              ai_behavior_params: aiBehaviorParams ${AI_BEHAVIOR_PARAMS_SELECTION}
             }
           }
         }