/**
 * Deep per-operation request/response schemas for the Dench API v1.
 *
 * These are the source of truth for:
 *   - OpenAPI generation (scripts/generate-openapi.ts) -> interactive
 *     Mintlify playground parameters, request bodies, and responses.
 *   - Runtime validation in the API v1 dispatcher.
 *   - The generated curl guide (public/references/API.md).
 *
 * Auth args (`sessionToken` / `apiKey` / `runId`) are intentionally
 * omitted here: the dispatcher injects them from the bearer token and
 * `x-dench-run-id` header. Path-parameter fields (e.g. `objectName`,
 * `entryId`) ARE included so they validate and reach the backend; any
 * decorative path segment a backend function does not accept is left out
 * so strict parsing drops it before the Convex call.
 *
 * Schemas mirror the real Convex `args` validators and gateway request
 * shapes. They avoid `.refine()`/`.transform()` so `z.toJSONSchema`
 * stays lossless for the playground.
 */
import { type ZodTypeAny, z } from "zod";
import {
  CONDITION_CHECKS,
  CONDITION_OPERATORS,
  checkCampaignSteps,
  checkStepEdits,
  hasWorkflowShape,
  LINKEDIN_REACTIONS,
  MAX_ACCEPTANCE_WAIT_HOURS,
  MAX_CAMPAIGN_STEPS,
  MAX_INMAIL_BODY_CHARS,
  MAX_INMAIL_SUBJECT_CHARS,
  MAX_LIKE_POST_AGE_DAYS,
  MAX_LIKE_POST_COUNT,
  MAX_WAIT_HOURS,
  MIN_ACCEPTANCE_WAIT_HOURS,
  MIN_WITHDRAW_AFTER_HOURS,
  STEP_TYPES,
  WORKFLOW_END,
} from "./campaign-steps";

const nativeEmailRecipient = z.object({
  email: z.string(),
  name: z.string().optional(),
});
const nativeEmailAttachment = z.object({
  storageId: z.string(),
  name: z.string(),
  contentType: z.string(),
  size: z.number(),
});
const nativeEmailContent = {
  to: z.array(nativeEmailRecipient).optional(),
  cc: z.array(nativeEmailRecipient).optional(),
  bcc: z.array(nativeEmailRecipient).optional(),
  subject: z.string().optional(),
  htmlBody: z.string().optional(),
  textBody: z.string().optional(),
  attachments: z.array(nativeEmailAttachment).optional(),
};
const nativeEmailCreate = z.object({
  organizationId: z.string().optional(),
  threadId: z.string().optional(),
  mailbox: z.string().optional(),
  requestId: z.string(),
  ...nativeEmailContent,
});
const inboxHeader = z.object({
  messageHandle: z.string(),
  threadHandle: z.string(),
  mailboxId: z.string(),
  from: nativeEmailRecipient,
  to: z.array(nativeEmailRecipient),
  subject: z.string(),
  at: z.number(),
  dateSource: z.enum(["sentAt", "createdAt"]),
  direction: z.enum(["inbound", "outbound"]),
  status: z.string(),
  hasAttachments: z.boolean(),
  headersTruncated: z.boolean(),
});
const inboxCoverage = z.object({
  source: z.literal("synced"),
  scope: z.literal("mailbox_linked_messages"),
  mailboxId: z.string(),
  mailboxEmail: z.string(),
  mailboxStatus: z.string(),
  ingestionMode: z.string(),
  phase: z.string(),
  syncStatus: z.string().nullable(),
  lastPolledAt: z.number().nullable(),
  lastBackfillCompletedAt: z.number().nullable(),
  oldestSeenAt: z.number().nullable(),
  backfillStatus: z.string().nullable(),
  backfillCapped: z.boolean(),
  providerComplete: z.literal(false),
  privacyLimited: z.boolean(),
});
const inboxPaging = {
  limit: z.coerce.number().int().min(1).max(50).optional(),
  cursor: z.string().optional(),
};
const inboxPage = z.object({
  page: z.array(inboxHeader),
  continueCursor: z.string().nullable(),
  isDone: z.boolean(),
  coverage: inboxCoverage,
  order: z.literal("sentAt_desc_then_undated"),
});
const nativeEmailReceipt = z
  .object({
    ok: z.boolean(),
    kind: z.literal("email"),
    draftId: z.string(),
    syncStatus: z.string(),
    revision: z.number(),
  })
  .passthrough();

// ---------------------------------------------------------------------------
// Shared enums + fragments (mirror convex validators)
// ---------------------------------------------------------------------------

export const FIELD_TYPES = [
  "text",
  "email",
  "phone",
  "url",
  "number",
  "boolean",
  "date",
  "richtext",
  "file",
  "user",
  "enum",
  "relation",
  "tags",
  "action",
] as const;

const fieldType = z
  .enum(FIELD_TYPES)
  .describe(
    "Field data type. `relation` needs relatedObjectName + relationshipType; `enum` uses enumValues/enumColors; `user` cells store one member userId or an array of member userIds; long prose belongs in the protected `Notes` richtext field.",
  );

const campaignCalculation = z
  .object({
    kind: z.literal("campaign_activity"),
    metric: z.enum([
      "email_opened",
      "email_clicked",
      "replied",
      "linkedin_connected",
    ]),
    campaignId: z
      .string()
      .min(1)
      .optional()
      .describe(
        "Same-workspace multichannel campaign ID readable by the viewer. Omit for any accessible multichannel campaign.",
      ),
  })
  .strict()
  .describe(
    "Read-only campaign activity boolean on people or lead (through Contact), not an expression. Cannot be required, indexed, enriched or have a default value.",
  );

const viewKind = z
  .enum(["table", "kanban", "calendar", "timeline", "gallery", "list"])
  .describe("Default view rendered for the object.");

const relationshipType = z
  .enum(["many_to_one", "many_to_many"])
  .describe("Relation cardinality for a `relation` field.");

/** A new field's settings: `crm.fields.create`, and each of `crm.objects.create`'s `fields`. */
const newCrmField = {
  name: z.string(),
  type: fieldType.optional().describe("Defaults to text."),
  required: z.boolean().optional(),
  defaultValue: z.string().optional(),
  relatedObjectName: z
    .string()
    .optional()
    .describe("Target object for `relation` fields."),
  relationshipType: relationshipType.optional(),
  enumValues: z
    .array(z.string())
    .optional()
    .describe("Options for `enum` fields."),
  enumColors: z
    .array(z.string())
    .optional()
    .describe("Hex colors aligned to enumValues."),
  enumMultiple: z.boolean().optional().describe("Allow multi-select enum."),
  description: z.string().optional(),
  indexed: z.boolean().optional().describe("Index for filter/search/sort."),
};

const memoryKind = z
  .enum([
    "fact",
    "decision",
    "preference",
    "goal",
    "tool_note",
    "other",
    "convention",
    "project_context",
    "agent_lesson",
    "docs_knowledge",
    "open_goal",
  ])
  .describe("Memory classification.");

const memorySensitivity = z
  .enum(["normal", "broad", "sensitive"])
  .describe("Sensitivity tier; `sensitive` memories land in needs-review.");

const memoryVisibility = z
  .enum(["user", "org"])
  .describe("Who can see the memory. Defaults to `user`.");

const riskLevel = z.enum(["low", "medium", "high"]).describe("Risk level.");

const repeatWeekday = z.enum(["mo", "tu", "we", "th", "fr", "sa", "su"]);
/** Structured repeat rule for tasks (mirrors convex/lib/crm/taskRepeatRule). */
const taskRepeatRuleSchema = z.discriminatedUnion("freq", [
  z.object({ freq: z.literal("daily"), interval: z.number().int().min(1) }),
  z.object({
    freq: z.literal("weekly"),
    interval: z.number().int().min(1),
    byWeekday: z.array(repeatWeekday).min(1),
  }),
  z.object({
    freq: z.literal("monthly"),
    interval: z.number().int().min(1),
    byMonthDay: z
      .number()
      .int()
      .describe("1–31, or -1 for the last day of the month.")
      .optional(),
    bySetPos: z
      .object({
        ordinal: z.number().int().describe("1–4, or -1 for the last week."),
        weekday: repeatWeekday,
      })
      .optional(),
  }),
  z.object({
    freq: z.literal("yearly"),
    interval: z.number().int().min(1),
    month: z.number().int().min(1).max(12),
    day: z.number().int().min(1).max(31),
  }),
]);

const approvalDecision = z
  .enum(["approved", "rejected"])
  .describe("Human decision for an approval request.");

const signInIntent = z
  .enum(["join_existing", "create_workspace"])
  .describe("Whether to join an existing workspace or create a new one.");

const reportType = z
  .enum(["pie", "bar", "line", "table"])
  .describe("Chart type for the generated report.");

const reportMetric = z
  .enum(["count", "sum", "avg", "min", "max"])
  .describe("Aggregation metric. Defaults to `count`.");

const overlapPolicy = z
  .enum(["skip", "queue", "kill_old"])
  .describe(
    "What to do when a previous run is still active. Defaults to `skip`.",
  );

const cronTarget = z.literal("chat_turn").describe("Routine run target.");

const scheduleSpec = z
  .union([
    z.object({
      kind: z.literal("every"),
      everyMs: z
        .number()
        .int()
        .positive()
        .describe("Interval in milliseconds (1s to 365d)."),
      anchorMs: z
        .number()
        .int()
        .optional()
        .describe("Optional anchor timestamp for the recurring fire."),
    }),
    z.object({
      kind: z.literal("cron"),
      expr: z.string().describe("5-field POSIX cron expression."),
      tz: z
        .string()
        .optional()
        .describe("IANA timezone, e.g. America/New_York."),
    }),
    z.object({
      kind: z.literal("at"),
      at: z.string().describe("ISO 8601 timestamp for a one-shot run."),
    }),
  ])
  .describe(
    "Schedule: recurring (`every`), cron expression, or one-shot (`at`).",
  );

const dataMap = z
  .record(z.string(), z.unknown())
  .describe(
    "Field-name -> value map. For `user` fields use one member userId or a userId array; preserve every assignee.",
  );

/**
 * The personal assignee scope — the same two arguments on every read that
 * supports it. Never part of the saved view; the caller's preference.
 */
const assigneeScopeRequest = {
  assignedTo: z
    .string()
    .optional()
    .describe(
      'Personal scope: "me" (the signed-in member / the human behind an agent session), "unassigned", or a member userId or email. Adds one has_any / is_empty rule on the object\'s assignee user field; rows, totalCount, sums and analytics all follow it. Never saved onto the view.',
    ),
  assigneeField: z
    .string()
    .optional()
    .describe(
      'Which `user` field "assigned" means. Default: the analytics owner role, else the task `Assignee`, else a user field named like owner/assignee, else the first user field.',
    ),
};

const assigneeScopeResponse = z
  .object({
    field: z.string().describe("The user field the scope keyed on."),
    target: z.union([
      z.object({ kind: z.literal("user"), userId: z.string() }),
      z.object({ kind: z.literal("unassigned") }),
    ]),
  })
  .nullable()
  .describe("The personal assignee scope that was applied, or null.");

const cellValue = z
  .unknown()
  .describe(
    "Cell value. Enum=option string, tags=string array, user=one member userId or a userId array, relation=related entry id, boolean=true/false.",
  );

const enrichmentConfig = z
  .object({
    category: z.enum(["people", "company"]),
    key: z.string(),
    apolloPath: z.string(),
    inputFieldName: z.string().optional(),
  })
  .describe(
    "Enrichment binding that lets the field auto-fill from a provider.",
  );

const crmOp = z
  .union([
    z.object({
      type: z.literal("entries.create"),
      objectName: z.string(),
      data: dataMap,
    }),
    z.object({
      type: z.literal("entries.update"),
      entryId: z.string(),
      data: dataMap,
    }),
    z.object({
      type: z.literal("entries.delete"),
      entryId: z.string(),
    }),
  ])
  .describe("A single CRM batch/transaction operation.");

// ---------------------------------------------------------------------------
// Email fragments (mirror convex/functions/emailCampaigns*.ts + gateway SES)
// ---------------------------------------------------------------------------

const emailAddress = z.object({
  email: z.string().describe("Recipient email address."),
  name: z.string().optional().describe("Optional display name."),
});

const emailIdentityType = z
  .enum(["domain", "email"])
  .describe(
    "Identity scope. `domain` verifies via DNS (DKIM); `email` verifies a single mailbox via a confirmation email.",
  );

const rawMessageStatus = z
  .enum([
    "queued",
    "sent",
    "failed",
    "delivered",
    "opened",
    "clicked",
    "bounced",
    "complained",
  ])
  .describe("Raw email message lifecycle status.");

const templateStatus = z
  .enum(["draft", "active", "archived"])
  .describe("Template lifecycle status. Defaults to `active`.");

const campaignRecipientInput = z.object({
  email: z.string().describe("Recipient email address."),
  displayName: z.string().optional(),
  personEntryId: z
    .string()
    .optional()
    .describe("Optional CRM people entry to link the send to."),
  companyEntryId: z.string().optional(),
  personalization: z
    .record(z.string(), z.unknown())
    .optional()
    .describe("Values for {{variable}} placeholders in the template."),
});

// ---------------------------------------------------------------------------
// Outreach campaign fragments (mirror convex/functions/outreachSequences.ts)
// ---------------------------------------------------------------------------

const campaignSenderPools = {
  emailMailboxAccountIds: z
    .array(z.string().trim().min(1))
    .max(50)
    .optional()
    .describe(
      "Campaign email sender pool: up to 50 emailMailboxAccounts ids both you and the campaign owner may use. Omit to preserve existing configuration; [] clears the pool. A person's sender stays fixed for their conversation. Launch validates sender availability.",
    ),
  linkedinAccountIds: z
    .array(z.string().trim().min(1))
    .max(50)
    .optional()
    .describe(
      "Campaign LinkedIn sender pool: up to 50 linkedinAccounts ids both you and the campaign owner may use. Omit to preserve existing configuration; [] clears the pool. Legacy step senders remain until a pool is configured.",
    ),
};

const campaignLineVariable = z
  .object({
    key: z
      .string()
      .describe(
        "The {{key}} used in steps: a letter, then letters, digits or _ (up to 40). Not a built-in field like firstName or company.",
      ),
    label: z.string().describe("The line's name, up to 60 characters."),
    prompt: z
      .string()
      .describe("What the writer should say, up to 600 characters."),
    fallback: z
      .string()
      .describe(
        "Sent when there is nothing specific to say; up to 300 characters, no {{variables}}.",
      ),
    fallbackFrom: z
      .string()
      .optional()
      .describe("A field to use before the fallback, e.g. Company."),
    maxChars: z
      .number()
      .int()
      .min(20)
      .max(300)
      .optional()
      .describe("The longest line, default 200 characters."),
  })
  .strict()
  .describe("One personalized line.");

const campaignLineTemplate = z
  .object({
    variables: z.array(campaignLineVariable).min(1).max(5),
    context: z
      .object({
        sells: z.string().describe("What you sell, up to 1000 characters."),
        offer: z
          .string()
          .optional()
          .describe("The offer or call to action, up to 300 characters."),
      })
      .strict(),
  })
  .strict();

const campaignLineBackfill = z.object({
  version: z.number(),
  eligible: z.number().describe("People who would get a line."),
  estimatedCents: z.number().describe("About 3 cents a person."),
  needsConfirm: z
    .boolean()
    .describe(
      "True when nothing was written: confirm with campaigns.personalization.write and confirmed: true.",
    ),
  queued: z.number().describe("People whose lines are being written now."),
});

const campaignPreviewedLine = z
  .object({
    key: z.string().describe("The line's {{key}}."),
    label: z.string(),
    value: z
      .string()
      .describe("What this person gets: the written line, or the fallback."),
    state: z
      .enum([
        "written",
        "edited",
        "writing",
        "paused",
        "fallback",
        "not_written",
      ])
      .describe(
        "written or edited: the line is final. fallback: nothing specific was found, so the fallback is used. writing, paused and not_written: the fallback shows until the line is written.",
      ),
    source: z
      .enum(["company", "news", "signal", "profile", "fallback"])
      .optional()
      .describe("What the line was written from."),
    maxChars: z.number(),
    rewriting: z
      .enum(["writing", "paused"])
      .optional()
      .describe("A new line is being written over the current one."),
  })
  .passthrough();

const campaignMessagePreview = z
  .object({
    channel: z.enum(["email", "linkedin"]),
    subject: z.string().optional().describe("Email steps."),
    textBody: z.string().optional().describe("Email steps: plain text."),
    htmlBody: z.string().optional().describe("Email steps: HTML."),
    messageBody: z
      .string()
      .optional()
      .describe(
        "LinkedIn steps: the note or message, or a line saying no note or message is sent.",
      ),
    fromName: z.string().optional().describe("The sending account."),
    fromEmail: z.string().optional(),
    toName: z.string(),
    toEmail: z.string().optional(),
    missingFields: z
      .array(z.string())
      .describe(
        "{{merge fields}} this person has no value for; fill them with campaigns.people.setField.",
      ),
    warnings: z.array(z.string()),
    skippedReason: z
      .string()
      .optional()
      .describe(
        "Set when the person would skip this step, e.g. no email address.",
      ),
    highlights: z.array(z.string()).optional(),
    personalized: z.array(campaignPreviewedLine).optional(),
  })
  .passthrough();

const campaignSenderLabel = z
  .object({
    accountId: z.string(),
    label: z.string().describe("The mailbox address or LinkedIn name."),
    status: z.string(),
  })
  .nullable();

const campaignMembership = z
  .object({
    enrollment: z
      .record(z.string(), z.unknown())
      .describe(
        "The person in that campaign: _id, sequenceId, status, currentStepIndex, repliedAt.",
      ),
    sequenceName: z.string(),
    isOwner: z.boolean(),
    canManage: z.boolean(),
    senders: z
      .object({ email: campaignSenderLabel, linkedin: campaignSenderLabel })
      .describe("The accounts that send to this person."),
  })
  .passthrough();

const campaignMailboxSummary = z
  .object({
    _id: z
      .string()
      .describe("The emailMailboxAccountId to put in emailMailboxAccountIds."),
    email: z.string(),
    provider: z.enum(["gmail", "outlook"]),
    status: z.enum(["running", "disconnected", "errored"]),
    statusReason: z.string().optional(),
    warmupStatus: z
      .enum(["skipped", "pending_auth", "warming", "ready", "error"])
      .describe(
        "ready or skipped: sends at its cap. warming: sends less until readyAt. pending_auth and error need the owner in the app.",
      ),
    readyAt: z
      .number()
      .optional()
      .describe(
        "When warm-up finished, or is expected to finish while warming (epoch ms).",
      ),
    dailyColdSendCap: z
      .number()
      .describe(
        "The most cold emails a day; the mailbox owner sets it in the app.",
      ),
    remainingToday: z.number().describe("Cold emails it can still send today."),
    ownerName: z.string(),
    isOwner: z.boolean(),
    visibility: z.enum(["private", "shared"]),
  })
  .passthrough()
  .describe("One mailbox a campaign can send from.");

const campaignLinkedinSenderSummary = z
  .object({
    linkedinAccountId: z
      .string()
      .describe(
        "Local sender id for linkedinAccountIds, never a provider credential.",
      ),
    displayName: z.string(),
    status: z.enum(["running", "paused", "disconnected", "errored"]),
    ownerName: z.string(),
    isOwner: z.boolean(),
    visibility: z.enum(["private", "shared"]),
    remainingToday: z
      .object({
        invites: z
          .number()
          .nonnegative()
          .describe(
            "Daily capacity, also bounded by the rolling weekly invite limit.",
          ),
        messages: z.number().nonnegative(),
        profiles: z.number().nonnegative(),
      })
      .strict(),
    remainingInvitesThisWeek: z.number().nonnegative(),
    availability: z
      .enum([
        "ready",
        "paused",
        "disconnected",
        "errored",
        "disabled",
        "circuit_break",
        "spacing",
        "outside_window",
        "daily_cap",
      ])
      .describe(
        "Account availability snapshot. Queued work, campaign limits and launch/dispatch checks still apply.",
      ),
  })
  .strict();

const campaignSendSchedule = z
  .object({
    name: z.string().describe('Label, e.g. "Mon-Fri 9-18".'),
    timezone: z.string().describe("IANA timezone, e.g. America/Los_Angeles."),
    startHour: z
      .number()
      .int()
      .min(0)
      .max(23)
      .describe("First hour sends may go out (0-23)."),
    endHour: z
      .number()
      .int()
      .min(1)
      .max(24)
      .describe("Hour sends stop (1-24); must be after startHour."),
    weekdays: z
      .array(z.number().int().min(0).max(6))
      .min(1)
      .describe("Days sends may go out: 0 = Sunday ... 6 = Saturday."),
  })
  .describe(
    "One send window. A campaign has one to eight; the first one's timezone is the campaign's.",
  );

const campaignStepType = z
  .enum(STEP_TYPES)
  .describe(
    "Step type. condition (If / else) and wait_for_connection (Wait for them to accept) send nothing; they continue on yesNext or noNext and make the campaign a workflow.",
  );

const workflowTarget = (exit: string) =>
  z
    .string()
    .min(1)
    .optional()
    .describe(
      `Workflow steps: ${exit}: another step's key, or "${WORKFLOW_END}" to stop there. Fixed once the campaign launches.`,
    );

const campaignStepModel = z
  .enum(["linear", "workflow"])
  .describe(
    "linear: steps run in order. workflow: steps have keys and paths (next, yesNext, noNext) and may include condition and wait_for_connection. Left out, a workflow stays one and steps with keys, paths or those types make one; nothing turns a workflow back into a list.",
  );

const campaignStepInput = z
  .object({
    type: campaignStepType,
    waitHours: z
      .number()
      .optional()
      .describe("wait steps: hours to wait before the next step."),
    emailMailboxAccountId: z
      .string()
      .optional()
      .describe(
        "Legacy email step sender. Pool campaigns choose senders in emailMailboxAccountIds on the campaign, not on individual steps.",
      ),
    emailSubject: z
      .string()
      .optional()
      .describe("email steps: subject; {{Column}} merge tokens allowed."),
    emailHtmlBody: z
      .string()
      .optional()
      .describe(
        "email steps: HTML body. Sent instead of emailTextBody when both are set, so when you edit the text, update or drop this too.",
      ),
    emailTextBody: z
      .string()
      .optional()
      .describe(
        "email steps: plain-text body; used as the email when there is no emailHtmlBody.",
      ),
    emailReplyToPrevious: z
      .boolean()
      .optional()
      .describe(
        "email steps: thread under the previous email step instead of a new subject.",
      ),
    onlyIf: z
      .enum(["always", "connected", "not_connected"])
      .optional()
      .describe(
        "email and linkedin_like_post only: always (default), connected or not_connected. InMail automatically skips connected people; do not set a condition on it.",
      ),
    linkedinAccountId: z
      .string()
      .optional()
      .describe(
        "Legacy LinkedIn step sender (also on wait_for_connection, and on a condition that checks linkedin_connected). Pool campaigns use the campaign's linkedinAccountIds instead.",
      ),
    linkedinMessageBody: z
      .string()
      .optional()
      .describe(
        `linkedin_connection: the invite note (optional, up to 300 chars; sent without it if LinkedIn refuses the note); linkedin_message: the required message (up to 3000 chars); linkedin_inmail: the required message (up to ${MAX_INMAIL_BODY_CHARS} chars).`,
      ),
    linkedinMessageMode: z
      .enum(["skip_if_not_connected", "wait_until_connected"])
      .optional()
      .describe(
        "linkedin_message: what to do when the invite is still pending.",
      ),
    connectionTimeoutHours: z
      .number()
      .min(1)
      .max(MAX_WAIT_HOURS)
      .optional()
      .describe(
        `linkedin_message with linkedinMessageMode=wait_until_connected: wait 1-${MAX_WAIT_HOURS} hours for acceptance (default 720); after a connection step this mode is the default in a linear campaign. wait_for_connection: wait ${MIN_ACCEPTANCE_WAIT_HOURS}-${MAX_ACCEPTANCE_WAIT_HOURS} hours (1-90 days, default 720) before taking the Not accepted path.`,
      ),
    likeReaction: z
      .enum(LINKEDIN_REACTIONS)
      .optional()
      .describe(
        "linkedin_like_post only: the reaction to leave (default like).",
      ),
    likeMaxPostAgeDays: z
      .number()
      .int()
      .min(1)
      .max(MAX_LIKE_POST_AGE_DAYS)
      .optional()
      .describe(
        `linkedin_like_post only: select the newest eligible original post from the last 1-${MAX_LIKE_POST_AGE_DAYS} days (default 30).`,
      ),
    likeSkipPreviousWait: z
      .boolean()
      .optional()
      .describe(
        "linkedin_like_post only: before the immediately preceding wait starts, check for eligible posts. If none exist, skip that wait and the like step, keeping following waits. Defaults to false when omitted.",
      ),
    likeSkipNextWait: z
      .boolean()
      .optional()
      .describe(
        "linkedin_like_post only: skip consecutive following wait steps whenever the reaction step is skipped (default true). False keeps those waits.",
      ),
    likeCount: z
      .number()
      .int()
      .min(1)
      .max(MAX_LIKE_POST_COUNT)
      .optional()
      .describe(
        `linkedin_like_post only: how many recent posts to react to, 1-${MAX_LIKE_POST_COUNT} (default 1).`,
      ),
    inmailSubject: z
      .string()
      .optional()
      .describe(
        `linkedin_inmail only: optional subject, up to ${MAX_INMAIL_SUBJECT_CHARS} characters; merge tokens allowed. Clear with an empty string.`,
      ),
    withdrawAfterHours: z
      .number()
      .min(MIN_WITHDRAW_AFTER_HOURS)
      .max(MAX_WAIT_HOURS)
      .nullable()
      .optional()
      .describe(
        `linkedin_connection only: withdraw a still-pending invitation sent by this campaign after ${MIN_WITHDRAW_AFTER_HOURS}-${MAX_WAIT_HOURS} hours (7-90 days). Omitted means off on creation; null turns it off on edit.`,
      ),
    key: z
      .string()
      .min(1)
      .optional()
      .describe(
        `Workflow steps: this step's id, unique in the campaign, which next, yesNext and noNext point at (not "${WORKFLOW_END}"). Left out, one is made.`,
      ),
    next: workflowTarget(
      "where a step that isn't a condition or wait_for_connection goes; left out, the following step",
    ),
    yesNext: workflowTarget(
      "condition and wait_for_connection only, required: where the Yes (Accepted) path goes",
    ),
    noNext: workflowTarget(
      "condition and wait_for_connection only, required: where the No (Not accepted) path goes",
    ),
    check: z
      .enum(CONDITION_CHECKS)
      .optional()
      .describe(
        "condition only, required: linkedin_connected, has_email, opened_last_email (needs an email before it on every path) or field_value. Fixed once the campaign launches.",
      ),
    conditionField: z
      .string()
      .optional()
      .describe(
        'condition with check=field_value: the lead field to check, like "Job Title" or "Source" (the campaign itself changes Status, Last touch and LinkedIn connection). Fixed once the campaign launches.',
      ),
    conditionOperator: z
      .enum(CONDITION_OPERATORS)
      .optional()
      .describe(
        "condition with check=field_value: is, is_not, contains, is_empty or is_not_empty (all case-insensitive). Fixed once the campaign launches.",
      ),
    conditionValue: z
      .string()
      .optional()
      .describe(
        "condition with check=field_value and is, is_not or contains: the text to compare with. Editable after launch.",
      ),
  })
  .describe("One campaign step, in order.");

const campaignTimelineRun = z
  .object({
    _id: z.string(),
    stepId: z.string().describe("The step's _id, as in steps[]."),
    stepIndex: z.number().describe("The step's place, from 0."),
    type: campaignStepType,
    status: z
      .enum([
        "queued",
        "running",
        "waiting",
        "retry",
        "sent",
        "skipped",
        "failed",
        "unknown",
      ])
      .describe(
        "sent: done (a wait that finished is sent too). skipped: see result.reason. retry: will be tried again at retryAt. unknown: needs a look.",
      ),
    scheduledAt: z.number().optional(),
    startedAt: z.number().optional(),
    waitUntil: z.number().optional(),
    retryAt: z.number().optional(),
    completedAt: z.number().optional(),
    emailMessageId: z
      .string()
      .optional()
      .describe("The email this run sent, in emailMessages[]."),
    lastError: z.string().optional(),
    timeoutAt: z
      .number()
      .optional()
      .describe("wait_for_connection: when it stops waiting for the accept."),
    result: z
      .unknown()
      .optional()
      .describe(
        'For a skipped step, { reason } says why. A finished condition or wait_for_connection has { branch: "yes" | "no" } (Yes / Accepted or No / Not accepted), and { reason } for some No paths.',
      ),
  })
  .passthrough();

const campaignPersonTimeline = z
  .object({
    enrollment: z
      .record(z.string(), z.unknown())
      .describe("The person in this campaign: status, lastError, repliedAt."),
    sequence: z.record(z.string(), z.unknown()).nullable(),
    steps: z
      .array(campaignStepInput.passthrough())
      .describe("The campaign's steps in order, each with its _id."),
    runs: z
      .array(campaignTimelineRun)
      .describe("One run for each step the person has reached, in order."),
    emailMessages: z
      .array(z.record(z.string(), z.unknown()))
      .describe(
        "The emails those runs sent: subject, textBody, status, sentAt, firstOpenedAt, firstClickedAt.",
      ),
    linkedinMessages: z
      .array(z.record(z.string(), z.unknown()))
      .describe(
        "The LinkedIn messages those runs sent: text, sentAt, deliveredAt, readAt, outreachStepRunId.",
      ),
  })
  .passthrough();

const campaignStatus = z
  .enum(["draft", "active", "paused", "completed", "archived"])
  .describe("Campaign lifecycle status.");

const campaignRow = z
  .object({
    _id: z.string(),
    name: z.string(),
    status: campaignStatus,
    stopOnReply: z.boolean(),
    ...campaignSenderPools,
    timezone: z.string().optional(),
    startsAt: z.number().optional(),
    endsAt: z.number().optional(),
    sendSchedules: z.array(campaignSendSchedule).optional(),
    dailySendCap: z.number().optional(),
    stepCount: z.number(),
    stepModel: campaignStepModel.optional(),
    totalEnrolled: z.number(),
    activeCount: z.number(),
    pausedCount: z.number(),
    finishedCount: z.number(),
    repliedCount: z.number(),
    failedCount: z.number(),
    stoppedCount: z.number(),
    launchedAt: z.number().optional(),
    ownerName: z.string().optional(),
    isOwner: z.boolean().optional(),
    createdAt: z.number(),
    updatedAt: z.number(),
  })
  .passthrough();

const campaignEnrollResult = z.object({
  added: z.number(),
  requested: z.number(),
  cappedAtLimit: z
    .number()
    .nullable()
    .describe(
      "The campaign's people cap when it cut the batch short (300), else null.",
    ),
  duplicates: z.number().describe("Already in this campaign."),
  merged: z
    .number()
    .describe("Duplicates that gained a missing email or LinkedIn URL."),
  duplicatesElsewhere: z
    .number()
    .describe(
      "Active in another campaign; skipped unless checkDuplicatesAcrossWorkspace is false.",
    ),
  suppressed: z.number(),
  invalid: z.number(),
  skippedNoIdentity: z
    .number()
    .describe("No usable email or LinkedIn URL on the record."),
  skippedSample: z.number(),
  skippedMissingInfo: z
    .number()
    .describe(
      "Launched campaigns only: a merge token the steps use is empty for them.",
    ),
  missingInfoSample: z
    .object({
      displayName: z.string().optional(),
      missingKeys: z.array(z.string()),
    })
    .optional(),
});

const campaignLaunchBlocker = z
  .object({
    code: z.string(),
    scope: z.enum(["sequence", "step", "person"]),
    target: z.enum(["sequence", "people", "schedule"]),
    title: z.string(),
    hint: z.string().optional(),
    stepIndex: z.number().optional(),
    people: z.array(
      z.object({ enrollmentId: z.string().optional(), name: z.string() }),
    ),
    count: z.number(),
  })
  .passthrough();

const campaignReadiness = z
  .object({
    ready: z.boolean(),
    fingerprint: z
      .string()
      .describe(
        "Pass this to `launch`; it changes whenever the campaign changes.",
      ),
    blockingReasons: z.array(z.string()),
    blockers: z.array(campaignLaunchBlocker),
    warnings: z.array(z.string()),
    stepCount: z.number(),
    audienceCount: z.number(),
    usesEmail: z.boolean(),
    usesLinkedin: z.boolean(),
  })
  .passthrough();

// ---------------------------------------------------------------------------
// Response fragments. These mirror the real backend return shapes (Convex
// `returns` validators / handler code / gateway response mapping). Objects
// built with `.passthrough()` may carry additional fields at runtime.
// ---------------------------------------------------------------------------

const okResponse = z.object({ ok: z.boolean() });

const fieldsMap = z
  .record(z.string(), z.unknown())
  .describe("Field-name -> cell value map.");

// -- auth / workspace ----------------------------------------------------

const organizationRef = z.object({
  id: z.string(),
  name: z.string(),
  slug: z.string(),
});

const agentRef = z.object({
  id: z.string(),
  name: z.string(),
  kind: z.string(),
});

const artifactRow = z.object({
  id: z.string(),
  runId: z.string(),
  title: z.string(),
  type: z.enum([
    "note",
    "draft",
    "report",
    "task_suggestion",
    "patch",
    "other",
  ]),
  status: z.enum(["draft", "approved", "rejected", "applied", "archived"]),
  content: z.string(),
  createdAt: z.number(),
  updatedAt: z.number(),
});

const workspaceStatusPayload = z
  .object({
    workspace: z.object({
      id: z.string(),
      name: z.string(),
      slug: z.string().optional(),
    }),
    agent: agentRef,
    rules: z.array(
      z.object({
        id: z.string(),
        title: z.string(),
        body: z.string(),
        scope: z.enum(["organization", "project"]),
      }),
    ),
    activeAgents: z.array(
      agentRef.extend({ lastSeenAt: z.number().optional() }),
    ),
    pendingApprovals: z.array(
      z
        .object({
          id: z.string(),
          title: z.string(),
          reason: z.string(),
          kind: z.string().optional(),
          risk: riskLevel,
          agentId: z.string().optional(),
          createdAt: z.number(),
        })
        .passthrough(),
    ),
    recentArtifacts: z.array(artifactRow),
    suggestedWork: z.array(
      artifactRow.extend({ nextCommands: z.array(z.string()) }),
    ),
    memory: z.array(
      z.object({
        id: z.string(),
        key: z.string(),
        kind: memoryKind,
        text: z.string(),
        tags: z.array(z.string()),
        status: z.enum(["active", "needs_review", "archived"]),
        updatedAt: z.number(),
      }),
    ),
    chatAgents: z.object({
      nextCommands: z.array(z.string()),
      activeRuns: z.array(
        z
          .object({
            id: z.string(),
            goal: z.string(),
            status: z.string(),
            model: z.string(),
            createdAt: z.number(),
          })
          .passthrough(),
      ),
      templates: z.array(z.string()),
    }),
    tools: z.object({
      discovery: z.array(z.string()),
      cli: z.array(z.string()),
      approvalPolicy: z.string(),
    }),
    nextActions: z.array(z.string()),
  })
  .describe(
    "Workspace orientation payload shared by /context, /status, /agents, and /approvals.",
  );

