@manta-eu/client 0.5.0 → 0.6.0

package/src/shared/action-graph.ts

@@ -0,0 +1,471 @@
+import { ProvActivitySchema } from "@manta-eu/ldo/schemas/prov";
+import { isPresent } from "@manta-eu/lib/present";
+import { owlNothingIri } from "@manta-eu/rdf-lib/namespaces";
+import { createLens, type Options, type Schema } from "ldkit";
+import { ldkit, rdf } from "ldkit/namespaces";
+import { uniq } from "ramda";
+import {
+  ActionPlanRunHistoryDocument,
+  ExecuteAgentActionGraphDocument,
+  type GQLActionPlanRunHistoryQuery,
+  type GQLExecuteActionErrorCode,
+  type GQLExecuteAgentActionGraphMutation,
+} from "../generated/graphql";
+import type { ActionInput } from "./action-document";
+
+/** Sends a GraphQL document to Manta, scoped to the datastore the caller works in. */
+export type ActionGraphql = (
+  document: string,
+  variables: Record<string, unknown>,
+  options?: { signal?: AbortSignal },
+) => Promise<unknown>;
+
+export type ActionDeletion = Omit<ActionInput, "properties">;
+
+export type GraphOp =
+  | { op: "add"; input: ActionInput }
+  | { op: "update"; input: ActionInput }
+  | { op: "delete"; input: ActionDeletion };
+
+export const adding = (input: ActionInput): GraphOp => ({ op: "add", input });
+
+export const updating = (input: ActionInput): GraphOp => ({ op: "update", input });
+
+export const deleting = (input: ActionDeletion): GraphOp => ({ op: "delete", input });
+
+export type ActionGraphNode = { "@id": string; "@type": string | readonly [string, ...string[]] } & Record<
+  string,
+  unknown
+>;
+
+export type ActionGraphInput = { graph: { "@graph": readonly ActionGraphNode[] } };
+
+export type ExecuteActionGraphVariables = { input: ActionGraphInput };
+
+/** Manta resolves the `m:` prefix against the realm it runs as, so the key holds in every realm. */
+export const actionShapeKey = "m:actionShape";
+
+/** Manta takes at most this many entities in one plan. */
+export const maxGraphNodes = 101;
+
+const typesIn = (value: unknown): string[] =>
+  Array.isArray(value)
+    ? value.filter((type): type is string => typeof type === "string")
+    : typeof value === "string"
+      ? [value]
+      : [];
+
+/** `@id` and `@type` come from the op's subject and type, never from whatever its properties hold. */
+export function graphNode(op: GraphOp): ActionGraphNode {
+  const shape = { [actionShapeKey]: { "@id": op.input.actionShape } };
+  if (op.op === "delete") return { "@id": op.input.subjectIri, "@type": owlNothingIri, ...shape };
+
+  const { "@id": _id, "@type": held, ...properties } = op.input.properties as Record<string, unknown>;
+  const [first = op.input.rdfType, ...rest] = uniq([op.input.rdfType, ...typesIn(held)]);
+  return { ...properties, "@id": op.input.subjectIri, "@type": [first, ...rest], ...shape };
+}
+
+export const actionGraphInput = (nodes: readonly ActionGraphNode[]): ActionGraphInput => ({
+  graph: { "@graph": nodes },
+});
+
+export type ActionOutcome =
+  | { status: "done"; planGraphIri: string }
+  | { status: "pending"; planGraphIri: string; workflowId?: string; message: string }
+  | { status: "failed"; message: string; subcode?: number };
+
+export type PendingAction = Extract<ActionOutcome, { status: "pending" }>;
+
+export type FollowPendingAction = (pending: PendingAction) => Promise<Exclude<ActionOutcome, PendingAction>>;
+
+export const rejectedWithoutReason = "Manta rejected the action without saying why.";
+
+export const unreachableMessage = "Manta could not be reached.";
+
+export const nothingToSendMessage = "Nothing in this change is something Manta can send.";
+
+export const skippedMessage = "Not sent, because a change it depends on was not made.";
+
+export const twiceMessage = "Not sent, because this change touches the same entity twice in different ways.";
+
+export const unconfirmedMessage = "Manta is still sending the change; the channel has not confirmed it yet.";
+
+const quotedPattern = (key: string, flags?: string) => new RegExp(`:${key} "((?:[^"\\\\]|\\\\.)*)"`, flags);
+
+/** The message a channel's error carries for a person, out of the raw error Manta recorded. */
+export function channelErrorMessage(raw: string): string {
+  const topics = uniq([...raw.matchAll(quotedPattern("topic", "g"))].flatMap((match) => match[1] ?? []));
+  if (isPresent(topics)) return `Policy: ${topics.join(", ")}.`;
+
+  const quoted = raw.match(quotedPattern("error_user_msg"))?.[1] ?? raw.match(quotedPattern("message"))?.[1];
+  return quoted ? quoted.replace(/\\"/g, '"') : raw;
+}
+
+export function channelErrorSubcode(raw: string): number | undefined {
+  const subcode = raw.match(/:error_subcode (\d+)/)?.[1];
+  return subcode === undefined ? undefined : Number(subcode);
+}
+
+const reasonOf = (cause: unknown): string => (cause instanceof Error ? cause.message : unreachableMessage);
+
+export type GraphStart =
+  | { status: "started"; planGraphIri: string; workflowId?: string }
+  | { status: "refused"; message: string; code?: GQLExecuteActionErrorCode | null }
+  | { status: "unknown"; message: string };
+
+export async function startActionGraph(
+  graphql: ActionGraphql,
+  nodes: readonly ActionGraphNode[],
+  options: { signal?: AbortSignal } = {},
+): Promise<GraphStart> {
+  try {
+    const variables: ExecuteActionGraphVariables = { input: actionGraphInput(nodes) };
+    const data = (await graphql(ExecuteAgentActionGraphDocument, variables, options)) as
+      | GQLExecuteAgentActionGraphMutation
+      | undefined;
+    const started = data?.executeActionGraph;
+    if (started === undefined) return { status: "unknown", message: rejectedWithoutReason };
+    if (!started.success) {
+      return { status: "refused", message: started.error ?? rejectedWithoutReason, code: started.code };
+    }
+    if (!isPresent(started.namedGraphIri)) {
+      return { status: "unknown", message: started.error ?? rejectedWithoutReason };
+    }
+    return {
+      status: "started",
+      planGraphIri: started.namedGraphIri,
+      ...(isPresent(started.workflowId) && { workflowId: started.workflowId }),
+    };
+  } catch (cause) {
+    return { status: "unknown", message: reasonOf(cause) };
+  }
+}
+
+type PlanRun = GQLActionPlanRunHistoryQuery["actionPlanRunHistory"]["runs"][number];
+
+async function latestRun(graphql: ActionGraphql, planGraphIri: string, signal: AbortSignal) {
+  try {
+    const data = (await graphql(
+      ActionPlanRunHistoryDocument,
+      { planGraphIris: [planGraphIri], limit: 1 },
+      { signal },
+    )) as GQLActionPlanRunHistoryQuery | undefined;
+    return data?.actionPlanRunHistory.runs[0] as PlanRun | undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function waitForPoll(intervalMs: number, signal: AbortSignal): Promise<void> {
+  return new Promise((resolve) => {
+    if (signal.aborted) return resolve();
+    const finish = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", finish);
+      resolve();
+    };
+    const timer = setTimeout(finish, intervalMs);
+    signal.addEventListener("abort", finish, { once: true });
+  });
+}
+
+export type AwaitRunArgs = {
+  planGraphIri: string;
+  workflowId?: string;
+  pollIntervalMs: number;
+  timeoutMs: number;
+  pendingMessage: string;
+  formatError?: (raw: string) => string;
+  signal?: AbortSignal;
+};
+
+/** Polls the plan's run until it completes or fails, or reports it pending once `timeoutMs` ends. */
+export async function awaitRun(graphql: ActionGraphql, args: AwaitRunArgs): Promise<ActionOutcome> {
+  const { planGraphIri, workflowId, pollIntervalMs, timeoutMs, pendingMessage } = args;
+  const formatError = args.formatError ?? channelErrorMessage;
+  const deadline = Date.now() + timeoutMs;
+  const pending: PendingAction = {
+    status: "pending",
+    planGraphIri,
+    ...(isPresent(workflowId) && { workflowId }),
+    message: pendingMessage,
+  };
+  if (timeoutMs <= 0 || args.signal?.aborted) return pending;
+
+  const observation = new AbortController();
+  const signal = args.signal ? AbortSignal.any([args.signal, observation.signal]) : observation.signal;
+  const timer = setTimeout(() => observation.abort(), timeoutMs);
+
+  try {
+    while (Date.now() < deadline && !signal.aborted) {
+      const run = await latestRun(graphql, planGraphIri, signal);
+      if (signal.aborted) break;
+
+      if (run?.status === "COMPLETED") return { status: "done", planGraphIri };
+      if (run?.status === "FAILED") {
+        const subcode = isPresent(run.errorMessage) ? channelErrorSubcode(run.errorMessage) : undefined;
+        return {
+          status: "failed",
+          message: isPresent(run.errorMessage) ? formatError(run.errorMessage) : rejectedWithoutReason,
+          ...(subcode !== undefined && { subcode }),
+        };
+      }
+
+      await waitForPoll(Math.min(pollIntervalMs, Math.max(0, deadline - Date.now())), signal);
+    }
+  } finally {
+    clearTimeout(timer);
+  }
+
+  return pending;
+}
+
+export type EntityOutcome = {
+  used: string;
+  generated: { iri: string; types: string[] }[];
+  errorMessage?: string;
+  skippedReason?: string;
+  startedAt?: string;
+  endedAt?: string;
+};
+
+export const PlanOutcomeSchema = {
+  "@type": ProvActivitySchema["@type"],
+  runPlan: { "@id": ProvActivitySchema.runPlan["@id"], "@type": ldkit.IRI },
+  used: { "@id": ProvActivitySchema.used["@id"], "@type": ldkit.IRI, "@optional": true, "@array": true },
+  generated: {
+    "@id": ProvActivitySchema.generated["@id"],
+    "@optional": true,
+    "@array": true,
+    "@schema": { types: { "@id": rdf.type, "@type": ldkit.IRI, "@optional": true, "@array": true } },
+  },
+  errorMessage: ProvActivitySchema.errorMessage,
+  skippedReason: ProvActivitySchema.skippedReason,
+  startedAt: { ...ProvActivitySchema.startedAtTime, "@optional": true },
+  endedAt: ProvActivitySchema.endedAtTime,
+} as const satisfies Schema;
+
+/** Every entity's own run inside the plan: the subject it used, what it created, or why it failed or was skipped. */
+export async function planOutcomes(planGraphIri: string, readOptions: Options): Promise<EntityOutcome[]> {
+  const runs = await createLens(PlanOutcomeSchema, readOptions).find({ where: { runPlan: planGraphIri } });
+
+  return runs.flatMap((run) =>
+    run.used.map((used) => ({
+      used,
+      generated: run.generated.map((created) => ({ iri: created.$id, types: created.types })),
+      ...(isPresent(run.errorMessage) && { errorMessage: run.errorMessage }),
+      ...(isPresent(run.skippedReason) && { skippedReason: run.skippedReason }),
+      ...(isPresent(run.startedAt) && { startedAt: run.startedAt.toISOString() }),
+      ...(isPresent(run.endedAt) && { endedAt: run.endedAt.toISOString() }),
+    })),
+  );
+}
+
+export type OpResult =
+  | { status: "done"; planGraphIri: string; created?: string }
+  | { status: "pending"; planGraphIri: string; message: string }
+  | { status: "failed"; message: string; subcode?: number; skipped?: boolean };
+
+/** `results` lines up with the ops sent; `outcome` is the whole change as one. */
+export type GraphRun = { outcome: ActionOutcome; results: OpResult[] };
+
+export type GraphRunOptions = {
+  graphql: ActionGraphql;
+  readOptions: Options;
+  pollIntervalMs?: number;
+  timeoutMs?: number;
+  pendingMessage?: string;
+  formatError?: (raw: string) => string;
+  signal?: AbortSignal;
+  /** Takes over a run still going when `timeoutMs` ends. */
+  follow?: FollowPendingAction;
+  /** Reads a finished plan's per-entity outcomes; `planOutcomes` over `readOptions` unless given. */
+  readOutcomes?: (planGraphIri: string) => Promise<EntityOutcome[]>;
+  /** Hears why a finished plan's outcomes could not be read; its ops then stay pending. */
+  onError?: (cause: unknown) => void;
+};
+
+/** A node may point at one an earlier plan of the same change created; it goes out under the created IRI. */
+export function withCreatedReferences(value: unknown, created: ReadonlyMap<string, string>): unknown {
+  if (Array.isArray(value)) return value.map((each) => withCreatedReferences(each, created));
+  if (value === null || typeof value !== "object") return value;
+  return Object.fromEntries(
+    Object.entries(value).map(([key, held]) => [
+      key,
+      key === "@id" && typeof held === "string" ? (created.get(held) ?? held) : withCreatedReferences(held, created),
+    ]),
+  );
+}
+
+const idsIn = (value: unknown): string[] => {
+  if (Array.isArray(value)) return value.flatMap(idsIn);
+  if (value === null || typeof value !== "object") return [];
+  return Object.entries(value).flatMap(([key, held]) =>
+    key === "@id" && typeof held === "string" ? [held] : idsIn(held),
+  );
+};
+
+/** Every IRI an op's node points at, its own subject included. */
+export const mentions = (op: GraphOp): string[] => idsIn(graphNode(op));
+
+const createdBy = (op: GraphOp, outcome: EntityOutcome) =>
+  (outcome.generated.find((made) => made.types.includes(op.input.rdfType)) ?? outcome.generated[0])?.iri;
+
+/** An op's own outcome, and whether the plan's outcomes could be read at all. */
+export type OutcomeRead = { outcome: EntityOutcome | undefined; known: boolean };
+
+/** What one op did, read off its entity's own activity in the plan's run. */
+export function opResult(
+  op: GraphOp,
+  planGraphIri: string,
+  run: ActionOutcome,
+  { outcome, known }: OutcomeRead,
+  formatError: (raw: string) => string = channelErrorMessage,
+): OpResult {
+  if (run.status === "pending") return run;
+  if (isPresent(outcome?.errorMessage)) {
+    const subcode = channelErrorSubcode(outcome.errorMessage);
+    return { status: "failed", message: formatError(outcome.errorMessage), ...(subcode !== undefined && { subcode }) };
+  }
+  if (isPresent(outcome?.skippedReason)) return { status: "failed", message: skippedMessage, skipped: true };
+  if (run.status === "failed" && outcome === undefined) return run;
+  if (!known) return { status: "pending", planGraphIri, message: unconfirmedMessage };
+
+  if (op.op !== "add") return { status: "done", planGraphIri };
+  if (outcome === undefined) return { status: "pending", planGraphIri, message: unconfirmedMessage };
+  const created = createdBy(op, outcome);
+  return { status: "done", planGraphIri, ...(isPresent(created) && { created }) };
+}
+
+async function runChunk(
+  ops: readonly GraphOp[],
+  created: ReadonlyMap<string, string>,
+  options: GraphRunOptions,
+): Promise<OpResult[]> {
+  const { graphql, readOptions, signal, follow, formatError, onError } = options;
+  const { pollIntervalMs = 2000, timeoutMs = 120_000, pendingMessage = unconfirmedMessage } = options;
+  const { readOutcomes = (planGraphIri: string) => planOutcomes(planGraphIri, readOptions) } = options;
+  const nodes = ops.map((op) => withCreatedReferences(graphNode(op), created) as ActionGraphNode);
+
+  const start = await startActionGraph(graphql, nodes, { signal });
+  if (start.status !== "started") return ops.map((): OpResult => ({ status: "failed", message: start.message }));
+
+  const waited = await awaitRun(graphql, { ...start, pollIntervalMs, timeoutMs, pendingMessage, formatError, signal });
+  const run = waited.status === "pending" && follow !== undefined ? await follow(waited) : waited;
+  if (run.status === "pending") return ops.map((): OpResult => run);
+
+  const outcomes = await readOutcomes(start.planGraphIri).catch((cause: unknown) => {
+    onError?.(cause);
+    return undefined;
+  });
+  const known = isPresent(outcomes);
+  const byUsed = new Map((outcomes ?? []).map((outcome) => [outcome.used, outcome]));
+  return ops.map((op, index) =>
+    opResult(op, start.planGraphIri, run, { outcome: byUsed.get(nodes[index]?.["@id"] ?? ""), known }, formatError),
+  );
+}
+
+type Unit = { op: GraphOp; indices: number[] };
+
+/** One unit per entity: several updates of it merge into one, later properties winning; any other repeat is refused. */
+function unitsOf(ops: readonly GraphOp[]): { units: Unit[]; refused: number[] } {
+  const bySubject = new Map<string, number[]>();
+  ops.forEach((op, index) =>
+    bySubject.set(op.input.subjectIri, [...(bySubject.get(op.input.subjectIri) ?? []), index]),
+  );
+
+  const units: Unit[] = [];
+  const refused: number[] = [];
+  for (const indices of bySubject.values()) {
+    const same = indices.flatMap((index) => ops[index] ?? []);
+    const updates = same.flatMap((op) => (op.op === "update" ? [op] : []));
+    const [first] = same;
+    if (first !== undefined && same.length === 1) units.push({ op: first, indices });
+    else if (first !== undefined && updates.length === same.length) {
+      const properties = Object.assign({}, ...updates.map((op) => op.input.properties)) as Record<string, unknown>;
+      units.push({ op: updating({ ...first.input, properties }), indices });
+    } else refused.push(...indices);
+  }
+  return { units, refused };
+}
+
+/** Each unit after the units it points at, otherwise in the given order, so a split never sends a dependent first. */
+function dependenciesFirst(units: readonly Unit[]): Unit[] {
+  const subjects = new Set(units.map((unit) => unit.op.input.subjectIri));
+  const needs = new Map(
+    units.map((unit) => [
+      unit,
+      mentions(unit.op).filter((iri) => iri !== unit.op.input.subjectIri && subjects.has(iri)),
+    ]),
+  );
+  const ordered: Unit[] = [];
+  const placed = new Set<string>();
+  const remaining = [...units];
+  while (isPresent(remaining)) {
+    const ready = remaining.findIndex((unit) => (needs.get(unit) ?? []).every((iri) => placed.has(iri)));
+    const [next] = remaining.splice(Math.max(ready, 0), 1);
+    if (next === undefined) break;
+    ordered.push(next);
+    placed.add(next.op.input.subjectIri);
+  }
+  return ordered;
+}
+
+/** The whole change as one outcome: a failure first, then a run still going, else done. */
+export function graphOutcome(results: readonly OpResult[]): ActionOutcome {
+  const failed = results.find((result) => result.status === "failed");
+  if (failed !== undefined) return failed;
+  const pending = results.find((result) => result.status === "pending");
+  if (pending !== undefined) return pending;
+  const done = [...results].reverse().find((result) => result.status === "done");
+  return done === undefined
+    ? { status: "failed", message: nothingToSendMessage }
+    : { status: "done", planGraphIri: done.planGraphIri };
+}
+
+/**
+ * Sends `ops` as one plan, or as few as Manta's per-plan cap allows, and reads back what each did. Past the cap,
+ * an entity that points at one an earlier plan did not make is skipped, as Manta skips it inside one plan.
+ */
+export async function runActionGraph(ops: readonly GraphOp[], options: GraphRunOptions): Promise<GraphRun> {
+  const results: OpResult[] = ops.map(() => ({ status: "failed", message: twiceMessage }));
+  const { units, refused } = unitsOf(ops);
+  const created = new Map<string, string>();
+  const missing = new Set(refused.flatMap((index) => ops[index]?.input.subjectIri ?? []));
+  const ordered = dependenciesFirst(units);
+
+  const settle = (unit: Unit, result: OpResult) => {
+    unit.indices.forEach((index) => (results[index] = result));
+    const subject = unit.op.input.subjectIri;
+    if (result.status === "done" && isPresent(result.created)) created.set(subject, result.created);
+    if (unit.op.op === "add" && result.status !== "done") missing.add(subject);
+  };
+
+  for (let at = 0; at < ordered.length; at += maxGraphNodes) {
+    const chunk = ordered.slice(at, at + maxGraphNodes);
+    // Dependencies come first, so one pass also blocks what points at an addition blocked just before it.
+    const blocked: Unit[] = [];
+    for (const unit of chunk) {
+      if (!mentions(unit.op).some((iri) => missing.has(iri))) continue;
+      blocked.push(unit);
+      if (unit.op.op === "add") missing.add(unit.op.input.subjectIri);
+    }
+    const sending = chunk.filter((unit) => !blocked.includes(unit));
+    const sent = isPresent(sending)
+      ? await runChunk(
+          sending.map((unit) => unit.op),
+          created,
+          options,
+        ).catch((cause: unknown) => sending.map((): OpResult => ({ status: "failed", message: reasonOf(cause) })))
+      : [];
+
+    blocked.forEach((unit) => settle(unit, { status: "failed", message: skippedMessage, skipped: true }));
+    sending.forEach((unit, index) => settle(unit, sent[index] ?? { status: "failed", message: nothingToSendMessage }));
+  }
+
+  return { outcome: graphOutcome(results), results };
+}
+
+/** What happened to the op on `subjectIri`, for a caller that keyed its ops by subject. */
+export const resultFor = (ops: readonly GraphOp[], run: GraphRun, subjectIri: string): OpResult | undefined =>
+  run.results[ops.findIndex((op) => op.input.subjectIri === subjectIri)];

package/src/shared/email.ts

@@ -4,6 +4,7 @@ import { isPresent } from "@manta-eu/lib/present";
 import type { Schema } from "ldkit";
 import { ExecuteAgentActionAdditionDocument, type GQLExecuteAgentActionAdditionMutation } from "../generated/graphql";
 import { entityActionInput } from "./action-document";
+import { adding, graphNode, maxGraphNodes, startActionGraph, type ActionGraphNode } from "./action-graph";
 
 export type EmailGraphql = (document: string, variables: Record<string, unknown>) => Promise<unknown>;
 
@@ -58,3 +59,30 @@ export async function startRenderedEmail(
     return { ok: false, error: cause instanceof Error ? cause.message : String(cause) };
   }
 }
+
+export function renderedEmailNode(terms: RealmEmailTerms, email: RenderedEmail): ActionGraphNode {
+  return graphNode(adding(renderedEmailAddition(terms, email)));
+}
+
+/**
+ * Sends every email as one plan; each email's own outcome is the plan activity that used its `subjectIri`.
+ * A plan holds at most `maxGraphNodes` entities, so a caller with more emails splits them into batches.
+ */
+export async function startRenderedEmails(
+  graphql: EmailGraphql,
+  terms: RealmEmailTerms,
+  emails: readonly RenderedEmail[],
+): Promise<EmailStart> {
+  if (emails.length > maxGraphNodes)
+    return {
+      ok: false,
+      error: `One plan sends at most ${maxGraphNodes} emails; split the ${emails.length} into batches.`,
+    };
+  const started = await startActionGraph(
+    graphql,
+    emails.map((email) => renderedEmailNode(terms, email)),
+  );
+  return started.status === "started"
+    ? { ok: true, plan: started.planGraphIri }
+    : { ok: false, error: started.message };
+}

package/src/shared/tools/metadata.ts

@@ -157,6 +157,16 @@ export const toolMetadata: ToolMetadata = {
     description: "Read the contents of a file the user uploaded to this conversation",
     getHumanName: () => "Reading attachment...",
   },
+  requestBudgetChange: {
+    name: "requestBudgetChange",
+    category: "action",
+    humanName: "Change budget",
+    description: "Change a Google or Meta budget within the hotel's budget band, or ask for approval beyond it",
+    getHumanName: (input) =>
+      input?.campaignName && input.amount !== undefined
+        ? `Change the ${input.campaignName} budget to ${input.amount}`
+        : "Changing budget...",
+  },
 } satisfies ToolMetadata;
 
 export function getToolMetadata<T extends ToolName>(toolName: T): ToolMetadata[T] {

package/src/shared/tools/types.ts

@@ -26,7 +26,8 @@ export type ToolName =
   | "checkAutoPilotStatus"
   | "setDailyChangeLimit"
   | "markAsLowRisk"
-  | "readUploadedFile";
+  | "readUploadedFile"
+  | "requestBudgetChange";
 
 export type ToolCategory = "knowledge-graph" | "scheduler" | "charts" | "action" | "auto-pilot";
 
@@ -198,6 +199,14 @@ export type ManageFactsOutput =
     }
   | ToolErrorResult;
 
+export type RequestBudgetChangeInput = {
+  humanIntent: string;
+  entityIri: string;
+  property: string;
+  amount: number;
+  campaignName: string;
+};
+
 export type ActionPlanStatus = "DRAFT" | "RUNNING" | "COMPLETED" | "FAILED" | "TIMED_OUT";
 
 export type ActionPlanShowcaseInput = {
@@ -282,6 +291,7 @@ export type ToolDefinitions = {
   setDailyChangeLimit: ToolDefinition<SetDailyChangeLimitInput, AutoPilotOutput>;
   markAsLowRisk: ToolDefinition<AutoPilotInput, AutoPilotOutput>;
   readUploadedFile: ToolDefinition<ReadUploadedFileInput, ReadUploadedFileOutput>;
+  requestBudgetChange: ToolDefinition<RequestBudgetChangeInput, unknown>;
 };
 
 export type ToolMetadata = {