@gravity-rail/sdk 0.7.2 → 0.7.3

package/dist/index.js

@@ -95,6 +95,7 @@ import {
   areDependenciesSatisfied,
   canPreviewVoice,
   clearRegistry,
+  createWorkspaceClient,
   decodePermissions,
   encodePermissions,
   eventRuleActionParams,
@@ -121,7 +122,7 @@ import {
   requiresAssistantParticipant,
   usesBuiltinAssistant,
   validateFeatureDependencies
-} from "./chunk-WXSLDWIA.js";
+} from "./chunk-YCASSXLL.js";
 import {
   AttendeeResponseStatus,
   AttendeeStatus,
@@ -136,6 +137,1212 @@ import {
   DataTypeRecordScope,
   IndexStatus
 } from "./chunk-QS6ZRQUZ.js";
+
+// src/workspace-builder/resource.ts
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isPlainRecord(value) {
+  if (!isRecord(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function slugify(name) {
+  return name.toLowerCase().replaceAll(" ", "_").replaceAll("-", "_");
+}
+var WorkspaceBuilderResource = class {
+  _id;
+  _uuid;
+  _created = false;
+  _existed = false;
+  matchKey() {
+    return void 0;
+  }
+  adopt(existing) {
+    this._id = existing.id;
+    this._uuid = existing.uuid;
+    this._existed = true;
+  }
+};
+function resolveRefs(params) {
+  return resolveRefValue(params);
+}
+function resolveRefValue(value) {
+  if (value instanceof WorkspaceBuilderResource) return value._uuid;
+  if (Array.isArray(value)) return value.map(resolveRefValue);
+  if (!isPlainRecord(value)) return value;
+  const out = {};
+  for (const [key, nestedValue] of Object.entries(value)) {
+    out[key] = resolveRefValue(nestedValue);
+  }
+  return out;
+}
+
+// src/workspace-builder/automation.ts
+var MemberFilterBuilder = class extends WorkspaceBuilderResource {
+  constructor(name, options = {}) {
+    super();
+    this.name = name;
+    this.description = options.description ?? "";
+  }
+  description;
+  rules = [];
+  addRule(objectType, filterType, options = {}) {
+    this.rules.push({
+      objectType,
+      filterType,
+      ...options.objectIds ? { objectIds: options.objectIds } : {},
+      ...options.query ? { query: options.query } : {}
+    });
+    return this;
+  }
+  planLine() {
+    return `MemberFilter: ${this.name}${this.rules.length ? ` (${this.rules.length} rules)` : ""}`;
+  }
+  async apply(client) {
+    const payload = {
+      name: this.name,
+      description: this.description,
+      rules: this.rules
+    };
+    const result = await client.createMemberFilter(payload);
+    this._id = result.id;
+    this._uuid = result.uuid;
+    this._created = true;
+  }
+};
+var RoutineBuilder = class extends WorkspaceBuilderResource {
+  constructor(name, cronSchedule = "", options = {}) {
+    super();
+    this.name = name;
+    this.cronSchedule = cronSchedule;
+    this.active = options.active ?? false;
+    this.description = options.description ?? "";
+  }
+  active;
+  description;
+  rules = [];
+  addRule(actionType, options = {}) {
+    this.rules.push({
+      actionType,
+      workflow: options.workflow,
+      memberFilter: options.memberFilter,
+      actionParams: options.actionParams ?? {}
+    });
+    return this;
+  }
+  planLine() {
+    const parts = [
+      ...this.cronSchedule ? [`cron=${this.cronSchedule}`] : [],
+      ...this.rules.length ? [`${this.rules.length} rules`] : [],
+      this.active ? "active" : "inactive"
+    ];
+    return `Routine: ${this.name} (${parts.join(", ")})`;
+  }
+  async apply(client) {
+    const eventRules = this.rules.map((rule) => {
+      const actionParams = { ...rule.actionParams };
+      if (rule.workflow?._id !== void 0) actionParams.workflowId = rule.workflow._id;
+      if (rule.memberFilter?._id !== void 0)
+        actionParams.memberFilterId = rule.memberFilter._id;
+      return {
+        uuid: crypto.randomUUID(),
+        objectType: "routine" /* ROUTINE */,
+        eventType: "routine:triggered" /* ROUTINE_TRIGGERED */,
+        actionType: rule.actionType,
+        actionParams,
+        active: true
+      };
+    });
+    const payload = {
+      name: this.name,
+      cronString: this.cronSchedule,
+      scheduleMode: this.cronSchedule ? "CRON" : void 0,
+      scheduleEnabled: this.active,
+      ...this.description ? { description: this.description } : {},
+      ...eventRules.length ? { eventRules } : {}
+    };
+    const result = await client.createRoutine(payload);
+    this._id = result.id;
+    this._uuid = result.uuid;
+    this._created = true;
+  }
+};
+var NotificationRuleBuilder = class extends WorkspaceBuilderResource {
+  constructor(name, options = {}) {
+    super();
+    this.name = name;
+    this.noticeType = options.noticeType ?? options.notice_type ?? name;
+    this.memberId = options.memberId ?? options.member_id;
+    this.workflow = options.workflow;
+    this.prompt = options.prompt ?? options.message;
+    this.notifySms = Boolean(options.notifySms ?? options.notify_sms);
+    this.notifyEmail = Boolean(options.notifyEmail ?? options.notify_email);
+    this.notifyVoice = Boolean(options.notifyVoice ?? options.notify_voice);
+  }
+  noticeType;
+  memberId;
+  workflow;
+  prompt;
+  notifySms;
+  notifyEmail;
+  notifyVoice;
+  planLine() {
+    const parts = [];
+    if (this.memberId !== void 0) parts.push(`memberId=${this.memberId}`);
+    if (this.workflow) parts.push(`workflow='${this.workflow.name}'`);
+    return `NotificationRule: ${this.name}${parts.length ? ` (${parts.join(", ")})` : ""}`;
+  }
+  async apply(client) {
+    if (this.memberId === void 0) {
+      throw new Error(`Notification rule '${this.name}' requires memberId`);
+    }
+    const payload = {
+      noticeType: this.noticeType,
+      memberId: this.memberId,
+      workflowId: this.workflow?._id,
+      prompt: this.prompt ?? null,
+      notifySms: this.notifySms,
+      notifyEmail: this.notifyEmail,
+      notifyVoice: this.notifyVoice
+    };
+    const result = await client.createNotificationRule(payload);
+    this._id = result.id;
+    this._created = true;
+  }
+};
+
+// src/workspace-builder/forms.ts
+function normalizeOptions(options) {
+  if (options.length === 0) return [];
+  const first = options[0];
+  if (isRecord(first)) return options;
+  if (Array.isArray(first)) {
+    return options.map((entry) => ({ label: String(entry[0]), value: entry[1] }));
+  }
+  return options.map((option) => ({ label: String(option), value: String(option) }));
+}
+function createFieldDraft(fieldType, name, slug, options = {}) {
+  return {
+    name,
+    slug,
+    fieldType,
+    required: Boolean(options.required),
+    order: options.order ?? 0,
+    ...options.description ? { description: options.description } : {},
+    ...options.choices ? { options: options.choices } : {},
+    ...options.cel ? { celFunction: options.cel } : {}
+  };
+}
+var FormBuilder = class extends WorkspaceBuilderResource {
+  name;
+  slug;
+  description;
+  prompt;
+  collection;
+  fields = [];
+  eventRules = [];
+  constructor(name, slug, options = {}) {
+    super();
+    this.name = name;
+    this.slug = slug ?? slugify(name);
+    this.description = options.description ?? "";
+    this.prompt = options.prompt ?? "";
+    this.collection = options.collection ?? false;
+    for (const field of options.fields ?? []) {
+      if (!isRecord(field) || !field.name) continue;
+      const choices = field.options ? normalizeOptions(field.options) : void 0;
+      this.fields.push(
+        createFieldDraft(
+          field.fieldType ?? field.field_type ?? "text" /* TEXT */,
+          field.name,
+          field.slug ?? slugify(field.name),
+          {
+            required: Boolean(field.required ?? field.isRequired),
+            order: field.order ?? 0,
+            description: field.description,
+            choices
+          }
+        )
+      );
+    }
+  }
+  field(fieldType, name, slug, options = {}) {
+    this.fields.push(createFieldDraft(fieldType, name, slug, options));
+    return this;
+  }
+  enumField(name, slug, options, settings = {}) {
+    return this.field("enum" /* ENUM */, name, slug, {
+      ...settings,
+      choices: normalizeOptions(options)
+    });
+  }
+  textField(name, slug, settings = {}) {
+    return this.field("text" /* TEXT */, name, slug, settings);
+  }
+  numberField(name, slug, settings = {}) {
+    return this.field("number" /* NUMBER */, name, slug, settings);
+  }
+  dateField(name, slug, settings = {}) {
+    return this.field("date" /* DATE */, name, slug, settings);
+  }
+  booleanField(name, slug, settings = {}) {
+    return this.field("boolean" /* BOOLEAN */, name, slug, settings);
+  }
+  functionField(name, slug, cel, settings = {}) {
+    return this.field("function" /* FUNCTION */, name, slug, { ...settings, cel });
+  }
+  emailField(name, slug, settings = {}) {
+    return this.field("email" /* EMAIL */, name, slug, settings);
+  }
+  phoneField(name, slug, settings = {}) {
+    return this.field("phone" /* PHONE */, name, slug, settings);
+  }
+  longtextField(name, slug, settings = {}) {
+    return this.field("longtext" /* LONGTEXT */, name, slug, settings);
+  }
+  integerField(name, slug, settings = {}) {
+    return this.field("integer" /* INTEGER */, name, slug, settings);
+  }
+  datetimeField(name, slug, settings = {}) {
+    return this.field("datetime" /* DATETIME */, name, slug, settings);
+  }
+  timeOfDayField(name, slug, settings = {}) {
+    return this.field("time_of_day" /* TIME_OF_DAY */, name, slug, settings);
+  }
+  usZipCodeField(name, slug, settings = {}) {
+    return this.field("us_zip_code" /* US_ZIP_CODE */, name, slug, settings);
+  }
+  arrayField(name, slug, settings = {}) {
+    return this.field("array" /* ARRAY */, name, slug, settings);
+  }
+  objectField(name, slug, settings = {}) {
+    return this.field("object" /* OBJECT */, name, slug, settings);
+  }
+  onRecordCreated(action, params = {}, condition, name) {
+    this.eventRules.push({
+      eventType: "data_record:created" /* DATA_RECORD_CREATED */,
+      actionType: action,
+      actionParams: params,
+      condition,
+      name
+    });
+    return this;
+  }
+  onRecordUpdated(action, params = {}, condition, name) {
+    this.eventRules.push({
+      eventType: "data_record:updated" /* DATA_RECORD_UPDATED */,
+      actionType: action,
+      actionParams: params,
+      condition,
+      name
+    });
+    return this;
+  }
+  matchKey() {
+    return this.slug;
+  }
+  planLine() {
+    return `Form: ${this.name} (slug=${this.slug}, ${this.fields.length} fields)`;
+  }
+  async apply(client) {
+    if (this._existed) return;
+    const payload = {
+      name: this.name,
+      slug: this.slug,
+      description: this.description,
+      prompt: this.prompt,
+      isCollection: this.collection,
+      fields: this.fields
+    };
+    const result = await client.createDataType(payload);
+    this._id = result.id;
+    this._uuid = result.uuid;
+    this._created = true;
+  }
+};
+var MemberLabelBuilder = class extends WorkspaceBuilderResource {
+  name;
+  slug;
+  color;
+  description;
+  constructor(name, slug, color = "8b5cf6", description = "") {
+    super();
+    this.name = name;
+    this.slug = slug ?? slugify(name);
+    this.color = color;
+    this.description = description;
+  }
+  matchKey() {
+    return this.slug;
+  }
+  planLine() {
+    return `Label: ${this.name} (slug=${this.slug})`;
+  }
+  async apply(client) {
+    if (this._existed) return;
+    const payload = {
+      name: this.name,
+      slug: this.slug,
+      color: this.color,
+      description: this.description
+    };
+    const result = await client.createMemberLabel(payload);
+    this._id = result.id;
+    this._uuid = result.uuid;
+    this._created = true;
+  }
+};
+
+// src/workspace-builder/journeys.ts
+var JourneyStepBuilder = class extends WorkspaceBuilderResource {
+  constructor(name, journey, order = 0, workflow, description = "") {
+    super();
+    this.name = name;
+    this.journey = journey;
+    this.order = order;
+    this.workflow = workflow;
+    this.description = description;
+  }
+  connections = [];
+  connectsTo(child, condition, required = false, timeoutSeconds) {
+    this.connections.push({ parent: this, child, condition, required, timeoutSeconds });
+    return this;
+  }
+  planLine() {
+    return `Step: ${this.name}${this.workflow ? ` -> workflow '${this.workflow.name}'` : ""}`;
+  }
+  async apply(client) {
+    if (this.journey._id === void 0) return;
+    const payload = {
+      name: this.name,
+      description: this.description,
+      order: this.order,
+      ...this.workflow?._id ? { workflowId: this.workflow._id } : {}
+    };
+    const result = await client.createStep(this.journey._id, payload);
+    this._id = result.id;
+    this._uuid = result.uuid;
+    this._created = true;
+  }
+};
+var JourneyBuilder = class extends WorkspaceBuilderResource {
+  constructor(name, options = {}) {
+    super();
+    this.name = name;
+    this.description = options.description ?? "";
+  }
+  description;
+  steps = [];
+  goals = [];
+  step(name, options = {}) {
+    const step = new JourneyStepBuilder(
+      name,
+      this,
+      options.order ?? 0,
+      options.workflow,
+      options.description ?? ""
+    );
+    this.steps.push(step);
+    return step;
+  }
+  goal(name, options = {}) {
+    this.goals.push({
+      name,
+      description: options.description ?? "",
+      step: options.step,
+      completionCel: options.completionCel ?? options.completion_cel,
+      value: options.value,
+      order: options.order ?? 0
+    });
+    return this;
+  }
+  planLine() {
+    const parts = [];
+    if (this.steps.length) parts.push(`${this.steps.length} steps`);
+    if (this.goals.length) parts.push(`${this.goals.length} goals`);
+    return `Journey: ${this.name}${parts.length ? ` (${parts.join(", ")})` : ""}`;
+  }
+  async apply(client) {
+    const result = await client.createJourney({
+      name: this.name,
+      description: this.description
+    });
+    this._id = result.id;
+    this._uuid = result.uuid;
+    this._created = true;
+  }
+};
+function buildJourneyConnectionPayload(connection) {
+  if (!connection.parent._uuid || !connection.child._uuid) return void 0;
+  return {
+    parentStepUuid: connection.parent._uuid,
+    childStepUuid: connection.child._uuid,
+    ...connection.condition ? { celCondition: connection.condition } : {},
+    ...connection.required ? { required: true } : {},
+    ...connection.timeoutSeconds ? { timeoutSeconds: connection.timeoutSeconds } : {}
+  };
+}
+function buildJourneyGoalPayload(goal) {
+  return {
+    name: goal.name,
+    description: goal.description,
+    order: goal.order,
+    ...goal.step?._uuid ? { goalStepUuid: goal.step._uuid } : {},
+    ...goal.completionCel ? { completionCel: goal.completionCel } : {},
+    ...goal.value !== void 0 ? { value: goal.value } : {}
+  };
+}
+
+// src/workspace-builder/role-update.ts
+var RoleUpdate = class extends WorkspaceBuilderResource {
+  constructor(roleId, workflowIds, dataTypeIds) {
+    super();
+    this.roleId = roleId;
+    this.workflowIds = workflowIds;
+    this.dataTypeIds = dataTypeIds;
+  }
+  planLine() {
+    const parts = [];
+    if (this.workflowIds) parts.push(`workflows=${JSON.stringify(this.workflowIds)}`);
+    if (this.dataTypeIds) parts.push(`dataTypes=${JSON.stringify(this.dataTypeIds)}`);
+    return `RoleUpdate: roleId=${this.roleId}${parts.length ? ` (${parts.join(", ")})` : ""}`;
+  }
+  async apply(client) {
+    const payload = {};
+    if (this.workflowIds) payload.workflowIds = this.workflowIds;
+    if (this.dataTypeIds) payload.dataTypeIds = this.dataTypeIds;
+    if (Object.keys(payload).length) await client.updateMemberRole(this.roleId, payload);
+    this._id = this.roleId;
+    this._created = true;
+  }
+};
+
+// src/workspace-builder/workflows.ts
+var PERM_KEYS = {
+  canRead: "canRead",
+  canCreate: "canCreate",
+  canEdit: "canEdit",
+  can_read: "canRead",
+  can_create: "canCreate",
+  can_edit: "canEdit"
+};
+var ABILITY_TYPE_MAP = {
+  data_access: "integration:data_access",
+  file_access: "integration:file_access",
+  escalation: "oversight:escalation"
+};
+var AbilityDef = class {
+  constructor(abilityType, options = {}) {
+    this.abilityType = abilityType;
+    this.config = options.config ?? {};
+    this.enabled = options.enabled ?? true;
+    this.celCondition = options.celCondition ?? options.cel_condition;
+    this.form = options.form;
+    for (const [inputKey, outputKey] of Object.entries(PERM_KEYS)) {
+      if (inputKey in options) this.perms[outputKey] = options[inputKey];
+    }
+  }
+  uuid = crypto.randomUUID();
+  config;
+  enabled;
+  celCondition;
+  form;
+  perms = {};
+  toAbility() {
+    const config = { ...this.config };
+    if (this.form?._uuid) {
+      config.dataTypeUuid = this.form._uuid;
+      Object.assign(config, this.perms);
+    }
+    return {
+      uuid: this.uuid,
+      abilityType: ABILITY_TYPE_MAP[this.abilityType] ?? this.abilityType,
+      config,
+      enabled: this.enabled,
+      ...this.celCondition ? { celCondition: this.celCondition } : {}
+    };
+  }
+};
+var TaskBuilder = class extends WorkspaceBuilderResource {
+  constructor(name, workflow, prompt = "", start = false, description = "") {
+    super();
+    this.name = name;
+    this.workflow = workflow;
+    this.prompt = prompt;
+    this.start = start;
+    this.description = description;
+  }
+  transitions = [];
+  eventRules = [];
+  transitionsTo(child, when, autoNext = false, required = false) {
+    if (child === this) {
+      throw new Error(`Task '${this.name}' cannot transition to itself`);
+    }
+    this.transitions.push({ parent: this, child, when, autoNext, required });
+    return this;
+  }
+  onEnter(action, params = {}, name) {
+    this.eventRules.push({
+      eventType: "task:execute" /* TASK_EXECUTE */,
+      actionType: action,
+      actionParams: params,
+      name
+    });
+    return this;
+  }
+  initialMessage(message, suggestions) {
+    return this.onEnter("assistant:message", {
+      message,
+      ...suggestions ? { suggestions } : {}
+    });
+  }
+  planLine() {
+    return `Task: ${this.name}${this.start ? " [start]" : ""}`;
+  }
+  async apply(client) {
+    if (this._existed || this.workflow._id === void 0) return;
+    const result = await client.createTask({
+      workflowId: this.workflow._id,
+      name: this.name,
+      prompt: this.prompt,
+      description: this.description
+    });
+    this._id = result.id;
+    this._uuid = result.uuid;
+    this._created = true;
+  }
+};
+var WorkflowBuilder = class extends WorkspaceBuilderResource {
+  constructor(name, options = {}) {
+    super();
+    this.name = name;
+    this.description = options.description ?? "";
+    this.prompt = options.prompt;
+    this.agentId = options.agentId ?? options.agent_id;
+  }
+  description;
+  prompt;
+  agentId;
+  tasks = [];
+  abilities = [];
+  task(name, options = {}) {
+    const task = new TaskBuilder(
+      name,
+      this,
+      options.prompt ?? "",
+      options.start ?? false,
+      options.description ?? ""
+    );
+    this.tasks.push(task);
+    return task;
+  }
+  ability(abilityType, options = {}) {
+    this.abilities.push(new AbilityDef(abilityType, options));
+    return this;
+  }
+  get startTask() {
+    return this.tasks.find((task) => task.start) ?? this.tasks[0];
+  }
+  matchKey() {
+    return this.name;
+  }
+  adopt(existing) {
+    super.adopt(existing);
+    const start = this.startTask;
+    if (start && existing.startTaskId) {
+      start._id = existing.startTaskId;
+      start._existed = true;
+    }
+  }
+  planLine() {
+    const details = [];
+    if (this.tasks.length) details.push(`${this.tasks.length} tasks`);
+    if (this.abilities.length) details.push(`${this.abilities.length} abilities`);
+    return `Workflow: ${this.name}${details.length ? ` (${details.join(", ")})` : ""}`;
+  }
+  async apply(client) {
+    if (this._existed) return;
+    const payload = {
+      name: this.name,
+      description: this.description,
+      createMode: "taskless",
+      ...this.prompt ? { prompt: this.prompt } : {},
+      ...this.agentId ? { agentId: this.agentId } : {},
+      ...this.abilities.length ? { abilities: this.abilities.map((ability) => ability.toAbility()) } : {}
+    };
+    const result = await client.createWorkflow(payload);
+    this._id = result.id;
+    this._uuid = result.uuid;
+    this._created = true;
+  }
+};
+var AgentBuilder = class extends WorkspaceBuilderResource {
+  constructor(name, options = {}) {
+    super();
+    this.name = name;
+    this.chatModelId = options.chatModelId ?? options.chat_model_id ?? "";
+    this.systemPrompt = options.systemPrompt ?? options.system_prompt ?? "";
+    this.memberRoleId = options.roleId ?? options.role_id;
+    this.tools = options.tools ?? [];
+    this.codeInterpreterEnabled = options.codeInterpreterEnabled ?? options.code_interpreter_enabled ?? false;
+  }
+  chatModelId;
+  systemPrompt;
+  memberRoleId;
+  tools;
+  codeInterpreterEnabled;
+  planLine() {
+    const parts = [];
+    if (this.chatModelId) parts.push(`model=${this.chatModelId}`);
+    if (this.tools.length) parts.push(`${this.tools.length} tools`);
+    return `Agent: ${this.name}${parts.length ? ` (${parts.join(", ")})` : ""}`;
+  }
+  async apply(client) {
+    if (this.memberRoleId === void 0) {
+      throw new Error(`Agent '${this.name}' requires memberRoleId`);
+    }
+    if (!this.chatModelId) {
+      throw new Error(`Agent '${this.name}' requires chatModelId`);
+    }
+    const payload = {
+      name: this.name,
+      memberRoleId: this.memberRoleId,
+      chatModelId: this.chatModelId,
+      systemPrompt: this.systemPrompt,
+      ...this.tools.length ? { tools: this.tools } : {},
+      ...this.codeInterpreterEnabled ? { codeInterpreterEnabled: true } : {}
+    };
+    const result = await client.createAgent(payload);
+    this._id = result.id;
+    this._uuid = result.uuid;
+    this._created = true;
+  }
+};
+
+// src/workspace-builder/orchestrator.ts
+var PHASES = /* @__PURE__ */ new Map([
+  [FormBuilder, 0],
+  [MemberLabelBuilder, 0],
+  [AgentBuilder, 1],
+  [WorkflowBuilder, 2],
+  [TaskBuilder, 3],
+  [RoleUpdate, 4],
+  [MemberFilterBuilder, 5],
+  [RoutineBuilder, 6],
+  [NotificationRuleBuilder, 6],
+  [JourneyBuilder, 7],
+  [JourneyStepBuilder, 8]
+]);
+var WorkspaceBuilder = class {
+  constructor(client) {
+    this.client = client;
+  }
+  resources = [];
+  form(name, options = {}) {
+    const form = new FormBuilder(name, options.slug, options);
+    this.resources.push(form);
+    return form;
+  }
+  workflow(name, options = {}) {
+    const workflow = new WorkflowBuilder(name, options);
+    this.resources.push(workflow);
+    return workflow;
+  }
+  label(name, options = {}) {
+    const label = new MemberLabelBuilder(
+      name,
+      options.slug,
+      options.color,
+      options.description ?? ""
+    );
+    this.resources.push(label);
+    return label;
+  }
+  journey(name, options = {}) {
+    const journey = new JourneyBuilder(name, options);
+    this.resources.push(journey);
+    return journey;
+  }
+  agent(name, options = {}) {
+    const agent = new AgentBuilder(name, options);
+    this.resources.push(agent);
+    return agent;
+  }
+  routine(name, cronSchedule = "", options = {}) {
+    const routine = new RoutineBuilder(name, cronSchedule, options);
+    this.resources.push(routine);
+    return routine;
+  }
+  memberFilter(name, options = {}) {
+    const filter = new MemberFilterBuilder(name, options);
+    this.resources.push(filter);
+    return filter;
+  }
+  notificationRule(name, options = {}) {
+    const rule = new NotificationRuleBuilder(name, options);
+    this.resources.push(rule);
+    return rule;
+  }
+  roleUpdate(roleId, workflowIds, dataTypeIds) {
+    const update = new RoleUpdate(roleId, workflowIds, dataTypeIds);
+    this.resources.push(update);
+    return update;
+  }
+  plan() {
+    const resources = this.sortedResources();
+    writeLine(`
+${"=".repeat(50)}`);
+    writeLine("Plan");
+    writeLine("=".repeat(50));
+    for (const resource of resources) {
+      writeLine(`  + ${resource.planLine()}`);
+    }
+    const wiring = this.collectWiringSummary(resources);
+    if (wiring.length) {
+      writeLine("\n  Wiring:");
+      for (const line of wiring) writeLine(`    ${line}`);
+    }
+    writeLine(`
+  Total: ${resources.length} resources, ${wiring.length} connections`);
+    writeLine(`${"=".repeat(50)}
+`);
+  }
+  async preview() {
+    const resources = this.sortedResources();
+    await this.resolveExisting(resources);
+    writeLine(`
+${"=".repeat(50)}`);
+    writeLine("Preview");
+    writeLine("=".repeat(50));
+    for (const resource of resources) {
+      if (resource._existed) {
+        writeLine(`  = ${resource.planLine()} (exists, id=${resource._id})`);
+      } else {
+        writeLine(`  + ${resource.planLine()}`);
+      }
+    }
+    const wiring = this.collectWiringSummary(resources);
+    if (wiring.length) {
+      writeLine("\n  Wiring:");
+      for (const line of wiring) writeLine(`    ${line}`);
+    }
+    const toCreate = resources.filter((resource) => !resource._existed);
+    const existing = resources.filter((resource) => resource._existed);
+    writeLine(
+      `
+  Total: ${toCreate.length} to create, ${existing.length} existing, ${wiring.length} connections`
+    );
+    writeLine(`${"=".repeat(50)}
+`);
+  }
+  async apply() {
+    const resources = this.sortedResources();
+    await this.resolveExisting(resources);
+    const summary = {};
+    writeLine("Applying...");
+    for (const resource of resources) {
+      try {
+        if (resource._existed) {
+          const key = resourceKey(resource);
+          summary[key] ??= [];
+          summary[key].push(resource._id);
+          writeLine(`  Exists ${resource.planLine()} -> id=${resource._id}`);
+          continue;
+        }
+        await resource.apply(this.client);
+        if (resource._created || resource._id !== void 0) {
+          const key = resourceKey(resource);
+          summary[key] ??= [];
+          summary[key].push(resource._id);
+          const startTag = resource instanceof TaskBuilder && resource.start ? " [start]" : "";
+          writeLine(`  Created ${resource.planLine()}${startTag} -> id=${resource._id}`);
+        } else {
+          writeLine(`  Skipped: ${resource.planLine()}`);
+        }
+      } catch (err) {
+        writeLine(`  FAILED: ${resource.planLine()}: ${summarizeError(err)}`);
+        throw new ApplyError(resource, err, summary);
+      }
+    }
+    await this.applyTransitions();
+    await this.applyEventRules(resources);
+    await this.applyJourneyConnections(resources);
+    await this.applyJourneyGoals(resources);
+    const count = Object.values(summary).reduce((total, ids) => total + ids.length, 0);
+    writeLine(`
+Done! Created ${count} resources.`);
+    return summary;
+  }
+  async resolveExisting(resources) {
+    const formSlugs = new Map(
+      resources.filter((resource) => resource instanceof FormBuilder).map((resource) => [resource.slug, resource])
+    );
+    const labelSlugs = new Map(
+      resources.filter(
+        (resource) => resource instanceof MemberLabelBuilder
+      ).map((resource) => [resource.slug, resource])
+    );
+    const workflowNames = new Map(
+      resources.filter((resource) => resource instanceof WorkflowBuilder).map((resource) => [resource.name, resource])
+    );
+    if (formSlugs.size) {
+      for (const existing of await this.client.getDataTypes()) {
+        if (existing.slug && formSlugs.has(existing.slug)) {
+          formSlugs.get(existing.slug).adopt(existing);
+        }
+      }
+    }
+    if (labelSlugs.size) {
+      for (const existing of await this.client.getMemberLabels()) {
+        if (existing.slug && labelSlugs.has(existing.slug)) {
+          labelSlugs.get(existing.slug).adopt(existing);
+        }
+      }
+    }
+    if (!workflowNames.size) return;
+    for (const existing of await this.client.getWorkflows()) {
+      if (existing.name && workflowNames.has(existing.name)) {
+        workflowNames.get(existing.name).adopt(existing);
+      }
+    }
+    const adoptedWorkflows = resources.filter(
+      (resource) => resource instanceof WorkflowBuilder && resource._existed && resource._id !== void 0
+    );
+    if (!adoptedWorkflows.length) return;
+    const existingTasks = await this.client.getTasks();
+    for (const workflow of adoptedWorkflows) {
+      const workflowTasks = existingTasks.filter((task) => task.workflowId === workflow._id);
+      const taskByName = new Map(workflowTasks.map((task) => [task.name, task]));
+      for (const taskBuilder of workflow.tasks) {
+        const match = taskByName.get(taskBuilder.name);
+        if (match) taskBuilder.adopt(match);
+      }
+      const ids = /* @__PURE__ */ new Map();
+      for (const taskBuilder of workflow.tasks) {
+        if (taskBuilder._id !== void 0) {
+          ids.set(taskBuilder._id, [...ids.get(taskBuilder._id) ?? [], taskBuilder]);
+        }
+      }
+      for (const builders of ids.values()) {
+        if (builders.length <= 1) continue;
+        const nameAdopted = builders.filter((task) => taskByName.has(task.name));
+        for (const task of builders.filter((builder) => !nameAdopted.includes(builder))) {
+          task._id = void 0;
+          task._existed = false;
+        }
+      }
+    }
+  }
+  sortedResources() {
+    const all = [];
+    for (const resource of this.resources) {
+      all.push(resource);
+      if (resource instanceof WorkflowBuilder) {
+        const start = resource.startTask;
+        const tasks = start === void 0 ? resource.tasks : [start, ...resource.tasks.filter((task) => task !== start)];
+        all.push(...tasks);
+      } else if (resource instanceof JourneyBuilder) {
+        all.push(...resource.steps);
+      }
+    }
+    return all.sort(
+      (a, b) => (PHASES.get(a.constructor) ?? 99) - (PHASES.get(b.constructor) ?? 99)
+    );
+  }
+  collectWiringSummary(resources) {
+    const lines = [];
+    for (const resource of resources) {
+      if (resource instanceof TaskBuilder) {
+        for (const transition of resource.transitions) {
+          lines.push(`${transition.parent.name} -> ${transition.child.name}`);
+        }
+        for (const rule of resource.eventRules) {
+          lines.push(`${rule.actionType} on enter '${resource.name}'`);
+        }
+      } else if (resource instanceof FormBuilder) {
+        for (const rule of resource.eventRules) {
+          lines.push(`${rule.actionType} on ${rule.eventType} '${resource.name}'`);
+        }
+      } else if (resource instanceof RoutineBuilder) {
+        for (const rule of resource.rules)
+          lines.push(`${rule.actionType} rule on '${resource.name}'`);
+      } else if (resource instanceof JourneyStepBuilder) {
+        for (const connection of resource.connections) {
+          lines.push(`${connection.parent.name} -> ${connection.child.name}`);
+        }
+      } else if (resource instanceof JourneyBuilder) {
+        for (const goal of resource.goals) lines.push(`Goal: ${goal.name}`);
+      }
+    }
+    return lines;
+  }
+  async applyTransitions() {
+    const parentChildren = /* @__PURE__ */ new Map();
+    for (const resource of this.sortedResources()) {
+      if (!(resource instanceof TaskBuilder)) continue;
+      for (const transition of resource.transitions) {
+        parentChildren.set(transition.parent, [
+          ...parentChildren.get(transition.parent) ?? [],
+          transition
+        ]);
+      }
+    }
+    for (const [parent, transitions] of parentChildren) {
+      if (parent._id === void 0) continue;
+      const childTasks = transitions.flatMap((transition) => {
+        const taskId = transition.child._id;
+        if (taskId === void 0 || taskId === parent._id) return [];
+        return [
+          {
+            taskId,
+            choicePrompt: transition.when,
+            celCondition: null,
+            autoNext: transition.autoNext,
+            required: transition.required
+          }
+        ];
+      });
+      if (!childTasks.length) continue;
+      await this.client.updateTask(parent._id, { childTasks });
+      writeLine(
+        `  Wired: ${parent.name} -> [${transitions.map((tr) => tr.child.name).join(", ")}]`
+      );
+    }
+  }
+  async applyEventRules(resources) {
+    for (const resource of resources) {
+      if (resource instanceof TaskBuilder) {
+        for (const rule of resource.eventRules) {
+          try {
+            const payload = {
+              objectType: "task" /* TASK */,
+              taskId: resource._id,
+              eventType: rule.eventType,
+              actionType: rule.actionType,
+              actionParams: resolveRefs(rule.actionParams),
+              ...rule.name ? { name: rule.name } : {}
+            };
+            await this.applyEventRule(
+              payload,
+              `${rule.actionType} on enter '${resource.name}'`
+            );
+          } catch (err) {
+            handleEventRuleApplyFailure(resource.name, err);
+          }
+        }
+      } else if (resource instanceof FormBuilder) {
+        for (const rule of resource.eventRules) {
+          try {
+            const payload = {
+              objectType: "data_record" /* DATA_RECORD */,
+              dataTypeId: resource._id,
+              eventType: rule.eventType,
+              actionType: rule.actionType,
+              actionParams: resolveRefs(rule.actionParams),
+              ...rule.condition ? { conditions: rule.condition } : {},
+              ...rule.name ? { name: rule.name } : {}
+            };
+            await this.applyEventRule(
+              payload,
+              `${rule.actionType} on ${rule.eventType} '${resource.name}'`
+            );
+          } catch (err) {
+            handleEventRuleApplyFailure(resource.name, err);
+          }
+        }
+      }
+    }
+  }
+  async applyEventRule(payload, label) {
+    const existing = await this.findMatchingEventRule(payload);
+    if (!existing) {
+      await this.client.createEventRule(payload);
+      writeLine(`  Wired: ${label}`);
+      return;
+    }
+    const update = eventRuleUpdate(existing, payload);
+    if (Object.keys(update).length) {
+      await this.client.updateEventRule(existing.id, update);
+      writeLine(`  Updated: ${label}`);
+    } else {
+      writeLine(`  Exists: ${label}`);
+    }
+  }
+  async findMatchingEventRule(payload) {
+    const sourceFilter = eventRuleSourceFilter(payload);
+    const candidates = await this.client.searchEventRules({
+      objectType: payload.objectType,
+      eventType: payload.eventType,
+      actionType: payload.actionType,
+      includeDisabled: true,
+      ...sourceFilter
+    });
+    return candidates.find((candidate) => eventRulesMatch(candidate, payload));
+  }
+  async applyJourneyConnections(resources) {
+    for (const resource of resources) {
+      if (!(resource instanceof JourneyStepBuilder)) continue;
+      for (const connection of resource.connections) {
+        if (resource.journey._id === void 0) continue;
+        const payload = buildJourneyConnectionPayload(connection);
+        if (!payload) continue;
+        await this.client.createConnection(resource.journey._id, payload);
+        writeLine(`  Wired: ${connection.parent.name} -> ${connection.child.name}`);
+      }
+    }
+  }
+  async applyJourneyGoals(resources) {
+    for (const resource of resources) {
+      if (!(resource instanceof JourneyBuilder) || resource._id === void 0) continue;
+      for (const goal of resource.goals) {
+        await this.client.createGoal(resource._id, buildJourneyGoalPayload(goal));
+        writeLine(`  Created goal: ${goal.name}`);
+      }
+    }
+  }
+};
+var ApplyError = class extends Error {
+  constructor(resource, cause, createdSoFar) {
+    super(
+      `Failed creating ${resource.planLine()}: ${summarizeError(cause)}
+Already created: ${JSON.stringify(
+        createdSoFar
+      )}`
+    );
+    this.resource = resource;
+    this.cause = cause;
+    this.createdSoFar = createdSoFar;
+  }
+};
+function resourceKey(resource) {
+  if (resource instanceof RoleUpdate) return "roleUpdates";
+  if (resource instanceof FormBuilder) return "forms";
+  if (resource instanceof MemberLabelBuilder) return "labels";
+  if (resource instanceof WorkflowBuilder) return "workflows";
+  if (resource instanceof TaskBuilder) return "tasks";
+  if (resource instanceof MemberFilterBuilder) return "memberFilters";
+  if (resource instanceof RoutineBuilder) return "routines";
+  if (resource instanceof NotificationRuleBuilder) return "notificationRules";
+  if (resource instanceof JourneyBuilder) return "journeys";
+  if (resource instanceof JourneyStepBuilder) return "journeySteps";
+  if (resource instanceof AgentBuilder) return "agents";
+  return "resources";
+}
+var SEARCHABLE_EVENT_RULE_SOURCE_FIELDS = [
+  "taskId",
+  "dataTypeId",
+  "routineId",
+  "workflowId",
+  "journeyStepId"
+];
+var EVENT_RULE_SOURCE_FIELDS = [
+  ...SEARCHABLE_EVENT_RULE_SOURCE_FIELDS,
+  "calendarId",
+  "calendarEventTypeId"
+];
+function eventRuleSourceFilter(payload) {
+  const filter = {};
+  for (const field of SEARCHABLE_EVENT_RULE_SOURCE_FIELDS) {
+    const value = payload[field];
+    if (value !== void 0 && value !== null) {
+      filter[field] = value;
+    }
+  }
+  return filter;
+}
+function eventRulesMatch(existing, payload) {
+  if (normalizeString(existing.name) !== normalizeString(payload.name)) return false;
+  if (existing.objectType !== payload.objectType) return false;
+  if (existing.eventType !== payload.eventType) return false;
+  if (existing.actionType !== payload.actionType) return false;
+  for (const field of EVENT_RULE_SOURCE_FIELDS) {
+    if ((existing[field] ?? null) !== (payload[field] ?? null)) return false;
+  }
+  if (normalizeString(payload.name)) return true;
+  if (normalizeString(existing.conditions) !== normalizeString(payload.conditions)) return false;
+  if (!eventRuleValueEqual(existing.actionParams, payload.actionParams ?? null)) return false;
+  if (!eventRuleValueEqual(existing.triggerParams, payload.triggerParams ?? null)) return false;
+  return true;
+}
+function eventRuleUpdate(existing, payload) {
+  const update = {};
+  const conditions = payload.conditions ?? null;
+  if (normalizeString(existing.conditions) !== normalizeString(conditions)) {
+    update.conditions = conditions;
+  }
+  const actionParams = payload.actionParams ?? null;
+  if (!eventRuleValueEqual(existing.actionParams, actionParams)) {
+    update.actionParams = payload.actionParams;
+  }
+  const triggerParams = payload.triggerParams ?? null;
+  if (!eventRuleValueEqual(existing.triggerParams, triggerParams)) {
+    update.triggerParams = payload.triggerParams;
+  }
+  const active = payload.active ?? true;
+  if (existing.active !== active) {
+    update.active = active;
+  }
+  const delay = payload.delay ?? 0;
+  if (existing.delay !== delay) {
+    update.delay = delay;
+  }
+  const order = payload.order ?? 0;
+  if (existing.order !== order) {
+    update.order = order;
+  }
+  return update;
+}
+function normalizeString(value) {
+  return value ?? "";
+}
+function eventRuleValueEqual(left, right) {
+  return JSON.stringify(stableValue(left)) === JSON.stringify(stableValue(right));
+}
+function stableValue(value) {
+  if (Array.isArray(value)) return value.map(stableValue);
+  if (!value || typeof value !== "object") return value;
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return value;
+  return Object.fromEntries(
+    Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, nested]) => [key, stableValue(nested)])
+  );
+}
+function writeLine(message = "") {
+  process.stdout.write(`${message}
+`);
+}
+function handleEventRuleApplyFailure(resourceName, err) {
+  if (hasStatus(err, 403)) {
+    writeLine(
+      `  WARNING: Event rule on '${resourceName}' failed (retry exec() with scopes=['automations:admin'])`
+    );
+    return;
+  }
+  const summary = summarizeError(err);
+  writeLine(`  FAILED: Event rule on '${resourceName}': ${summary}`);
+  throw new Error(`Failed wiring event rule on '${resourceName}': ${summary}`);
+}
+function summarizeError(err) {
+  if (err instanceof Error) return err.name || "Error";
+  return typeof err;
+}
+function hasStatus(err, status) {
+  if (typeof err === "object" && err !== null) {
+    const candidate = err;
+    if (candidate.status === status || candidate.statusCode === status) return true;
+  }
+  const message = err instanceof Error ? err.message : typeof err === "string" ? err : "";
+  return message.includes(String(status));
+}
+async function runWorkspaceScript(client, build, mode = "plan") {
+  const workspace = new WorkspaceBuilder(client);
+  await build(workspace);
+  if (mode === "plan") return workspace.plan();
+  if (mode === "preview") return workspace.preview();
+  if (mode === "apply") return workspace.apply();
+  throw new Error(`Unknown mode '${mode}'. Use plan, preview, or apply.`);
+}
 export {
   AbilityConfigIssueCode,
   AbilityConfigIssueSeverity,
@@ -144,7 +1351,9 @@ export {
   AccessGrantStatus,
   AccessGrantTrigger,
   AccessLevel,
+  AgentBuilder,
   ApiError,
+  ApplyError,
   AppsApi,
   AttendeeResponseStatus,
   AttendeeStatus,
@@ -181,19 +1390,25 @@ export {
   FhirClientType,
   FhirConnectionState,
   FhirVendor,
+  FormBuilder,
   GravityRailClient,
   IndexStatus,
   InvitationStatus,
   JobPosition,
+  JourneyBuilder,
+  JourneyStepBuilder,
   MASKED_SECRET_SENTINEL,
   McpServerState,
   MemberFeature,
+  MemberFilterBuilder,
+  MemberLabelBuilder,
   MemberType,
   MenuItemResponseItemType,
   MenuItemResponseItemType as MenuItemType,
   ModelProvider,
   ModelType,
   NO_ASSISTANT_PARTICIPANT_CHAT_TYPES,
+  NotificationRuleBuilder,
   OIDCAdminConfigViewProviderType,
   ORG_ONLY_RESOURCES,
   OrgApi,
@@ -219,6 +1434,8 @@ export {
   Region,
   RegistrationIdentifier,
   Resource,
+  RoleUpdate,
+  RoutineBuilder,
   SCOPES,
   SCOPE_PRESETS,
   SMS_DELIVERY_FAILURE_STATUSES,
@@ -238,15 +1455,19 @@ export {
   TTS_MODEL_ELEVENLABS_TURBO,
   TTS_MODEL_POCKET,
   TTS_PREVIEW_PROVIDERS,
+  TaskBuilder,
   TemplatesApi,
   ToolkitState,
   WorkflowAccessWarningResourceType,
+  WorkflowBuilder,
   WorkflowAccessWarningResourceType as WorkflowResourceType,
+  WorkspaceBuilder,
   WorkspaceFeature,
   WorkspaceProvisionStatus,
   areDependenciesSatisfied,
   canPreviewVoice,
   clearRegistry,
+  createWorkspaceClient,
   decodePermissions,
   encodePermissions,
   eventRuleActionParams,
@@ -271,6 +1492,7 @@ export {
   isRegistryInitialized,
   isSMSDeliveryFailureStatus,
   requiresAssistantParticipant,
+  runWorkspaceScript,
   usesBuiltinAssistant,
   validateFeatureDependencies
 };