const workspaceInstructionsResponse = z.object({
  instructions: z
    .string()
    .describe(
      "Markdown standing instructions for external agents connected to this workspace.",
    ),
  workspace: z.object({
    name: z.string(),
    slug: z.string().optional(),
  }),
});

const memoryDoc = z
  .object({
    _id: z.string(),
    _creationTime: z.number(),
    key: z.string(),
    kind: memoryKind,
    text: z.string(),
    tags: z.array(z.string()),
    status: z.enum(["active", "needs_review", "archived"]),
    source: z.string(),
    visibility: memoryVisibility.optional(),
    confidence: z.number().optional(),
    importance: z.number().optional(),
    createdAt: z.number(),
    updatedAt: z.number(),
  })
  .passthrough()
  .describe("A workspace memory document.");

// -- billing ---------------------------------------------------------------

const billingStatusResponse = z
  .object({
    workspace: organizationRef,
    availableCreditsCents: z.number(),
    creditConsumedCents: z.number(),
    billedCents: z.number(),
    onDemandSpendCents: z.number(),
    monthlySpendLimitCents: z.number(),
    spendLimitRemainingCents: z.number(),
    subscriptionStatus: z.string().nullable(),
    stripeCustomerId: z.string().nullable(),
    grants: z.array(
      z.object({
        id: z.string(),
        source: z.enum([
          "starter",
          "trial",
          "monthly",
          "topup",
          "manual",
          "referral",
        ]),
        category: z.enum(["promotional", "paid"]),
        status: z.enum(["pending", "granted", "depleted", "expired", "voided"]),
        amountCents: z.number(),
        usedCents: z.number(),
        remainingCents: z.number(),
        effectiveAt: z.number(),
        expiresAt: z.number().nullable(),
      }),
    ),
    nextCommands: z.array(z.string()),
  })
  .passthrough();

// -- chat --------------------------------------------------------------------

const chatThreadRow = z.object({
  threadId: z.string(),
  title: z.string(),
  lastMessageAt: z.number(),
  createdAt: z.number(),
  status: z.enum(["idle", "streaming", "error"]),
  visibility: z.enum(["private", "shared"]),
  createdByUserId: z.string(),
  archivedAt: z.number().nullable(),
  fileContextPath: z.string().nullable(),
  parentThreadId: z
    .string()
    .nullable()
    .describe("Parent thread when this is a spawned sub-agent."),
  nestingDepth: z.number().nullable(),
  summary: z.string().nullable(),
  activeRunId: z.string().nullable(),
});

const chatSpawnResponse = z.object({
  threadId: z.string(),
  runId: z.string(),
  workflowRunId: z.string().nullable(),
  threadUrl: z.string().describe("Web URL of the thread."),
  streamUrl: z.string().describe("SSE stream URL for the live response."),
  yolo: z.boolean(),
});

// -- crm ---------------------------------------------------------------------

const savedViewSortRule = z.object({
  field: z.string().describe("Field name to sort by."),
  direction: z.enum(["asc", "desc"]),
});

/**
 * SavedView definition as stored in `crmObjects.savedViews` and
 * validated by `convex/lib/savedView.ts`. `filters` is a FilterGroup:
 * `{id, conjunction: "and"|"or", rules: [{id, field, operator,
 * value?}]}` with one level of nested groups allowed.
 */
const savedViewDefinition = z
  .object({
    name: z
      .string()
      .min(1)
      .max(100)
      .describe("View name (upsert key; shows in the view dropdown)."),
    view_type: viewKind.optional(),
    filters: z
      .record(z.string(), z.unknown())
      .optional()
      .describe(
        'FilterGroup, e.g. {"id":"g1","conjunction":"and","rules":[{"id":"r1","field":"Status","operator":"is","value":"Hot"}]}. ' +
          'Date rules support operator "date_preset" with value "today", "yesterday", "this_week", ' +
          '"last_week", "this_month", "last_month", "this_quarter", "last_quarter", "this_year", or ' +
          '"last_year", plus "relative_past"/"relative_next" with relativeAmount + relativeUnit ' +
          "(days|weeks|months|quarters|years). Rules may target the system timestamps " +
          '"created_at" / "updated_at", e.g. {"field":"created_at","operator":"relative_past","relativeAmount":7,"relativeUnit":"days"}.',
      ),
    sort: z.array(savedViewSortRule).optional(),
    columns: z
      .array(z.string())
      .optional()
      .describe("Visible-column ordering. Omit to keep the default set."),
    settings: z
      .record(z.string(), z.unknown())
      .optional()
      .describe(
        "View-type settings (kanbanField, calendarDateField, timelineStartField, …).",
      ),
    pinnedEntryIds: z
      .array(z.string())
      .optional()
      .describe(
        "Pinned-list mode: show EXACTLY these entry ids (mutually exclusive with filters).",
      ),
  })
  .passthrough();

const objectVisibility = z
  .enum(["workspace", "owner_only", "owner_plus_members"])
  .describe(
    "Who can read the object's records. Always reported as the value the object behaves as: `meeting` defaults to owner_plus_members, `calendar_event` to owner_only, anything else to workspace.",
  );

const crmObjectDoc = z
  .object({
    _id: z.string(),
    _creationTime: z.number(),
    organizationId: z.string(),
    name: z.string(),
    description: z.string().optional(),
    defaultView: viewKind,
    sortOrder: z.number(),
    immutable: z.boolean(),
    visibility: objectVisibility.optional(),
    icon: z.string().optional(),
    viewSettings: z.record(z.string(), z.unknown()).optional(),
    savedViews: z.array(z.record(z.string(), z.unknown())).optional(),
    entryCount: z.number().optional(),
    createdAt: z.number(),
    updatedAt: z.number(),
  })
  .passthrough()
  .describe("A CRM object (table) document.");

const crmFieldDoc = z
  .object({
    _id: z.string(),
    _creationTime: z.number(),
    organizationId: z.string(),
    objectId: z.string(),
    name: z.string(),
    description: z.string().optional(),
    type: fieldType,
    required: z.boolean(),
    defaultValue: z.string().optional(),
    calculation: campaignCalculation.optional(),
    relatedObjectId: z.string().optional(),
    relationshipType: relationshipType.optional(),
    enumValues: z.array(z.string()).optional(),
    enumColors: z.array(z.string()).optional(),
    enumMultiple: z.boolean().optional(),
    sortOrder: z.number(),
    indexed: z.boolean().optional(),
    createdAt: z.number(),
    updatedAt: z.number(),
  })
  .passthrough()
  .describe("A CRM field (column) document.");

// Presentation metadata is separate from CRM field maps and optional on raw results.
const referenceIdentity = {
  label: z.string(),
  href: z.string(),
  url: z.string().optional(),
  imageUrl: z.string().optional(),
  objectIcon: z.string().optional(),
};
const workspaceReference = z.discriminatedUnion("kind", [
  z.object({
    kind: z.literal("crm-entry"),
    objectName: z.string(),
    entryId: z.string(),
    ...referenceIdentity,
  }),
  z.object({
    kind: z.literal("crm-object"),
    objectName: z.string(),
    ...referenceIdentity,
  }),
  z.object({
    kind: z.literal("campaign"),
    sequenceId: z.string(),
    ...referenceIdentity,
  }),
]);
const workspaceReferenceFields = {
  references: z.array(workspaceReference).max(100),
  referenceCoverage: z.object({
    returned: z.number().int().nonnegative(),
    available: z.number().int().nonnegative(),
    truncated: z.boolean(),
  }),
};
const optionalWorkspaceReferenceFields = {
  references: workspaceReferenceFields.references.optional(),
  referenceCoverage: workspaceReferenceFields.referenceCoverage.optional(),
};
const withReferencesRequest = {
  withReferences: z
    .boolean()
    .optional()
    .describe(
      "Include bounded navigation references. Array reads return {data, references, referenceCoverage}; existing result envelopes keep their fields.",
    ),
};
function referenceListResponse<T extends z.ZodTypeAny>(row: T) {
  return z.union([
    z.array(row),
    z.object({ data: z.array(row), ...workspaceReferenceFields }),
  ]);
}

const crmEntryShape = z
  .object({
    id: z.string(),
    objectId: z.string(),
    fields: fieldsMap,
    createdAt: z.number(),
    updatedAt: z.number(),
    updatedBy: z.string(),
    sortOrder: z.number(),
  })
  .describe("A materialized CRM entry (row).");

const entryWriteResponse = z.object({
  entryId: z.string(),
  ...optionalWorkspaceReferenceFields,
});

const commentActorShape = z
  .object({
    kind: z.string(),
    label: z.string(),
    displayName: z.string().optional(),
    imageUrl: z.string().optional(),
    userId: z.string().optional(),
    isDench: z.boolean(),
  })
  .passthrough();

const commentShape = z
  .object({
    _id: z.string(),
    entryId: z.string(),
    parentCommentId: z.string().optional(),
    rootCommentId: z.string().optional(),
    depth: z.number(),
    body: z.string().describe("Markdown."),
    actor: commentActorShape,
    mentionedUserIds: z.array(z.string()),
    mentionsDench: z.boolean(),
    replyCount: z.number(),
    reactionSummary: z.array(
      z.object({ emoji: z.string(), count: z.number() }),
    ),
    viewerReactions: z.array(z.string()),
    editedAt: z.number().optional(),
    deletedAt: z.number().optional(),
    denchStatus: z.enum(["pending", "failed", "done"]).optional(),
    canEdit: z.boolean(),
    createdAt: z.number(),
  })
  .passthrough()
  .describe("A comment on a CRM entry.");

const commentPage = z.object({
  page: z.array(commentShape),
  isDone: z.boolean(),
  continueCursor: z.string(),
});

const notificationShape = z
  .object({
    _id: z.string(),
    kind: z.string(),
    title: z.string(),
    body: z.string().optional(),
    link: z.string().optional(),
    readAt: z.number().optional(),
    archivedAt: z.number().optional(),
    createdAt: z.number(),
  })
  .passthrough();

const syncSettingsShape = z
  .object({
    detectAccounts: z.boolean(),
    linkedinContacts: z.boolean(),
    slackConnectAccounts: z.boolean(),
    calendarContacts: z.boolean(),
    dossier: z.boolean(),
    emailTasks: z.boolean(),
    leadAutoQualify: z.boolean(),
    intelligence: z.boolean(),
  })
  .describe(
    "Settings → Sync, resolved: absent switches read as true. Off stops new work; nothing already created is removed.",
  );

const syncSettingsPatchShape = z.object({
  detectAccounts: z
    .boolean()
    .optional()
    .describe(
      "Accounts from email — new prospects and customers who email you become accounts and contacts.",
    ),
  linkedinContacts: z
    .boolean()
    .optional()
    .describe(
      "Contacts from LinkedIn — everyone you message on LinkedIn becomes a contact, with their company.",
    ),
  slackConnectAccounts: z
    .boolean()
    .optional()
    .describe(
      "Accounts from Slack Connect — a shared channel binds to the company on the other side.",
    ),
  calendarContacts: z
    .boolean()
    .optional()
    .describe(
      "Contacts from calendar — external invitees on upcoming meetings become contacts.",
    ),
  dossier: z
    .boolean()
    .optional()
    .describe(
      "Research dossier — Dench researches each new account into its Notes.",
    ),
  emailTasks: z
    .boolean()
    .optional()
    .describe(
      "Tasks from email — replies and follow-ups you owe become tasks; support issues become cases.",
    ),
  leadAutoQualify: z
    .boolean()
    .optional()
    .describe(
      "Qualify leads that book — a lead who books a meeting moves to Qualified and converts.",
    ),
  intelligence: z
    .boolean()
    .optional()
    .describe(
      "Summaries and Brief — conversations are summarised and each record keeps a Brief.",
    ),
});

const notificationPreferencesShape = z.object({
  inAppEnabled: z.boolean(),
  emailEnabled: z.boolean(),
  perKind: z.record(
    z.string(),
    z.object({ inApp: z.boolean().optional(), email: z.boolean().optional() }),
  ),
  timezone: z.string().nullable(),
  digestWindowMinutes: z.number(),
  maxEmailsPerDay: z.number(),
});

const crmBatchResults = z.object({
  ...optionalWorkspaceReferenceFields,
  results: z.array(
    z
      .object({
        entryId: z.string(),
        deleted: z.boolean().optional(),
      })
      .passthrough(),
  ),
  count: z.number(),
});

const presenceState = z.enum(["online", "away", "offline"]);

const memberShape = z.object({
  userId: z.string(),
  name: z.string().nullable(),
  email: z.string().nullable(),
  image: z.string().nullable(),
  tagline: z.string().nullable(),
  timezone: z
    .string()
    .nullable()
    .describe("IANA zone, when the member set one."),
  presence: presenceState,
  lastActiveAt: z.number().nullable(),
  role: z.string(),
  joinedAt: z.number(),
});

const memberProfileShape = z.object({
  userId: z.string(),
  name: z.string().nullable(),
  email: z.string().nullable(),
  image: z.string().nullable(),
  tagline: z.string().nullable(),
  role: z.enum(["ADMIN", "MEMBER"]),
  joinedAt: z.number(),
  timezone: z
    .object({
      value: z.string(),
      source: z.enum(["auto", "manual", "agent"]),
      updatedAt: z.number(),
    })
    .nullable(),
  presence: z.object({
    state: presenceState,
    lastActiveAt: z.number().nullable(),
  }),
  openTaskCount: z.number().describe("Capped at 500."),
  openTaskCountCapped: z
    .boolean()
    .optional()
    .describe("True when openTaskCount stopped at its cap."),
  commentCount: z.number().describe("Capped at 200."),
  changeCount: z.number().describe("Capped at 200."),
  lastContributionAt: z.number().nullable(),
  isSelf: z.boolean(),
});

const memberActivityRow = z.union([
  z.object({
    kind: z.literal("comment"),
    id: z.string(),
    entryId: z.string(),
    objectName: z.string(),
    entryLabel: z.string(),
    body: z.string(),
    parentCommentId: z.string().optional(),
    deleted: z.boolean(),
    at: z.number(),
  }),
  z
    .object({
      kind: z.literal("change"),
      id: z.string(),
      entryId: z.string(),
      objectName: z.string(),
      entryLabel: z.string(),
      changeKind: z.enum(["create", "update", "delete"]),
      changes: z.array(
        z.object({
          fieldName: z.string(),
          before: z.unknown().optional(),
          after: z.unknown().optional(),
        }),
      ),
      at: z.number(),
    })
    .passthrough(),
]);

// -- routines ------------------------------------------------------------------

const cronJobShape = z
  .object({
    id: z.string(),
    name: z.string(),
    description: z.string().optional(),
    enabled: z.boolean(),
    deleteAfterRun: z.boolean(),
    createdAtMs: z.number(),
    updatedAtMs: z.number(),
    schedule: scheduleSpec.optional(),
    sessionTarget: z.string(),
    wakeMode: z.string(),
    payload: z.union([
      z.object({ kind: z.literal("agentTurn"), message: z.string() }),
      z.object({ kind: z.literal("systemEvent"), text: z.string() }),
    ]),
    state: z.object({
      nextRunAtMs: z.number().optional(),
      runningAtMs: z.number().optional(),
      lastRunAtMs: z.number().optional(),
      lastStatus: z.enum(["ok", "error", "skipped"]).optional(),
      lastError: z.string().optional(),
      lastDurationMs: z.number().optional(),
    }),
  })
  .passthrough()
  .describe("A routine (cron trigger).");

const cronRunEntry = z
  .object({
    ts: z.number(),
    jobId: z.string(),
    action: z.string(),
    status: z.enum(["ok", "error", "skipped", "running"]).optional(),
    error: z.string().optional(),
    summary: z.string().optional(),
    sessionId: z.string().optional(),
    runAtMs: z.number().optional(),
    durationMs: z.number().optional(),
    nextRunAtMs: z.number().optional(),
  })
  .passthrough();

const cronWriteResponse = z.object({
  jobId: z.string(),
  nextFireAt: z.number().nullable().optional(),
});

// -- files -----------------------------------------------------------------

const fileTreeRow = z
  .object({
    _id: z.string(),
    _creationTime: z.number(),
    path: z.string(),
    parentPath: z.string(),
    isDir: z.boolean(),
    size: z.number().optional(),
    mtime: z.number().optional(),
    contentHash: z.string().optional(),
    storageId: z.string().optional(),
    lastModifiedBy: z.string().optional(),
    virtual: z
      .boolean()
      .optional()
      .describe("True for synthesized magic files (IDENTITY.md etc.)."),
  })
  .passthrough()
  .describe("A workspace file-tree row.");

// -- email -------------------------------------------------------------------

const campaignStatusEnum = z
  .enum([
    "draft",
    "pending_approval",
    "scheduled",
    "sending",
    "paused",
    "completed",
    "cancelled",
    "failed",
  ])
  .describe("Campaign lifecycle status.");

const deliveryVerificationStatus = z
  .enum(["pending", "verified", "failed", "disabled"])
  .describe("Provider-side (DNS/mailbox) verification status.");

const denchVerificationStatus = z
  .enum(["pending", "verified", "expired", "disabled"])
  .describe("Workspace-side sender verification status.");

const dnsRecordShape = z.object({
  type: z.string().describe("Record type, e.g. CNAME or TXT."),
  name: z.string(),
  value: z.string(),
  purpose: z.string().describe("Why the record is needed (DKIM/SPF/DMARC)."),
});

const emailIdentityRow = z.object({
  identityId: z.string(),
  type: emailIdentityType,
  domain: z.string().optional(),
  fromEmail: z.string(),
  fromName: z.string().optional(),
  deliveryVerificationStatus,
  denchVerificationStatus,
  disabled: z.boolean(),
  disabledAt: z.number().optional(),
  createdAt: z.number(),
});

const identitySummaryShape = z.object({
  identityId: z.string(),
  fromEmail: z.string(),
  domain: z.string().optional(),
  disabled: z.boolean(),
});

const emailMessageShape = z
  .object({
    messageId: z.string(),
    status: rawMessageStatus,
    fromEmail: z.string(),
    fromName: z.string().optional(),
    to: z.array(emailAddress),
    cc: z.array(emailAddress).optional(),
    bcc: z.array(emailAddress).optional(),
    subject: z.string(),
    inReplyTo: z.string().optional(),
    references: z.array(z.string()).optional(),
    providerMessageId: z.string().optional(),
    rfcMessageId: z.string().optional(),
    recipientCount: z.number(),
    openCount: z.number(),
    clickCount: z.number(),
    sentAt: z.number().optional(),
    deliveredAt: z.number().optional(),
    firstOpenedAt: z.number().optional(),
    lastOpenedAt: z.number().optional(),
    firstClickedAt: z.number().optional(),
    bouncedAt: z.number().optional(),
    complainedAt: z.number().optional(),
    lastError: z.string().optional(),
    createdAt: z.number(),
  })
  .describe("A raw email message with delivery + engagement counters.");

const campaignSummaryShape = z.object({
  campaignId: z.string(),
  status: campaignStatusEnum,
  totalRecipients: z.number(),
  queuedCount: z.number(),
  sendingCount: z.number(),
  sentCount: z.number(),
  deliveredCount: z.number(),
  openedCount: z.number(),
  clickedCount: z.number(),
  bouncedCount: z.number(),
  complainedCount: z.number(),
  failedCount: z.number(),
  suppressedCount: z.number(),
  unsubscribedCount: z.number(),
});

const campaignDoc = z
  .object({
    _id: z.string(),
    _creationTime: z.number(),
    organizationId: z.string(),
    name: z.string(),
    status: campaignStatusEnum,
    sendingIdentityId: z.string(),
    templateId: z.string(),
    subjectSnapshot: z.string(),
    htmlSnapshot: z.string(),
    textSnapshot: z.string().optional(),
    fromEmailSnapshot: z.string(),
    fromNameSnapshot: z.string().optional(),
    replyToEmailSnapshot: z.string().optional(),
    scheduledAt: z.number().optional(),
    submittedAt: z.number().optional(),
    startedAt: z.number().optional(),
    completedAt: z.number().optional(),
    cancelledAt: z.number().optional(),
    createdBy: z.string(),
    totalRecipients: z.number(),
    queuedCount: z.number(),
    sendingCount: z.number(),
    sentCount: z.number(),
    deliveredCount: z.number(),
    openedCount: z.number(),
    clickedCount: z.number(),
    bouncedCount: z.number(),
    complainedCount: z.number(),
    failedCount: z.number(),
    suppressedCount: z.number(),
    unsubscribedCount: z.number(),
    maxRecipients: z.number(),
    batchSize: z.number(),
    lastError: z.string().optional(),
    createdAt: z.number(),
    updatedAt: z.number(),
  })
  .passthrough()
  .describe("The full campaign document with counters.");

// -- gateway (Exa, images, Composio, enrichment) ----------------------------

const exaResultItem = z
  .object({
    url: z.string(),
    title: z.string().optional(),
    publishedDate: z.string().optional(),
    author: z.string().optional(),
    score: z.number().optional(),
    text: z.string().optional(),
    summary: z.string().optional(),
    highlights: z.array(z.string()).optional(),
    image: z.string().optional(),
    favicon: z.string().optional(),
    id: z.string().optional(),
    entities: z
      .array(z.record(z.string(), z.unknown()))
      .optional()
      .describe(
        "Structured entity metadata returned by category=people or category=company.",
      ),
  })
  .passthrough()
  .describe("A web search result.");

const exaSearchResponse = z
  .object({
    results: z.array(exaResultItem),
    resolvedSearchType: z.string().optional(),
    autopromptString: z.string().optional(),
    requestId: z.string().optional(),
    costDollars: z.record(z.string(), z.unknown()).optional(),
  })
  .passthrough()
  .describe("A web search response.");

const exaAnswerResponse = z
  .object({
    answer: z.string(),
    citations: z.array(exaResultItem).optional(),
    costDollars: z.record(z.string(), z.unknown()).optional(),
  })
  .passthrough()
  .describe(
    "An answer with citations. With stream: true the response is text/event-stream instead.",
  );

const imageEnvelope = z
  .object({
    ok: z.boolean(),
    model: z.string(),
    endpoint: z.enum(["generations", "edits"]),
    prompt: z.string(),
    revisedPrompt: z.string().optional(),
    quality: z.string().optional(),
    requestedSize: z.string().optional(),
    format: z.string().optional(),
    mimeType: z.string().optional(),
    estimatedCostUsd: z.number().optional(),
    b64_json: z.string().describe("Base64-encoded image bytes."),
    storageId: z.string().optional(),
    path: z.string().describe("Workspace path where the image was saved."),
    signedUrl: z.string().nullable(),
    contentHash: z.string().optional(),
    sizeBytes: z.number().optional(),
    usage: z
      .object({
        inputTokens: z.number().optional(),
        outputTokens: z.number().optional(),
        totalTokens: z.number().optional(),
      })
      .passthrough()
      .optional(),
  })
  .passthrough()
  .describe("Gateway image envelope wrapping the OpenAI image result.");

const composioConnection = z
  .object({
    id: z.string().nullable(),
    connectionId: z.string().nullable(),
    toolkit: z
      .object({
        slug: z.string().nullable(),
        name: z.string().nullable(),
      })
      .passthrough(),
    status: z.string().nullable().describe('e.g. "ACTIVE".'),
    createdAt: z.string().nullable(),
    updatedAt: z.string().nullable(),
    account: z
      .record(z.string(), z.unknown())
      .describe("Normalized account identity (stableId, label, email, ...)."),
    reconnect: z.record(z.string(), z.unknown()).optional(),
  })
  .passthrough()
  .describe("A connected app.");

const composioConnectionsResponse = z
  .object({
    items: z.array(composioConnection),
    connections: z
      .array(composioConnection)
      .describe("Alias of items for older clients."),
    raw: z
      .unknown()
      .describe(
        "Deprecated: the unprocessed provider response. Do not depend on it.",
      ),
  })
  .passthrough();

const toolSearchResponse = z
  .object({
    success: z.boolean().optional(),
    error: z.string().nullable().optional(),
    results: z
      .array(
        z
          .object({
            use_case: z.string(),
            primary_tool_slugs: z.array(z.string()).optional(),
            related_tool_slugs: z.array(z.string()).optional(),
            toolkits: z.array(z.string()).optional(),
            execution_guidance: z.string().optional(),
            recommended_plan_steps: z.array(z.string()).optional(),
            known_pitfalls: z.array(z.string()).optional(),
          })
          .passthrough(),
      )
      .optional(),
    toolkit_connection_statuses: z
      .array(
        z
          .object({
            toolkit: z.string(),
            has_active_connection: z.boolean(),
            status_message: z.string().nullable().optional(),
            accounts: z.array(z.record(z.string(), z.unknown())).optional(),
          })
          .passthrough(),
      )
      .optional(),
    tool_schemas: z
      .record(z.string(), z.record(z.string(), z.unknown()))
      .optional()
      .describe(
        "Tool slug -> schema with gateway-added execution_ref for tool.run.",
      ),
    session: z
      .object({ id: z.string() })
      .passthrough()
      .optional()
      .describe("Tool-router session; reuse session.id for follow-up calls."),
    items: z.array(z.record(z.string(), z.unknown())).optional(),
    nativeAvailable: z.boolean().optional(),
    available: z.boolean().optional(),
    execution_ref_version: z.number().optional(),
  })
  .passthrough()
  .describe("Tool search response with gateway enrichments.");

const toolRunResponse = z
  .object({
    data: z
      .unknown()
      .optional()
      .describe("Tool output (provider passthrough)."),
    error: z.unknown().nullable().optional(),
    log_id: z.string().optional(),
    execution_mode: z.string().optional(),
    tool_slug: z.string().optional(),
    tool_router_session_id: z.string().optional(),
    toolkit: z.string().optional(),
    account: z.string().optional(),
  })
  .passthrough()
  .describe("Tool execution result with gateway metadata.");

const enrichmentMetadata = z
  .object({
    total: z
      .number()
      .optional()
      .describe(
        "Total matches for the search. Stable across pages; absent when only an estimate exists.",
      ),
    totalIsEstimate: z
      .boolean()
      .optional()
      .describe("True when the total is a lower bound rather than exact."),
    offset: z.number().optional(),
    nextPageToken: z
      .string()
      .optional()
      .describe(
        "Opaque token for the next page. Pass it back as pageToken; absent on the last page.",
      ),
  })
  .passthrough()
  .optional();

const searchBillingResponse = z.object({
  estimatedCents: z
    .number()
    .int()
    .nonnegative()
    .describe("Search cost ceiling authorized by Dench billing, in cents."),
  chargedCents: z
    .number()
    .int()
    .nonnegative()
    .describe(
      "Actual workspace search charge reported by Dench billing, in cents.",
    ),
});

const enrichedPeopleResponse = z
  .object({
    source: z.enum(["live", "cache"]),
    people: z
      .array(
        z
          .object({
            fullName: z.string().optional(),
            firstName: z.string().optional(),
            lastName: z.string().optional(),
            headline: z.string().optional(),
            seniority: z.string().optional(),
            jobFunctions: z.array(z.string()).optional(),
            currentCompanyName: z.string().optional(),
            currentCompanyWebsite: z.string().optional(),
            linkedinID: z.string().optional(),
            emails: z.array(z.record(z.string(), z.unknown())).optional(),
            phones: z.array(z.record(z.string(), z.unknown())).optional(),
          })
          .passthrough(),
      )
      .describe("Search results normalized to the CRM upsert shape."),
    resolvedPersonIds: z.array(z.string()),
    creditsCharged: z.number(),
    billing: searchBillingResponse.optional(),
    metadata: enrichmentMetadata,
  })
  .passthrough();

const enrichedCompaniesResponse = z
  .object({
    source: z.enum(["live", "cache"]),
    companies: z
      .array(
        z
          .object({
            name: z.string().optional(),
            website: z.string().optional(),
            description: z.string().optional(),
            founded: z.number().optional(),
            headcount: z.number().optional(),
            industry: z.string().optional(),
            linkedinUrl: z.string().optional(),
            linkedinID: z.string().optional(),
          })
          .passthrough(),
      )
      .describe("Search results normalized to the CRM upsert shape."),
    resolvedCompanyIds: z.array(z.string()),
    creditsCharged: z.number(),
    billing: searchBillingResponse.optional(),
    metadata: enrichmentMetadata,
  })
  .passthrough();

// -- agent config -------------------------------------------------------------

const timedContent = z.object({
  content: z.string(),
  updatedAt: z.number(),
});

const agentConfigBlock = z.object({
  identity: timedContent.nullable(),
  organisation: timedContent.nullable(),
  memoryAggregate: timedContent.nullable(),
  toolsNotes: timedContent.nullable(),
  bootstrap: z.object({
    completed: z.boolean(),
    completedAt: z.number().optional(),
    template: z.string().optional(),
  }),
});

const agentConfigPayload = z
  .object({
    agentConfig: agentConfigBlock,
    userProfile: timedContent.nullable(),
    userTimezone: z
      .object({
        value: z.string(),
        source: z.enum(["auto", "manual", "agent"]),
        updatedAt: z.number(),
      })
      .nullable(),
    organizationId: z.string(),
  })
  .passthrough()
  .describe(
    "Agent harness config payload shared by every /agent-config GET endpoint.",
  );

// ---------------------------------------------------------------------------
// Gateway request shapes (re-declared without refine/transform)
// ---------------------------------------------------------------------------

const exaSearch = z.object({
  query: z.string().describe("Search query."),
  type: z
    .enum(["auto", "neural", "fast", "deep", "deep-reasoning", "instant"])
    .optional(),
  numResults: z.number().int().min(1).max(100).optional(),
  category: z
    .enum([
      "company",
      "research paper",
      "news",
      "personal site",
      "financial report",
      "people",
    ])
    .optional()
    .describe(
      "Entity categories return structured entities. Domain filters are unsupported for people; published-date filters are unsupported for people and company.",
    ),
  includeDomains: z
    .array(z.string())
    .optional()
    .describe("Unsupported for category=people."),
  excludeDomains: z
    .array(z.string())
    .optional()
    .describe("Unsupported for category=people."),
  startPublishedDate: z
    .string()
    .optional()
    .describe("Unsupported for category=people and category=company."),
  endPublishedDate: z
    .string()
    .optional()
    .describe("Unsupported for category=people and category=company."),
  includeText: z.array(z.string()).optional(),
  excludeText: z.array(z.string()).optional(),
  userLocation: z.string().optional(),
  moderation: z.boolean().optional(),
});

const exaContents = z.object({
  urls: z.array(z.string()).describe("URLs to fetch (max 10)."),
  text: z.boolean().optional(),
  summary: z
    .object({ query: z.string().optional() })
    .optional()
    .describe("Optional per-URL summary."),
});

const exaAnswer = z.object({
  query: z.string().describe("Question to answer with web search."),
  text: z.boolean().optional(),
  stream: z.boolean().optional(),
  outputSchema: z.record(z.string(), z.unknown()).optional(),
});

const imageGenerate = z.object({
  prompt: z.string().min(1).max(32_000).describe("Image prompt."),
  size: z.string().optional().describe("e.g. 1024x1024, 1536x1024, auto."),
  quality: z.enum(["auto", "low", "medium", "high"]).optional(),
  format: z.enum(["png", "jpeg", "webp"]).optional(),
  output_compression: z.number().int().min(0).max(100).optional(),
  background: z.enum(["auto", "opaque", "transparent"]).optional(),
  savePath: z
    .string()
    .optional()
    .describe("Workspace path to write the image."),
});

const imageEdit = imageGenerate.extend({
  input_images_base64: z
    .array(z.string())
    .min(1)
    .max(8)
    .describe("Base64-encoded source images (1-8)."),
  mask_base64: z.string().optional().describe("Optional base64 mask image."),
});

const composioConnect = z
  .object({
    toolkit: z
      .string()
      .min(1)
      .optional()
      .describe("Toolkit slug, e.g. github, gmail, stripe."),
    toolkit_slug: z.string().min(1).optional(),
    callback_url: z
      .string()
      .optional()
      .describe("Optional OAuth callback URL."),
    returnTo: z
      .string()
      .optional()
      .describe("Native OAuth return path within the workspace."),
  })
  .refine((value) => Boolean(value.toolkit || value.toolkit_slug), {
    message: "A toolkit is required.",
    path: ["toolkit"],
  });

const composioToolSearch = z.object({
  queries: z
    .array(
      z.object({
        use_case: z.string().min(1).describe("Natural-language use case."),
        known_fields: z.string().optional(),
      }),
    )
    .min(1)
    .max(7)
    .optional(),
  query: z.string().min(1).optional(),
  toolkit: z.string().min(1).optional(),
  toolkit_slug: z.string().min(1).optional(),
  limit: z.number().int().min(1).max(100).optional(),
  important: z.boolean().optional(),
  session: z
    .object({ id: z.string().optional(), generate_id: z.boolean().optional() })
    .optional(),
  account: z.string().optional(),
  model: z.string().optional(),
});

const composioToolRun = z.object({
  execution_ref: z
    .string()
    .optional()
    .describe(
      "Execution ref from a prior search, OR pass session_id+tool_slug.",
    ),
  session_id: z.string().optional(),
  tool_slug: z
    .string()
    .optional()
    .describe("Tool slug, e.g. SLACK_LIST_CHANNELS."),
  arguments: z
    .record(z.string(), z.unknown())
    .optional()
    .describe("Tool arguments object."),
  account: z.string().optional(),
  connected_account_id: z.string().optional(),
  approvalId: z.string().optional(),
});

/**
 * One list-filter entry: a plain string includes the value; the object
 * form supports per-value `exclude` / `exactMatch`.
 */
const searchFilterItem = z.union(
  [
    z.string(),
    // Strict: a misspelled control (`excluded`) must fail, not be stripped
    // into an include.
    z
      .object({
        value: z.string(),
        exclude: z.boolean().optional(),
        exactMatch: z.boolean().optional(),
      })
      .strict(),
  ],
  {
    error: (issue) => {
      // Name what was wrong with the object form ("Unrecognized key:
      // excluded"); the default union message is only "Invalid input".
      const branches = (issue as { errors?: { message: string }[][] }).errors;
      const detail = branches?.[1]?.map((entry) => entry.message).join("; ");
      return `Use a string or {"value": "…", "exclude": true, "exactMatch": true}${detail ? ` (${detail})` : ""}`;
    },
  },
);

const FILTER_OPTIONS_NOTE =
  "Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json.";

const searchRange = z
  .object({
    min: z.number().int().nonnegative().optional(),
    max: z.number().int().nonnegative().optional(),
  })
  // A range has no exclude: an extra key would silently turn into a
  // positive range.
  .strict()
  .refine(
    (range) =>
      range.min === undefined ||
      range.max === undefined ||
      range.min <= range.max,
    { message: "Provide a range with min no greater than max." },
  );

const peopleSearch = z.object({
  linkedinUrl: z.string().optional(),
  fullName: z.string().optional(),
  firstName: z.string().optional(),
  lastName: z.string().optional(),
  keywords: z
    .string()
    .optional()
    .describe(
      `Current-title text only. For profile or work descriptions, use profileKeywords. ${FILTER_OPTIONS_NOTE}`,
    ),
  companyDomain: z.string().optional(),
  companyName: z.string().optional(),
  titles: z
    .array(searchFilterItem)
    .max(50)
    .optional()
    .describe(`Current job titles (free text). ${FILTER_OPTIONS_NOTE}`),
  pastTitles: z
    .array(searchFilterItem)
    .max(50)
    .optional()
    .describe("Past job titles (free text)."),
  personNames: z.array(searchFilterItem).max(20).optional(),
  pastSeniorities: z
    .array(searchFilterItem)
    .max(20)
    .optional()
    .describe(
      `Seniority in any past role, independent of pastCompanyNames/pastTitles. Current seniority vocabulary plus Founding Team. Founder includes Co-Founder; C-level and Founding Team do not imply founder. ${FILTER_OPTIONS_NOTE}`,
    ),
  profileKeywords: z
    .array(searchFilterItem)
    .max(50)
    .optional()
    .describe(
      "Text in headline/about or any current/past work description. OR includes, global exclusions. Always loose text matching; missing evidence does not match.",
    ),
  companyKeywords: z
    .array(searchFilterItem)
    .max(50)
    .optional()
    .describe(
      "Current employer business focus/model (e.g. SaaS, B2B, Cloud), from description/tagline/business tags; distinct from legal companyTypes. Same employer as other current-job filters. Always loose text matching. May need another filter to retrieve candidates.",
    ),
  seniorities: z
    .array(searchFilterItem)
    .max(20)
    .optional()
    .describe(
      "Exact enum: Owner, Founder, C-level, Partner, VP, Head, Director, Manager, Senior.",
    ),
  jobFunctions: z
    .array(searchFilterItem)
    .max(20)
    .optional()
    .describe(
      `Exact enum, e.g. Sales, Marketing, Software. ${FILTER_OPTIONS_NOTE}`,
    ),
  subFunctions: z
    .array(searchFilterItem)
    .max(50)
    .optional()
    .describe(
      `Exact enum, e.g. SDR/BDR, Demand Generation. ${FILTER_OPTIONS_NOTE}`,
    ),
  industries: z
    .array(searchFilterItem)
    .max(50)
    .optional()
    .describe(`Exact enum, e.g. Software Development. ${FILTER_OPTIONS_NOTE}`),
  locations: z
    .array(searchFilterItem)
    .max(50)
    .optional()
    .describe(
      `Person locations — cities, states, countries, or metros (free text). ${FILTER_OPTIONS_NOTE}`,
    ),
  headcountRanges: z
    .array(searchFilterItem)
    .max(20)
    .optional()
    .describe(
      "Exact buckets: 1-10, 11-50, 51-200, 201-500, 501-1000, 1001-5000, 5001-10000, 10001+.",
    ),
  companyNames: z.array(searchFilterItem).max(50).optional(),
  pastCompanyNames: z.array(searchFilterItem).max(50).optional(),
  companyDomains: z.array(searchFilterItem).max(50).optional(),
  companyHeadquarters: z
    .array(searchFilterItem)
    .max(50)
    .optional()
    .describe(
      `Company HQ locations — cities, states, countries, or metros (free text). ${FILTER_OPTIONS_NOTE}`,
    ),
  companyTypes: z
    .array(searchFilterItem)
    .max(10)
    .optional()
    .describe(
      "Exact enum: Partnership, Nonprofit, Educational, Privately Held, Public Company, Self-Owned, Self-Employed, Government Agency.",
    ),
  universities: z
    .array(searchFilterItem)
    .max(50)
    .optional()
    .describe(`Universities attended (free text). ${FILTER_OPTIONS_NOTE}`),
  skills: z
    .array(searchFilterItem)
    .max(50)
    .optional()
    .describe(`Profile skills (free text). ${FILTER_OPTIONS_NOTE}`),
  languages: z
    .array(searchFilterItem)
    .max(20)
    .optional()
    .describe(`Spoken languages, e.g. English, German. ${FILTER_OPTIONS_NOTE}`),
  yearsInRole: searchRange.optional(),
  yearsAtCompany: searchRange.optional(),
  daysSinceJobChange: searchRange.optional(),
  foundedYears: searchRange
    .optional()
    .describe("Company founded-year range, e.g. {min: 2015, max: 2024}."),
  exactMatch: z
    .boolean()
    .optional()
    .describe(
      "Match free-text filters as whole strings. Default false: titles " +
        "['Founder'] also returns 'Co-Founder' and 'Founder & CEO'. Set " +
        "true to narrow. Domains, LinkedIn URLs, enum filters and numeric " +
        "ranges are always exact; keywords is always a loose text probe.",
    ),
  limit: z.number().int().positive().max(5000).optional(),
  offset: z.number().int().nonnegative().optional(),
  pageToken: z
    .string()
    .optional()
    .describe(
      "Opaque token from a previous response's metadata.nextPageToken.",
    ),
  preferCache: z.boolean().optional(),
});

export const campaignAudienceFiltersSchema = peopleSearch
  .omit({
    limit: true,
    offset: true,
    pageToken: true,
  })
  .strict();

const campaignSignal = z.enum([
  "post_engagement",
  "keyword",
  "hiring",
  "funding",
  "launch",
  "new_leader",
  "voice_engagement",
  "company_engagement",
  "brand_engagement",
  "lookalike",
]);
/** Signals that take terms: topics, roles, or LinkedIn profile/page URLs. */
const campaignTermSignal = z.enum([
  "post_engagement",
  "keyword",
  "hiring",
  "voice_engagement",
  "company_engagement",
  "brand_engagement",
]);
const campaignTargeting = z.object({
  titles: z.array(z.string()),
  locations: z.array(z.string()),
  companySizes: z.array(z.string()),
  industries: z.array(z.string()),
  excludes: z.array(z.string()),
  companies: z.array(z.string()).optional(),
  companyTypes: z.array(z.string()).optional(),
});
/**
 * Targeting a request sends. Strict: a key the builder can't represent
 * (seniorities, companyHeadquarters, companyDomains…) is refused, not
 * dropped, since dropping it would quietly widen the audience.
 */
const campaignTargetingInput = campaignTargeting.strict();
const campaignSignalTerms = z
  .object({
    post_engagement: z
      .array(z.string())
      .optional()
      .describe(
        'Post topics, phrased as what the buyer does ("using AI for outbound"), not bare product names.',
      ),
    keyword: z.array(z.string()).optional(),
    hiring: z.array(z.string()).optional().describe("Roles being hired for."),
    voice_engagement: z
      .array(z.string())
      .optional()
      .describe("LinkedIn profile URLs of market voices whose posts to watch."),
    company_engagement: z
      .array(z.string())
      .optional()
      .describe("LinkedIn company page URLs of companies and competitors."),
    brand_engagement: z
      .array(z.string())
      .optional()
      .describe("The sender's own LinkedIn company page URL."),
    exact: z
      .array(z.enum(["post_engagement", "keyword"]))
      .optional()
      .describe(
        "Topic signals searched by their exact keywords only (no drafted phrases).",
      ),
  })
  // A term list under a signal it doesn't recognize is refused, not dropped.
  .strict();
const campaignDraftSource = z
  .enum(["signals", "lookalike", "existing", "crm", "search"])
  .describe(
    "How people come in: buying signals, people like one best lead, a pasted list or CSV, CRM records, or a people search.",
  );
const campaignDraftScreen = z.enum([
  "source",
  "signals",
  "lookalike",
  "target",
  "messages",
  "outreach",
  "review",
]);
const campaignLookalike = z.object({
  seed: z.object({
    name: z.string(),
    linkedinUrl: z.string(),
    title: z.string().optional(),
    companyName: z.string().optional(),
    companyDomain: z.string().optional(),
    avatarUrl: z.string().optional(),
  }),
  title: z.string(),
  similarRoles: z.boolean(),
  roles: z.array(z.string()),
  location: z.string().optional(),
  industry: z.string().optional(),
  relatedIndustries: z.boolean(),
  industries: z.array(z.string()),
  companySizes: z.array(z.string()),
  companies: z.array(z.object({ name: z.string(), domain: z.string() })),
});
const campaignOutreachBrief = z.object({
  goal: z.string().describe("What a reply should lead to, e.g. a demo."),
  helpWith: z.string().describe("The problem the product solves for them."),
  tone: z.enum(["conversational", "warm", "direct", "formal"]),
  channels: z.enum(["both", "email", "linkedin"]),
});
// Strict, with the bounds saving enforces: a field or value it can't keep
// (an HTML body, a 13th step, a negative wait) is refused, not dropped.
const campaignDraftStep = z
  .object({
    type: z.enum(["email", "wait", "linkedin_connection", "linkedin_message"]),
    waitHours: z
      .number()
      .min(1)
      .max(24 * 60)
      .optional()
      .describe("Hours to wait, 1 to 1440. Required on a wait step."),
    emailSubject: z.string().max(200).optional(),
    emailTextBody: z
      .string()
      .max(5000)
      .optional()
      .describe("Plain text only; draft steps keep no HTML body."),
    emailReplyToPrevious: z.boolean().optional(),
    onlyIf: z.enum(["always", "connected", "not_connected"]).optional(),
    linkedinMessageBody: z.string().max(5000).optional(),
    linkedinMessageMode: z
      .enum(["skip_if_not_connected", "wait_until_connected"])
      .optional(),
    connectionTimeoutHours: z
      .number()
      .min(1)
      .max(24 * 60)
      .optional(),
  })
  .strict()
  .refine((step) => step.type !== "wait" || step.waitHours !== undefined, {
    message: "A wait step needs waitHours (1 to 1440).",
    path: ["waitHours"],
  });
const campaignDraftSending = z.object({
  emailMailboxAccountIds: z.array(z.string()),
  linkedinAccountIds: z.array(z.string()),
  timezone: z.string(),
  startHour: z.number().int().min(0).max(24),
  endHour: z.number().int().min(0).max(24),
  weekdays: z
    .array(z.number().int().min(0).max(6))
    .describe("0 is Sunday, 6 is Saturday."),
  dailySendCap: z.number().int().min(1).max(100).optional(),
});
const campaignApprovalMode = z
  .enum(["auto", "manual"])
  .describe(
    "auto: new people a signal finds start the sequence on their own. manual: they wait for approval.",
  );
const campaignClientRequestId = z
  .string()
  .trim()
  .min(8)
  .max(64)
  .describe(
    "Your stable id for this request, 8-64 characters. Retrying with the same id returns the same draft instead of creating another.",
  );
const campaignRecipient = z
  .object({
    email: z.string().optional(),
    linkedinProfileUrl: z.string().optional(),
    displayName: z.string().optional(),
    personalization: z
      .record(z.string(), z.unknown())
      .optional()
      .describe(
        'Merge values keyed by name, e.g. {"Company":"Acme"} for {{Company}}.',
      ),
  })
  .strict()
  .describe(
    "One person. Needs email and/or linkedinProfileUrl; unknown keys are rejected, not dropped.",
  );
const campaignBatchResult = z.object({
  added: z.number(),
  requested: z.number(),
  cappedAtLimit: z.number().nullable(),
  duplicates: z.number(),
  duplicatesElsewhere: z.number(),
  suppressed: z.number(),
  invalid: z.number(),
  skippedNoIdentity: z.number(),
  skippedMissingInfo: z.number(),
  missingInfoSample: z.unknown().optional(),
});
const campaignSearchPage = z.object({
  rows: z.array(z.record(z.string(), z.unknown())),
  people: z.array(z.unknown()),
  recipients: z.array(campaignRecipient),
  metadata: z.record(z.string(), z.unknown()),
  estimatedCents: z
    .number()
    .nullable()
    .describe(
      "The search cost ceiling reported by Dench billing, in cents. Null means the receipt is unavailable.",
    ),
  chargedCents: z
    .number()
    .nullable()
    .describe(
      "The actual search charge reported by Dench billing, in cents. Null means the receipt is unavailable; results remain valid.",
    ),
});

const companySearch = z.object({
  domain: z.string().optional(),
  name: z.string().optional(),
  linkedinUrl: z.string().optional(),
  keywords: z.string().optional(),
  industries: z
    .array(z.string())
    .max(50)
    .optional()
    .describe(`Exact enum, e.g. Software Development. ${FILTER_OPTIONS_NOTE}`),
  locations: z
    .array(z.string())
    .max(50)
    .optional()
    .describe(
      `Cities, states, countries, or metros (free text). ${FILTER_OPTIONS_NOTE}`,
    ),
  headcountRanges: z
    .array(z.string())
    .max(20)
    .optional()
    .describe(
      "Exact buckets: 1-10, 11-50, 51-200, 201-500, 501-1000, 1001-5000, 5001-10000, 10001+.",
    ),
  exactMatch: z
    .boolean()
    .optional()
    .describe(
      "Match free-text filters (name, locations, keywords) as whole " +
        "strings. Default false. Domain, linkedinUrl and enum filters are " +
        "always exact.",
    ),
  limit: z.number().int().positive().max(5000).optional(),
  offset: z.number().int().nonnegative().optional(),
  pageToken: z
    .string()
    .optional()
    .describe(
      "Opaque token from a previous response's metadata.nextPageToken.",
    ),
  preferCache: z.boolean().optional(),
});

const jobsSearch = z.object({
  titles: z
    .array(z.string())
    .max(50)
    .optional()
    .describe(`Job titles (free text). ${FILTER_OPTIONS_NOTE}`),
  locations: z
    .array(z.string())
    .max(50)
    .optional()
    .describe(
      `Cities, states, countries, or metros (free text). ${FILTER_OPTIONS_NOTE}`,
    ),
  companyDomain: z.string().optional(),
  companyName: z.string().optional(),
  companyLinkedinUrl: z.string().optional(),
  keywords: z.string().optional(),
  postedAfter: z.string().optional(),
  postedBefore: z
    .string()
    .optional()
    .describe(
      "Inclusive posting end date (YYYY-MM-DD); includes the whole UTC day.",
    ),
  limit: z.number().int().positive().max(5000).optional(),
  pageToken: z
    .string()
    .optional()
    .describe(
      "Opaque token from a previous response's metadata.nextPageToken.",
    ),
  preferCache: z.boolean().optional(),
});

const jobsSearchResponse = z
  .object({
    source: z.enum(["live", "cache"]),
    jobs: z
      .array(
        z
          .object({
            title: z.string().optional(),
            company: z.string().optional(),
            location: z.string().optional(),
            url: z.string().optional(),
            workplaceType: z.string().optional(),
            postedAt: z.string().optional(),
          })
          .passthrough(),
      )
      .describe("Job postings in the canonical job_posting shape."),
    metadata: enrichmentMetadata,
  })
  .passthrough();

const companyRelatedKind = z.enum([
  "employees",
  "founders",
  "funding",
  "investors",
  "acquisitions",
  "investments",
]);
const profileLookup = z
  .union([
    z.object({ linkedinUrl: z.string().url() }).strict(),
    z.object({ email: z.string().email() }).strict(),
    z.object({ domain: z.string().trim().min(1) }).strict(),
  ])
  .describe(
    "Exactly one identifier per lookup. People: linkedinUrl or email. Companies: domain or linkedinUrl. The gateway validates the identifier against kind.",
  );
const enrichmentCharge = z.object({
  charged_cents: z.number().int().nonnegative(),
});

// ---------------------------------------------------------------------------
// Request schemas keyed by operation id
// ---------------------------------------------------------------------------

/**
 * Strict no-input request schema. Used for operations whose backend takes
 * no caller-supplied fields (auth args are injected by the dispatcher).
 * Strict parsing drops stray query params / body keys so Convex argument
 * validators never see unexpected args.
 */
const noInput = z.object({});

// -- crm analytics -----------------------------------------------------------
// Mirrors `convex/lib/crm/analyticsConfig.ts` (the validators the mutations
// enforce) and the `computePanels` result shape. A panel names a metric, an
// optional group-by, an optional date bucketing and optional filters — no
// SQL. Synthetic `$createdAt` (row creation time) and `$location` (the
// `location` role, resolved through one relation hop) may be used anywhere a
// field name is accepted.

const analyticsPeriod = z
  .enum([
    "all",
    "this_week",
    "this_month",
    "last_month",
    "this_quarter",
    "last_quarter",
    "this_year",
  ])
  .describe(
    'Period preset. Scopes every panel by a date_preset on the object\'s closeDate role (else $createdAt) and fills previousValue from the previous calendar interval. "all" = no scope.',
  );

const roleDoc = {
  amount:
    'Numeric field holding the deal value ("Amount") — the "Value field" in the setup sheet.',
  stage:
    'Enum field driving the pipeline ("Stage" / "Status") — the "Progress field".',
  wonValues: "`stage` options that count as won (closed, successful).",
  lostValues: "`stage` options that count as lost (closed, gone).",
  convertedValues:
    '`stage` options that count as converted (a lead reached "Qualified").',
  closeDate:
    "Date field for time bucketing, forecasts and the period pill (falls back to $createdAt).",
  owner:
    'User field naming who owns each record ("Owner"). Rankings on it default to a narrow card and draw member faces.',
  location:
    'Place-name field maps plot. May be a relation path like "Account.HQ Location" (one hop through a relation).',
  recurrence:
    "How a won amount recurs: annual treats Amount as ARR, monthly as MRR, one_time disables MRR/ARR panels.",
  stageProbabilities:
    "Chance of closing per OPEN stage, 0..1, for the weighted forecast. Unlisted stages are spaced evenly; won = 1, lost = 0.",
};

const recurrence = z.enum(["monthly", "annual", "one_time"]);

const analyticsFieldRoles = z
  .object({
    amount: z.string().optional().describe(roleDoc.amount),
    stage: z.string().optional().describe(roleDoc.stage),
    wonValues: z.array(z.string()).optional().describe(roleDoc.wonValues),
    lostValues: z.array(z.string()).optional().describe(roleDoc.lostValues),
    convertedValues: z
      .array(z.string())
      .optional()
      .describe(roleDoc.convertedValues),
    closeDate: z.string().optional().describe(roleDoc.closeDate),
    owner: z.string().optional().describe(roleDoc.owner),
    location: z.string().optional().describe(roleDoc.location),
    recurrence: recurrence.optional().describe(roleDoc.recurrence),
    stageProbabilities: z
      .record(z.string(), z.number())
      .optional()
      .describe(roleDoc.stageProbabilities),
  })
  .describe(
    "The object's analytics setup, shared by every chart and every view: the semantic field roles derived metrics (win rate, won $, open pipeline, forecast, MRR/ARR), maps and card defaults read.",
  );

const analyticsFieldRolesPatch = z
  .object({
    amount: z.string().nullable().optional().describe(roleDoc.amount),
    stage: z.string().nullable().optional().describe(roleDoc.stage),
    wonValues: z
      .array(z.string())
      .nullable()
      .optional()
      .describe(roleDoc.wonValues),
    lostValues: z
      .array(z.string())
      .nullable()
      .optional()
      .describe(roleDoc.lostValues),
    convertedValues: z
      .array(z.string())
      .nullable()
      .optional()
      .describe(roleDoc.convertedValues),
    closeDate: z.string().nullable().optional().describe(roleDoc.closeDate),
    owner: z.string().nullable().optional().describe(roleDoc.owner),
    location: z.string().nullable().optional().describe(roleDoc.location),
    recurrence: recurrence.nullable().optional().describe(roleDoc.recurrence),
    stageProbabilities: z
      .record(z.string(), z.number())
      .nullable()
      .optional()
      .describe(roleDoc.stageProbabilities),
  })
  .describe(
    "Field roles as an edit: the same keys; null clears one. Applied onto the stored mapping with merge: true, otherwise replaces it.",
  );

const analyticsPanelType = z.enum([
  "stat",
  "bar",
  "line",
  "area",
  "donut",
  "funnel",
  "leaderboard",
  "forecast",
  "map",
]);

const analyticsPanel = z
  .object({
    id: z
      .string()
      .describe("Stable id (template panels use `tpl:<template>:<slug>`)."),
    title: z.string(),
    type: analyticsPanelType,
    metric: z.enum(["count", "sum", "avg", "min", "max"]),
    metricField: z
      .string()
      .optional()
      .describe("Numeric field for sum/avg/min/max. Ignored for count."),
    groupBy: z
      .string()
      .optional()
      .describe(
        "Bucketing field (enum/user/relation/boolean/text, or $location). On a time-series panel it splits the series into one line per value.",
      ),
    dateField: z
      .string()
      .optional()
      .describe("Date field for line/area/forecast bucketing (or $createdAt)."),
    dateBucket: z.enum(["day", "week", "month", "quarter"]).optional(),
    filters: z
      .record(z.string(), z.unknown())
      .optional()
      .describe("Panel-scoped FilterGroup, same shape as saved-view filters."),
    size: z
      .enum(["sm", "md", "lg"])
      .optional()
      .describe("Deprecated; ignored for layout. Use `span`."),
    span: z
      .union([z.literal(2), z.literal(3), z.literal(4), z.literal(6)])
      .optional()
      .describe(
        "Card width on the 6-track dashboard grid: 2 = a third, 3 = half, 4 = two thirds, 6 = full row. Defaults: funnel 4; map and leaderboard 2; bar/donut grouped by a user field 2, by anything else 4; trends 3.",
      ),
    hidden: z
      .boolean()
      .optional()
      .describe(
        "Hide from the strip above the table; still shown in the full analytics view.",
      ),
    sortOrder: z.number(),
    derived: z
      .enum([
        "conversion_rate",
        "win_rate",
        "won_amount",
        "lost_amount",
        "open_pipeline",
        "pipeline_forecast",
        "mrr",
        "arr",
      ])
      .optional()
      .describe(
        "Role-driven derived metric; when set the panel computes from fieldRoles instead of metric/groupBy.",
      ),
  })
  .describe("One analytics panel definition.");

/**
 * An ad-hoc panel as callers actually write it: `id`, `title`, `metric`
 * and `sortOrder` may be omitted (the CLI's `--panel '{"type":"donut",
 * "groupBy":"Source"}'` already did this; the App SDK and REST path must
 * accept the same). `normalizeAdHocPanels` fills the defaults before the
 * Convex validator sees them — see `convexExtras["crm.analytics.compute"]`.
 */
const adHocAnalyticsPanel = analyticsPanel
  .partial({ id: true, title: true, metric: true, sortOrder: true })
  .describe(
    "One ad-hoc panel. `id`, `title`, `metric` (default count) and `sortOrder` (default: position) are optional.",
  );

/** Fill `id` / `title` / `metric` / `sortOrder` on ad-hoc compute panels. */
export function normalizeAdHocPanels(panels: unknown): unknown {
  if (!Array.isArray(panels)) return panels;
  return panels.map((raw, index) => {
    if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
    const panel = raw as Record<string, unknown>;
    const slug = String(panel.title ?? panel.type ?? "panel")
      .toLowerCase()
      .replace(/[^a-z0-9]+/g, "-")
      .replace(/(^-|-$)/g, "");
    const id =
      typeof panel.id === "string" && panel.id.trim()
        ? panel.id.trim()
        : `adhoc:${slug}-${index}`;
    return {
      ...panel,
      id,
      title: typeof panel.title === "string" ? panel.title : id,
      metric: typeof panel.metric === "string" ? panel.metric : "count",
      sortOrder: typeof panel.sortOrder === "number" ? panel.sortOrder : index,
    };
  });
}

const analyticsPanelPatch = analyticsPanel
  .omit({ id: true, size: true })
  .partial()
  .extend({
    metricField: z.string().nullable().optional(),
    groupBy: z.string().nullable().optional(),
    dateField: z.string().nullable().optional(),
    dateBucket: z
      .enum(["day", "week", "month", "quarter"])
      .nullable()
      .optional(),
    filters: z.record(z.string(), z.unknown()).nullable().optional(),
    span: z
      .union([z.literal(2), z.literal(3), z.literal(4), z.literal(6)])
      .nullable()
      .optional()
      .describe("Width in tracks; null restores the chart kind's default."),
    derived: analyticsPanel.shape.derived.unwrap().nullable().optional(),
  })
  .describe(
    "Partial panel edit: only the keys present change; null clears an optional key; hidden: false is stored as absent.",
  );

const analyticsPanelContainer = z.object({
  panels: z.array(analyticsPanel),
  removedPanelIds: z
    .array(z.string())
    .optional()
    .describe("Template panel ids the user deleted; never resurrected."),
});

const analyticsConfig = analyticsPanelContainer.extend({
  fieldRoles: analyticsFieldRoles.optional(),
  stripCollapsed: z.boolean().optional(),
});

const analyticsSeriesPoint = z.object({
  bucket: z.string(),
  label: z.string(),
  value: z.number(),
  count: z.number(),
  projected: z.boolean().optional(),
});

const analyticsPanelResult = z.object({
  id: z.string(),
  unit: z.enum(["number", "currency", "percent"]),
  value: z.number().optional(),
  secondaryValue: z.number().optional(),
  previousValue: z
    .number()
    .optional()
    .describe(
      "The same value over the comparison window (period / compareFilters).",
    ),
  buckets: z
    .array(
      z.object({
        key: z.string(),
        label: z.string(),
        count: z.number(),
        value: z.number(),
        color: z.string().optional(),
        amount: z
          .number()
          .optional()
          .describe(
            "Funnel only: sum of the amount role over the rows in this stage.",
          ),
      }),
    )
    .optional(),
  series: z.array(analyticsSeriesPoint).optional(),
  seriesGroups: z
    .array(
      z.object({
        key: z.string(),
        label: z.string(),
        color: z.string().optional(),
        series: z.array(analyticsSeriesPoint),
      }),
    )
    .optional(),
  error: z.string().optional(),
});

// ---------------------------------------------------------------------------
// Request schemas keyed by operation id
// ---------------------------------------------------------------------------

export const requestSchemas: Record<string, ZodTypeAny> = {
  "lists.save": z
    .object({
      createdFrom: z
        .enum([
          "find_people",
          "find_companies",
          "find_jobs",
          "mixed",
          "watch_fire",
          "generate_image",
        ])
        .describe(
          "Use find_people, find_companies or find_jobs for a prospect list.",
        ),
      title: z.string().min(1).describe("Name of the new list."),
      saved: z
        .boolean()
        .optional()
        .describe(
          "True makes the list visible in Find. Omitted saves an unlisted draft that can still be read or added to a campaign by id.",
        ),
      filters: z
        .unknown()
        .optional()
        .describe(
          "Original search filters to retain with the list. Saving does not run a search.",
        ),
      people: z
        .array(z.record(z.string(), z.unknown()))
        .optional()
        .describe(
          "Complete person records from a search, including existing contact details and custom fields.",
        ),
      companies: z
        .array(z.record(z.string(), z.unknown()))
        .optional()
        .describe("Complete company records from a search."),
      jobs: z
        .array(z.record(z.string(), z.unknown()))
        .optional()
        .describe("Complete job records from a search."),
    })
    .strict(),
  "lists.update": z
    .object({
      artifactId: z.string().describe("The existing list id."),
      title: z.string().min(1).optional(),
      filters: z
        .unknown()
        .optional()
        .describe("Replacement filter metadata; does not run a new search."),
      people: z
        .array(z.record(z.string(), z.unknown()))
        .optional()
        .describe(
          "Replacement people. Omit to preserve existing rows; an empty array clears them.",
        ),
      companies: z
        .array(z.record(z.string(), z.unknown()))
        .optional()
        .describe("Replacement companies. Omit to preserve existing rows."),
      jobs: z
        .array(z.record(z.string(), z.unknown()))
        .optional()
        .describe("Replacement jobs. Omit to preserve existing rows."),
    })
    .strict(),
  // Meta
  "commands.list": noInput,

  // Outreach campaigns (dench campaign)
  "campaigns.drafts.create": z
    .object({
      clientRequestId: campaignClientRequestId,
      name: z.string().max(120).optional(),
      timezone: z
        .string()
        .optional()
        .describe(
          "IANA timezone, e.g. America/Los_Angeles. Sets a Mon-Fri 9-18 send window in it; without one the draft has no send window.",
        ),
      emailMailboxAccountIds: z
        .array(z.string().min(1))
        .max(50)
        .optional()
        .describe(
          "Mailboxes to send from instead of your own running ones. Checked as the draft is created: one you can't use creates nothing.",
        ),
      linkedinAccountIds: z
        .array(z.string().min(1))
        .max(50)
        .optional()
        .describe(
          "LinkedIn accounts to send from instead of your own running ones. Checked as the draft is created.",
        ),
    })
    .strict(),
  "campaigns.audience.search": z
    .object({
      sequenceId: z.string().optional(),
      filters: campaignAudienceFiltersSchema,
      limit: z.number().int().min(1).max(100).optional(),
      pageToken: z.string().optional(),
    })
    .strict(),
  "campaigns.people.addFromSearch": z
    .object({
      sequenceId: z.string(),
      filters: campaignAudienceFiltersSchema,
      limit: z.number().int().min(1).max(50).optional(),
      pageToken: z.string().optional(),
      checkDuplicatesAcrossWorkspace: z.boolean().optional(),
    })
    .strict(),
  "campaigns.people.addBatch": z
    .object({
      sequenceId: z.string(),
      recipients: z.array(campaignRecipient).min(1).max(50),
      newRecordsObject: z.enum(["lead", "people"]).optional(),
      checkDuplicatesAcrossWorkspace: z.boolean().optional(),
    })
    .strict(),
  "campaigns.sources.get": z.object({ sequenceId: z.string() }).strict(),
  "campaigns.sources.signals": z.object({ sequenceId: z.string() }).strict(),
  "campaigns.sources.update": z
    .object({
      sequenceId: z.string(),
      status: z.enum(["active", "paused"]).optional(),
      cadence: z.enum(["daily", "weekly", "monthly"]).optional(),
      findMoreMatching: z.boolean().optional(),
      approvalMode: campaignApprovalMode.optional(),
      targeting: campaignTargetingInput.optional(),
      signal: z
        .object({ signal: campaignSignal, enabled: z.boolean() })
        .optional(),
      terms: z
        .object({
          signal: campaignTermSignal,
          values: z.array(z.string()),
        })
        .optional(),
    })
    .strict(),
  "campaigns.sources.run": z.object({ sequenceId: z.string() }).strict(),
  "campaigns.sources.overview": z.object({ sequenceId: z.string() }).strict(),
  "campaigns.sources.pending": z.object({ sequenceId: z.string() }).strict(),
  "campaigns.sources.review": z
    .object({
      sequenceId: z.string(),
      enrollmentIds: z.array(z.string()).min(1),
      decision: z.enum(["approve", "reject"]),
    })
    .strict(),
  "campaigns.queue": z.object({ sequenceId: z.string() }).strict(),
  "campaigns.sources.preview": z
    .object({
      sequenceId: z.string(),
      signal: campaignSignal,
      terms: z.array(z.string()).optional(),
    })
    .strict(),
  "campaigns.builder.profile": noInput,
  "campaigns.builder.save": z
    .object({
      clientRequestId: campaignClientRequestId,
      targeting: campaignTargetingInput,
      signals: z.array(campaignSignal),
      signalTerms: campaignSignalTerms.optional(),
      findMoreMatching: z
        .boolean()
        .optional()
        .describe("Also add people who match the audience without a signal."),
      name: z.string().max(120).optional(),
      source: campaignDraftSource.optional(),
      screen: campaignDraftScreen.optional(),
      lookalike: campaignLookalike
        .optional()
        .describe(
          'For source lookalike: the edited result of builder lookalike, with signals ["lookalike"].',
        ),
    })
    .strict(),
  "campaigns.builder.get": z.object({ draftId: z.string() }).strict(),
  "campaigns.builder.build": z.object({ draftId: z.string() }).strict(),
  "campaigns.builder.create": z
    .object({
      draftId: z.string(),
      name: z.string().max(120).optional(),
      timezone: z.string().optional(),
      paused: z
        .boolean()
        .optional()
        .describe("Save paused: signals wait to run until launch."),
    })
    .strict(),
  "campaigns.builder.drafts": noInput,
  "campaigns.builder.resume": z.object({ draftId: z.string() }).strict(),
  "campaigns.builder.discard": z.object({ draftId: z.string() }).strict(),
  "campaigns.builder.outreach": z
    .object({
      draftId: z.string(),
      outreachMode: z
        .enum(["ai", "manual"])
        .optional()
        .describe(
          "ai: generate the sequence from the brief. manual: write steps.",
        ),
      brief: campaignOutreachBrief.optional(),
      steps: z
        .array(campaignDraftStep)
        .max(12, "A sequence can have up to 12 steps.")
        .optional(),
      sending: campaignDraftSending.optional(),
      approvalMode: campaignApprovalMode.optional(),
    })
    .strict(),
  "campaigns.builder.sequence": z
    .object({ draftId: z.string(), brief: campaignOutreachBrief })
    .strict(),
  "campaigns.builder.lookalike": z
    .object({
      linkedinUrl: z
        .string()
        .max(300)
        .optional()
        .describe("The best lead's LinkedIn profile URL."),
      suggest: z
        .object({ title: z.string(), industry: z.string().optional() })
        .optional()
        .describe("Suggest similar roles and related industries again."),
      rescope: z
        .object({
          seed: campaignLookalike.shape.seed,
          company: z.string(),
          title: z.string().optional(),
          location: z.string().optional(),
        })
        .optional()
        .describe("Re-scope the lookalike to a different company."),
    })
    .strict(),
  "campaigns.builder.voices": z
    .object({
      topics: z.array(z.string()).optional(),
      market: z.string().max(300).optional(),
    })
    .strict(),
  "campaigns.builder.opener": z
    .object({ draftId: z.string(), leadId: z.string(), opener: z.string() })
    .strict(),
  "campaigns.builder.autofill": z
    .object({ description: z.string().min(3).max(300) })
    .strict(),
  "campaigns.builder.estimate": z
    .object({
      kind: z.enum(["people", "week"]),
      targeting: campaignTargetingInput,
      signals: z.array(campaignSignal).optional(),
      signalTerms: campaignSignalTerms.optional(),
    })
    .strict(),
  "campaigns.accounts.linkedin": noInput,
  "campaigns.accounts.email": noInput,
  "campaigns.list": z.object({
    ...withReferencesRequest,
    includeArchived: z
      .boolean()
      .optional()
      .describe("Include archived campaigns."),
  }),
  "campaigns.create": z.object({
    name: z.string(),
    ...campaignSenderPools,
    timezone: z
      .string()
      .optional()
      .describe("IANA timezone for the default Mon-Fri 9-18 send window."),
  }),
  "campaigns.duplicate": z
    .object({
      sequenceId: z
        .string()
        .describe("The campaign to copy; any status, including archived."),
    })
    .strict(),
  "campaigns.get": z.object({ sequenceId: z.string() }),
  "campaigns.analytics": z.object({ sequenceId: z.string() }),
  "campaigns.live": z.object({ sequenceId: z.string() }),
  "campaigns.update": z.object({
    sequenceId: z.string(),
    name: z.string().optional(),
    ...campaignSenderPools,
    stopOnReply: z
      .boolean()
      .optional()
      .describe("Stop a person's remaining steps when they reply."),
    startsAt: z
      .number()
      .nullable()
      .optional()
      .describe("Epoch ms; null clears the start."),
    endsAt: z
      .number()
      .nullable()
      .optional()
      .describe("Epoch ms; null clears the end."),
    sendSchedules: z.array(campaignSendSchedule).min(1).max(8).optional(),
    timezone: z
      .string()
      .optional()
      .describe("Legacy single-window timezone. Prefer sendSchedules."),
    sendWindowStartHour: z
      .number()
      .int()
      .min(0)
      .max(23)
      .optional()
      .describe("Legacy single-window start hour. Prefer sendSchedules."),
    sendWindowEndHour: z
      .number()
      .int()
      .min(1)
      .max(24)
      .optional()
      .describe("Legacy single-window end hour. Prefer sendSchedules."),
    sendWeekdays: z
      .array(z.number().int().min(0).max(6))
      .min(1)
      .optional()
      .describe(
        "Legacy single-window weekdays, 0 = Sunday. Prefer sendSchedules.",
      ),
    dailySendCap: z
      .number()
      .int()
      .min(1)
      .max(100)
      .optional()
      .describe("Cold emails per day, 1-100."),
  }),
  "campaigns.steps.replace": z
    .object({
      sequenceId: z.string(),
      steps: z
        .array(
          campaignStepInput.strict().describe("One campaign step, in order."),
        )
        .min(1)
        .max(MAX_CAMPAIGN_STEPS)
        .describe(
          "Every step, in send order (a workflow may list them in any order; they are stored in path order). Rejected, not trimmed: a field the step type would drop (onlyIf off email/post-like steps, a body on a visit, reply-in-thread on the first email, condition fields its check ignores), a missing subject or required body, an overlength note/message/InMail subject, out-of-range wait/withdrawal/post-age/acceptance values, {TOKEN} single braces, which would be sent as typed, and workflow paths that don't hold together (duplicate keys, a target that isn't a key or end, a condition or wait_for_connection without both yesNext and noNext, or any other step with them).",
        ),
      stepModel: campaignStepModel
        .optional()
        .describe(
          "linear: steps run in order. workflow: steps have keys and paths (next, yesNext, noNext) and may include condition and wait_for_connection. Left out, a workflow stays one and steps with keys, paths or those types make one; nothing turns a workflow back into a list. When replacing a workflow's steps, send workflow, so steps without keys or paths are checked here the way they will be saved.",
        ),
      allowSingleBraces: z
        .boolean()
        .optional()
        .describe(
          "Send {single braces} exactly as typed instead of rejecting them. Merge tokens always use {{double braces}}.",
        ),
    })
    .strict()
    .superRefine((input, ctx) => {
      if (input.stepModel === "linear") {
        const shaped = input.steps.findIndex(hasWorkflowShape);
        if (shaped >= 0)
          ctx.addIssue({
            code: "custom",
            message: `Step ${shaped + 1}: condition, wait_for_connection, key, next, yesNext and noNext only work in a workflow. Send stepModel "workflow", or leave it out.`,
            path: ["steps", shaped],
          });
      }
      for (const issue of checkCampaignSteps(input.steps, {
        allowSingleBraces: input.allowSingleBraces,
        ...(input.stepModel
          ? { workflow: input.stepModel === "workflow" }
          : {}),
      }).errors)
        ctx.addIssue({
          code: "custom",
          message: issue.message,
          path: issue.step
            ? ["steps", issue.step - 1, ...(issue.field ? [issue.field] : [])]
            : ["steps"],
        });
    }),
  "campaigns.steps.update": z
    .object({
      sequenceId: z.string(),
      steps: z
        .array(
          campaignStepInput
            .partial()
            .extend({
              stepId: z
                .string()
                .describe("The step's _id from campaigns.get steps[]."),
              expectedUpdatedAt: z
                .number()
                .describe(
                  "The step's updatedAt when you read it. If someone saved it since, the edit is refused instead of overwriting theirs.",
                ),
              type: campaignStepType.describe(
                "The step's current type. A launched step's type can't change.",
              ),
            })
            .strict()
            .describe(
              "One step edit: only the fields given change. Clear text with an empty string, onlyIf with always, emailReplyToPrevious with false and withdrawAfterHours with null. Like settings are optional; omitted values stay unchanged. A workflow step's key, next, yesNext, noNext, check, conditionField and conditionOperator can't change after launch (send them unchanged or leave them out); conditionValue and a wait_for_connection's connectionTimeoutHours can.",
            ),
        )
        .min(1)
        .max(MAX_CAMPAIGN_STEPS)
        .describe(
          "The steps to change. Rejected, not trimmed: a field the step type would drop, an overlength note/message/InMail subject, out-of-range wait/withdrawal/post-age/acceptance values, {TOKEN} single braces, and a changed path or If / else check.",
        ),
      allowSingleBraces: z
        .boolean()
        .optional()
        .describe(
          "Send {single braces} exactly as typed instead of rejecting them. Merge tokens always use {{double braces}}.",
        ),
    })
    .strict()
    .superRefine((input, ctx) => {
      const edits = input.steps.map(
        ({ stepId: _stepId, expectedUpdatedAt: _expected, ...edit }) => edit,
      );
      for (const issue of checkStepEdits(edits, {
        allowSingleBraces: input.allowSingleBraces,
      }).errors)
        ctx.addIssue({
          code: "custom",
          message: issue.message,
          path: issue.step
            ? ["steps", issue.step - 1, ...(issue.field ? [issue.field] : [])]
            : ["steps"],
        });
    }),
  "campaigns.personalization.get": z
    .object({ sequenceId: z.string() })
    .strict(),
  "campaigns.personalization.set": z
    .object({
      sequenceId: z.string(),
      template: campaignLineTemplate
        .nullable()
        .describe("The lines and context; null turns personalized lines off."),
    })
    .strict(),
  "campaigns.personalization.clear": z
    .object({ sequenceId: z.string() })
    .strict(),
  "campaigns.personalization.write": z
    .object({
      sequenceId: z.string(),
      mode: z
        .enum(["missing", "all"])
        .optional()
        .describe(
          "missing (default): only people without lines. all: rewrite everyone's.",
        ),
      confirmed: z
        .boolean()
        .optional()
        .describe(
          "true after the user accepts the estimate from needsConfirm.",
        ),
    })
    .strict(),
  "campaigns.personalization.edit": z
    .object({
      enrollmentId: z.string().describe("From dench campaign people."),
      key: z.string().describe("The line's key, as in {{key}}."),
      value: z
        .string()
        .describe("The line to send; an empty string undoes the edit."),
    })
    .strict(),
  "campaigns.personalization.rewrite": z
    .object({
      enrollmentId: z.string().describe("From dench campaign people."),
      key: z
        .string()
        .optional()
        .describe("One line's key; leave out to rewrite all of their lines."),
    })
    .strict(),
  "campaigns.people.addFromCrm": z.object({
    sequenceId: z.string(),
    objectName: z
      .string()
      .describe("CRM object the ids belong to, e.g. lead or people."),
    entryIds: z.array(z.string()).min(1).max(100),
    emailFieldName: z
      .string()
      .optional()
      .describe('Column holding the email when it is not "Email".'),
    linkedinUrlFieldName: z
      .string()
      .optional()
      .describe("Column holding the LinkedIn profile URL."),
    nameFieldName: z.string().optional(),
    relationFieldName: z
      .string()
      .optional()
      .describe("Follow this relation to the person record first."),
    relationDirection: z.literal("reverse").optional(),
    checkDuplicatesAcrossWorkspace: z
      .boolean()
      .optional()
      .describe("Default true: skip people active in another campaign."),
  }),
  "campaigns.people.add": z.object({
    sequenceId: z.string(),
    displayName: z.string().optional(),
    email: z.string().optional(),
    linkedinProfileUrl: z.string().optional(),
    entryId: z
      .string()
      .optional()
      .describe("Existing CRM people entry to link."),
    sourceEntryId: z.string().optional(),
    sourceObjectName: z.string().optional(),
    emailIdentityId: z.string().optional(),
    linkedinIdentityId: z.string().optional(),
    linkedinProviderUserId: z.string().optional(),
    newRecordsObject: z
      .enum(["lead", "people"])
      .optional()
      .describe("CRM object a new record is created in when none matches."),
    personalization: z.record(z.string(), z.unknown()).optional(),
    checkDuplicatesAcrossWorkspace: z.boolean().optional(),
  }),
  "campaigns.preview": z
    .object({
      sequenceId: z.string(),
      enrollmentId: z
        .string()
        .describe("The person to preview, from dench campaign people."),
      stepId: z
        .string()
        .describe(
          "An email or LinkedIn step, its _id from campaigns.get steps[]. A wait step sends nothing.",
        ),
    })
    .strict(),
  "campaigns.launch.preview": z.object({ sequenceId: z.string() }),
  "campaigns.launch": z.object({
    sequenceId: z.string(),
    fingerprint: z.string().describe("From the launch preview."),
    linkedinRiskAcknowledged: z
      .boolean()
      .optional()
      .describe("Required when the campaign has LinkedIn steps."),
  }),
  "campaigns.pause": z.object({ sequenceId: z.string() }),
  "campaigns.resume": z.object({ sequenceId: z.string() }),
  "campaigns.archive": z.object({ sequenceId: z.string() }),
  "campaigns.events": z.object({
    sequenceId: z.string(),
    numItems: z
      .number()
      .int()
      .min(1)
      .max(200)
      .optional()
      .describe("Page size, default 50."),
    cursor: z
      .string()
      .optional()
      .describe("continueCursor from the previous page."),
  }),
  "campaigns.people.stop": z.object({ enrollmentId: z.string() }),
  "campaigns.people.resume": z.object({ enrollmentId: z.string() }),
  "campaigns.people.sync": z.object({ sequenceId: z.string() }).strict(),
  "campaigns.people.resumeAll": z
    .object({
      sequenceId: z.string().describe("An active campaign."),
    })
    .strict(),
  "campaigns.people.setEmail": z
    .object({
      enrollmentId: z.string().describe("From dench campaign people."),
      email: z.string().describe("The address email steps should use."),
    })
    .strict(),
  "campaigns.people.setLinkedin": z
    .object({
      enrollmentId: z.string().describe("From dench campaign people."),
      linkedinProfileUrl: z
        .string()
        .describe(
          "A LinkedIn member profile URL, e.g. https://linkedin.com/in/ada.",
        ),
    })
    .strict(),
  "campaigns.people.setField": z
    .object({
      enrollmentId: z.string().describe("From dench campaign people."),
      key: z
        .string()
        .describe(
          "The merge token name without braces, e.g. Company for {{Company}} or fund for {{fund}}.",
        ),
      value: z.string().describe("Up to 2000 characters."),
    })
    .strict(),
  "campaigns.pipeline": z.object({ sequenceId: z.string() }).strict(),
  "campaigns.people.forRecord": z
    .object({
      entryId: z
        .string()
        .describe("A CRM record's _id: a person, or a lead created from one."),
    })
    .strict(),
  "campaigns.people.timeline": z
    .object({
      enrollmentId: z.string().describe("From dench campaign people."),
    })
    .strict(),
  "campaigns.people.remove": z.object({
    enrollmentId: z
      .string()
      .describe(
        "From dench campaign people; the person must never have been contacted.",
      ),
  }),

  // Auth
  "auth.signin.create": z.object({
    codeHash: z.string(),
    sessionTokenHash: z.string(),
    agentName: z.string(),
    agentKind: z.string().describe("Agent kind, normalized to snake_case."),
    intent: signInIntent,
    proposedOrganizationName: z
      .string()
      .optional()
      .describe("Required when intent is create_workspace."),
    requestedOrganizationSelector: z.string().optional(),
    userAgent: z.string().optional(),
  }),
  "auth.signin.poll": z.object({
    codeHash: z.string(),
    sessionTokenHash: z.string(),
  }),
  "auth.otp.start": z.object({
    email: z.string().describe("Email to send the code to."),
  }),
  "auth.otp.verify": z.object({
    email: z.string(),
    code: z.string().describe("6+ digit code from the email."),
    agentName: z.string(),
    agentKind: z.string(),
    sessionTokenHash: z
      .string()
      .describe("sha256 hex of the local session token."),
    intent: signInIntent,
    proposedOrganizationName: z.string().optional(),
    organizationSelector: z.string().optional(),
    userAgent: z.string().optional(),
  }),
  "auth.otp.finalize": z.object({
    authToken: z.string(),
    organizationId: z
      .string()
      .optional()
      .describe("Provide this OR newOrganizationName."),
    newOrganizationName: z.string().optional(),
  }),

  // Workspace
  "workspace.context.sections": z.object({
    organizationId: z.string().optional(),
    sections: z
      .array(
        z.enum([
          "identity",
          "organisation",
          "user",
          "memory",
          "rules",
          "tools",
        ]),
      )
      .optional(),
  }),
  "email.inbox.search": z.object({
    ...inboxPaging,
    mailbox: z.string().optional(),
    from: z.string().min(1).max(500).optional(),
    to: z.string().min(1).max(500).optional(),
    subject: z.string().min(1).max(500).optional(),
    query: z
      .string()
      .min(1)
      .max(500)
      .optional()
      .describe(
        "Words that must all appear in the subject, sender or recipients (case-insensitive).",
      ),
    after: z.coerce
      .number()
      .optional()
      .describe(
        "Inclusive Unix milliseconds; missing sentAt falls back to createdAt.",
      ),
    before: z.coerce
      .number()
      .optional()
      .describe("Exclusive Unix milliseconds."),
    direction: z.enum(["inbound", "outbound"]).optional(),
  }),
  "email.inbox.thread": z.object({ ...inboxPaging, threadHandle: z.string() }),
  "email.inbox.message": z.object({
    messageHandle: z.string(),
    format: z.enum(["text", "html"]).optional(),
    maxBytes: z.coerce.number().int().min(1).max(100000).optional(),
  }),
  "email.drafts.create": nativeEmailCreate,
  "email.native.send": nativeEmailCreate.extend({
    to: z.array(nativeEmailRecipient).min(1),
  }),
  "email.drafts.get": z.object({ draftId: z.string() }),
  "email.drafts.senders": z.object({ organizationId: z.string().optional() }),
  "email.drafts.update": z.object({
    draftId: z.string(),
    expectedRevision: z.number().int().nonnegative(),
    patch: z.object({
      mailboxAccountId: z.string().optional(),
      ...nativeEmailContent,
    }),
  }),
  "email.drafts.send": z.object({
    draftId: z.string(),
    expectedRevision: z.number().int().nonnegative(),
    requestId: z.string().optional(),
  }),
  "email.drafts.upload": z.object({
    draftId: z.string(),
    name: z.string(),
    contentType: z.string(),
    contentBase64: z.string(),
  }),
  "email.drafts.signature": z.object({ draftId: z.string() }),
  "workspace.context": noInput,
  "workspace.instructions": z.object({ organizationId: z.string().optional() }),
  "workspace.status": noInput,
  "workspace.agents": noInput,
  "workspace.approvals.list": noInput,
  "workspace.artifacts.list": z.object({
    limit: z.coerce.number().int().min(1).max(100).optional(),
  }),
  "workspace.suggestedWork.list": z.object({
    limit: z.coerce.number().int().min(1).max(100).optional(),
  }),

  // Memory
  "memory.search": z.object({
    query: z.string().describe("Full-text query."),
    limit: z.coerce.number().int().min(1).max(20).optional(),
  }),
  "memory.save": z.object({
    key: z.string().describe("Stable memory key."),
    kind: memoryKind,
    text: z.string().describe("Memory body. No secrets or scratch notes."),
    tags: z.array(z.string()).optional(),
    sensitivity: memorySensitivity.optional(),
    visibility: memoryVisibility.optional(),
    projectId: z.string().optional(),
    sourceQuote: z.string().optional(),
    confidence: z.number().optional(),
    importance: z.number().optional(),
  }),

  // Approvals
  "approval.request": z.object({
    title: z.string().describe("What needs human approval."),
    reason: z.string().optional(),
    risk: riskLevel,
  }),
  "approval.decide": z.object({
    approvalId: z.string(),
    decision: approvalDecision,
    evidence: z
      .string()
      .optional()
      .describe("Required when the requesting agent records its own decision."),
  }),

  // Billing
  "billing.status": noInput,
  "billing.topup": z.object({
    requestId: z
      .string()
      .describe("Idempotency key (1-200 of [A-Za-z0-9:_-])."),
    amountUsd: z.number().describe("USD amount, $5 to $1000."),
  }),
  "billing.upgrade": z.object({
    tier: z.enum(["pro", "max", "cloud", "desktop", "api"]).optional(),
    billingCycle: z.enum(["monthly", "yearly"]).optional(),
    requestId: z.string().optional(),
    returnPath: z
      .string()
      .optional()
      .describe("Internal return path beginning with /."),
  }),

  // Chat
  "chat.list": z.object({
    titleQuery: z.string().optional(),
    limit: z.coerce.number().int().min(1).max(100).optional(),
    includeArchived: z.coerce.boolean().optional(),
    includeAutomated: z.coerce.boolean().optional(),
  }),
  "chat.search": z.object({
    query: z.string().describe("Full-text query across past messages."),
    limit: z.coerce.number().int().min(1).max(50).optional(),
    excludeThreadId: z.string().optional(),
    includeAutomated: z.coerce.boolean().optional(),
  }),
  "chat.read": z.object({
    threadId: z.string(),
    limit: z.coerce.number().int().min(1).max(200).optional(),
    visibleTextOnly: z
      .boolean()
      .optional()
      .describe(
        "Message text as a person sees it: text parts only, without reasoning or tool calls.",
      ),
  }),
  "chat.tree": z.object({
    titleQuery: z.string().optional().describe("Filter threads by title."),
    limit: z.coerce.number().int().min(1).max(100).optional(),
    includeArchived: z.coerce.boolean().optional(),
    includeAutomated: z.coerce
      .boolean()
      .optional()
      .describe("Include routine-spawned threads. Defaults false."),
  }),
  "chat.rename": z.object({
    items: z
      .array(z.object({ threadId: z.string(), title: z.string() }))
      .min(1)
      .max(50),
  }),
  "chat.delete": z.object({
    threadIds: z.array(z.string()).min(1).max(25),
    includeAutomated: z.boolean().optional(),
  }),
  "chat.new": z.object({
    environment: z
      .string()
      .regex(/^[a-z][a-z0-9-]{0,63}$/)
      .optional(),
    prompt: z.string().describe("The user message that starts the turn."),
    model: z.string().optional(),
    fileContextPath: z.string().optional(),
    visibility: z.enum(["private", "shared"]).optional(),
    yolo: z
      .boolean()
      .optional()
      .describe("Bypass approval gates for this turn."),
    title: z.string().optional(),
  }),
  "chat.send": z.object({
    threadId: z.string(),
    prompt: z.string().describe("The message to append."),
    model: z.string().optional(),
    yolo: z.boolean().optional(),
  }),
  "chat.follow": z.object({ threadId: z.string() }),

  // CRM objects
  "crm.objects.list": z.object(withReferencesRequest),
  "crm.objects.listCompact": noInput,
  "crm.objects.get": z.object({ name: z.string() }),
  "crm.objects.create": z.object({
    name: z.string().describe("Object name (lowercased, singular)."),
    description: z.string().optional(),
    defaultView: viewKind.optional(),
    icon: z
      .string()
      .optional()
      .describe(
        "Hugeicons (or legacy Lucide) icon name, e.g. user-multiple, target-01.",
      ),
    fields: z
      .array(z.object(newCrmField))
      .optional()
      .describe(
        "Fields to add after the built-in Notes, in column order. The object and its fields are created in one transaction: if any field is rejected, nothing is created.",
      ),
  }),
  "crm.objects.update": z.object({
    name: z.string(),
    description: z.string().optional(),
    defaultView: viewKind.optional(),
    icon: z.string().optional(),
    viewSettings: z.record(z.string(), z.unknown()).optional(),
    savedViews: z.array(z.record(z.string(), z.unknown())).optional(),
    visibility: objectVisibility
      .optional()
      .describe(
        "Who can see the object's records: every workspace member, only the record's owner, or the owner plus the members listed on the record. Admins only (a signed-in admin; an org-scoped key cannot change it). Records created before the switch have no owner and are hidden from everyone until one is set; switch back to workspace to see them again.",
      ),
  }),
  "crm.objects.rename": z.object({
    from: z.string().describe("Current object name (path)."),
    to: z.string().describe("New object name."),
  }),
  "crm.objects.delete": z.object({ name: z.string() }),
  "crm.objects.archive": z.object({ name: z.string() }),
  "crm.objects.unarchive": z.object({ name: z.string() }),

  // The workspace app rail
  "crm.sidebar.list": z.object({}),
  "crm.sidebar.move": z.object({
    navId: z
      .string()
      .describe("Nav id from `sidebar list`, e.g. crm-object:task."),
    position: z
      .union([z.literal("top"), z.literal("bottom"), z.number().int().min(1)])
      .describe("Where to land among the visible rows; N is 1-based."),
  }),

  // CRM saved views
  "crm.views.list": z.object({ objectName: z.string() }),
  "crm.views.get": z.object({
    objectName: z.string(),
    viewName: z.string(),
  }),
  "crm.views.entries": z.object({
    objectName: z.string(),
    viewName: z.string(),
    page: z.number().int().min(1).optional(),
    pageSize: z.number().int().min(1).optional(),
    ...assigneeScopeRequest,
  }),
  "crm.views.create": z.object({
    objectName: z.string(),
    view: savedViewDefinition,
    replaceExisting: z
      .boolean()
      .optional()
      .describe("Overwrite an existing view with the same name."),
    setActive: z
      .boolean()
      .optional()
      .describe("Also switch the object's active view to this one."),
  }),
  "crm.views.update": z.object({
    objectName: z.string(),
    viewName: z.string().describe("Name of the view to replace (path)."),
    view: savedViewDefinition
      .partial()
      .optional()
      .describe(
        "Full replacement definition; the path viewName is used as the name.",
      ),
    setActive: z.boolean().optional(),
  }),
  "crm.views.delete": z.object({
    objectName: z.string(),
    viewName: z.string(),
  }),
  "crm.views.archive": z.object({
    objectName: z.string(),
    viewName: z.string(),
  }),
  "crm.views.unarchive": z.object({
    objectName: z.string(),
    viewName: z.string(),
  }),

  // CRM fields
  "crm.fields.list": z.object({ objectName: z.string() }),
  "crm.fields.listCompact": z.object({ objectName: z.string() }),
  "crm.fields.create": z.object({
    objectName: z.string(),
    ...newCrmField,
    type: fieldType
      .optional()
      .describe(
        "Defaults to boolean with calculation, otherwise text. Calculations require boolean.",
      ),
    enrichment: enrichmentConfig.optional(),
    calculation: campaignCalculation.optional(),
  }),
  "crm.fields.update": z.object({
    objectName: z.string(),
    fieldName: z.string(),
    name: z.string().optional().describe("Rename the field."),
    description: z.string().optional(),
    required: z.boolean().optional(),
    enumValues: z
      .array(z.string())
      .optional()
      .describe("Full replacement of options."),
    enumColors: z.array(z.string()).optional(),
    enumMultiple: z.boolean().optional(),
    indexed: z.boolean().optional(),
    enrichment: enrichmentConfig.optional(),
    clearEnrichment: z.boolean().optional(),
    calculation: campaignCalculation
      .optional()
      .describe(
        "Replace an existing calculation's metric/source. Stored fields cannot be converted; create a new column instead.",
      ),
    clearCalculation: z
      .boolean()
      .optional()
      .describe(
        "Explicitly remove an existing calculation, leaving an editable boolean. Does not snapshot calculated values. Mutually exclusive with calculation.",
      ),
  }),
  "crm.fields.delete": z.object({
    objectName: z.string(),
    fieldName: z.string(),
  }),
  "crm.fields.reorder": z.object({
    objectName: z.string(),
    orderedFieldNames: z
      .array(z.string())
      .describe("Field names in desired order."),
  }),
  "crm.fields.enum.reorder": z.object({
    objectName: z.string(),
    fieldName: z.string(),
    orderedValues: z
      .array(z.string())
      .describe("Exact permutation of existing options."),
  }),
  "crm.fields.enum.add": z.object({
    objectName: z.string(),
    fieldName: z.string(),
    value: z.string().describe("Option value to add."),
    color: z.string().optional().describe("Hex color for the option."),
    position: z
      .number()
      .int()
      .optional()
      .describe("0-based insert index; defaults to append."),
  }),
  "crm.fields.enum.remove": z.object({
    objectName: z.string(),
    fieldName: z.string(),
    value: z.string(),
  }),
  "crm.fields.enum.rename": z.object({
    objectName: z.string(),
    fieldName: z.string(),
    oldValue: z.string().describe("Existing option value (path)."),
    newValue: z
      .string()
      .describe("New option value; migrates entries + statuses."),
  }),
  "crm.fields.enum.color": z.object({
    objectName: z.string(),
    fieldName: z.string(),
    value: z.string(),
    color: z.string().describe("Hex color, e.g. #22c55e."),
  }),

  // CRM entries
  "crm.entries.list": z.object({
    ...withReferencesRequest,
    objectName: z.string(),
    limit: z.coerce.number().int().min(1).max(1000).optional(),
    ...assigneeScopeRequest,
  }),
  "crm.entries.get": z.object({
    objectName: z.string(),
    entryId: z.string(),
  }),
  "crm.entries.create": z.object({
    objectName: z.string(),
    data: dataMap,
  }),
  "crm.entries.createMany": z.object({
    objectName: z.string(),
    entries: z.array(dataMap).max(200).describe("Up to 200 field maps."),
  }),
  "crm.entries.update": z.object({
    objectName: z.string(),
    entryId: z.string(),
    data: dataMap,
  }),
  "crm.entries.updateMany": z.object({
    objectName: z.string().describe("Object the entries belong to."),
    updates: z
      .array(
        z
          .object({
            entryId: z.string().optional(),
            id: z.string().optional(),
            data: dataMap,
          })
          .refine((u) => u.entryId || u.id, {
            message: "Each update must include entryId or id",
          }),
      )
      .max(200)
      .describe("Per-entry partial updates (entryId or id + data)."),
  }),
  "crm.entries.delete": z.object({
    objectName: z.string().optional(),
    entryId: z.string(),
  }),
  "crm.entries.bulkDelete": z.object({
    objectName: z.string().optional(),
    entryIds: z.array(z.string()).max(200),
  }),

  // CRM comments
  "crm.comments.list": z.object({
    objectName: z.string(),
    entryId: z.string(),
    limit: z.coerce.number().int().min(1).max(100).optional(),
    cursor: z
      .string()
      .optional()
      .describe("continueCursor from the prior page."),
    replies: z.coerce
      .number()
      .int()
      .min(0)
      .max(50)
      .optional()
      .describe("Preview replies per root (default 2)."),
  }),
  "crm.comments.replies": z.object({
    commentId: z.string().describe("Root comment id."),
    limit: z.coerce.number().int().min(1).max(100).optional(),
    cursor: z.string().optional(),
  }),
  "crm.comments.get": z.object({ commentId: z.string() }),
  "crm.comments.create": z.object({
    objectName: z.string(),
    entryId: z.string(),
    body: z
      .string()
      .min(1)
      .describe(
        "Markdown. Mention a member with [@Name](/?member=<userId>); mention Dench with [@Dench](/?member=dench).",
      ),
    parentCommentId: z
      .string()
      .optional()
      .describe("Reply under this comment (any depth)."),
    mentionUserIds: z
      .array(z.string())
      .optional()
      .describe("Extra members to notify without writing mention links."),
    mentionDench: z
      .boolean()
      .optional()
      .describe("Summon Dench to reply in the thread."),
  }),
  "crm.comments.update": z.object({
    commentId: z.string(),
    body: z.string().min(1),
  }),
  "crm.comments.delete": z.object({ commentId: z.string() }),
  "crm.comments.react": z.object({
    commentId: z.string(),
    emoji: z.string().describe("A single emoji, e.g. 👍."),
  }),
  "crm.watch.get": z.object({ objectName: z.string(), entryId: z.string() }),
  "crm.watch.set": z.object({
    objectName: z.string(),
    entryId: z.string(),
    watching: z
      .boolean()
      .optional()
      .describe("Defaults to true; false unfollows."),
  }),

  // CRM tasks
  "crm.tasks.mine": z.object({
    limit: z.coerce.number().int().min(1).max(500).optional(),
    priority: z
      .string()
      .optional()
      .describe(
        'Only tasks at this priority — one of the workspace\'s Priority options ("high"; case-insensitive).',
      ),
  }),
  "crm.tasks.forEntry": z.object({
    objectName: z.string(),
    entryId: z.string(),
  }),
  "crm.tasks.createForEntry": z.object({
    objectName: z.string(),
    entryId: z.string(),
    name: z.string().min(1),
    assigneeUserId: z.string().optional(),
    dueDateKey: z
      .string()
      .regex(/^\d{4}-\d{2}-\d{2}$/)
      .optional()
      .describe("YYYY-MM-DD"),
    priority: z
      .string()
      .optional()
      .describe(
        "One of the workspace's Priority options (default Low | Medium | High; case-insensitive).",
      ),
  }),
  "crm.tasks.complete": z.object({ entryId: z.string() }),
  "crm.tasks.reopen": z.object({ entryId: z.string() }),
  "crm.tasks.setPriority": z.object({
    entryId: z.string(),
    priority: z
      .string()
      .nullable()
      .describe(
        'One of the workspace\'s Priority options ("high"; case-insensitive), or null to clear.',
      ),
  }),
  "crm.tasks.subtasks.list": z.object({ entryId: z.string() }),
  "crm.tasks.subtasks.create": z.object({
    entryId: z.string().describe("The parent task."),
    name: z.string().min(1),
    assigneeUserId: z.string().optional(),
    dueDateKey: z
      .string()
      .regex(/^\d{4}-\d{2}-\d{2}$/)
      .optional()
      .describe("YYYY-MM-DD"),
    priority: z.string().optional(),
  }),
  "crm.tasks.setParent": z.object({
    entryId: z.string(),
    parentEntryId: z
      .string()
      .nullable()
      .describe("The parent task, or null to promote to a top-level task."),
  }),
  "crm.tasks.delete": z.object({
    entryId: z.string(),
    subtasks: z
      .enum(["delete", "keep"])
      .optional()
      .describe(
        "What happens to its subtasks: delete them too (default) or keep them as tasks.",
      ),
  }),
  "crm.tasks.repeat.get": z.object({ entryId: z.string() }),
  "crm.tasks.repeat.set": z.object({
    entryId: z.string(),
    rule: taskRepeatRuleSchema
      .optional()
      .describe("Structured rule; alternative to `rrule`."),
    rrule: z
      .string()
      .optional()
      .describe(
        "RFC 5545 subset: FREQ, INTERVAL, BYDAY (ordinal allowed for MONTHLY, e.g. 2TU / -1FR), BYMONTHDAY, BYMONTH, COUNT, UNTIL. Bare FREQ=MONTHLY / YEARLY / WEEKLY take the day from the task's due date.",
      ),
    trigger: z
      .enum(["after_completion", "on_schedule"])
      .optional()
      .describe(
        "When the next occurrence is created: after this one is done (default) or on schedule regardless.",
      ),
    ends: z
      .union([
        z.object({ kind: z.literal("never") }),
        z.object({ kind: z.literal("count"), count: z.number().int().min(1) }),
        z.object({
          kind: z.literal("until"),
          dateKey: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
        }),
      ])
      .optional(),
    options: z
      .object({
        skipWeekends: z.boolean().optional(),
        keepAssignee: z.boolean().optional(),
        copyNotes: z.boolean().optional(),
        copySubtasks: z.boolean().optional(),
      })
      .optional(),
  }),
  "crm.tasks.repeat.clear": z.object({ entryId: z.string() }),
  "crm.tasks.repeat.skip": z.object({ entryId: z.string() }),
  "crm.tasks.repeat.pause": z.object({ entryId: z.string() }),
  "crm.tasks.repeat.resume": z.object({ entryId: z.string() }),
  "crm.tasks.series.list": z.object({
    status: z.enum(["active", "paused", "ended"]).optional(),
  }),
  "crm.tasks.series.occurrences": z.object({ seriesId: z.string() }),

  // Meetings — the record itself is a CRM entry on `meeting`; these reach
  // the transcript, action-item and attendance side tables.
  "meetings.list": z.object({
    limit: z.coerce.number().int().min(1).max(100).optional(),
    cursor: z
      .string()
      .optional()
      .describe("continueCursor from the prior page."),
  }),
  "meetings.transcript.list": z.object({
    meetingEntryId: z.string(),
    limit: z.coerce.number().int().min(1).max(500).optional(),
    cursor: z.string().optional(),
  }),
  "meetings.transcript.append": z.object({
    meetingEntryId: z.string(),
    segments: z
      .array(
        z.object({
          seq: z
            .number()
            .int()
            .min(0)
            .optional()
            .describe("Ordinal; omitted continues after the last row."),
          speakerName: z.string().nullable().optional(),
          speakerEmail: z
            .string()
            .nullable()
            .optional()
            .describe(
              "Links the speaker to an existing person by exact email.",
            ),
          startMs: z.number().min(0).optional(),
          endMs: z.number().min(0).optional(),
          text: z.string().min(1),
        }),
      )
      .min(1)
      .max(500),
  }),
  "meetings.transcript.clear": z.object({ meetingEntryId: z.string() }),
  "meetings.actionItems.list": z.object({ meetingEntryId: z.string() }),
  "meetings.actionItems.add": z.object({
    meetingEntryId: z.string(),
    items: z
      .array(
        z.object({
          text: z.string().min(1),
          ownerName: z.string().nullable().optional(),
          done: z.boolean().optional(),
        }),
      )
      .min(1)
      .max(100),
    replace: z.boolean().optional().describe("Delete the existing list first."),
  }),
  "meetings.actionItems.setDone": z.object({
    itemId: z.string(),
    done: z.boolean(),
  }),
  "meetings.actionItems.delete": z.object({ itemId: z.string() }),
  "meetings.sharing.get": z.object({ meetingEntryId: z.string() }),
  "meetings.sharing.set": z.object({
    meetingEntryId: z.string(),
    shared: z
      .boolean()
      .describe(
        "true opens the meeting to every workspace member; false returns it to the owner plus the members who were on the invite.",
      ),
  }),
  "meetings.participants.list": z.object({ meetingEntryId: z.string() }),
  "meetings.participants.set": z.object({
    meetingEntryId: z.string(),
    participants: z
      .array(
        z.object({
          name: z.string().nullable().optional(),
          email: z.string().nullable().optional(),
          isHost: z.boolean().optional(),
        }),
      )
      .min(1)
      .max(200),
    replace: z
      .boolean()
      .optional()
      .describe("Drop attendees not in this list. Default merges."),
  }),

  // Members + my profile
  "members.presence": z.object({
    userIds: z
      .string()
      .optional()
      .describe("Comma-separated user ids; omit for every member."),
  }),
  "members.get": z.object({ userId: z.string() }),
  "members.activity": z.object({
    userId: z.string(),
    limit: z.coerce.number().int().min(1).max(100).optional(),
    kinds: z
      .string()
      .optional()
      .describe("Comma-separated subset of comments,changes."),
  }),
  "members.tasks": z.object({
    userId: z.string(),
    limit: z.coerce.number().int().min(1).max(50).optional(),
    todayStartMs: z.coerce.number().optional(),
  }),
  "me.profile.get": noInput,
  "me.profile.update": z.object({
    name: z.string().min(1).max(80).optional(),
    tagline: z.string().max(160).optional().describe("Empty string clears."),
    imageUrl: z
      .string()
      .optional()
      .describe("http(s) image URL; empty string clears the avatar."),
    timezone: z
      .string()
      .nullable()
      .optional()
      .describe("IANA zone; null returns to browser detection."),
  }),
  "me.avatar.uploadUrl": noInput,
  "me.avatar.set": z.object({
    storageId: z.string().describe("storageId returned by the upload POST."),
  }),
  "me.avatar.clear": noInput,

  // CRM cells
  "crm.cells.get": z.object({
    objectName: z.string(),
    entryId: z.string(),
    fieldName: z.string(),
  }),
  "crm.cells.set": z.object({
    objectName: z.string(),
    entryId: z.string(),
    fieldName: z.string(),
    value: cellValue,
  }),
  "crm.cells.setMany": z.object({
    cells: z
      .array(
        z.object({
          objectName: z.string(),
          entryId: z.string(),
          fieldName: z.string(),
          value: cellValue,
        }),
      )
      .max(200),
  }),
  "crm.cells.append": z.object({
    objectName: z.string(),
    entryId: z.string(),
    fieldName: z.string(),
    value: cellValue,
  }),

  // CRM query
  "crm.query": z.object({
    ...withReferencesRequest,
    objectName: z.string(),
    dsl: z
      .object({
        filter: z.record(z.string(), z.unknown()).optional(),
        select: z.array(z.string()).optional(),
        sort: z.string().optional().describe("e.g. -Score,Name (- = desc)."),
        limit: z.number().int().optional(),
      })
      .optional()
      .describe("Query DSL. Bare equality only; use dslJson for $-operators."),
    dslJson: z
      .string()
      .optional()
      .describe(
        "JSON string of the DSL when filters use operators like $gt/$in/$contains/$and/$or. " +
          "Date fields and the system timestamps created_at/updated_at also accept " +
          '$datePreset ("today", "yesterday", "this_week", "last_week", "this_month", ' +
          '"last_month", "this_quarter", "last_quarter", "this_year", "last_year"), and ' +
          '$inLast/$inNext rolling windows (a day count like 7, or {"amount":2,"unit":"weeks"} ' +
          "with unit days|weeks|months|quarters|years). " +
          'Example: {"filter":{"updated_at":{"$datePreset":"this_month"}}}.',
      ),
    ...assigneeScopeRequest,
  }),
  "crm.queryPage": z.object({
    objectName: z.string(),
    dsl: z.record(z.string(), z.unknown()).optional(),
    dslJson: z.string().optional(),
    ...assigneeScopeRequest,
    ...withReferencesRequest,
    paginationOpts: z.object({
      numItems: z.number().int().min(1).max(100),
      cursor: z.string().nullable(),
    }),
  }),
  "crm.sql": z.object({
    objectName: z.string(),
    dsl: z.record(z.string(), z.unknown()).optional(),
    dslJson: z.string().optional(),
  }),
  "crm.aggregate": z.object({
    objectName: z.string(),
    fieldName: z.string().describe("Field to bucket by."),
    sumField: z
      .string()
      .optional()
      .describe(
        "Number field to total per bucket (e.g. Amount grouped by Stage). Exact at any table size.",
      ),
  }),
  "crm.search.page": z.object({
    ...withReferencesRequest,
    text: z.string().describe("Full-text query over readable entries."),
    objectName: z.string().optional(),
    select: z.array(z.string().min(1)).min(1).max(30).optional(),
    selectionMode: z
      .enum(["strict", "compact"])
      .optional()
      .describe(
        "Defaults to strict. Explicit modes require objectName and select. Compact recovers unknown selected names with bounded canonical columns and explicit selectionFallback metadata in the same response. Does not guess aliases.",
      ),
    limit: z.coerce.number().int().min(1).max(100).optional(),
    cursor: z
      .string()
      .optional()
      .describe(
        "Use the preceding continueCursor, with the same query and projection.",
      ),
  }),
  "crm.search": z.object({
    ...withReferencesRequest,
    text: z.string().describe("Full-text query."),
    objectName: z.string().optional().describe("Omit to search org-wide."),
    limit: z.coerce.number().int().min(1).max(100).optional(),
  }),

  // CRM statuses
  "crm.statuses.list": z.object({ objectName: z.string() }),
  "crm.statuses.set": z.object({
    objectName: z.string(),
    statuses: z.array(
      z.object({
        name: z.string(),
        color: z.string().describe("Hex color."),
        sortOrder: z.number().optional(),
        isDefault: z.boolean().optional(),
      }),
    ),
  }),

  // CRM batch + transactions
  "crm.batch": z.object({
    ...withReferencesRequest,
    ops: z.array(crmOp).max(200),
    idempotencyKey: z.string().optional(),
  }),
  "crm.transaction.begin": z.object({}),
  "crm.transaction.add": z.object({ txnId: z.string(), op: crmOp }),
  "crm.transaction.commit": z.object({ txnId: z.string() }),
  "crm.transaction.abort": z.object({ txnId: z.string() }),
  "crm.transaction.inspect": z.object({ txnId: z.string() }),

  // CRM docs / actions / reports / enrich / members
  "crm.docs.list": noInput,
  "crm.members.list": noInput,
  "crm.docs.create": z.object({
    title: z.string(),
    filePath: z.string(),
    icon: z.string().optional(),
    coverImage: z.string().optional(),
    parentId: z.string().optional(),
    parentObjectName: z.string().optional(),
    entryId: z.string().optional(),
  }),
  "crm.docs.link": z.object({
    filePath: z.string(),
    objectName: z.string().optional(),
    entryId: z.string().optional(),
  }),
  "crm.docs.delete": z.object({
    documentId: z.string().describe("The id crm docs create returned."),
  }),
  "crm.actions.list": z.object({ entryId: z.string() }),
  "crm.actions.create": z
    .object({
      objectName: z.string(),
      fieldName: z.string(),
      actionId: z.string().optional(),
      label: z.string().optional(),
      variant: z.string().optional(),
      icon: z.string().optional(),
      confirmMessage: z.string().optional(),
      recipe: z.array(z.any()).optional(),
      script: z.string().optional(),
      scriptPath: z.string().optional(),
    })
    .passthrough(),
  "crm.actions.update": z
    .object({
      actionId: z.string(),
      objectName: z.string(),
      fieldName: z.string(),
      label: z.string().optional(),
      variant: z.string().optional(),
      icon: z.string().optional(),
      confirmMessage: z.string().optional(),
      recipe: z.array(z.any()).optional(),
      script: z.string().optional(),
      scriptPath: z.string().optional(),
    })
    .passthrough(),
  "crm.actions.delete": z
    .object({
      actionId: z.string(),
      objectName: z.string(),
      fieldName: z.string().optional(),
      fieldId: z.string().optional(),
      deleteFieldIfEmpty: z.boolean().optional(),
    })
    .passthrough(),
  "crm.actions.run": z.object({
    actionId: z.string(),
    objectName: z.string(),
    fieldId: z.string(),
    entryIds: z.array(z.string()),
    prompts: z.record(z.string(), z.string()).optional(),
  }),
  "crm.reports.generate": z.object({
    objectName: z.string(),
    type: reportType,
    groupByField: z.string(),
    metric: reportMetric.optional(),
    metricField: z
      .string()
      .optional()
      .describe(
        "Number field to sum/avg per bucket (e.g. Amount grouped by Stage). Defaults to the group field itself.",
      ),
  }),
  "crm.enrich.cell": z.object({
    objectName: z.string(),
    entryId: z.string(),
    fieldName: z.string(),
  }),
  "crm.enrich.object": z.object({
    objectName: z.string(),
    fieldName: z.string(),
    missingOnly: z
      .boolean()
      .optional()
      .describe("Only enrich empty cells. Defaults true."),
  }),
  "crm.people.search": peopleSearch,
  "crm.companies.search": companySearch,
  "enrichment.jobs.search": jobsSearch,
  "enrichment.search.preview": z
    .object({
      kind: z.enum(["people", "companies", "jobs"]).optional(),
    })
    .passthrough(),
  "enrichment.person": z
    .object({
      linkedinURL: z.string().optional(),
      linkedinID: z.string().optional(),
      email: z.string().optional(),
    })
    .passthrough(),
  "enrichment.company": z
    .object({
      website: z.string().optional(),
      linkedinURL: z.string().optional(),
      linkedinID: z.string().optional(),
    })
    .passthrough(),
  "enrichment.person.contact": z
    .object({
      contacts: z.array(z.record(z.string(), z.unknown())).min(1),
    })
    .passthrough(),
  "enrichment.profiles.bulk": z
    .object({
      kind: z.enum(["people", "companies"]),
      lookups: z
        .array(profileLookup)
        .min(1)
        .max(100)
        .describe(
          "Input order is preserved. Does not purchase contact data or write CRM records.",
        ),
    })
    .strict(),
  "enrichment.company.related": z
    .object({
      domain: z
        .string()
        .trim()
        .min(1)
        .optional()
        .describe(
          "Company domain. Provide exactly one of domain or linkedinUrl.",
        ),
      linkedinUrl: z
        .string()
        .url()
        .optional()
        .describe("Company LinkedIn URL. Omit when domain is provided."),
      kind: companyRelatedKind,
      limit: z
        .number()
        .int()
        .min(1)
        .max(100)
        .optional()
        .describe(
          "Records per page; defaults to 25. Keep unchanged when using pageToken.",
        ),
      pageToken: z
        .string()
        .min(1)
        .optional()
        .describe(
          "Opaque metadata.nextPageToken from this same company, kind, and page size.",
        ),
    })
    .strict(),

  // Email (sender identities, raw sends, templates, campaigns)
  "email.identity.verify": z.object({
    type: emailIdentityType,
    identity: z
      .string()
      .describe("Domain (example.com) or mailbox (founder@example.com)."),
    configurationSetName: z
      .string()
      .optional()
      .describe("Optional provider configuration set override."),
  }),
  "email.identity.create": z.object({
    type: emailIdentityType,
    domain: z
      .string()
      .optional()
      .describe("Lowercase domain; required when type is `domain`."),
    fromEmail: z.string().describe("Sender mailbox, e.g. founder@example.com."),
    fromName: z
      .string()
      .optional()
      .describe("Default display name for the sender."),
    replyToEmail: z.string().optional(),
    configurationSetName: z.string().optional(),
  }),
  "email.identity.refresh": z.object({
    identityId: z.string().describe("Sending identity id."),
  }),
  "email.identity.beginVerification": z.object({
    identityId: z
      .string()
      .describe("Sending identity id from `POST /email/sending-identities`."),
  }),
  "email.identity.status": z.object({
    identity: z.string().describe("Email address or domain to check."),
  }),
  "email.identity.list": z.object({
    domain: z.string().optional().describe("Filter identities by domain."),
  }),
  "email.identity.dns": z.object({
    identityId: z.string().describe("Sending identity id."),
  }),
  "email.identity.disable": z.object({
    identity: z
      .string()
      .describe(
        "Identity id, sender email, or domain (disables every sender on the domain).",
      ),
  }),
  "email.identity.restore": z.object({
    identity: z.string().describe("Identity id, sender email, or domain."),
  }),
  "email.identity.delete": z.object({
    identity: z
      .string()
      .describe(
        "Identity id, sender email, or domain (deletes every sender on the domain). Permanent: re-adding requires re-verification.",
      ),
  }),
  "email.send": z.object({
    fromEmail: z.string().describe("Verified sender mailbox."),
    fromName: z.string().optional().describe("Display name override."),
    to: z
      .array(emailAddress)
      .min(1)
      .describe("Primary recipients. to+cc+bcc is capped at 50."),
    cc: z.array(emailAddress).optional(),
    bcc: z.array(emailAddress).optional(),
    replyToEmail: z.string().optional(),
    subject: z.string(),
    htmlBody: z
      .string()
      .optional()
      .describe("HTML body. Provide htmlBody and/or textBody."),
    textBody: z.string().optional(),
    replyToMessageId: z
      .string()
      .optional()
      .describe(
        "Dench messageId or RFC 5322 Message-ID to thread this send as a reply.",
      ),
    configurationSetName: z.string().optional(),
  }),
  "email.message.get": z.object({
    messageId: z.string().describe("Raw email message id."),
  }),
  "email.message.list": z.object({
    limit: z.coerce.number().int().min(1).max(100).optional(),
    status: rawMessageStatus.optional(),
  }),
  "email.template.create": z.object({
    name: z.string(),
    subject: z.string().describe("Supports {{variable}} placeholders."),
    htmlBody: z.string().describe("HTML body with {{variable}} placeholders."),
    textBody: z.string().optional(),
    status: templateStatus.optional(),
  }),
  "email.template.preview": z.object({
    templateId: z.string(),
    data: z
      .record(z.string(), z.unknown())
      .optional()
      .describe("Personalization data for {{variable}} placeholders."),
  }),
  "email.campaign.create": z.object({
    name: z.string(),
    identityId: z
      .string()
      .describe("Sending identity id OR a verified from-email."),
    templateId: z.string(),
    scheduledAt: z
      .number()
      .optional()
      .describe("Epoch ms to start sending; omit to send on submit."),
    maxRecipients: z.number().optional(),
    batchSize: z.number().optional(),
    metadata: z.record(z.string(), z.unknown()).optional(),
  }),
  "email.campaign.get": z.object({ campaignId: z.string() }),
  "email.campaign.recipients.add": z.object({
    campaignId: z.string(),
    recipients: z
      .array(campaignRecipientInput)
      .max(500)
      .describe("Up to 500 recipients per call."),
  }),
  "email.campaign.preview": z.object({
    campaignId: z.string(),
    sample: z
      .number()
      .int()
      .optional()
      .describe("Number of rendered previews to return (default 5)."),
  }),
  "email.campaign.submit": z.object({
    campaignId: z.string(),
    approvalId: z
      .string()
      .optional()
      .describe(
        "Approval request id when workspace policy requires human sign-off.",
      ),
  }),
  "email.campaign.pause": z.object({ campaignId: z.string() }),
  "email.campaign.resume": z.object({ campaignId: z.string() }),
  "email.campaign.cancel": z.object({ campaignId: z.string() }),
  "email.campaign.list": z.object({
    limit: z.coerce.number().int().min(1).max(100).optional(),
    cursor: z.coerce.string().optional(),
    status: z.string().optional(),
  }),
  "email.campaign.recipients.list": z.object({
    campaignId: z.string(),
    limit: z.coerce.number().int().min(1).max(100).optional(),
    cursor: z.coerce.string().optional(),
    status: z.string().optional(),
    includePeople: z
      .boolean()
      .optional()
      .describe("Default true: attach each recipient's CRM record."),
  }),
  "email.sequence.enrollments.list": z.object({
    sequenceId: z.string(),
    limit: z.coerce.number().int().min(1).max(100).optional(),
    cursor: z.coerce.string().optional(),
    status: z.string().optional(),
  }),

  // Routines
  "cron.list": z.object({ enabledOnly: z.coerce.boolean().optional() }),
  "cron.history": z.object({
    limit: z.coerce.number().int().min(1).max(200).optional(),
  }),
  "cron.get": z.object({ jobId: z.string() }),
  "cron.create": z.object({
    name: z.string(),
    prompt: z.string().describe("Agent goal/message for each run."),
    schedule: scheduleSpec,
    description: z.string().optional(),
    overlapPolicy: overlapPolicy.optional(),
    enabled: z.boolean().optional(),
    deleteAfterRun: z.boolean().optional(),
    target: cronTarget.optional(),
  }),
  "cron.update": z.object({
    jobId: z.string(),
    name: z.string().optional(),
    prompt: z.string().optional(),
    schedule: scheduleSpec.optional(),
    description: z.string().optional(),
    overlapPolicy: overlapPolicy.optional(),
    enabled: z.boolean().optional(),
    deleteAfterRun: z.boolean().optional(),
    target: cronTarget.optional(),
  }),
  "cron.delete": z.object({ jobId: z.string() }),
  "cron.enable": z.object({ jobId: z.string() }),
  "cron.disable": z.object({ jobId: z.string() }),
  "cron.run": z.object({ jobId: z.string() }),
  "cron.runs": z.object({
    jobId: z.string(),
    limit: z.coerce.number().int().min(1).max(200).optional(),
  }),

  // Files
  "files.list": z.object({
    prefix: z.string().optional().describe("Directory path, defaults to /."),
    slug: z.string().optional(),
  }),
  "files.content": z.object({
    path: z
      .string()
      .describe(
        "Workspace file path, e.g. /reports/q2.md. A leading /workspace/ mount prefix is stripped.",
      ),
    slug: z.string().optional(),
  }),
  "files.write": z.object({
    path: z
      .string()
      .describe(
        "Workspace file path, e.g. /reports/q2.md. A leading /workspace/ mount prefix is stripped.",
      ),
    content: z.string().describe("Full replacement text (UTF-8, <= 400 KB)."),
    expectedPreviousHash: z
      .string()
      .optional()
      .describe(
        "contentHash from the last read; the write is rejected with version_mismatch if the file changed since.",
      ),
  }),
  "files.downloadUrl": z.object({ path: z.string() }),
  "files.delete": z.object({ path: z.string() }),
  "files.mkdir": z.object({ path: z.string() }),
  "files.move": z.object({
    from: z.string().describe("Source workspace path."),
    to: z.string().describe("Destination workspace path."),
  }),
  "files.stage": z.object({
    files: z
      .array(
        z.object({
          path: z.string(),
          text: z.string().optional(),
          base64: z.string().optional(),
        }),
      )
      .optional()
      .describe("Files to write. Each needs text or base64."),
    path: z.string().optional().describe("Single-file shortcut."),
    text: z.string().optional(),
    base64: z.string().optional(),
    lastModifiedBy: z.string().optional(),
  }),

  // Apps (App Store + app webhooks)
  "apps.list": noInput,
  "apps.gallery": noInput,
  "apps.create": z.object({
    slug: z.string().describe("Folder slug; becomes /apps/<slug>.dench.app."),
    name: z.string(),
    icon: z.string().optional().describe("Lucide icon name."),
    description: z.string().optional(),
  }),
  "apps.install": z.object({ listingId: z.string() }),
  "apps.publish": z.object({
    appPath: z.string().describe("Workspace path of the .dench.app folder."),
    slug: z.string(),
    name: z.string(),
    description: z.string().optional(),
    icon: z.string().optional(),
    visibility: z.enum(["org", "public", "official", "unlisted"]).optional(),
    version: z.string().optional(),
    permissions: z.array(z.string()).optional(),
  }),
  "apps.uninstall": z.object({ slug: z.string() }),
  "apps.setEnabled": z.object({ slug: z.string(), enabled: z.boolean() }),
  "apps.setPinned": z.object({ slug: z.string(), pinned: z.boolean() }),
  "apps.webhooks.register": z.object({
    slug: z.string().describe("Installed app slug."),
    hookName: z
      .string()
      .regex(/^[a-z0-9][a-z0-9_-]{0,63}$/i)
      .describe("Hook name, e.g. `stripe` or `github-push`."),
  }),
  "apps.webhooks.list": z.object({ slug: z.string() }),
  "apps.webhooks.poll": z.object({
    slug: z.string(),
    hookName: z.string(),
    since: z.coerce
      .number()
      .optional()
      .describe("Only events received after this epoch ms."),
    limit: z.coerce.number().int().min(1).max(200).optional(),
  }),
  "apps.webhooks.delete": z.object({ slug: z.string(), hookName: z.string() }),

  // Agent config
  "agentConfig.identity.show": noInput,
  "agentConfig.organisation.show": noInput,
  "agentConfig.user.show": noInput,
  "agentConfig.tools.show": noInput,
  "agentConfig.mem.show": noInput,
  "agentConfig.bootstrap.show": noInput,
  "agentConfig.daily.today": noInput,
  "agentConfig.identity.edit": z.object({ content: z.string() }),
  "agentConfig.organisation.edit": z.object({ content: z.string() }),
  "agentConfig.user.edit": z.object({ content: z.string() }),
  "agentConfig.tools.edit": z.object({ content: z.string() }),
  "agentConfig.mem.edit": z.object({
    content: z.string(),
    append: z.boolean().optional(),
  }),
  "agentConfig.bootstrap.complete": z.object({
    completed: z.boolean().optional(),
  }),
  "agentConfig.bootstrap.template": z.object({ content: z.string() }),
  "agentConfig.model.default": z.object({
    modelId: z.string().nullable().describe("Model id, or null to clear."),
  }),
  "agentConfig.model.thread": z.object({
    threadId: z.string(),
    modelId: z.string().nullable(),
  }),
  // `{date}` in the path is decorative: the backend returns the full agent
  // config and the caller derives the daily file path for that date. Strict
  // parsing must drop the segment so getAgentConfig never sees it.
  "agentConfig.daily.show": z.object({}),

  // Gateway: search + images + tools
  "integrations.list": noInput,
  "tool.status": noInput,
  "search.web": exaSearch,
  "search.contents": exaContents,
  "search.answer": exaAnswer,
  "image.generate": imageGenerate,
  "image.edit": imageEdit,
  "tool.connect": composioConnect,
  "tool.search": composioToolSearch,
  "tool.run": composioToolRun,
  "tool.disconnect": z.object({ connectionId: z.string() }),
  "tool.label.set": z.object({
    connectionId: z.string(),
    displayName: z
      .string()
      .describe("Human name for the account. Empty clears it."),
  }),

  // Notifications
  "notifications.list": z.object({
    filter: z.enum(["inbox", "unread", "archived", "all"]).optional(),
    limit: z.coerce.number().int().min(1).max(100).optional(),
  }),
  "notifications.unreadCount": noInput,
  "notifications.read": z.object({
    notificationId: z.string(),
    read: z
      .boolean()
      .optional()
      .describe("Defaults to true; false marks unread."),
  }),
  "notifications.readAll": noInput,
  "notifications.archive": z.object({ notificationId: z.string() }),
  "settings.sync.get": noInput,
  "settings.sync.update": syncSettingsPatchShape,
  "notifications.preferences.get": noInput,
  "notifications.preferences.update": z.object({
    inAppEnabled: z.boolean().optional(),
    emailEnabled: z.boolean().optional(),
    perKind: z
      .record(
        z.string(),
        z.object({
          inApp: z.boolean().optional(),
          email: z.boolean().optional(),
        }),
      )
      .optional(),
    timezone: z.string().optional(),
    digestWindowMinutes: z.number().int().optional(),
    maxEmailsPerDay: z.number().int().optional(),
  }),
  "crm.analytics.get": z.object({
    objectName: z.string(),
    viewName: z
      .string()
      .optional()
      .describe(
        "Also return this saved view's own dashboard (viewAnalytics) when it has one.",
      ),
  }),
  "crm.analytics.compute": z.object({
    objectName: z.string(),
    viewName: z
      .string()
      .optional()
      .describe(
        "Compute the saved view's own dashboard instead of the object's (ignored when the view inherits).",
      ),
    panelIds: z
      .array(z.string())
      .optional()
      .describe("Only these stored panels."),
    panels: z
      .array(adHocAnalyticsPanel)
      .optional()
      .describe(
        "Ad-hoc panel definitions to compute instead of the stored dashboard (nothing is persisted). id/title/metric/sortOrder are filled in when omitted.",
      ),
    period: analyticsPeriod.optional(),
    extraFilters: z
      .record(z.string(), z.unknown())
      .optional()
      .describe(
        "FilterGroup applied to every panel (e.g. the view's rules). Forces the bounded scan path.",
      ),
    compareFilters: z
      .record(z.string(), z.unknown())
      .optional()
      .describe(
        "FilterGroup for the comparison window; every panel's value over it comes back as previousValue. Derived automatically from `period`.",
      ),
    fieldRolesOverride: analyticsFieldRoles
      .optional()
      .describe("Preview an unsaved role mapping."),
    ...assigneeScopeRequest,
    drillFilters: z
      .array(
        z.object({
          dimension: z
            .string()
            .describe(
              "The bare field the click came from — a panel's groupBy or dateField, or `$location` for a map. Panels drawn along it keep their full picture; every other panel is scoped.",
            ),
          filter: z
            .record(z.string(), z.unknown())
            .describe("FilterGroup selecting the clicked bucket."),
        }),
      )
      .optional()
      .describe(
        "Click-to-filter chips, same as the strip: each scopes every panel EXCEPT those whose dimensions include `dimension`.",
      ),
  }),
  "crm.analytics.save": z.object({
    objectName: z.string(),
    panelId: z.string().describe("Panel id (path); becomes panel.id."),
    panel: analyticsPanel
      .omit({ id: true })
      .extend({ id: z.string().optional() })
      .describe("The panel definition to upsert."),
    viewName: z
      .string()
      .optional()
      .describe(
        "Write the saved view's own dashboard (forks a copy if it was inheriting).",
      ),
  }),
  "crm.analytics.update": z.object({
    objectName: z.string(),
    panelId: z.string().describe("Stored panel id (path)."),
    patch: analyticsPanelPatch,
    viewName: z
      .string()
      .optional()
      .describe(
        "Edit the saved view's own dashboard (forks a copy if it was inheriting).",
      ),
  }),
  "crm.analytics.hide": z.object({
    objectName: z.string(),
    panelId: z.string(),
    viewName: z.string().optional(),
  }),
  "crm.analytics.show": z.object({
    objectName: z.string(),
    panelId: z.string(),
    viewName: z.string().optional(),
  }),
  "crm.analytics.resize": z.object({
    objectName: z.string(),
    panelId: z.string(),
    span: z
      .union([z.literal(2), z.literal(3), z.literal(4), z.literal(6)])
      .nullable()
      .describe(
        "2 = third, 3 = half, 4 = two thirds, 6 = full row; null = the chart kind's default.",
      ),
    viewName: z.string().optional(),
  }),
  "crm.analytics.delete": z.object({
    objectName: z.string(),
    panelId: z.string(),
    viewName: z.string().optional(),
  }),
  "crm.analytics.reorder": z.object({
    objectName: z.string(),
    panelIds: z
      .array(z.string())
      .describe("Every stored panel id of the targeted dashboard, in order."),
    viewName: z.string().optional(),
  }),
  "crm.analytics.roles": z.object({
    objectName: z.string(),
    fieldRoles: analyticsFieldRolesPatch,
    merge: z
      .boolean()
      .optional()
      .describe(
        "true: change only the keys given (null clears one). Default replaces the whole mapping.",
      ),
  }),
  "crm.analytics.collapse": z.object({ objectName: z.string() }),
  "crm.analytics.expand": z.object({ objectName: z.string() }),
  "crm.analytics.scope": z.object({
    objectName: z.string(),
    viewName: z.string(),
    mode: z
      .enum(["own", "shared"])
      .describe(
        '"own": the view gets its own dashboard (a copy of the object\'s panels); "shared": it shows the object\'s again.',
      ),
  }),
};

// ---------------------------------------------------------------------------
// Response schemas keyed by operation id (representative subset)
// ---------------------------------------------------------------------------

export const responseSchemas: Record<string, ZodTypeAny> = {
  "lists.save": z.object({
    artifactId: z.string(),
    filePath: z.string(),
    rowCount: z.number(),
    previewRows: z.array(z.unknown()),
    title: z.string(),
    createdFrom: z.string(),
  }),
  "lists.update": z.object({
    artifactId: z.string(),
    rowCount: z.number(),
    previewRows: z.array(z.unknown()),
    title: z.string(),
  }),
  "campaigns.drafts.create": z.object({
    sequenceId: z.string(),
    ...optionalWorkspaceReferenceFields,
  }),
  "campaigns.audience.search": campaignSearchPage,
  "campaigns.people.addBatch": campaignBatchResult,
  "campaigns.people.addFromSearch": campaignSearchPage
    .merge(campaignBatchResult)
    .extend({ found: z.number(), skippedSearchProfiles: z.number() }),
  "campaigns.sources.get": z.record(z.string(), z.unknown()).nullable(),
  "campaigns.sources.signals": z.record(z.string(), z.unknown()).nullable(),
  "campaigns.sources.update": z.null(),
  "campaigns.sources.preview": z.object({ ok: z.boolean() }).passthrough(),
  "campaigns.sources.run": z.null(),
  "campaigns.sources.overview": z.record(z.string(), z.unknown()),
  "campaigns.sources.pending": z.array(z.record(z.string(), z.unknown())),
  "campaigns.sources.review": z.record(z.string(), z.unknown()),
  "campaigns.queue": z.record(z.string(), z.unknown()).nullable(),
  "campaigns.builder.profile": z
    .object({ hasProfile: z.boolean(), targeting: campaignTargeting })
    .passthrough(),
  "campaigns.builder.save": z.object({ draftId: z.string() }),
  "campaigns.builder.get": z
    .object({
      status: z.string(),
      targeting: campaignTargeting,
      signals: z.array(campaignSignal),
      people: z.array(z.record(z.string(), z.unknown())),
    })
    .passthrough(),
  "campaigns.builder.build": z.object({
    ok: z.boolean(),
    started: z.boolean(),
  }),
  "campaigns.builder.create": z.object({
    sequenceId: z.string(),
    enrolled: z.number(),
  }),
  "campaigns.builder.opener": z.null(),
  "campaigns.builder.drafts": z.array(z.record(z.string(), z.unknown())),
  "campaigns.builder.resume": z
    .object({
      clientRequestId: z.string(),
      status: z.string(),
      targeting: campaignTargeting,
      signals: z.array(campaignSignal),
    })
    .passthrough()
    .nullable(),
  "campaigns.builder.discard": z.null(),
  "campaigns.builder.outreach": z.null(),
  "campaigns.builder.sequence": z.record(z.string(), z.unknown()),
  "campaigns.builder.lookalike": z.record(z.string(), z.unknown()),
  "campaigns.builder.voices": z.record(z.string(), z.unknown()),
  "campaigns.builder.autofill": z
    .object({ targeting: campaignTargeting })
    .passthrough(),
  "campaigns.builder.estimate": z
    .object({ count: z.number().nullable() })
    .passthrough(),
  // Meta
  // Outreach campaigns (dench campaign)
  "campaigns.accounts.linkedin": z.array(campaignLinkedinSenderSummary),
  "campaigns.accounts.email": z.array(campaignMailboxSummary),
  "campaigns.list": referenceListResponse(campaignRow),
  "campaigns.create": z.object({
    sequenceId: z.string(),
    ...optionalWorkspaceReferenceFields,
  }),
  "campaigns.duplicate": z.object({
    ...optionalWorkspaceReferenceFields,
    sequenceId: z
      .string()
      .describe("The new draft. Rename it with campaigns.update."),
  }),
  "campaigns.get": z
    .object({
      ...optionalWorkspaceReferenceFields,
      sequence: campaignRow,
      steps: z
        .array(campaignStepInput.passthrough())
        .describe(
          "The steps in order, each with its _id. condition and wait_for_connection steps also carry a readable label.",
        ),
      enrollments: z.array(z.record(z.string(), z.unknown())),
      currentRuns: z
        .record(z.string(), z.unknown())
        .describe(
          "enrollmentId -> the step run in progress, its hold and LinkedIn action.",
        ),
      lastTouches: z.record(
        z.string(),
        z.object({ type: z.string(), at: z.number() }),
      ),
      connectedEntries: z
        .record(z.string(), z.unknown())
        .describe("enrollmentId -> linked CRM record and lead status."),
      connectedFieldNames: z.array(z.string()),
      isOwner: z.boolean(),
    })
    .passthrough()
    .nullable(),
  "campaigns.analytics": z
    .object({
      audience: z.number(),
      contacted: z.number(),
      linkedinInvited: z.number(),
      linkedinConnected: z.number(),
      linkedinMessaged: z.number(),
      linkedinReplied: z.number(),
      active: z.number(),
      paused: z.number(),
      finished: z.number(),
      replied: z.number(),
      failed: z.number(),
      stopped: z.number(),
      emailSent: z.number(),
      opened: z.number(),
      clicked: z.number(),
      linkedinSent: z.number(),
      replyRate: z.number(),
      openRate: z.number(),
      clickRate: z.number(),
      branchStats: z
        .array(
          z.object({
            stepId: z.string(),
            yes: z
              .number()
              .describe("People who took the Yes (Accepted) path."),
            no: z
              .number()
              .describe("People who took the No (Not accepted) path."),
          }),
        )
        .optional()
        .describe(
          "Workflows only: each condition and wait_for_connection step, in step order, with how many people took each path.",
        ),
      truncated: z.boolean(),
    })
    .passthrough(),
  "campaigns.live": z
    .object({
      status: campaignStatus,
      usesEmail: z.boolean(),
      usesLinkedin: z.boolean(),
      emailsToday: z.number(),
      dailySendCap: z.number().nullable(),
      nextEmailAt: z.number().nullable(),
      now: z.record(z.string(), z.unknown()).nullable(),
      next: z
        .object({
          kind: z
            .string()
            .describe(
              "profile, visit, invite, message, like, inmail, withdraw, email, wait or check (an If / else).",
            ),
          acceptanceDeadline: z
            .number()
            .optional()
            .describe(
              "Waiting for them to accept: when the wait ends either way.",
            ),
          label: z
            .string()
            .optional()
            .describe(
              'kind check: what the If / else checks, e.g. "Has an email address".',
            ),
        })
        .passthrough()
        .nullable(),
      paused: z.record(z.string(), z.unknown()).nullable(),
      senders: z.array(z.record(z.string(), z.unknown())),
    })
    .passthrough(),
  "campaigns.update": okResponse,
  "campaigns.steps.replace": z.object({
    ok: z.boolean(),
    stepCount: z.number(),
  }),
  "campaigns.steps.update": z.object({
    ok: z.boolean(),
    stepCount: z.number().describe("How many steps were edited."),
  }),
  "campaigns.personalization.get": z
    .object({
      template: campaignLineTemplate
        .extend({ version: z.number(), updatedAt: z.number() })
        .passthrough()
        .nullable(),
      counts: z.object({
        done: z.number(),
        pending: z.number(),
        failed: z.number(),
        total: z.number(),
      }),
      paused: z.boolean(),
      notice: z
        .object({ code: z.literal("insufficient_credits"), at: z.number() })
        .nullable(),
      suggestedContext: z.object({ sells: z.string().optional() }),
      estimatedCentsPerPerson: z.number(),
      eligible: z.number(),
    })
    .passthrough(),
  "campaigns.personalization.set": campaignLineBackfill,
  "campaigns.personalization.clear": campaignLineBackfill,
  "campaigns.personalization.write": campaignLineBackfill,
  "campaigns.personalization.edit": okResponse,
  "campaigns.personalization.rewrite": z.object({
    queued: z
      .boolean()
      .describe("False when new lines are already being written."),
  }),
  "campaigns.people.addFromCrm": campaignEnrollResult,
  "campaigns.people.add": z.object({ enrollmentId: z.string() }),
  "campaigns.preview": campaignMessagePreview,
  "campaigns.launch.preview": campaignReadiness,
  "campaigns.launch": z.object({
    ok: z.boolean(),
    status: z.literal("active"),
  }),
  "campaigns.pause": okResponse,
  "campaigns.resume": okResponse,
  "campaigns.archive": okResponse,
  "campaigns.events": z
    .object({
      page: z.array(z.record(z.string(), z.unknown())),
      isDone: z.boolean(),
      continueCursor: z.string(),
    })
    .passthrough(),
  "campaigns.people.stop": okResponse,
  "campaigns.people.resume": okResponse,
  "campaigns.people.sync": z.object({
    updated: z
      .number()
      .describe("How many people gained a detail from their CRM record."),
  }),
  "campaigns.people.resumeAll": z.object({
    resumed: z.number().describe("How many paused people were resumed."),
  }),
  "campaigns.people.setEmail": okResponse,
  "campaigns.people.setLinkedin": okResponse,
  "campaigns.people.setField": okResponse,
  "campaigns.pipeline": z
    .object({
      total: z.number().describe("People in the campaign."),
      statuses: z
        .array(
          z.object({
            name: z.string().describe("A lead Status, as named in the CRM."),
            color: z.string(),
            count: z.number().describe("Enrolled leads at this Status."),
          }),
        )
        .describe("The workspace's lead Statuses, in pipeline order."),
      other: z
        .number()
        .describe("People with no lead, or a Status outside the pipeline."),
    })
    .nullable(),
  "campaigns.people.forRecord": z.array(campaignMembership),
  "campaigns.people.timeline": campaignPersonTimeline,
  "campaigns.people.remove": okResponse,

  "commands.list": z.object({
    operations: z.array(
      z.object({
        id: z.string(),
        group: z.string(),
        summary: z.string(),
        cli: z.string(),
        aliases: z.array(z.string()),
        method: z.string(),
        path: z.string(),
        backend: z.enum(["api", "gateway", "custom", "local"]),
        deprecated: z.boolean(),
      }),
    ),
  }),

  // Auth
  "auth.signin.create": z.object({
    status: z.literal("pending"),
    expiresAt: z.number().describe("Epoch ms when the sign-in code expires."),
  }),
  "auth.signin.poll": z.object({
    status: z.enum(["pending", "approved", "rejected", "expired"]),
    organization: organizationRef.optional().describe("Present once approved."),
    agent: agentRef.optional(),
    sessionExpiresAt: z.number().optional(),
  }),
  "auth.otp.start": okResponse,
  "auth.otp.verify": z.object({
    ok: z.boolean(),
    result: z.union([
      z.object({
        kind: z.literal("completed"),
        organization: organizationRef.optional(),
        sessionExpiresAt: z.number().optional(),
      }),
      z.object({
        kind: z.literal("requiresOrgChoice"),
        authToken: z
          .string()
          .describe("Pass to /auth/otp/finalize with the chosen org."),
        organizations: z.array(organizationRef),
        expiresAt: z.number(),
      }),
    ]),
  }),
  "auth.otp.finalize": z.object({
    ok: z.boolean(),
    result: z.object({
      organization: organizationRef.optional(),
      sessionExpiresAt: z.number().optional(),
    }),
  }),

  // Workspace orientation
  "workspace.context.sections": z.object({}).passthrough(),
  "email.inbox.search": inboxPage,
  "email.inbox.thread": inboxPage,
  "email.inbox.message": z.object({
    header: inboxHeader,
    coverage: inboxCoverage,
    body: z.object({
      format: z.enum(["text", "html"]),
      content: z.string(),
      truncated: z.boolean(),
      totalBytes: z.number(),
    }),
    recipients: z.object({
      to: z.array(nativeEmailRecipient),
      cc: z.array(nativeEmailRecipient),
      bcc: z.array(nativeEmailRecipient),
      truncated: z.boolean(),
    }),
  }),
  "email.drafts.create": nativeEmailReceipt,
  "email.drafts.get": nativeEmailReceipt,
  "email.drafts.update": nativeEmailReceipt,
  "email.drafts.send": nativeEmailReceipt,
  "email.native.send": nativeEmailReceipt,
  "email.drafts.senders": z.array(z.object({}).passthrough()),
  "email.drafts.upload": nativeEmailAttachment,
  "email.drafts.signature": z.object({}).passthrough(),
  "workspace.context": workspaceStatusPayload,
  "workspace.instructions": workspaceInstructionsResponse,
  "workspace.status": workspaceStatusPayload,
  "workspace.agents": workspaceStatusPayload,
  "workspace.approvals.list": workspaceStatusPayload,
  "workspace.artifacts.list": z.array(artifactRow),
  "workspace.suggestedWork.list": z.array(artifactRow),

  // Memory + approvals
  "memory.search": z.array(memoryDoc),
  "memory.save": z.object({
    ok: z.boolean(),
    memoryId: z.string(),
    status: z.enum(["active", "needs_review", "archived"]),
  }),
  "approval.request": z.object({ ok: z.boolean(), approvalId: z.string() }),
  "approval.decide": z.union([
    z.object({
      ok: z.literal(true),
      status: approvalDecision,
    }),
    z.object({
      ok: z.literal(false),
      code: z.string().describe("e.g. approval_not_pending."),
      error: z.string(),
    }),
  ]),

  // Billing
  "billing.status": billingStatusResponse,
  "billing.topup": z.union([
    z
      .object({ charged: z.literal(true), amountCents: z.number() })
      .describe("Saved card charged directly."),
    z
      .object({ url: z.string().nullable() })
      .describe("Stripe Checkout link to complete the top-up."),
  ]),
  "billing.upgrade": z.union([
    z
      .object({
        updated: z.literal(true),
        tier: z.string(),
        billingCycle: z.string().optional(),
        stripeSubscriptionId: z.string(),
      })
      .describe("Existing subscription updated in place."),
    z
      .object({ url: z.string().nullable() })
      .describe("Stripe Checkout link to complete the upgrade."),
  ]),

  // Chat
  "chat.list": z.array(chatThreadRow),
  "chat.search": z.array(
    z.object({
      threadId: z.string(),
      threadTitle: z.string(),
      messageId: z.string(),
      role: z.enum(["user", "assistant", "system"]),
      snippet: z.string(),
      createdAt: z.number(),
      runId: z.string().nullable(),
    }),
  ),
  "chat.read": z.object({
    thread: chatThreadRow,
    messages: z.array(
      z.object({
        id: z.string(),
        role: z.enum(["user", "assistant", "system"]),
        createdAt: z.number(),
        updatedAt: z.number(),
        text: z.string(),
        runId: z.string().nullable(),
        status: z
          .enum(["streaming", "complete", "error", "canceled"])
          .nullable(),
        revision: z.number(),
        isDraft: z.boolean(),
      }),
    ),
  }),
  "chat.tree": z
    .array(chatThreadRow)
    .describe("Flat thread rows; parentThreadId encodes the hierarchy."),
  "chat.rename": z.object({
    results: z.array(
      z.object({
        threadId: z.string(),
        ok: z.boolean(),
        error: z.string().optional(),
      }),
    ),
    succeeded: z.number(),
    failed: z.number(),
  }),
  "chat.delete": z.object({
    scheduled: z.number(),
    rejected: z.array(
      z.object({
        threadId: z.string(),
        reason: z.string().describe("e.g. automated_thread_protected."),
        message: z.string().optional(),
      }),
    ),
    total: z.number(),
  }),
  "chat.new": chatSpawnResponse,
  "chat.send": chatSpawnResponse,
  "chat.follow": z
    .string()
    .describe(
      "text/event-stream of UI message chunks (text-delta, tool calls, finish).",
    ),

  // CRM objects
  "crm.objects.list": referenceListResponse(crmObjectDoc),
  "crm.objects.listCompact": z.array(
    z.object({
      _id: z.string(),
      name: z.string(),
      displayName: z.string(),
      description: z.string().optional(),
      entryCount: z.number().nullable(),
      countScope: z.enum(["workspace", "private_unknown"]),
      visibility: z.enum(["workspace", "owner_only", "owner_plus_members"]),
      archived: z.boolean(),
    }),
  ),
  "crm.objects.get": crmObjectDoc
    .extend(optionalWorkspaceReferenceFields)
    .nullable(),
  "crm.objects.create": z.object({
    id: z.string(),
    fields: z
      .array(z.object({ id: z.string(), name: z.string() }))
      .optional()
      .describe("The fields created from `fields`, in order."),
    ...optionalWorkspaceReferenceFields,
  }),
  "crm.objects.update": okResponse,
  "crm.objects.rename": okResponse,
  "crm.objects.delete": okResponse,
  "crm.objects.archive": okResponse,
  "crm.objects.unarchive": okResponse,

  // The workspace app rail
  "crm.sidebar.list": z.object({
    visible: z.array(z.record(z.string(), z.unknown())),
    hidden: z.array(z.record(z.string(), z.unknown())),
  }),
  "crm.sidebar.move": z.object({
    ok: z.boolean(),
    navId: z.string(),
    /** 1-based slot the row landed in, or null when the move was refused. */
    position: z.number().nullable(),
    visibleOrder: z.array(z.string()).optional(),
    error: z.string().optional(),
  }),

  // CRM saved views
  "crm.views.list": z.object({
    objectName: z.string(),
    activeView: z.string().nullable(),
    views: z.array(z.record(z.string(), z.unknown())),
  }),
  "crm.views.get": z.record(z.string(), z.unknown()),
  "crm.views.create": z.object({
    ok: z.boolean(),
    objectName: z.string(),
    viewName: z.string(),
    replaced: z.boolean(),
    activeView: z.string().nullable(),
  }),
  "crm.views.update": z.object({
    ok: z.boolean(),
    objectName: z.string(),
    viewName: z.string(),
    replaced: z.boolean(),
    activeView: z.string().nullable(),
  }),
  "crm.views.delete": z.object({
    ok: z.boolean(),
    objectName: z.string(),
    viewName: z.string(),
    removed: z.boolean(),
  }),
  "crm.views.archive": okResponse,
  "crm.views.unarchive": okResponse,

  // CRM fields
  "crm.fields.list": z.array(crmFieldDoc),
  "crm.fields.listCompact": z.array(
    z.object({
      _id: z.string(),
      name: z.string(),
      type: z.string(),
      required: z.boolean(),
      readOnly: z.boolean(),
      defaultValue: z.string().optional(),
      enumValues: z.array(z.string()).optional(),
      enumMultiple: z.boolean(),
      relatedObjectId: z.string().optional(),
      relationshipType: z.string().optional(),
    }),
  ),
  "crm.fields.create": z.object({ id: z.string() }),
  "crm.fields.update": okResponse,
  "crm.fields.delete": okResponse,
  "crm.fields.reorder": okResponse,
  "crm.fields.enum.reorder": z.object({
    ok: z.boolean(),
    enumValues: z.array(z.string()),
    enumColors: z.array(z.string()).nullable(),
  }),
  "crm.fields.enum.add": z.object({
    ok: z.boolean(),
    enumValues: z.array(z.string()),
    enumColors: z.array(z.string()),
    inserted: z.boolean(),
  }),
  "crm.fields.enum.remove": z.object({
    ok: z.boolean(),
    enumValues: z.array(z.string()),
    enumColors: z.array(z.string()).nullable(),
    removed: z.boolean(),
  }),
  "crm.fields.enum.rename": z.object({
    ok: z.boolean(),
    enumValues: z.array(z.string()),
    enumColors: z.array(z.string()),
    entriesUpdated: z.number(),
  }),
  "crm.fields.enum.color": z.object({
    ok: z.boolean(),
    enumColors: z.array(z.string()),
  }),

  // CRM entries + cells
  "crm.entries.list": referenceListResponse(crmEntryShape),
  "crm.views.entries": z
    .object({
      entries: z
        .array(z.record(z.string(), z.unknown()))
        .describe(
          "Materialized rows: id, entry_id, created_at, updated_at plus one key per field.",
        ),
      totalCount: z.number(),
      page: z.number(),
      pageSize: z.number(),
      truncated: z
        .boolean()
        .describe(
          "True when the read hit a server budget and rows may be missing.",
        ),
      assigneeScope: assigneeScopeResponse,
    })
    .passthrough()
    .describe(
      "The same payload the workspace table renders from (fields, statuses, savedViews, …).",
    ),
  "crm.entries.get": crmEntryShape
    .extend(optionalWorkspaceReferenceFields)
    .nullable(),
  "crm.entries.create": entryWriteResponse,
  "crm.entries.createMany": z.object({
    ...optionalWorkspaceReferenceFields,
    results: z.array(z.object({ entryId: z.string() })),
    count: z.number(),
  }),
  "crm.entries.update": entryWriteResponse,
  "crm.entries.updateMany": crmBatchResults,
  "crm.entries.delete": okResponse,
  "crm.entries.bulkDelete": z.object({ count: z.number() }),
  "crm.cells.get": cellValue,
  "crm.cells.set": entryWriteResponse,
  "crm.cells.setMany": z.object({
    results: z.array(z.object({ entryId: z.string() })),
    count: z.number(),
  }),
  "crm.cells.append": entryWriteResponse,

  // CRM comments + tasks
  "crm.comments.list": commentPage.extend({
    page: z.array(commentShape.extend({ replies: z.array(commentShape) })),
  }),
  "crm.comments.replies": commentPage,
  "crm.comments.get": commentShape.extend({
    objectName: z.string(),
    entryLabel: z.string(),
  }),
  "crm.comments.create": z.object({
    id: z.string(),
    rootCommentId: z.string().optional(),
    depth: z.number(),
    mentionedUserIds: z.array(z.string()),
    mentionsDench: z.boolean(),
  }),
  "crm.comments.update": z.object({
    ok: z.boolean(),
    newlyMentioned: z.array(z.string()),
  }),
  "crm.comments.delete": z.object({ ok: z.boolean(), tombstoned: z.boolean() }),
  "crm.comments.react": z.object({
    reacted: z.boolean(),
    reactionSummary: z.array(
      z.object({ emoji: z.string(), count: z.number() }),
    ),
  }),
  "crm.watch.get": z.object({
    watching: z.boolean(),
    reason: z.string().optional(),
    watcherCount: z.number(),
  }),
  "crm.watch.set": z.object({ watching: z.boolean() }),
  "crm.tasks.mine": z.array(z.object({}).passthrough()),
  "crm.tasks.forEntry": z.array(z.object({}).passthrough()),
  "crm.tasks.createForEntry": z.object({}).passthrough(),
  "crm.tasks.complete": z.object({}).passthrough(),
  "crm.tasks.reopen": z.object({}).passthrough(),
  "crm.tasks.setPriority": z.object({}).passthrough(),
  "crm.tasks.subtasks.list": z.array(z.object({}).passthrough()),
  "crm.tasks.subtasks.create": z.object({}).passthrough(),
  "crm.tasks.setParent": z.object({}).passthrough(),
  "crm.tasks.delete": z.object({}).passthrough(),
  "crm.tasks.repeat.get": z.object({}).passthrough().nullable(),
  "crm.tasks.repeat.set": z.object({}).passthrough().nullable(),
  "crm.tasks.repeat.clear": z.null(),
  "crm.tasks.repeat.skip": z.object({}).passthrough(),
  "crm.tasks.repeat.pause": z.null(),
  "crm.tasks.repeat.resume": z.null(),
  "crm.tasks.series.list": z.array(z.object({}).passthrough()),
  "crm.tasks.series.occurrences": z.array(z.object({}).passthrough()),

  // Notifications
  "notifications.list": z.array(notificationShape),
  "notifications.unreadCount": z.number(),
  "notifications.read": okResponse,
  "notifications.readAll": z.object({ ok: z.boolean(), patched: z.number() }),
  "notifications.archive": okResponse,
  "notifications.preferences.get": notificationPreferencesShape.nullable(),
  "notifications.preferences.update": okResponse,

  // Workspace settings
  "settings.sync.get": syncSettingsShape,
  "settings.sync.update": syncSettingsShape,

  // CRM query + search
  "crm.query": referenceListResponse(
    z.record(z.string(), z.unknown()),
  ).describe(
    "Entry rows. With dsl.select the rows are flat {_id, ...selectedFields} objects instead.",
  ),
  "crm.sql": z
    .array(crmEntryShape)
    .describe(
      "Entry rows. With dsl.select the rows are flat {_id, ...selectedFields} objects instead.",
    ),
  "crm.aggregate": z.array(
    z.object({
      key: z.string(),
      count: z.number(),
      sumNumber: z.number().optional(),
    }),
  ),
  "crm.search.page": z.object({
    ...optionalWorkspaceReferenceFields,
    page: z.array(
      z.object({ _id: z.string(), objectId: z.string(), data: fieldsMap }),
    ),
    isDone: z.boolean(),
    continueCursor: z.string().nullable(),
    returnedCount: z.number(),
    selectedFields: z.array(z.string()).nullable(),
    selectionFallback: z
      .object({
        mode: z.literal("compact"),
        requestedFields: z.array(z.string()),
        unresolvedFields: z.array(z.string()),
        availableFields: z.array(
          z.object({ name: z.string(), type: z.string() }),
        ),
        availableFieldCount: z.number(),
        schemaTruncated: z.boolean(),
        omittedFieldCount: z.number(),
        truncatedValues: z.array(
          z.object({ entryId: z.string(), fields: z.array(z.string()) }),
        ),
      })
      .optional()
      .describe(
        "Present only when compact mode recovered unknown selected fields. selectedFields and row keys use actual canonical names; unresolved names are never fabricated as empty cells. Truncated values are previews, not complete cell values.",
      ),
    completeness: z.literal("page"),
  }),
  "crm.search": referenceListResponse(
    z
      .object({
        _id: z.string(),
        _creationTime: z.number(),
        objectId: z.string(),
        data: fieldsMap,
        sortOrder: z.number(),
        createdAt: z.number(),
        updatedAt: z.number(),
        updatedBy: z.string(),
      })
      .passthrough(),
  ),

  // CRM statuses, batch, transactions
  "crm.statuses.list": z.array(
    z
      .object({
        _id: z.string(),
        _creationTime: z.number(),
        objectId: z.string(),
        name: z.string(),
        color: z.string(),
        sortOrder: z.number(),
        isDefault: z.boolean(),
      })
      .passthrough(),
  ),
  "crm.statuses.set": okResponse,
  "crm.batch": crmBatchResults,
  "crm.transaction.begin": z.object({ txnId: z.string() }),
  "crm.transaction.add": okResponse,
  "crm.transaction.commit": crmBatchResults,
  "crm.transaction.abort": okResponse,
  "crm.transaction.inspect": z
    .object({
      _id: z.string(),
      _creationTime: z.number(),
      status: z.enum(["open", "committed", "aborted"]),
      ops: z.array(z.record(z.string(), z.unknown())).optional(),
      results: z.array(z.record(z.string(), z.unknown())).optional(),
      committedAt: z.number().optional(),
      createdAt: z.number(),
      updatedAt: z.number(),
    })
    .passthrough()
    .nullable(),

  // CRM docs, actions, members, reports, enrichment
  "crm.docs.list": z.array(
    z
      .object({
        _id: z.string(),
        _creationTime: z.number(),
        title: z.string(),
        icon: z.string().optional(),
        coverImage: z.string().optional(),
        filePath: z.string(),
        parentId: z.string().optional(),
        parentObjectId: z.string().optional(),
        entryId: z.string().optional(),
        sortOrder: z.number(),
        isPublished: z.boolean(),
        createdAt: z.number(),
        updatedAt: z.number(),
      })
      .passthrough(),
  ),
  "crm.docs.create": z.object({ id: z.string() }),
  "crm.docs.link": okResponse,
  "crm.docs.delete": okResponse,
  "crm.actions.list": z.array(
    z
      .object({
        _id: z.string(),
        _creationTime: z.number(),
        actionId: z.string(),
        fieldId: z.string(),
        entryId: z.string(),
        objectId: z.string(),
        runId: z.string().optional(),
        status: z.enum(["pending", "running", "completed", "failed"]),
        startedAt: z.number(),
        completedAt: z.number().optional(),
        result: z.string().optional(),
        error: z.string().optional(),
      })
      .passthrough(),
  ),
  "crm.actions.create": z.object({
    fieldId: z.string(),
    actionId: z.string(),
    fieldCreated: z.boolean(),
  }),
  "crm.actions.update": z.object({
    fieldId: z.string(),
    actionId: z.string(),
    fieldCreated: z.boolean(),
  }),
  "crm.actions.delete": z.object({
    ok: z.boolean(),
    remaining: z.number(),
    fieldDeleted: z.boolean(),
  }),
  "crm.actions.run": z.object({
    results: z.array(
      z.object({
        entryId: z.string(),
        status: z.enum(["success", "error"]),
        operations: z.number().optional(),
        error: z.string().optional(),
      }),
    ),
  }),
  "crm.members.list": z.object({
    members: z.array(memberShape),
    organizationId: z.string(),
    organizationSlug: z.string().nullable(),
    organizationName: z.string(),
  }),
  "members.presence": z.array(
    z.object({
      userId: z.string(),
      state: presenceState,
      lastActiveAt: z.number().nullable(),
    }),
  ),
  "members.get": memberProfileShape.nullable(),
  "members.activity": z.array(memberActivityRow),
  "members.tasks": z.array(
    z.object({
      id: z.string(),
      name: z.string(),
      title: z.string().describe("Same as name: the task's title field."),
      status: z.string().nullable(),
      dueDate: z.number().nullable(),
      dueDateKey: z.string().nullable(),
      done: z.boolean(),
    }),
  ),
  "me.profile.get": memberProfileShape.nullable(),
  "me.profile.update": memberProfileShape,
  "me.avatar.uploadUrl": z.string().describe("One-time upload URL."),
  "me.avatar.set": z.object({ image: z.string() }),
  "me.avatar.clear": okResponse,
  "crm.reports.generate": z.object({
    spec: z.object({
      objectName: z.string(),
      type: reportType,
      groupByField: z.string(),
      metric: reportMetric,
      metricField: z.string().optional(),
    }),
    buckets: z.array(
      z.object({
        key: z.string(),
        label: z.string(),
        count: z.number(),
        sum: z.number().optional(),
        avg: z.number().optional(),
      }),
    ),
    totalCount: z.number(),
    truncated: z
      .boolean()
      .optional()
      .describe(
        "True when a bounded row scan (not the exact pre-aggregates) produced the sums.",
      ),
  }),
  "crm.enrich.cell": z.object({
    enqueued: z.boolean(),
    hint: z.string(),
  }),
  "crm.enrich.object": z.object({
    enqueued: z.number().describe("Number of cells queued for enrichment."),
  }),
  "crm.people.search": enrichedPeopleResponse,
  "crm.companies.search": enrichedCompaniesResponse,
  "enrichment.jobs.search": jobsSearchResponse,
  "enrichment.search.preview": z.object({
    count: z.number(),
    source: z.enum(["live", "cache"]).optional(),
  }),
  "enrichment.person": z
    .object({
      source: z.enum(["live", "cache"]),
      data: z.unknown().nullable(),
    })
    .passthrough(),
  "enrichment.company": z
    .object({
      source: z.enum(["live", "cache"]),
      data: z.unknown().nullable(),
    })
    .passthrough(),
  "enrichment.person.contact": z.object({}).passthrough(),
  "enrichment.profiles.bulk": z.object({
    kind: z.enum(["people", "companies"]),
    records: z.array(
      z.object({
        inputIndex: z.number().int().nonnegative(),
        data: z
          .record(z.string(), z.unknown())
          .nullable()
          .describe(
            "Dench person/company profile, or null for a genuine miss. No provider-specific IDs or payloads.",
          ),
      }),
    ),
    billing: enrichmentCharge,
  }),
  "enrichment.company.related": z.object({
    kind: companyRelatedKind,
    items: z
      .array(z.record(z.string(), z.unknown()))
      .describe(
        "Normalized records for the requested kind; employees include employment, funding includes USD amounts and investors.",
      ),
    metadata: z.object({
      total: z.number().int().nonnegative(),
      nextPageToken: z.string().optional(),
    }),
    billing: enrichmentCharge,
  }),

  // Email
  "email.identity.verify": z
    .object({
      ok: z.boolean(),
      identity: z.string(),
      type: emailIdentityType,
      identityType: z
        .string()
        .nullable()
        .describe('Provider identity type, e.g. "DOMAIN" or "EMAIL_ADDRESS".'),
      verifiedForSendingStatus: z.boolean(),
      messageId: z
        .string()
        .nullable()
        .optional()
        .describe("Verification email id (email identities only)."),
      dkimTokens: z
        .array(z.string())
        .describe("DKIM tokens for DNS records (domain identities)."),
    })
    .passthrough(),
  "email.identity.create": z.object({ identityId: z.string() }),
  "email.identity.refresh": z
    .object({
      identityId: z.string(),
      identity: z.string(),
      deliveryVerificationStatus,
      deliveryVerified: z.boolean(),
      domain: z.string().optional(),
      domainVerified: z.boolean(),
      emailVerified: z.boolean(),
      denchVerificationStatus,
      disabled: z.boolean(),
      dnsRecords: z.array(dnsRecordShape).optional(),
      domainVerificationInfo: z
        .object({
          errorType: z.string().optional(),
          lastCheckedAt: z.string().optional(),
          lastSuccessAt: z.string().optional(),
        })
        .optional()
        .describe("Provider DNS poll info for pending domains."),
      message: z.string().optional(),
    })
    .passthrough(),
  "email.identity.beginVerification": z.object({
    identityId: z.string(),
    fromEmail: z.string(),
    denchVerificationStatus: z.enum(["pending", "verified"]),
    deliveryVerificationStatus: z.enum(["pending", "verified"]),
    action: z.enum([
      "already_verified",
      "mailbox_verification_sent",
      "domain_dns_ready",
      "workspace_verification_sent",
    ]),
    dkimTokens: z.array(z.string()).optional(),
    dnsRecords: z.array(dnsRecordShape).optional(),
    message: z.string(),
  }),
  "email.identity.status": z
    .object({
      ok: z.boolean(),
      identity: z.string(),
      verifiedForSendingStatus: z.boolean(),
      verificationStatus: z
        .string()
        .describe('Provider status, e.g. "PENDING" | "SUCCESS" | "FAILED".'),
      dkimAttributes: z
        .record(z.string(), z.unknown())
        .nullable()
        .describe("Provider DKIM attributes (Tokens, Status, ...)."),
      mailFromAttributes: z.record(z.string(), z.unknown()).nullable(),
      verificationInfo: z
        .object({
          errorType: z.string().nullable(),
          lastCheckedAt: z.string().nullable(),
          lastSuccessAt: z.string().nullable(),
        })
        .nullable(),
    })
    .passthrough(),
  "email.identity.list": z.array(emailIdentityRow),
  "email.identity.dns": z
    .object({
      identityId: z.string(),
      identity: z.string(),
      deliveryVerificationStatus,
      deliveryVerified: z.boolean(),
      domain: z.string().optional(),
      domainVerified: z.boolean(),
      emailVerified: z.boolean(),
      denchVerificationStatus,
      disabled: z.boolean(),
      dnsRecords: z
        .array(dnsRecordShape)
        .optional()
        .describe("DKIM/SPF/DMARC records to add for a pending domain."),
      message: z.string().optional(),
    })
    .passthrough(),
  "email.identity.disable": z.object({
    ok: z.boolean(),
    disabled: z.array(identitySummaryShape),
  }),
  "email.identity.restore": z.object({
    ok: z.boolean(),
    restored: z.array(identitySummaryShape),
  }),
  "email.identity.delete": z.object({
    ok: z.boolean(),
    deleted: z.array(identitySummaryShape),
  }),
  "email.send": z.object({
    ok: z.boolean(),
    messageId: z
      .string()
      .describe("Dench message id for `dench email message status`."),
    providerMessageId: z.string(),
    rfcMessageId: z
      .string()
      .optional()
      .describe("RFC 5322 Message-ID usable for reply threading."),
    recipients: z.number(),
    status: z.literal("sent"),
    inReplyTo: z.string().optional(),
    message: z.string(),
  }),
  "email.message.get": emailMessageShape,
  "email.message.list": z.array(emailMessageShape),
  "email.template.create": z.object({ templateId: z.string() }),
  "email.template.preview": z.object({
    subject: z.string(),
    htmlBody: z.string(),
    textBody: z.string().optional(),
    variableNames: z.array(z.string()),
  }),
  "email.campaign.create": z.object({ campaignId: z.string() }),
  "email.campaign.get": campaignDoc,
  "email.campaign.recipients.add": z.object({
    added: z.number(),
    duplicates: z.number(),
    suppressed: z.number(),
    invalid: z.number(),
    totalRecipients: z.number(),
  }),
  "email.campaign.preview": z.object({
    campaignId: z.string(),
    previews: z.array(
      z.object({
        recipientId: z.string(),
        to: z.string(),
        subject: z.string(),
        htmlBody: z.string(),
        textBody: z.string().optional(),
      }),
    ),
  }),
  "email.campaign.submit": z.object({
    ok: z.boolean(),
    summary: campaignSummaryShape,
  }),
  "email.campaign.pause": campaignSummaryShape,
  "email.campaign.resume": campaignSummaryShape,
  "email.campaign.cancel": campaignSummaryShape,

  // Routines
  "cron.list": z.object({
    jobs: z.array(cronJobShape),
    cronStatus: z.object({
      enabled: z.boolean(),
      nextWakeAtMs: z.number().nullable(),
    }),
  }),
  "cron.history": z.object({ entries: z.array(cronRunEntry) }),
  "cron.get": cronJobShape,
  "cron.create": cronWriteResponse,
  "cron.update": cronWriteResponse,
  "cron.delete": okResponse,
  "cron.enable": cronWriteResponse,
  "cron.disable": cronWriteResponse,
  "cron.run": z.object({
    runId: z.string(),
    threadId: z.string(),
    target: z.literal("chat_turn"),
  }),
  "cron.runs": z.object({ entries: z.array(cronRunEntry) }),

  // Files
  "files.list": z.array(fileTreeRow),
  "files.content": z
    .object({
      path: z.string(),
      isDir: z.boolean(),
      virtual: z.boolean(),
      size: z.number().nullable(),
      mtime: z.number().nullable().optional(),
      content: z
        .string()
        .nullable()
        .describe("Inline text, or null for binary / uncached files."),
      encoding: z.string().nullable(),
      contentHash: z.string().nullable().optional(),
      downloadable: z.boolean(),
    })
    .passthrough()
    .nullable()
    .describe("The file, or null when nothing exists at the path."),
  "files.write": z.object({
    path: z.string().describe("Normalized workspace path that was written."),
    contentHash: z.string(),
  }),
  "files.downloadUrl": z
    .string()
    .nullable()
    .describe("Signed download URL, or null when the file has no blob."),
  "files.delete": z
    .object({ path: z.string() })
    .nullable()
    .describe("Deleted path, or null when nothing existed at the path."),
  "files.move": z.object({
    ok: z.boolean(),
    from: z.string(),
    to: z.string(),
    moved: z.array(z.object({ from: z.string(), to: z.string() })),
  }),
  "files.stage": z.object({
    ok: z.boolean(),
    staged: z.array(
      z.object({
        path: z.string(),
        size: z.number(),
        result: z
          .object({
            path: z.string(),
            contentHash: z.string(),
          })
          .passthrough(),
      }),
    ),
  }),

  // Gateway: search, images, apps, tools
  "search.web": exaSearchResponse,
  "search.contents": exaSearchResponse,
  "search.answer": exaAnswerResponse,
  "image.generate": imageEnvelope,
  "image.edit": imageEnvelope,
  "integrations.list": composioConnectionsResponse,
  "tool.status": composioConnectionsResponse,
  "tool.connect": z
    .object({
      redirect_url: z
        .string()
        .optional()
        .describe("OAuth URL the user opens to finish connecting."),
      connection_id: z.string().optional(),
      redirectUrl: z.string().optional(),
      link: z.string().optional(),
      artifact: z
        .object({
          kind: z.literal("connect"),
          data: z.object({ toolkit: z.string() }),
        })
        .optional(),
    })
    .passthrough()
    .describe("Connect-link response."),
  "tool.search": toolSearchResponse,
  "tool.run": toolRunResponse,
  "tool.disconnect": z
    .object({
      id: z.string().optional(),
      deleted: z.boolean().optional(),
    })
    .passthrough()
    .describe("Delete response."),
  "tool.labels.list": z.object({
    labels: z.array(
      z.object({ composioConnectionId: z.string(), displayName: z.string() }),
    ),
  }),
  "tool.label.set": z.object({
    ok: z.boolean(),
    displayName: z.string().nullable(),
  }),

  // Agent config
  "agentConfig.identity.show": agentConfigPayload,
  "agentConfig.identity.edit": agentConfigBlock,
  "agentConfig.organisation.show": agentConfigPayload,
  "agentConfig.organisation.edit": agentConfigBlock,
  "agentConfig.user.show": agentConfigPayload,
  "agentConfig.user.edit": timedContent,
  "agentConfig.tools.show": agentConfigPayload,
  "agentConfig.tools.edit": agentConfigBlock,
  "agentConfig.mem.show": agentConfigPayload,
  "agentConfig.mem.edit": agentConfigBlock,
  "agentConfig.bootstrap.show": agentConfigPayload,
  "agentConfig.bootstrap.complete": agentConfigBlock,
  "agentConfig.bootstrap.template": agentConfigBlock,
  "agentConfig.model.default": z.object({
    defaultChatModelId: z.string().nullable(),
  }),
  "agentConfig.model.thread": z.object({
    threadId: z.string(),
    modelOverride: z.string().nullable(),
  }),
  "agentConfig.daily.today": agentConfigPayload,
  "agentConfig.daily.show": agentConfigPayload,
  "crm.analytics.get": z.object({
    objectName: z.string(),
    analytics: analyticsConfig.nullable(),
    viewAnalytics: analyticsPanelContainer
      .nullable()
      .describe("The named view's own dashboard, or null when it inherits."),
    viewExists: z.boolean(),
    fields: z.array(
      z.object({
        name: z.string(),
        type: z.string(),
        enumValues: z.array(z.string()).nullable(),
        enumColors: z.array(z.string()).nullable(),
      }),
    ),
  }),
  "crm.analytics.compute": z.object({
    objectName: z.string(),
    truncated: z
      .boolean()
      .describe(
        "True when the table exceeded the 5,000-row scan and numbers are approximate.",
      ),
    scannedRows: z.number(),
    locationRole: z.string().optional(),
    panels: z.array(analyticsPanelResult),
  }),
  "crm.analytics.save": z.object({ ok: z.boolean(), panelId: z.string() }),
  "crm.analytics.update": z.object({ ok: z.boolean(), panel: analyticsPanel }),
  "crm.analytics.hide": z.object({ ok: z.boolean(), panel: analyticsPanel }),
  "crm.analytics.show": z.object({ ok: z.boolean(), panel: analyticsPanel }),
  "crm.analytics.resize": z.object({ ok: z.boolean(), panel: analyticsPanel }),
  "crm.analytics.delete": z.object({ ok: z.boolean(), removed: z.boolean() }),
  "crm.analytics.reorder": okResponse,
  "crm.analytics.roles": z.object({
    ok: z.boolean(),
    fieldRoles: analyticsFieldRoles.describe(
      "The mapping as stored after the write.",
    ),
  }),
  "crm.analytics.collapse": okResponse,
  "crm.analytics.expand": okResponse,
  "crm.analytics.scope": z.object({ ok: z.boolean(), changed: z.boolean() }),
};

// ---------------------------------------------------------------------------
// Convex backend extras (fixedArgs / transformArgs) keyed by operation id
// ---------------------------------------------------------------------------

export type ConvexExtras = {
  withReferencesFunctionName?: string;
  fixedArgs?: Record<string, unknown>;
  transformArgs?: (input: Record<string, unknown>) => Record<string, unknown>;
};

export const convexExtras: Record<string, ConvexExtras> = {
  "campaigns.list": {
    withReferencesFunctionName:
      "functions/outreachSequences:listSequencesWithReferences",
  },
  "crm.objects.list": {
    withReferencesFunctionName: "functions/crm/objects:listWithReferences",
  },
  "crm.entries.list": {
    withReferencesFunctionName: "functions/crm/entries:listWithReferences",
  },
  "crm.query": {
    withReferencesFunctionName:
      "functions/crm/query:runQueryEntriesWithReferences",
  },
  "crm.search": {
    withReferencesFunctionName: "functions/crm/query:searchWithReferences",
  },

  "campaigns.steps.replace": {
    transformArgs: ({ allowSingleBraces: _allowSingleBraces, ...input }) =>
      input,
  },
  "campaigns.steps.update": {
    transformArgs: ({ allowSingleBraces: _allowSingleBraces, ...input }) =>
      input,
  },
  "campaigns.personalization.clear": { fixedArgs: { template: null } },
  "campaigns.personalization.write": {
    transformArgs: (input) => ({ ...input, mode: input.mode ?? "missing" }),
  },
  "campaigns.preview": { fixedArgs: { stepIndex: 0 } },
  // The events query paginates with Convex's `paginationOpts`; the flat
  // `numItems` / `cursor` query params are folded into it here.
  "campaigns.events": {
    transformArgs: (input) => ({
      sequenceId: input.sequenceId,
      paginationOpts: {
        numItems: typeof input.numItems === "number" ? input.numItems : 50,
        cursor: typeof input.cursor === "string" ? input.cursor : null,
      },
    }),
  },
  // Ad-hoc panels arrive without id/title/metric/sortOrder from apps and
  // curl; the Convex validator requires all four.
  "crm.analytics.compute": {
    transformArgs: (input) =>
      input.panels === undefined
        ? { ...input }
        : { ...input, panels: normalizeAdHocPanels(input.panels) },
  },
  "cron.enable": { fixedArgs: { enabled: true } },
  "cron.disable": { fixedArgs: { enabled: false } },
  // Archive/unarchive are one mutation behind two paths, so the flag comes
  // from the route rather than the body — a caller cannot un-archive by
  // POSTing `{ archived: false }` to `/archive`.
  "crm.objects.archive": { fixedArgs: { archived: true } },
  "crm.objects.unarchive": { fixedArgs: { archived: false } },
  // Same mutation for a saved view, but the path calls the object
  // `objectName` while `setArchived` calls it `name`.
  "crm.views.archive": {
    transformArgs: (input) => ({
      name: input.objectName,
      viewName: input.viewName,
    }),
    fixedArgs: { archived: true },
  },
  "crm.views.unarchive": {
    transformArgs: (input) => ({
      name: input.objectName,
      viewName: input.viewName,
    }),
    fixedArgs: { archived: false },
  },
  // PATCH /crm/objects/{objectName}/views/{viewName} — the path's
  // viewName is the upsert key: fold it into `view.name` and force
  // replaceExisting so the mutation overwrites instead of erroring on
  // the (guaranteed) name collision.
  "crm.views.update": {
    transformArgs: (input) => {
      const { viewName, view, ...rest } = input as {
        viewName?: unknown;
        view?: unknown;
      } & Record<string, unknown>;
      const baseView =
        view && typeof view === "object" && !Array.isArray(view)
          ? (view as Record<string, unknown>)
          : {};
      return {
        ...rest,
        view: { ...baseView, name: String(viewName ?? baseView.name ?? "") },
        replaceExisting: true,
      };
    },
  },
  "crm.entries.updateMany": {
    transformArgs: (input) => {
      const updates = Array.isArray(input.updates) ? input.updates : [];
      return {
        ops: updates.map((raw) => {
          const update = (raw ?? {}) as {
            entryId?: unknown;
            id?: unknown;
            data?: unknown;
          };
          return {
            type: "entries.update",
            entryId: String(update.entryId ?? update.id ?? ""),
            data: update.data ?? {},
          };
        }),
      };
    },
  },
  "crm.analytics.collapse": { fixedArgs: { collapsed: true } },
  "crm.analytics.expand": { fixedArgs: { collapsed: false } },
  // hide / show / resize are `updateAnalyticsPanel` with a one-key patch.
  "crm.analytics.hide": { fixedArgs: { patch: { hidden: true } } },
  "crm.analytics.show": { fixedArgs: { patch: { hidden: false } } },
  "crm.analytics.resize": {
    transformArgs: (input) => {
      const { span, ...rest } = input as { span?: unknown } & Record<
        string,
        unknown
      >;
      return { ...rest, patch: { span: span ?? null } };
    },
  },
  // PUT /crm/objects/{objectName}/analytics/panels/{panelId} — the path's
  // panelId is the upsert key: fold it into `panel.id`.
  "crm.analytics.save": {
    transformArgs: (input) => {
      const { panelId, panel, ...rest } = input as {
        panelId?: unknown;
        panel?: unknown;
      } & Record<string, unknown>;
      const basePanel =
        panel && typeof panel === "object" && !Array.isArray(panel)
          ? (panel as Record<string, unknown>)
          : {};
      return {
        ...rest,
        panel: { ...basePanel, id: String(panelId ?? basePanel.id ?? "") },
      };
    },
  },
};

// ---------------------------------------------------------------------------
// Curated request examples keyed by operation id (for playground + curl)
// ---------------------------------------------------------------------------

export const requestExamples: Record<string, unknown> = {
  "email.native.send": {
    requestId: "send-intro-001",
    to: [{ email: "ada@example.com", name: "Ada" }],
    subject: "Introduction",
    textBody: "Hello Ada",
  },
  "campaigns.accounts.linkedin": {},
  "campaigns.create": {
    name: "Founder outreach",
    timezone: "America/Los_Angeles",
    emailMailboxAccountIds: ["<emailMailboxAccountId>"],
    linkedinAccountIds: ["<linkedinAccountId>"],
  },
  "campaigns.update": {
    sequenceId: "<sequenceId>",
    emailMailboxAccountIds: ["<emailMailboxAccountId>"],
    linkedinAccountIds: ["<linkedinAccountId>"],
    dailySendCap: 30,
    sendSchedules: [
      {
        name: "Mon-Fri 9-18",
        timezone: "America/Los_Angeles",
        startHour: 9,
        endHour: 18,
        weekdays: [1, 2, 3, 4, 5],
      },
    ],
  },
  "campaigns.steps.replace": {
    sequenceId: "<sequenceId>",
    stepModel: "workflow",
    steps: [
      {
        key: "connected",
        type: "condition",
        check: "linkedin_connected",
        yesNext: "message",
        noNext: "invite",
      },
      {
        key: "invite",
        type: "linkedin_connection",
        linkedinMessageBody:
          "Hi {{First name}}, enjoyed your post on {{Topic}}.",
        next: "accept",
      },
      {
        key: "accept",
        type: "wait_for_connection",
        connectionTimeoutHours: 240,
        yesNext: "message",
        noNext: "email",
      },
      {
        key: "email",
        type: "email",
        emailSubject: "Quick question, {{First name}}",
        emailTextBody: "Hi {{First name}}, ...",
        next: "end",
      },
      {
        key: "message",
        type: "linkedin_message",
        linkedinMessageBody: "Thanks for connecting, {{First name}}. ...",
        next: "end",
      },
    ],
  },
  "campaigns.steps.update": {
    sequenceId: "<sequenceId>",
    steps: [
      {
        stepId: "<stepId>",
        expectedUpdatedAt: 1765526400000,
        type: "email",
        emailSubject: "A quicker question, {{First name}}",
      },
      {
        stepId: "<waitStepId>",
        expectedUpdatedAt: 1765526400000,
        type: "wait",
        waitHours: 96,
      },
      {
        stepId: "<waitForConnectionStepId>",
        expectedUpdatedAt: 1765526400000,
        type: "wait_for_connection",
        connectionTimeoutHours: 336,
      },
    ],
  },
  "campaigns.personalization.set": {
    sequenceId: "<sequenceId>",
    template: {
      variables: [
        {
          key: "companyHook",
          label: "Company hook",
          prompt:
            "One sentence about something specific their company does or recently did. 8 to 18 words.",
          fallback: "Your team caught my eye.",
          maxChars: 160,
        },
      ],
      context: {
        sells: "Senior engineers who join your team in your time zone.",
      },
    },
  },
  "campaigns.people.addFromCrm": {
    sequenceId: "<sequenceId>",
    objectName: "lead",
    entryIds: ["<entryId1>", "<entryId2>"],
  },
  "campaigns.people.add": {
    sequenceId: "<sequenceId>",
    displayName: "Ada Lovelace",
    email: "ada@example.com",
    linkedinProfileUrl: "https://linkedin.com/in/ada",
  },
  "campaigns.launch": {
    sequenceId: "<sequenceId>",
    fingerprint: "<fingerprint from the launch preview>",
    linkedinRiskAcknowledged: true,
  },
  "browser.action": {
    action: "open",
    url: "https://example.com",
  },
  "browser.session.create": {
    viewport: { width: 1280, height: 800 },
  },
  "crm.objects.create": {
    name: "lead",
    description: "Sales leads",
    defaultView: "kanban",
    icon: "target",
  },
  "crm.fields.create": {
    name: "Status",
    type: "enum",
    enumValues: ["New", "Working", "Qualified", "Lost"],
    enumColors: ["#94a3b8", "#3b82f6", "#22c55e", "#ef4444"],
    indexed: true,
  },
  "crm.views.create": {
    view: {
      name: "Hot leads",
      view_type: "table",
      filters: {
        id: "g1",
        conjunction: "and",
        rules: [{ id: "r1", field: "Status", operator: "is", value: "Hot" }],
      },
      sort: [{ field: "created_at", direction: "desc" }],
    },
    setActive: true,
  },
  "crm.views.update": {
    view: {
      sort: [{ field: "Score", direction: "desc" }],
      columns: ["Name", "Email", "Status", "Score"],
    },
  },
  "crm.fields.enum.color": { color: "#22c55e" },
  "crm.fields.enum.add": { value: "Nurturing", color: "#eab308", position: 2 },
  "crm.entries.create": {
    data: {
      Name: "Joint review",
      Assignee: ["user_kumar", "user_mark"],
      Status: "New",
    },
  },
  "crm.comments.create": {
    body: "Kickoff went well — [@Bob](/?member=user_bob) can you send the proposal? [@Dench](/?member=dench) what's the ARR here?",
  },
  "crm.comments.update": { body: "Kickoff went well — proposal sent." },
  "crm.watch.set": { watching: true },
  "crm.tasks.createForEntry": {
    name: "Send proposal",
    assigneeUserId: "user_bob",
    dueDateKey: "2026-09-05",
  },
  "notifications.read": { read: true },
  "notifications.preferences.update": {
    emailEnabled: true,
    perKind: { entry_activity: { email: false } },
  },
  "settings.sync.update": { linkedinContacts: false },
  "me.profile.update": {
    tagline: "Head of Ops",
    timezone: "America/New_York",
  },
  "me.avatar.set": { storageId: "kg2abc123def456" },
  "crm.entries.createMany": {
    entries: [
      { Name: "Jane", Email: "jane@example.com" },
      { Name: "Bob", Email: "bob@example.com" },
    ],
  },
  "crm.cells.set": { value: ["user_kumar", "user_mark"] },
  "crm.query": {
    objectName: "lead",
    dslJson:
      '{"filter":{"Status":"Qualified","Score":{"$gt":50}},"sort":"-Score","limit":50}',
  },
  "crm.transaction.add": {
    op: {
      type: "entries.update",
      entryId: "ent_lead99",
      data: { Status: "Qualified" },
    },
  },
  "crm.statuses.set": {
    statuses: [
      { name: "New", color: "#94a3b8" },
      { name: "Working", color: "#3b82f6" },
      { name: "Qualified", color: "#22c55e", isDefault: true },
    ],
  },
  "crm.batch": {
    ops: [
      { type: "entries.create", objectName: "people", data: { Name: "Jane" } },
    ],
    idempotencyKey: "import-2026-06-01",
  },
  "memory.save": {
    key: "deployment-policy",
    kind: "decision",
    text: "Never deploy without human approval.",
    tags: ["deployment", "policy"],
  },
  "approval.request": {
    title: "Deploy the new API branch?",
    reason: "Production deploy changes public behavior.",
    risk: "high",
  },
  "approval.decide": {
    decision: "approved",
    evidence: "User said yes in chat",
  },
  "chat.new": { prompt: "Summarize the latest CRM changes." },
  "chat.rename": {
    items: [{ threadId: "th_abc123", title: "Deploy checklist" }],
  },
  "chat.delete": { threadIds: ["th_abc123"] },
  "cron.create": {
    name: "Daily digest",
    prompt: "Summarize open CRM tasks.",
    schedule: { kind: "every", everyMs: 86_400_000 },
  },
  "search.web": { query: "latest AI CRM workflows", numResults: 5 },
  "web.scrape": {
    input: { url: "https://example.com", useMainContentOnly: true },
  },
  "web.brand": { input: { domain: "stripe.com" } },
  "web.sitemap": { input: { domain: "example.com", maxLinks: 1000 } },
  "web.crawl": {
    input: {
      url: "https://example.com",
      maxPages: 15,
      useMainContentOnly: true,
    },
  },
  "web.screenshot": {
    input: { directUrl: "https://example.com", fullScreenshot: false },
  },
  "web.extract": {
    input: {
      url: "https://example.com",
      schema: { type: "object", properties: { title: { type: "string" } } },
    },
  },
  "web.product": { input: { url: "https://example.com/product" } },
  "web.competitors": { input: { domain: "stripe.com", numCompetitors: 5 } },
  "web.styleguide": { input: { domain: "stripe.com" } },
  "web.fonts": { input: { domain: "stripe.com" } },
  "web.classify": { input: { input: "stripe.com" } },
  "web.brandSearch": { input: { query: "stripe" } },
  "image.generate": {
    prompt: "A minimal flat-vector app icon",
    size: "1024x1024",
  },
  "image.edit": {
    prompt: "Make the background transparent",
    input_images_base64: ["iVBORw0KGgoAAAANSUhEUg..."],
  },
  "tool.search": {
    queries: [{ use_case: "list Slack channels" }],
  },
  "tool.run": {
    tool_slug: "SLACK_LIST_CHANNELS",
    arguments: { limit: 10 },
  },
  "crm.people.search": {
    titles: ["Head of Sales"],
    industries: ["SaaS"],
    companyDomains: ["acme.com", "globex.com"],
    limit: 10,
  },
  "crm.companies.search": { domain: "example.com" },
  "enrichment.jobs.search": {
    titles: ["Account Executive"],
    locations: ["San Francisco"],
    companyDomains: ["acme.com", "globex.com"],
    limit: 50,
  },
  "enrichment.search.preview": { kind: "people", titles: ["VP Sales"] },
  "enrichment.person": {
    linkedinURL: "https://www.linkedin.com/in/janedoe",
  },
  "enrichment.company": { website: "acme.com" },
  "enrichment.person.contact": {
    contacts: [{ linkedinUrl: "https://www.linkedin.com/in/janedoe" }],
  },
  "enrichment.profiles.bulk": {
    kind: "companies",
    lookups: [{ domain: "acme.com" }],
  },
  "enrichment.company.related": {
    domain: "acme.com",
    kind: "founders",
    limit: 10,
  },
  "email.identity.verify": { type: "email", identity: "founder@example.com" },
  "email.identity.create": {
    type: "domain",
    domain: "example.com",
    fromEmail: "founder@example.com",
    fromName: "Ada at Example",
  },
  "email.send": {
    fromEmail: "founder@example.com",
    to: [{ email: "ada@lovelace.dev", name: "Ada" }],
    subject: "Quick intro",
    htmlBody: "<p>Hi Ada — great meeting you!</p>",
  },
  "email.template.create": {
    name: "Intro outreach",
    subject: "Hi {{firstName}}",
    htmlBody: "<p>Hi {{firstName}}, saw your work at {{company}}.</p>",
  },
  "email.template.preview": {
    data: { firstName: "Ada", company: "Lovelace Labs" },
  },
  "email.campaign.create": {
    name: "Q2 outreach",
    identityId: "founder@example.com",
    templateId: "etpl_abc123",
  },
  "email.campaign.recipients.add": {
    recipients: [
      {
        email: "ada@lovelace.dev",
        displayName: "Ada Lovelace",
        personalization: { firstName: "Ada", company: "Lovelace Labs" },
      },
    ],
  },
  "email.campaign.preview": { sample: 5 },
  "crm.analytics.compute": {
    period: "this_month",
    panels: [
      {
        id: "adhoc:leads-by-source",
        title: "New leads by source",
        type: "donut",
        metric: "count",
        groupBy: "Source",
        sortOrder: 0,
      },
    ],
  },
  "crm.analytics.save": {
    panel: {
      title: "Open pipeline",
      type: "stat",
      metric: "sum",
      derived: "open_pipeline",
      sortOrder: 10,
    },
  },
  "crm.analytics.reorder": {
    panelIds: ["tpl:sales:total-leads", "tpl:sales:leads-by-source"],
  },
  "crm.analytics.roles": {
    fieldRoles: {
      amount: "Amount",
      stage: "Stage",
      wonValues: ["Closed Won"],
      lostValues: ["Closed Lost"],
      closeDate: "Close Date",
      owner: "Owner",
      location: "Account.HQ Location",
      recurrence: "annual",
    },
  },
  "crm.analytics.scope": { mode: "own" },
};

// ---------------------------------------------------------------------------
// Curated 200-response examples keyed by operation id (for the playground).
// Mirror real backend outputs; ids are illustrative opaque strings.
// ---------------------------------------------------------------------------

/** /context, /status, /agents, and /approvals all return this payload. */
const workspaceStatusExample = {
  workspace: { id: "org_abc123", name: "Acme", slug: "acme" },
  agent: { id: "ag_xyz789", name: "Cursor", kind: "cursor" },
  rules: [],
  activeAgents: [
    {
      id: "ag_xyz789",
      name: "Cursor",
      kind: "cursor",
      lastSeenAt: 1765526400000,
    },
  ],
  pendingApprovals: [],
  recentArtifacts: [],
  suggestedWork: [],
  memory: [],
  chatAgents: {
    nextCommands: ['dench agent new "Find useful work" --follow --json'],
    activeRuns: [],
    templates: [],
  },
  tools: {
    discovery: ["dench_list_apps", "dench_search_tools"],
    cli: ["dench apps --json"],
    approvalPolicy: "Read-only tools can run by default.",
  },
  nextActions: ["Ask for a goal or start a chat agent"],
};

export const responseExamples: Record<string, unknown> = {
  "campaigns.pipeline": {
    total: 12,
    statuses: [
      { name: "New", color: "#94a3b8", count: 3 },
      { name: "Contacted", color: "#3b82f6", count: 5 },
      { name: "Replied", color: "#22c55e", count: 2 },
    ],
    other: 2,
  },
  "campaigns.people.forRecord": [
    {
      enrollment: {
        _id: "<enrollmentId>",
        sequenceId: "<sequenceId>",
        displayName: "Grace Hopper",
        status: "active",
        currentStepIndex: 1,
      },
      sequenceName: "Founder outreach",
      isOwner: true,
      canManage: true,
      senders: {
        email: {
          accountId: "<emailMailboxAccountId>",
          label: "ada@example.com",
          status: "running",
        },
        linkedin: null,
      },
    },
  ],
  "campaigns.people.timeline": {
    enrollment: {
      _id: "<enrollmentId>",
      displayName: "Grace Hopper",
      status: "active",
    },
    sequence: { _id: "<sequenceId>", name: "Founder outreach" },
    steps: [
      { _id: "<stepId1>", order: 0, type: "email", emailSubject: "Hello" },
      { _id: "<stepId2>", order: 1, type: "wait", waitHours: 72 },
    ],
    runs: [
      {
        _id: "<runId1>",
        stepId: "<stepId1>",
        stepIndex: 0,
        type: "email",
        status: "sent",
        completedAt: 1765526400000,
        emailMessageId: "<emailId1>",
      },
      {
        _id: "<runId2>",
        stepId: "<stepId2>",
        stepIndex: 1,
        type: "wait",
        status: "waiting",
        waitUntil: 1765785600000,
      },
    ],
    emailMessages: [
      {
        _id: "<emailId1>",
        subject: "Hello",
        textBody: "Hi Grace, ...",
        status: "opened",
        sentAt: 1765526400000,
        firstOpenedAt: 1765530000000,
      },
    ],
    linkedinMessages: [],
  },
  "campaigns.preview": {
    channel: "email",
    subject: "A quicker question, Grace",
    textBody:
      "Hi Grace,\n\nYour team at Acme is hiring senior engineers. We place them in your time zone within two weeks.\n\nWorth a chat?",
    htmlBody:
      "<p>Hi Grace,</p><p>Your team at Acme is hiring senior engineers. We place them in your time zone within two weeks.</p><p>Worth a chat?</p>",
    fromName: "Ada Lovelace",
    fromEmail: "ada@example.com",
    toName: "Grace Hopper",
    toEmail: "grace@acme.com",
    missingFields: [],
    warnings: [],
    personalized: [
      {
        key: "companyHook",
        label: "Company hook",
        value: "Acme is hiring senior engineers.",
        state: "written",
        source: "company",
        maxChars: 160,
      },
    ],
  },
  "campaigns.accounts.email": [
    {
      _id: "<emailMailboxAccountId>",
      email: "ada@example.com",
      provider: "gmail",
      status: "running",
      warmupStatus: "warming",
      readyAt: 1765526400000,
      dailyColdSendCap: 30,
      remainingToday: 12,
      ownerName: "Ada",
      isOwner: true,
      visibility: "shared",
    },
  ],
  "campaigns.accounts.linkedin": [
    {
      linkedinAccountId: "<linkedinAccountId>",
      displayName: "Ada Lovelace",
      status: "running",
      ownerName: "Ada",
      isOwner: true,
      visibility: "private",
      remainingToday: { invites: 12, messages: 36, profiles: 40 },
      remainingInvitesThisWeek: 50,
      availability: "ready",
    },
  ],
  "browser.session.create": {
    provider: "dench_browser",
    sessionId: "bb_sess_123",
    connectUrl:
      "wss://gateway.merseoriginals.com/v1/browser/sessions/bb_sess_123/cdp?relay_token=...",
    liveViewUrl: "https://www.dench.com/dench?...",
    status: "live",
  },
  "commands.list": {
    operations: [
      {
        id: "crm.entries.create",
        group: "crm",
        summary: "Create a CRM entry.",
        cli: "dench crm entries create",
        aliases: [],
        method: "POST",
        path: "/crm/objects/{objectName}/entries",
        backend: "api",
        deprecated: false,
      },
    ],
  },
  "auth.signin.create": { status: "pending", expiresAt: 1765526400000 },
  "auth.signin.poll": {
    status: "approved",
    organization: { id: "org_abc123", name: "Acme", slug: "acme" },
    agent: { id: "ag_xyz789", name: "Cursor", kind: "cursor" },
    sessionExpiresAt: 1773302400000,
  },
  "auth.otp.start": { ok: true },
  "auth.otp.verify": {
    ok: true,
    result: {
      kind: "completed",
      organization: { id: "org_abc123", name: "Acme", slug: "acme" },
      sessionExpiresAt: 1773302400000,
    },
  },
  "auth.otp.finalize": {
    ok: true,
    result: {
      organization: { id: "org_abc123", name: "Acme", slug: "acme" },
      sessionExpiresAt: 1773302400000,
    },
  },
  "workspace.context": workspaceStatusExample,
  "workspace.instructions": {
    workspace: { name: "Acme", slug: "acme" },
    instructions:
      "# Dench Workspace Instructions\n\nWorkspace: Acme (acme)\n\n## Identity\nYou are Dench...",
  },
  "workspace.status": workspaceStatusExample,
  "workspace.agents": workspaceStatusExample,
  "workspace.approvals.list": workspaceStatusExample,
  "workspace.artifacts.list": [
    {
      id: "ra_def456",
      runId: "rn_ghi789",
      title: "Research summary",
      type: "report",
      status: "draft",
      content: "Key findings...",
      createdAt: 1765526400000,
      updatedAt: 1765526400000,
    },
  ],
  "workspace.suggestedWork.list": [
    {
      id: "ra_def456",
      runId: "rn_ghi789",
      title: "Follow up with 3 stale leads",
      type: "task_suggestion",
      status: "draft",
      content: "These leads have not been contacted in 30 days...",
      createdAt: 1765526400000,
      updatedAt: 1765526400000,
    },
  ],
  "memory.search": [
    {
      _id: "wm_jkl012",
      _creationTime: 1765526400000,
      key: "deployment-policy",
      kind: "decision",
      text: "Never deploy without human approval.",
      tags: ["deployment", "policy"],
      status: "active",
      source: "agent",
      createdAt: 1765526400000,
      updatedAt: 1765526400000,
    },
  ],
  "memory.save": { ok: true, memoryId: "wm_jkl012", status: "active" },
  "approval.request": { ok: true, approvalId: "ap_mno345" },
  "approval.decide": { ok: true, status: "approved" },
  "billing.status": {
    workspace: { id: "org_abc123", name: "Acme", slug: "acme" },
    availableCreditsCents: 500,
    creditConsumedCents: 120,
    billedCents: 120,
    onDemandSpendCents: 0,
    monthlySpendLimitCents: 5000,
    spendLimitRemainingCents: 4880,
    subscriptionStatus: "active",
    stripeCustomerId: "cus_abc123",
    grants: [
      {
        id: "gr_pqr678",
        source: "starter",
        category: "promotional",
        status: "granted",
        amountCents: 500,
        usedCents: 120,
        remainingCents: 380,
        effectiveAt: 1765526400000,
        expiresAt: null,
      },
    ],
    nextCommands: ["dench billing topup --amount 20"],
  },
  "billing.topup": { url: "https://checkout.stripe.com/c/pay/cs_test_abc123" },
  "billing.upgrade": {
    url: "https://checkout.stripe.com/c/pay/cs_test_xyz789",
  },
  "chat.list": [
    {
      threadId: "th_abc123",
      title: "Deploy checklist",
      lastMessageAt: 1765526400000,
      createdAt: 1765526000000,
      status: "idle",
      visibility: "private",
      createdByUserId: "us_xyz789",
      archivedAt: null,
      fileContextPath: null,
      parentThreadId: null,
      nestingDepth: null,
      summary: null,
      activeRunId: null,
    },
  ],
  "chat.search": [
    {
      threadId: "th_abc123",
      threadTitle: "Deploy checklist",
      messageId: "cm_def456",
      role: "user",
      snippet: "How do we deploy to prod?",
      createdAt: 1765526400000,
      runId: null,
    },
  ],
  "chat.read": {
    thread: {
      threadId: "th_abc123",
      title: "Deploy checklist",
      lastMessageAt: 1765526400000,
      createdAt: 1765526000000,
      status: "idle",
      visibility: "private",
      createdByUserId: "us_xyz789",
      archivedAt: null,
      fileContextPath: null,
      parentThreadId: null,
      nestingDepth: null,
      summary: null,
      activeRunId: null,
    },
    messages: [
      {
        id: "cm_def456",
        role: "user",
        createdAt: 1765526400000,
        updatedAt: 1765526400000,
        text: "How do we deploy?",
        runId: null,
        status: "complete",
        revision: 0,
        isDraft: false,
      },
      {
        id: "cm_ghi789",
        role: "assistant",
        createdAt: 1765526460000,
        updatedAt: 1765526460000,
        text: "Push to main; Vercel auto-deploys.",
        runId: "rn_jkl012",
        status: "complete",
        revision: 1,
        isDraft: false,
      },
    ],
  },
  "chat.tree": [
    {
      threadId: "th_abc123",
      title: "Deploy checklist",
      lastMessageAt: 1765526400000,
      createdAt: 1765526000000,
      status: "idle",
      visibility: "private",
      createdByUserId: "us_xyz789",
      archivedAt: null,
      fileContextPath: null,
      parentThreadId: null,
      nestingDepth: null,
      summary: null,
      activeRunId: null,
    },
  ],
  "chat.rename": {
    results: [{ threadId: "th_abc123", ok: true }],
    succeeded: 1,
    failed: 0,
  },
  "chat.delete": { scheduled: 2, rejected: [], total: 2 },
  "chat.new": {
    threadId: "th_abc123",
    runId: "rn_def456",
    workflowRunId: "wrun_01HX9",
    threadUrl: "https://www.dench.com/acme/chat/th_abc123",
    streamUrl: "https://www.dench.com/api/chat/stream?sessionId=th_abc123",
    yolo: false,
  },
  "chat.send": {
    threadId: "th_abc123",
    runId: "rn_ghi789",
    workflowRunId: "wrun_01HXA",
    threadUrl: "https://www.dench.com/acme/chat/th_abc123",
    streamUrl: "https://www.dench.com/api/chat/stream?sessionId=th_abc123",
    yolo: false,
  },
  "chat.follow":
    'data: {"type":"start","messageId":"msg_01"}\n\ndata: {"type":"text-delta","id":"t1","delta":"Hello"}\n\ndata: {"type":"finish"}\n\n',
  "crm.objects.list": [
    {
      _id: "obj_lead01",
      _creationTime: 1765526400000,
      organizationId: "org_abc123",
      name: "lead",
      description: "Sales leads",
      defaultView: "kanban",
      sortOrder: 100,
      immutable: false,
      icon: "target",
      entryCount: 42,
      createdAt: 1765526400000,
      updatedAt: 1765612800000,
    },
  ],
  "crm.objects.get": {
    _id: "obj_lead01",
    _creationTime: 1765526400000,
    organizationId: "org_abc123",
    name: "lead",
    description: "Sales leads",
    defaultView: "kanban",
    sortOrder: 100,
    immutable: false,
    icon: "target",
    entryCount: 42,
    createdAt: 1765526400000,
    updatedAt: 1765612800000,
  },
  "crm.objects.create": { id: "obj_lead01" },
  "crm.objects.update": { ok: true },
  "crm.objects.rename": { ok: true },
  "crm.objects.delete": { ok: true },
  "crm.views.list": {
    objectName: "lead",
    activeView: "Hot leads",
    views: [
      {
        name: "Hot leads",
        view_type: "table",
        filters: {
          id: "g1",
          conjunction: "and",
          rules: [{ id: "r1", field: "Status", operator: "is", value: "Hot" }],
        },
        sort: [{ field: "created_at", direction: "desc" }],
      },
    ],
  },
  "crm.views.create": {
    ok: true,
    objectName: "lead",
    viewName: "Hot leads",
    replaced: false,
    activeView: "Hot leads",
  },
  "crm.views.update": {
    ok: true,
    objectName: "lead",
    viewName: "Hot leads",
    replaced: true,
    activeView: null,
  },
  "crm.views.delete": {
    ok: true,
    objectName: "lead",
    viewName: "Hot leads",
    removed: true,
  },
  "crm.fields.list": [
    {
      _id: "fld_status01",
      _creationTime: 1765526400000,
      organizationId: "org_abc123",
      objectId: "obj_lead01",
      name: "Status",
      type: "enum",
      required: false,
      enumValues: ["New", "Working", "Qualified", "Lost"],
      enumColors: ["#94a3b8", "#3b82f6", "#22c55e", "#ef4444"],
      enumMultiple: false,
      sortOrder: 200,
      indexed: true,
      createdAt: 1765526400000,
      updatedAt: 1765612800000,
    },
  ],
  "crm.fields.create": { id: "fld_score01" },
  "crm.fields.update": { ok: true },
  "crm.fields.delete": { ok: true },
  "crm.fields.reorder": { ok: true },
  "crm.fields.enum.reorder": {
    ok: true,
    enumValues: ["New", "Qualified", "Working", "Lost"],
    enumColors: ["#94a3b8", "#22c55e", "#3b82f6", "#ef4444"],
  },
  "crm.fields.enum.add": {
    ok: true,
    enumValues: ["New", "Working", "Nurturing", "Qualified", "Lost"],
    enumColors: ["#94a3b8", "#3b82f6", "#eab308", "#22c55e", "#ef4444"],
    inserted: true,
  },
  "crm.fields.enum.remove": {
    ok: true,
    enumValues: ["New", "Working", "Qualified"],
    enumColors: ["#94a3b8", "#3b82f6", "#22c55e"],
    removed: true,
  },
  "crm.fields.enum.rename": {
    ok: true,
    enumValues: ["New", "Working", "Closed Won", "Lost"],
    enumColors: ["#94a3b8", "#3b82f6", "#22c55e", "#ef4444"],
    entriesUpdated: 7,
  },
  "crm.fields.enum.color": {
    ok: true,
    enumColors: ["#94a3b8", "#3b82f6", "#22c55e", "#ef4444"],
  },
  "crm.comments.list": {
    page: [
      {
        _id: "cmt_01",
        entryId: "ent_lead99",
        depth: 0,
        body: "Kickoff went well — [@Bob](/?member=user_bob) can you send the proposal?",
        actor: {
          kind: "user",
          label: "Ada",
          displayName: "Ada Lovelace",
          userId: "user_ada",
          isDench: false,
        },
        mentionedUserIds: ["user_bob"],
        mentionsDench: false,
        replyCount: 1,
        reactionSummary: [{ emoji: "👍", count: 2 }],
        viewerReactions: ["👍"],
        canEdit: true,
        createdAt: 1765526400000,
        replies: [
          {
            _id: "cmt_02",
            entryId: "ent_lead99",
            parentCommentId: "cmt_01",
            rootCommentId: "cmt_01",
            depth: 1,
            body: "On it.",
            actor: {
              kind: "user",
              label: "Bob",
              displayName: "Bob Smith",
              userId: "user_bob",
              isDench: false,
            },
            mentionedUserIds: [],
            mentionsDench: false,
            replyCount: 0,
            reactionSummary: [],
            viewerReactions: [],
            canEdit: false,
            createdAt: 1765530000000,
          },
        ],
      },
    ],
    isDone: true,
    continueCursor: "",
  },
  "crm.comments.create": {
    id: "cmt_03",
    rootCommentId: "cmt_01",
    depth: 1,
    mentionedUserIds: ["user_bob"],
    mentionsDench: true,
  },
  "crm.comments.react": {
    reacted: true,
    reactionSummary: [{ emoji: "👍", count: 3 }],
  },
  "crm.watch.get": { watching: true, reason: "commented", watcherCount: 3 },
  "notifications.list": [
    {
      _id: "ntf_01",
      kind: "mention",
      title: "Ada Lovelace mentioned you in Ramp",
      body: "Kickoff went well — @Bob can you send the proposal?",
      link: "/acme?entry=company%3Aent_lead99&comment=cmt_01",
      createdAt: 1765526400000,
    },
  ],
  "notifications.unreadCount": 3,
  "crm.entries.list": [
    {
      id: "ent_lead99",
      objectId: "obj_lead01",
      fields: { Name: "Ada Lovelace", Email: "ada@example.com", Status: "New" },
      createdAt: 1765526400000,
      updatedAt: 1765612800000,
      updatedBy: "user:us_xyz789",
      sortOrder: 0,
    },
  ],
  "crm.entries.get": {
    id: "ent_lead99",
    objectId: "obj_lead01",
    fields: { Name: "Ada Lovelace", Email: "ada@example.com", Status: "New" },
    createdAt: 1765526400000,
    updatedAt: 1765612800000,
    updatedBy: "user:us_xyz789",
    sortOrder: 0,
  },
  "crm.entries.create": { entryId: "ent_lead99" },
  "crm.entries.createMany": {
    results: [{ entryId: "ent_lead99" }, { entryId: "ent_lead100" }],
    count: 2,
  },
  "crm.entries.update": { entryId: "ent_lead99" },
  "crm.entries.updateMany": {
    results: [{ entryId: "ent_lead99" }, { entryId: "ent_lead100" }],
    count: 2,
  },
  "crm.entries.delete": { ok: true },
  "crm.entries.bulkDelete": { count: 3 },
  "crm.cells.get": "Qualified",
  "crm.cells.set": { entryId: "ent_lead99" },
  "crm.cells.setMany": {
    results: [{ entryId: "ent_lead99" }, { entryId: "ent_lead100" }],
    count: 2,
  },
  "crm.cells.append": { entryId: "ent_lead99" },
  "crm.query": [
    {
      id: "ent_lead99",
      objectId: "obj_lead01",
      fields: { Name: "Ada Lovelace", Status: "Qualified", Score: 85 },
      createdAt: 1765526400000,
      updatedAt: 1765612800000,
      updatedBy: "user:us_xyz789",
      sortOrder: 0,
    },
  ],
  "crm.sql": [
    {
      id: "ent_lead99",
      objectId: "obj_lead01",
      fields: { Name: "Ada Lovelace", Status: "Qualified", Score: 85 },
      createdAt: 1765526400000,
      updatedAt: 1765612800000,
      updatedBy: "user:us_xyz789",
      sortOrder: 0,
    },
  ],
  "crm.aggregate": [
    { key: "Stage:New", count: 12, sum: 48000 },
    { key: "Stage:Qualified", count: 8, sum: 64000 },
  ],
  "crm.search": [
    {
      _id: "ent_lead99",
      _creationTime: 1765526400000,
      objectId: "obj_lead01",
      data: { Name: "Acme Corp", Status: "Qualified" },
      sortOrder: 0,
      createdAt: 1765526400000,
      updatedAt: 1765612800000,
      updatedBy: "user:us_xyz789",
    },
  ],
  "crm.statuses.list": [
    {
      _id: "sts_new01",
      _creationTime: 1765526400000,
      objectId: "obj_lead01",
      name: "New",
      color: "#94a3b8",
      sortOrder: 100,
      isDefault: true,
    },
  ],
  "crm.statuses.set": { ok: true },
  "crm.batch": {
    results: [
      { entryId: "ent_lead101" },
      { entryId: "ent_lead99", deleted: true },
    ],
    count: 2,
  },
  "crm.transaction.begin": { txnId: "txn_abc01" },
  "crm.transaction.add": { ok: true },
  "crm.transaction.commit": {
    results: [{ entryId: "ent_deal01" }],
    count: 1,
  },
  "crm.transaction.abort": { ok: true },
  "crm.transaction.inspect": {
    _id: "txn_abc01",
    _creationTime: 1765526400000,
    status: "open",
    ops: [
      {
        type: "entries.create",
        objectName: "lead",
        data: { Name: "Beta Inc" },
      },
    ],
    createdAt: 1765526400000,
    updatedAt: 1765526400000,
  },
  "crm.docs.list": [
    {
      _id: "doc_q2notes",
      _creationTime: 1765526400000,
      title: "Q2 Pipeline Notes",
      filePath: "/docs/q2-pipeline.md",
      sortOrder: 1765526400000,
      isPublished: false,
      createdAt: 1765526400000,
      updatedAt: 1765612800000,
    },
  ],
  "crm.docs.create": { id: "doc_q2notes" },
  "crm.docs.link": { ok: true },
  "crm.docs.delete": { ok: true },
  "crm.actions.list": [
    {
      _id: "arun_01",
      _creationTime: 1765526400000,
      actionId: "enrich_company",
      fieldId: "fld_action01",
      entryId: "ent_lead99",
      objectId: "obj_lead01",
      status: "completed",
      startedAt: 1765526400000,
      completedAt: 1765526460000,
      result: "Enriched 4 fields",
    },
  ],
  "crm.actions.create": {
    fieldId: "fld_actions",
    actionId: "mark_won",
    fieldCreated: true,
  },
  "crm.actions.update": {
    fieldId: "fld_actions",
    actionId: "mark_won",
    fieldCreated: false,
  },
  "crm.actions.delete": { ok: true, remaining: 0, fieldDeleted: false },
  "crm.actions.run": {
    results: [{ entryId: "ent_lead99", status: "success", operations: 1 }],
  },
  "crm.members.list": {
    members: [
      {
        userId: "us_xyz789",
        name: "Jane Doe",
        email: "jane@acme.com",
        image: null,
        tagline: "Head of Ops",
        timezone: "America/New_York",
        presence: "online",
        lastActiveAt: 1765612790000,
        role: "ADMIN",
        joinedAt: 1765440000000,
      },
    ],
    organizationId: "org_abc123",
    organizationSlug: "acme",
    organizationName: "Acme",
  },
  "members.get": {
    userId: "us_xyz789",
    name: "Jane Doe",
    email: "jane@acme.com",
    image: null,
    tagline: "Head of Ops",
    role: "ADMIN",
    joinedAt: 1765440000000,
    timezone: {
      value: "America/New_York",
      source: "manual",
      updatedAt: 1765440000000,
    },
    presence: { state: "online", lastActiveAt: 1765612790000 },
    openTaskCount: 4,
    commentCount: 31,
    changeCount: 118,
    lastContributionAt: 1765612800000,
    isSelf: false,
  },
  "members.activity": [
    {
      kind: "comment",
      id: "cmt_01",
      entryId: "ent_lead99",
      objectName: "company",
      entryLabel: "Ramp",
      body: "Kickoff went well.",
      deleted: false,
      at: 1765612800000,
    },
    {
      kind: "change",
      id: "hist_01",
      entryId: "ent_lead99",
      objectName: "company",
      entryLabel: "Ramp",
      changeKind: "update",
      changes: [{ fieldName: "Status", before: "New", after: "Qualified" }],
      at: 1765612700000,
    },
  ],
  "members.presence": [
    { userId: "us_xyz789", state: "online", lastActiveAt: 1765612790000 },
    { userId: "us_abc123", state: "offline", lastActiveAt: null },
  ],
  "crm.reports.generate": {
    spec: {
      objectName: "lead",
      type: "bar",
      groupByField: "Status",
      metric: "count",
    },
    buckets: [
      { key: "New", label: "New", count: 12, sum: 0, avg: 0 },
      { key: "Qualified", label: "Qualified", count: 8, sum: 640, avg: 80 },
    ],
    totalCount: 20,
  },
  "crm.enrich.cell": {
    enqueued: true,
    hint: "Enrichment queued; the cell fills in once search responds.",
  },
  "crm.enrich.object": { enqueued: 37 },
  "crm.people.search": {
    source: "live",
    people: [
      {
        fullName: "Jane Doe",
        firstName: "Jane",
        lastName: "Doe",
        headline: "VP Engineering",
        currentCompanyName: "Acme",
        currentCompanyWebsite: "acme.com",
        linkedinID: "janedoe",
      },
    ],
    resolvedPersonIds: ["per_abc123"],
    creditsCharged: 1,
    billing: { estimatedCents: 1, chargedCents: 1 },
    metadata: { total: 1, offset: 0 },
  },
  "crm.companies.search": {
    source: "live",
    companies: [
      {
        name: "Acme",
        website: "acme.com",
        description: "An example company",
        linkedinUrl: "https://linkedin.com/company/acme",
        linkedinID: "acme",
      },
    ],
    resolvedCompanyIds: ["com_abc123"],
    creditsCharged: 1,
    billing: { estimatedCents: 1, chargedCents: 1 },
    metadata: { total: 1, offset: 0 },
  },
  "enrichment.jobs.search": {
    source: "live",
    jobs: [
      {
        title: "Account Executive",
        company: "Acme",
        location: "San Francisco",
        url: "https://example.com/jobs/ae",
        workplaceType: "hybrid",
      },
    ],
  },
  "enrichment.search.preview": { count: 247, source: "live" },
  "enrichment.person": {
    source: "live",
    data: { fullName: "Jane Doe", linkedinID: "janedoe" },
  },
  "enrichment.company": {
    source: "live",
    data: { name: "Acme", website: "acme.com" },
  },
  "enrichment.person.contact": { enrichmentId: "job_123", status: "queued" },
  "enrichment.profiles.bulk": {
    kind: "companies",
    records: [{ inputIndex: 0, data: { name: "Acme", website: "acme.com" } }],
    billing: { charged_cents: 3 },
  },
  "enrichment.company.related": {
    kind: "founders",
    items: [
      {
        fullName: "Jane Doe",
        linkedinUrl: "https://www.linkedin.com/in/janedoe",
      },
    ],
    metadata: { total: 1 },
    billing: { charged_cents: 1 },
  },
  "email.identity.verify": {
    ok: true,
    identity: "example.com",
    type: "domain",
    identityType: "DOMAIN",
    verifiedForSendingStatus: false,
    dkimTokens: ["abc123token", "def456token", "ghi789token"],
  },
  "email.identity.create": { identityId: "esi_abc123" },
  "email.identity.refresh": {
    identityId: "esi_abc123",
    identity: "example.com",
    deliveryVerificationStatus: "pending",
    deliveryVerified: false,
    domain: "example.com",
    domainVerified: false,
    emailVerified: true,
    denchVerificationStatus: "verified",
    disabled: false,
    dnsRecords: [
      {
        type: "CNAME",
        name: "abc123token._domainkey.example.com",
        value: "abc123token.dkim.amazonses.com",
        purpose: "DKIM (required for domain verification)",
      },
    ],
    message: "Domain example.com is pending DNS verification.",
  },
  "email.identity.beginVerification": {
    identityId: "esi_abc123",
    fromEmail: "founder@example.com",
    denchVerificationStatus: "pending",
    deliveryVerificationStatus: "pending",
    action: "mailbox_verification_sent",
    message:
      "Verification email sent. Open the link in that mailbox, then check sender status again.",
  },
  "email.identity.status": {
    ok: true,
    identity: "example.com",
    verifiedForSendingStatus: false,
    verificationStatus: "PENDING",
    dkimAttributes: { Tokens: ["abc123token"], Status: "PENDING" },
    mailFromAttributes: null,
    verificationInfo: {
      errorType: null,
      lastCheckedAt: "2026-06-12T10:00:00.000Z",
      lastSuccessAt: null,
    },
  },
  "email.identity.list": [
    {
      identityId: "esi_abc123",
      type: "email",
      fromEmail: "founder@example.com",
      fromName: "Ada at Example",
      deliveryVerificationStatus: "verified",
      denchVerificationStatus: "verified",
      disabled: false,
      createdAt: 1765526400000,
    },
  ],
  "email.identity.dns": {
    identityId: "esi_abc123",
    identity: "example.com",
    deliveryVerificationStatus: "pending",
    deliveryVerified: false,
    domain: "example.com",
    domainVerified: false,
    emailVerified: false,
    denchVerificationStatus: "verified",
    disabled: false,
    dnsRecords: [
      {
        type: "CNAME",
        name: "abc123token._domainkey.example.com",
        value: "abc123token.dkim.amazonses.com",
        purpose: "DKIM (required for domain verification)",
      },
      {
        type: "TXT",
        name: "example.com",
        value: "v=spf1 include:amazonses.com ~all",
        purpose: "SPF (recommended)",
      },
    ],
  },
  "email.identity.disable": {
    ok: true,
    disabled: [
      {
        identityId: "esi_abc123",
        fromEmail: "founder@example.com",
        disabled: true,
      },
    ],
  },
  "email.identity.restore": {
    ok: true,
    restored: [
      {
        identityId: "esi_abc123",
        fromEmail: "founder@example.com",
        disabled: false,
      },
    ],
  },
  "email.identity.delete": {
    ok: true,
    deleted: [
      {
        identityId: "esi_abc123",
        fromEmail: "founder@example.com",
        disabled: false,
      },
    ],
  },
  "email.send": {
    ok: true,
    messageId: "emsg_abc123",
    providerMessageId: "0100018abc-provider-id",
    rfcMessageId: "<0100018abc@email.amazonses.com>",
    recipients: 1,
    status: "sent",
    message:
      "Email sent. Track opens/clicks with `dench email message status`.",
  },
  "email.message.get": {
    messageId: "emsg_abc123",
    status: "opened",
    fromEmail: "founder@example.com",
    to: [{ email: "ada@lovelace.dev", name: "Ada" }],
    subject: "Quick intro",
    providerMessageId: "0100018abc-provider-id",
    rfcMessageId: "<0100018abc@email.amazonses.com>",
    recipientCount: 1,
    openCount: 2,
    clickCount: 1,
    sentAt: 1765526400000,
    deliveredAt: 1765526410000,
    firstOpenedAt: 1765529700000,
    createdAt: 1765526395000,
  },
  "email.message.list": [
    {
      messageId: "emsg_abc123",
      status: "sent",
      fromEmail: "founder@example.com",
      to: [{ email: "ada@lovelace.dev" }],
      subject: "Quick intro",
      recipientCount: 1,
      openCount: 0,
      clickCount: 0,
      sentAt: 1765526400000,
      createdAt: 1765526395000,
    },
  ],
  "email.template.create": { templateId: "etpl_abc123" },
  "email.template.preview": {
    subject: "Hi Ada",
    htmlBody: "<p>Hi Ada, saw your work at Lovelace Labs.</p>",
    variableNames: ["company", "firstName"],
  },
  "email.campaign.create": { campaignId: "ecmp_abc123" },
  "email.campaign.get": {
    _id: "ecmp_abc123",
    _creationTime: 1765526395000,
    organizationId: "org_abc123",
    name: "Q2 outreach",
    status: "sending",
    sendingIdentityId: "esi_abc123",
    templateId: "etpl_abc123",
    subjectSnapshot: "Hi {{firstName}}",
    htmlSnapshot: "<p>Hi {{firstName}}, saw your work at {{company}}.</p>",
    fromEmailSnapshot: "founder@example.com",
    createdBy: "user:us_xyz789",
    totalRecipients: 120,
    queuedCount: 70,
    sendingCount: 0,
    sentCount: 50,
    deliveredCount: 48,
    openedCount: 12,
    clickedCount: 3,
    bouncedCount: 1,
    complainedCount: 0,
    failedCount: 0,
    suppressedCount: 2,
    unsubscribedCount: 0,
    maxRecipients: 0,
    batchSize: 50,
    createdAt: 1765526395000,
    updatedAt: 1765526460000,
  },
  "email.campaign.recipients.add": {
    added: 47,
    duplicates: 2,
    suppressed: 1,
    invalid: 0,
    totalRecipients: 120,
  },
  "email.campaign.preview": {
    campaignId: "ecmp_abc123",
    previews: [
      {
        recipientId: "ecr_abc123",
        to: "ada@lovelace.dev",
        subject: "Hi Ada",
        htmlBody: "<p>Hi Ada, saw your work at Lovelace Labs.</p>",
      },
    ],
  },
  "email.campaign.submit": {
    ok: true,
    summary: {
      campaignId: "ecmp_abc123",
      status: "sending",
      totalRecipients: 120,
      queuedCount: 120,
      sendingCount: 0,
      sentCount: 0,
      deliveredCount: 0,
      openedCount: 0,
      clickedCount: 0,
      bouncedCount: 0,
      complainedCount: 0,
      failedCount: 0,
      suppressedCount: 2,
      unsubscribedCount: 0,
    },
  },
  "email.campaign.pause": {
    campaignId: "ecmp_abc123",
    status: "paused",
    totalRecipients: 120,
    queuedCount: 70,
    sendingCount: 0,
    sentCount: 50,
    deliveredCount: 48,
    openedCount: 12,
    clickedCount: 3,
    bouncedCount: 1,
    complainedCount: 0,
    failedCount: 0,
    suppressedCount: 2,
    unsubscribedCount: 0,
  },
  "email.campaign.resume": {
    campaignId: "ecmp_abc123",
    status: "sending",
    totalRecipients: 120,
    queuedCount: 70,
    sendingCount: 0,
    sentCount: 50,
    deliveredCount: 48,
    openedCount: 12,
    clickedCount: 3,
    bouncedCount: 1,
    complainedCount: 0,
    failedCount: 0,
    suppressedCount: 2,
    unsubscribedCount: 0,
  },
  "email.campaign.cancel": {
    campaignId: "ecmp_abc123",
    status: "cancelled",
    totalRecipients: 120,
    queuedCount: 70,
    sendingCount: 0,
    sentCount: 50,
    deliveredCount: 48,
    openedCount: 12,
    clickedCount: 3,
    bouncedCount: 1,
    complainedCount: 0,
    failedCount: 0,
    suppressedCount: 2,
    unsubscribedCount: 0,
  },
  "cron.list": {
    jobs: [
      {
        id: "trg_cron001",
        name: "Daily digest",
        enabled: true,
        deleteAfterRun: false,
        createdAtMs: 1765526400000,
        updatedAtMs: 1765526400000,
        schedule: { kind: "cron", expr: "0 9 * * *", tz: "America/New_York" },
        sessionTarget: "isolated",
        wakeMode: "now",
        payload: { kind: "agentTurn", message: "Summarize open CRM tasks." },
        state: { nextRunAtMs: 1765612800000, lastStatus: "ok" },
      },
    ],
    cronStatus: { enabled: true, nextWakeAtMs: 1765612800000 },
  },
  "cron.history": {
    entries: [
      {
        ts: 1765526400000,
        jobId: "trg_cron001",
        action: "finished",
        status: "ok",
        summary: "Summarized 3 open tasks.",
        sessionId: "th_abc123",
        runAtMs: 1765526350000,
        durationMs: 45000,
        nextRunAtMs: 1765612800000,
      },
    ],
  },
  "cron.get": {
    id: "trg_cron001",
    name: "Daily digest",
    enabled: true,
    deleteAfterRun: false,
    createdAtMs: 1765526400000,
    updatedAtMs: 1765526400000,
    schedule: { kind: "every", everyMs: 86400000 },
    sessionTarget: "isolated",
    wakeMode: "now",
    payload: { kind: "agentTurn", message: "Summarize open CRM tasks." },
    state: { nextRunAtMs: 1765612800000 },
  },
  "cron.create": { jobId: "trg_cron001", nextFireAt: 1765612800000 },
  "cron.update": { jobId: "trg_cron001", nextFireAt: 1765612800000 },
  "cron.delete": { ok: true },
  "cron.enable": { jobId: "trg_cron001", nextFireAt: 1765612800000 },
  "cron.disable": { jobId: "trg_cron001" },
  "cron.run": {
    runId: "rn_def456",
    threadId: "th_abc123",
    target: "chat_turn",
  },
  "cron.runs": {
    entries: [
      {
        ts: 1765526400000,
        jobId: "trg_cron001",
        action: "finished",
        status: "ok",
        runAtMs: 1765526350000,
        durationMs: 45000,
      },
    ],
  },
  "files.list": [
    {
      _id: "ft_abc123",
      _creationTime: 1765526400000,
      path: "/prospects",
      parentPath: "/",
      isDir: true,
      mtime: 1765526400000,
      lastModifiedBy: "user:us_xyz789",
    },
    {
      _id: "ft_def456",
      _creationTime: 1765526400000,
      path: "/README.md",
      parentPath: "/",
      isDir: false,
      size: 2048,
      mtime: 1765526400000,
      contentHash: "9f86d081884c7d65",
      lastModifiedBy: "api-v1",
    },
  ],
  "files.content": {
    path: "/README.md",
    isDir: false,
    virtual: false,
    size: 2048,
    content: "# Acme workspace\n",
    encoding: "utf-8",
    contentHash: "9f86d081884c7d65",
    downloadable: true,
  },
  "files.write": { path: "/reports/q2.md", contentHash: "9f86d081884c7d65" },
  "files.downloadUrl": "https://files.example.com/abc123?download=README.md",
  "files.delete": { path: "/README.md" },
  "files.move": {
    ok: true,
    from: "/drafts/report.md",
    to: "/reports/q2.md",
    moved: [{ from: "/drafts/report.md", to: "/reports/q2.md" }],
  },
  "files.stage": {
    ok: true,
    staged: [
      {
        path: "/prospects/leads.csv",
        size: 1024,
        result: {
          path: "/prospects/leads.csv",
          contentHash: "9f86d081884c7d65",
        },
      },
    ],
  },
  "search.web": {
    results: [
      {
        url: "https://example.com/ai-crm",
        title: "AI CRM workflows in 2026",
        publishedDate: "2026-05-01T00:00:00.000Z",
        author: "Jane Doe",
        id: "https://example.com/ai-crm",
      },
    ],
    resolvedSearchType: "neural",
    requestId: "req_abc123",
    costDollars: { total: 0.005 },
  },
  "search.contents": {
    results: [
      {
        url: "https://example.com/ai-crm",
        title: "AI CRM workflows in 2026",
        text: "The article content...",
        summary: "AI CRMs automate lead routing.",
      },
    ],
    costDollars: { total: 0.002 },
  },
  "search.answer": {
    answer: "Dench is an AI agent workspace with a built-in CRM.",
    citations: [
      {
        url: "https://www.dench.com",
        title: "Dench",
        id: "https://www.dench.com",
      },
    ],
    costDollars: { total: 0.005 },
  },
  "image.generate": {
    ok: true,
    model: "image-model",
    endpoint: "generations",
    prompt: "A minimal flat-vector app icon",
    quality: "auto",
    requestedSize: "1024x1024",
    format: "png",
    mimeType: "image/png",
    estimatedCostUsd: 0.053,
    b64_json: "iVBORw0KGgoAAAANS...",
    path: "/image-generations/20260612-app-icon.png",
    signedUrl: "https://files.example.com/img123",
    sizeBytes: 245760,
    usage: { inputTokens: 12, outputTokens: 1056, totalTokens: 1068 },
  },
  "image.edit": {
    ok: true,
    model: "image-model",
    endpoint: "edits",
    prompt: "Make the background transparent",
    quality: "auto",
    requestedSize: "1024x1024",
    format: "png",
    mimeType: "image/png",
    estimatedCostUsd: 0.066,
    b64_json: "iVBORw0KGgoAAAANS...",
    path: "/image-generations/20260612-app-icon-edit.png",
    signedUrl: "https://files.example.com/img124",
    sizeBytes: 198432,
  },
  "integrations.list": {
    items: [
      {
        id: "ca_github01",
        connectionId: "ca_github01",
        toolkit: { slug: "github", name: "GitHub" },
        status: "ACTIVE",
        createdAt: "2026-06-01T12:00:00.000Z",
        updatedAt: "2026-06-01T12:00:00.000Z",
        account: {
          stableId: "octocat",
          label: "octocat",
          email: "octo@github.com",
        },
      },
    ],
    connections: [
      {
        id: "ca_github01",
        connectionId: "ca_github01",
        toolkit: { slug: "github", name: "GitHub" },
        status: "ACTIVE",
        createdAt: "2026-06-01T12:00:00.000Z",
        updatedAt: "2026-06-01T12:00:00.000Z",
        account: {
          stableId: "octocat",
          label: "octocat",
          email: "octo@github.com",
        },
      },
    ],
    raw: [],
  },
  "tool.status": {
    items: [
      {
        id: "ca_gmail01",
        connectionId: "ca_gmail01",
        toolkit: { slug: "gmail", name: "Gmail" },
        status: "ACTIVE",
        createdAt: "2026-06-01T12:00:00.000Z",
        updatedAt: "2026-06-01T12:00:00.000Z",
        account: { stableId: "ada@example.com", label: "ada@example.com" },
      },
    ],
    connections: [
      {
        id: "ca_gmail01",
        connectionId: "ca_gmail01",
        toolkit: { slug: "gmail", name: "Gmail" },
        status: "ACTIVE",
        createdAt: "2026-06-01T12:00:00.000Z",
        updatedAt: "2026-06-01T12:00:00.000Z",
        account: { stableId: "ada@example.com", label: "ada@example.com" },
      },
    ],
    raw: [],
  },
  "tool.connect": {
    redirect_url: "https://connect.dench.com/s/abc123",
    connection_id: "ca_github01",
  },
  "tool.search": {
    success: true,
    error: null,
    results: [
      {
        use_case: "list Slack channels",
        primary_tool_slugs: ["SLACK_LIST_CHANNELS"],
        toolkits: ["slack"],
      },
    ],
    toolkit_connection_statuses: [
      { toolkit: "slack", has_active_connection: true },
    ],
    tool_schemas: {
      SLACK_LIST_CHANNELS: {
        toolkit: "slack",
        tool_slug: "SLACK_LIST_CHANNELS",
        execution_ref: "eyJzZXNzaW9uIjoi...",
        execution_ref_version: 1,
      },
    },
    session: { id: "trs_abc123", generate_id: true },
    execution_ref_version: 1,
  },
  "tool.run": {
    data: { channels: [{ id: "C_EXAMPLE", name: "general" }] },
    error: null,
    log_id: "log_exec_01",
    execution_mode: "gateway_tool_router",
    tool_slug: "SLACK_LIST_CHANNELS",
    tool_router_session_id: "trs_abc123",
  },
  "tool.disconnect": { id: "ca_github01", deleted: true },
  "agentConfig.identity.show": {
    agentConfig: {
      identity: {
        content: "# IDENTITY\nYou are Atlas...",
        updatedAt: 1765526400000,
      },
      organisation: null,
      memoryAggregate: null,
      toolsNotes: null,
      bootstrap: { completed: true, completedAt: 1765526400000 },
    },
    userProfile: { content: "Name: Alex", updatedAt: 1765526400000 },
    userTimezone: {
      value: "America/New_York",
      source: "manual",
      updatedAt: 1765526400000,
    },
    organizationId: "org_abc123",
  },
  "agentConfig.identity.edit": {
    identity: {
      content: "# IDENTITY\nYou are Atlas...",
      updatedAt: 1765526400000,
    },
    organisation: null,
    memoryAggregate: null,
    toolsNotes: null,
    bootstrap: { completed: true, completedAt: 1765526400000 },
  },
  "agentConfig.organisation.show": {
    agentConfig: {
      identity: null,
      organisation: {
        content: "Acme builds widgets.",
        updatedAt: 1765526400000,
      },
      memoryAggregate: null,
      toolsNotes: null,
      bootstrap: { completed: true, completedAt: 1765526400000 },
    },
    userProfile: null,
    userTimezone: null,
    organizationId: "org_abc123",
  },
  "agentConfig.organisation.edit": {
    identity: null,
    organisation: { content: "Acme builds widgets.", updatedAt: 1765526400000 },
    memoryAggregate: null,
    toolsNotes: null,
    bootstrap: { completed: true, completedAt: 1765526400000 },
  },
  "agentConfig.user.show": {
    agentConfig: {
      identity: null,
      organisation: null,
      memoryAggregate: null,
      toolsNotes: null,
      bootstrap: { completed: true, completedAt: 1765526400000 },
    },
    userProfile: {
      content: "Name: Alex\nRole: Engineer",
      updatedAt: 1765526400000,
    },
    userTimezone: null,
    organizationId: "org_abc123",
  },
  "agentConfig.user.edit": {
    content: "Name: Alex\nRole: Engineer",
    updatedAt: 1765526400000,
  },
  "agentConfig.tools.show": {
    agentConfig: {
      identity: null,
      organisation: null,
      memoryAggregate: null,
      toolsNotes: {
        content: "Prefer dench tool run for Stripe.",
        updatedAt: 1765526400000,
      },
      bootstrap: { completed: true, completedAt: 1765526400000 },
    },
    userProfile: null,
    userTimezone: null,
    organizationId: "org_abc123",
  },
  "agentConfig.tools.edit": {
    identity: null,
    organisation: null,
    memoryAggregate: null,
    toolsNotes: {
      content: "Prefer dench tool run for Stripe.",
      updatedAt: 1765526400000,
    },
    bootstrap: { completed: true, completedAt: 1765526400000 },
  },
  "agentConfig.mem.show": {
    agentConfig: {
      identity: null,
      organisation: null,
      memoryAggregate: {
        content: "Deploys go through Vercel.",
        updatedAt: 1765526400000,
      },
      toolsNotes: null,
      bootstrap: { completed: true, completedAt: 1765526400000 },
    },
    userProfile: null,
    userTimezone: null,
    organizationId: "org_abc123",
  },
  "agentConfig.mem.edit": {
    identity: null,
    organisation: null,
    memoryAggregate: {
      content: "Deploys go through Vercel.",
      updatedAt: 1765526400000,
    },
    toolsNotes: null,
    bootstrap: { completed: true, completedAt: 1765526400000 },
  },
  "agentConfig.bootstrap.show": {
    agentConfig: {
      identity: null,
      organisation: null,
      memoryAggregate: null,
      toolsNotes: null,
      bootstrap: { completed: false, template: "Welcome! Let's set up." },
    },
    userProfile: null,
    userTimezone: null,
    organizationId: "org_abc123",
  },
  "agentConfig.bootstrap.complete": {
    identity: null,
    organisation: null,
    memoryAggregate: null,
    toolsNotes: null,
    bootstrap: { completed: true, completedAt: 1765526400000 },
  },
  "agentConfig.bootstrap.template": {
    identity: null,
    organisation: null,
    memoryAggregate: null,
    toolsNotes: null,
    bootstrap: { completed: false, template: "Welcome! Let's set up." },
  },
  "agentConfig.model.default": {
    defaultChatModelId: "anthropic/claude-sonnet-4",
  },
  "agentConfig.model.thread": {
    threadId: "th_abc123",
    modelOverride: "anthropic/claude-opus-4",
  },
  "agentConfig.daily.today": {
    agentConfig: {
      identity: null,
      organisation: null,
      memoryAggregate: null,
      toolsNotes: null,
      bootstrap: { completed: true, completedAt: 1765526400000 },
    },
    userProfile: null,
    userTimezone: null,
    organizationId: "org_abc123",
  },
  "agentConfig.daily.show": {
    agentConfig: {
      identity: null,
      organisation: null,
      memoryAggregate: null,
      toolsNotes: null,
      bootstrap: { completed: true, completedAt: 1765526400000 },
    },
    userProfile: null,
    userTimezone: null,
    organizationId: "org_abc123",
  },
  "crm.analytics.get": {
    objectName: "lead",
    analytics: {
      panels: [
        {
          id: "tpl:sales:total-leads",
          title: "Total leads",
          type: "stat",
          metric: "count",
          sortOrder: 0,
        },
        {
          id: "tpl:sales:leads-by-source",
          title: "Leads by source",
          type: "donut",
          metric: "count",
          groupBy: "Source",
          sortOrder: 1,
        },
      ],
      fieldRoles: { stage: "Status", convertedValues: ["Qualified"] },
      stripCollapsed: false,
    },
    viewAnalytics: null,
    viewExists: false,
    fields: [
      {
        name: "Status",
        type: "enum",
        enumValues: ["New", "Qualified"],
        enumColors: null,
      },
      { name: "$createdAt", type: "date", enumValues: null, enumColors: null },
    ],
  },
  "crm.analytics.compute": {
    objectName: "lead",
    truncated: false,
    scannedRows: 42,
    panels: [
      {
        id: "adhoc:leads-by-source",
        unit: "number",
        value: 42,
        previousValue: 31,
        buckets: [
          { key: "Website", label: "Website", count: 25, value: 25 },
          { key: "Referral", label: "Referral", count: 17, value: 17 },
        ],
      },
    ],
  },
  "crm.analytics.save": { ok: true, panelId: "adhoc:open-pipeline" },
  "crm.analytics.delete": { ok: true, removed: true },
  "crm.analytics.reorder": { ok: true },
  "crm.analytics.roles": { ok: true },
  "crm.analytics.collapse": { ok: true },
  "crm.analytics.expand": { ok: true },
  "crm.analytics.scope": { ok: true, changed: true },
};