@getmodus/sdk 0.1.0

package/dist/management/index.js

@@ -0,0 +1,896 @@
+import {
+  CustomContextItemsResource,
+  ModusClientBase,
+  ScopeConversationsResource,
+  aipListParams,
+  asRecord,
+  buildAipPage,
+  invokeWithRetry,
+  omitUndefined,
+  validateId,
+  validatePageSize
+} from "../chunk-VLHNZJBG.js";
+
+// src/_query.ts
+function updateMaskQuery(updateMask) {
+  if (updateMask === void 0) return void 0;
+  if (!updateMask.trim()) {
+    throw new Error("update_mask must be a non-empty comma-separated list of field names");
+  }
+  return { updateMask };
+}
+
+// src/management/_access-config.ts
+var EVERYONE_GROUP_ID = "__everyone__";
+function accessConfigWireForCreate(guardrails) {
+  return {
+    visibility: "shared",
+    groupPermissions: { [EVERYONE_GROUP_ID]: { use: true, manage: true } },
+    guardrails,
+    sharedWith: []
+  };
+}
+function accessConfigWireForUpdate(existing, guardrails) {
+  if (!existing || Object.keys(existing).length === 0) {
+    return accessConfigWireForCreate(guardrails);
+  }
+  return { ...existing, guardrails };
+}
+function accessFromSkillResponse(raw) {
+  const value = raw.accessConfig ?? raw.access_config;
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return {};
+}
+function accessConfigBodyForCreate(guardrails) {
+  if (guardrails === void 0) return void 0;
+  return accessConfigWireForCreate(guardrails);
+}
+async function accessConfigBodyForUpdate(guardrails, loadResource) {
+  if (guardrails === void 0) return void 0;
+  const existing = accessFromSkillResponse(await loadResource());
+  return accessConfigWireForUpdate(existing, guardrails);
+}
+
+// src/management/agents/interfaces.ts
+var WorkflowInterfacesResource = class {
+  constructor(http, config, workflowId) {
+    this.http = http;
+    this.config = config;
+    this.workflowId = workflowId;
+  }
+  async list() {
+    validateId(this.workflowId, "workflow_id");
+    const data = await invokeWithRetry(this.config, this.http, "WorkflowInterfacesController_list", {
+      pathParams: { id: this.workflowId }
+    });
+    return data.interfaces;
+  }
+  async create(options) {
+    validateId(this.workflowId, "workflow_id");
+    return await invokeWithRetry(this.config, this.http, "WorkflowInterfacesController_add", {
+      pathParams: { id: this.workflowId },
+      jsonBody: omitUndefined(options)
+    });
+  }
+  async update(interfaceId, options, updateMask) {
+    validateId(this.workflowId, "workflow_id");
+    validateId(interfaceId, "interface_id");
+    return await invokeWithRetry(this.config, this.http, "WorkflowInterfacesController_update", {
+      pathParams: { id: this.workflowId, interfaceId },
+      query: updateMaskQuery(updateMask),
+      jsonBody: updateMask === void 0 ? omitUndefined(options) : options
+    });
+  }
+  async delete(interfaceId) {
+    validateId(this.workflowId, "workflow_id");
+    validateId(interfaceId, "interface_id");
+    await invokeWithRetry(this.config, this.http, "WorkflowInterfacesController_delete", {
+      pathParams: { id: this.workflowId, interfaceId }
+    });
+  }
+  async deleteAll() {
+    validateId(this.workflowId, "workflow_id");
+    await invokeWithRetry(this.config, this.http, "WorkflowInterfacesController_deleteAll", {
+      pathParams: { id: this.workflowId }
+    });
+  }
+};
+
+// src/management/agents/agents.ts
+var MANAGEMENT_WORKFLOW_OPERATIONS = {
+  list: "WorkflowsController_list",
+  get: "WorkflowsController_get",
+  create: "WorkflowsController_create",
+  update: "WorkflowsController_update",
+  deploy: "WorkflowsController_deploy",
+  delete: "WorkflowsController_delete",
+  restore: "WorkflowsController_restore",
+  requestOwnershipTransfer: "WorkflowsController_requestOwnershipTransfer",
+  cancelOwnershipTransfer: "WorkflowsController_cancelOwnershipTransfer",
+  acceptOwnershipTransfer: "WorkflowsController_acceptOwnershipTransfer",
+  toggle: "WorkflowsController_toggle"
+};
+function workflowsListParams(pageSize, pageToken, search, type, view, includeVariation) {
+  const extra = {};
+  if (search !== void 0) extra.search = search;
+  if (type !== void 0) extra.type = type;
+  if (view !== void 0) extra.view = view;
+  if (includeVariation !== void 0) extra.includeVariation = includeVariation;
+  return aipListParams(pageSize, pageToken, extra);
+}
+function parseWorkflow(raw) {
+  return raw;
+}
+var ManagementWorkflowsResource = class {
+  constructor(http, config) {
+    this.http = http;
+    this.config = config;
+    this.ops = MANAGEMENT_WORKFLOW_OPERATIONS;
+  }
+  list(options = {}) {
+    const pageSize = options.pageSize ?? 25;
+    validatePageSize(pageSize);
+    return this.listPage(
+      pageSize,
+      options.pageToken,
+      options.search,
+      options.type,
+      options.view,
+      options.includeVariation
+    );
+  }
+  async listPage(pageSize, pageToken, search, type, view, includeVariation) {
+    const data = asRecord(
+      await invokeWithRetry(this.config, this.http, this.ops.list, {
+        query: workflowsListParams(pageSize, pageToken, search, type, view, includeVariation)
+      })
+    );
+    return buildAipPage(
+      data,
+      "agents",
+      parseWorkflow,
+      (token) => this.listPage(pageSize, token, search, type, view, includeVariation)
+    );
+  }
+  async get(workflowId, options = {}) {
+    validateId(workflowId, "workflow_id");
+    const query = options.view !== void 0 ? { view: options.view } : void 0;
+    const data = await invokeWithRetry(this.config, this.http, this.ops.get, {
+      pathParams: { id: workflowId },
+      query
+    });
+    return parseWorkflow(data);
+  }
+  interfaces(workflowId) {
+    return new WorkflowInterfacesResource(this.http, this.config, workflowId);
+  }
+  async create(options) {
+    const body = omitUndefined({
+      name: options.name,
+      type: options.type,
+      description: options.description,
+      trigger: options.trigger,
+      agentSelection: options.agentSelection,
+      workflowStructure: options.workflowStructure,
+      accessConfig: accessConfigBodyForCreate(options.guardrails)
+    });
+    const data = await invokeWithRetry(this.config, this.http, this.ops.create, {
+      jsonBody: body
+    });
+    return parseWorkflow(data);
+  }
+  async update(workflowId, options = {}) {
+    validateId(workflowId, "workflow_id");
+    const accessConfig = await accessConfigBodyForUpdate(
+      options.guardrails,
+      async () => asRecord(
+        await invokeWithRetry(this.config, this.http, this.ops.get, {
+          pathParams: { id: workflowId }
+        })
+      )
+    );
+    const fields = {
+      name: options.name,
+      type: options.type,
+      description: options.description,
+      trigger: options.trigger,
+      agentSelection: options.agentSelection,
+      workflowStructure: options.workflowStructure,
+      accessConfig
+    };
+    const body = options.updateMask !== void 0 ? fields : omitUndefined(fields);
+    const data = await invokeWithRetry(this.config, this.http, this.ops.update, {
+      pathParams: { id: workflowId },
+      query: updateMaskQuery(options.updateMask),
+      jsonBody: body
+    });
+    return parseWorkflow(data);
+  }
+  async deploy(workflowId) {
+    validateId(workflowId, "workflow_id");
+    const data = asRecord(
+      await invokeWithRetry(this.config, this.http, this.ops.deploy, {
+        pathParams: { id: workflowId },
+        jsonBody: {}
+      })
+    );
+    return parseWorkflow(data.agent);
+  }
+  async toggle(workflowId, options) {
+    validateId(workflowId, "workflow_id");
+    const data = await invokeWithRetry(this.config, this.http, this.ops.toggle, {
+      pathParams: { id: workflowId },
+      jsonBody: { active: options.active }
+    });
+    return parseWorkflow(data);
+  }
+  async delete(workflowId) {
+    validateId(workflowId, "workflow_id");
+    await invokeWithRetry(this.config, this.http, this.ops.delete, {
+      pathParams: { id: workflowId }
+    });
+  }
+  async restore(workflowId) {
+    validateId(workflowId, "workflow_id");
+    const data = await invokeWithRetry(this.config, this.http, this.ops.restore, {
+      pathParams: { id: workflowId },
+      jsonBody: {}
+    });
+    return parseWorkflow(data);
+  }
+  async requestOwnershipTransfer(workflowId, options) {
+    validateId(workflowId, "workflow_id");
+    const data = await invokeWithRetry(
+      this.config,
+      this.http,
+      this.ops.requestOwnershipTransfer,
+      {
+        pathParams: { id: workflowId },
+        jsonBody: omitUndefined({ newOwnerUserId: options.newOwnerUserId })
+      }
+    );
+    return parseWorkflow(data);
+  }
+  async cancelOwnershipTransfer(workflowId) {
+    validateId(workflowId, "workflow_id");
+    const data = await invokeWithRetry(
+      this.config,
+      this.http,
+      this.ops.cancelOwnershipTransfer,
+      { pathParams: { id: workflowId } }
+    );
+    return parseWorkflow(data);
+  }
+  async acceptOwnershipTransfer(workflowId) {
+    validateId(workflowId, "workflow_id");
+    const data = await invokeWithRetry(
+      this.config,
+      this.http,
+      this.ops.acceptOwnershipTransfer,
+      { pathParams: { id: workflowId }, jsonBody: {} }
+    );
+    return parseWorkflow(data);
+  }
+};
+
+// src/management/context/_content-merge.ts
+function requireContentDict(item, contextType) {
+  if (item.contextType !== contextType) {
+    throw new Error(`Expected contextType ${contextType}, got ${item.contextType}.`);
+  }
+  if (!item.content || typeof item.content !== "object" || Array.isArray(item.content)) {
+    throw new Error(`Context item ${item.uid} has no object content; cannot merge ${contextType} fields.`);
+  }
+  return item.content;
+}
+function mergeNoteContent(existing, options) {
+  return { ...existing, title: options.title, content: options.body };
+}
+function mergeLinkContent(existing, options) {
+  const merged = { ...existing };
+  if (options.title !== void 0) merged.title = options.title;
+  if (options.url !== void 0) merged.url = options.url;
+  return merged;
+}
+function mergeSavedQueryContent(existing, options) {
+  const merged = { ...existing, name: options.name, query: options.query };
+  if (options.connectionId !== void 0) merged.connectionId = options.connectionId;
+  if (options.path !== void 0) merged.path = options.path;
+  return merged;
+}
+async function resolveExistingContent(items, uid, contextType, existing) {
+  const item = existing ?? await items.get(uid);
+  return requireContentDict(item, contextType);
+}
+async function updateWithMergedContent(items, uid, options) {
+  if (options.existing) requireContentDict(options.existing, options.contextType);
+  return items.update(uid, {
+    contextType: options.contextType,
+    content: options.mergedContent,
+    description: options.description,
+    userFeedback: options.userFeedback,
+    topics: options.topics
+  });
+}
+async function resolveAndUpdateNote(items, uid, options) {
+  const content = await resolveExistingContent(items, uid, "note", options.existing);
+  return updateWithMergedContent(items, uid, {
+    contextType: "note",
+    mergedContent: mergeNoteContent(content, { title: options.title, body: options.body }),
+    existing: options.existing,
+    description: options.description,
+    userFeedback: options.userFeedback,
+    topics: options.topics
+  });
+}
+async function resolveAndUpdateSavedQuery(items, uid, options) {
+  const content = await resolveExistingContent(items, uid, "saved_query", options.existing);
+  return updateWithMergedContent(items, uid, {
+    contextType: "saved_query",
+    mergedContent: mergeSavedQueryContent(content, options),
+    existing: options.existing,
+    description: options.description,
+    userFeedback: options.userFeedback,
+    topics: options.topics
+  });
+}
+async function resolveAndUpdateLink(items, uid, options) {
+  if (options.title === void 0 && options.url === void 0 && options.description === void 0 && options.userFeedback === void 0 && options.topics === void 0) {
+    throw new Error("Provide at least one field to update.");
+  }
+  if (options.title === void 0 && options.url === void 0) {
+    return items.update(uid, {
+      description: options.description,
+      userFeedback: options.userFeedback,
+      topics: options.topics
+    });
+  }
+  const content = await resolveExistingContent(items, uid, "link", options.existing);
+  return updateWithMergedContent(items, uid, {
+    contextType: "link",
+    mergedContent: mergeLinkContent(content, { title: options.title, url: options.url }),
+    existing: options.existing,
+    description: options.description,
+    userFeedback: options.userFeedback,
+    topics: options.topics
+  });
+}
+
+// src/management/context/items.ts
+function contextListParams(pageSize, pageToken, contextType) {
+  const extra = {};
+  if (contextType !== void 0) extra.contextTypes = [contextType];
+  return aipListParams(pageSize, pageToken, extra);
+}
+function parseContextItem(raw) {
+  return raw;
+}
+var ManagementContextItemsResource = class {
+  constructor(http, config) {
+    this.http = http;
+    this.config = config;
+  }
+  list(options = {}) {
+    const pageSize = options.pageSize ?? 25;
+    validatePageSize(pageSize);
+    return this.listPage(pageSize, options.pageToken, options.contextType);
+  }
+  async listPage(pageSize, pageToken, contextType) {
+    const data = asRecord(
+      await invokeWithRetry(this.config, this.http, "ContextItemsController_list", {
+        query: contextListParams(pageSize, pageToken, contextType)
+      })
+    );
+    return buildAipPage(
+      data,
+      "contextItems",
+      parseContextItem,
+      (token) => this.listPage(pageSize, token, contextType)
+    );
+  }
+  async get(uid) {
+    const data = await invokeWithRetry(this.config, this.http, "ContextItemsController_get", {
+      pathParams: { uid }
+    });
+    return parseContextItem(data);
+  }
+  async update(uid, options = {}) {
+    const body = options.updateMask !== void 0 ? {
+      content: options.content,
+      contextType: options.contextType,
+      description: options.description,
+      userFeedback: options.userFeedback,
+      topics: options.topics
+    } : omitUndefined({
+      content: options.content,
+      contextType: options.contextType,
+      description: options.description,
+      userFeedback: options.userFeedback,
+      topics: options.topics
+    });
+    await invokeWithRetry(this.config, this.http, "ContextItemsController_update", {
+      pathParams: { uid },
+      query: updateMaskQuery(options.updateMask),
+      jsonBody: body
+    });
+    return this.get(uid);
+  }
+  async delete(uid) {
+    const data = await invokeWithRetry(this.config, this.http, "ContextItemsController_delete", {
+      pathParams: { uid }
+    });
+    return data;
+  }
+};
+
+// src/management/context/context.ts
+var ManagementContextResource = class {
+  constructor(http, config) {
+    this.http = http;
+    this.config = config;
+    this.items = new ManagementContextItemsResource(http, config);
+    this.customItems = new CustomContextItemsResource(http, config);
+  }
+  async create(operationId, payload) {
+    const data = await invokeWithRetry(this.config, this.http, operationId, {
+      jsonBody: payload
+    });
+    return data;
+  }
+  createNote(title, content) {
+    return this.create("ContextCreatorsController_createNote", omitUndefined({ title, content }));
+  }
+  updateNote(uid, options) {
+    return resolveAndUpdateNote(this.items, uid, options);
+  }
+  createSavedQuery(name, options) {
+    return this.create(
+      "ContextCreatorsController_createSavedQuery",
+      omitUndefined({
+        name,
+        query: options.query,
+        connectionId: options.connectionId,
+        description: options.description,
+        path: options.path
+      })
+    );
+  }
+  updateSavedQuery(uid, options) {
+    return resolveAndUpdateSavedQuery(this.items, uid, options);
+  }
+  createLink(url, options = {}) {
+    return this.create(
+      "ContextCreatorsController_createLink",
+      omitUndefined({
+        url,
+        title: options.title,
+        isCrawl: options.isCrawl,
+        pageLimit: options.pageLimit
+      })
+    );
+  }
+  updateLink(uid, options) {
+    return resolveAndUpdateLink(this.items, uid, options);
+  }
+};
+
+// src/management/organization.ts
+var ManagementOrganizationResource = class {
+  constructor(http, config) {
+    this.http = http;
+    this.config = config;
+  }
+  async delete() {
+    await invokeWithRetry(this.config, this.http, "OrganizationController_deleteOrganization");
+  }
+};
+
+// src/management/skills/memories.ts
+function parseMemory(raw) {
+  return raw;
+}
+var ScopeMemoriesResource = class {
+  constructor(http, config, scopeId) {
+    this.http = http;
+    this.config = config;
+    this.scopeId = scopeId;
+  }
+  list(options = {}) {
+    const pageSize = options.pageSize ?? 25;
+    validatePageSize(pageSize);
+    return this.listPage(pageSize, options.pageToken, options.userId);
+  }
+  async listPage(pageSize, pageToken, userId) {
+    validateId(this.scopeId, "scope_id");
+    const extra = {};
+    if (userId !== void 0) extra.userId = userId;
+    const data = asRecord(
+      await invokeWithRetry(this.config, this.http, "ScopeMemoriesController_list", {
+        pathParams: { id: this.scopeId },
+        query: aipListParams(pageSize, pageToken, extra)
+      })
+    );
+    return buildAipPage(
+      data,
+      "memories",
+      parseMemory,
+      (token) => this.listPage(pageSize, token, userId)
+    );
+  }
+  async search(request) {
+    validateId(this.scopeId, "scope_id");
+    const data = await invokeWithRetry(this.config, this.http, "ScopeMemoriesController_search", {
+      pathParams: { id: this.scopeId },
+      jsonBody: omitUndefined(request)
+    });
+    return data;
+  }
+  async update(memoryId, update, options = {}) {
+    validateId(memoryId, "memory_id");
+    validateId(this.scopeId, "scope_id");
+    const data = await invokeWithRetry(this.config, this.http, "ScopeMemoriesController_update", {
+      pathParams: { id: this.scopeId, memoryId },
+      query: updateMaskQuery(options.updateMask),
+      jsonBody: omitUndefined(update)
+    });
+    return parseMemory(data);
+  }
+  async delete(memoryId) {
+    validateId(memoryId, "memory_id");
+    validateId(this.scopeId, "scope_id");
+    await invokeWithRetry(this.config, this.http, "ScopeMemoriesController_delete", {
+      pathParams: { id: this.scopeId, memoryId }
+    });
+  }
+};
+
+// src/management/skills/evaluations.ts
+function parseConfig(raw) {
+  return raw;
+}
+function parseRun(raw) {
+  return raw;
+}
+var ScopeEvaluationsResource = class {
+  constructor(http, config, scopeId) {
+    this.http = http;
+    this.config = config;
+    this.scopeId = scopeId;
+  }
+  async getConfig() {
+    validateId(this.scopeId, "scope_id");
+    const data = await invokeWithRetry(this.config, this.http, "EvaluationsController_getConfig", {
+      pathParams: { id: this.scopeId }
+    });
+    return parseConfig(data);
+  }
+  async updateConfig(update) {
+    validateId(this.scopeId, "scope_id");
+    const data = await invokeWithRetry(this.config, this.http, "EvaluationsController_updateConfig", {
+      pathParams: { id: this.scopeId },
+      jsonBody: omitUndefined(update)
+    });
+    return parseConfig(data);
+  }
+  async triggerRun() {
+    validateId(this.scopeId, "scope_id");
+    const data = await invokeWithRetry(this.config, this.http, "EvaluationsController_triggerRun", {
+      pathParams: { id: this.scopeId }
+    });
+    return data;
+  }
+  listRuns(options = {}) {
+    const pageSize = options.pageSize ?? 25;
+    validatePageSize(pageSize);
+    return this.listRunsPage(pageSize, options.pageToken);
+  }
+  async listRunsPage(pageSize, pageToken) {
+    validateId(this.scopeId, "scope_id");
+    const data = asRecord(
+      await invokeWithRetry(this.config, this.http, "EvaluationsController_listRuns", {
+        pathParams: { id: this.scopeId },
+        query: aipListParams(pageSize, pageToken)
+      })
+    );
+    return buildAipPage(data, "runs", parseRun, (token) => this.listRunsPage(pageSize, token));
+  }
+  async getRun(runId) {
+    validateId(this.scopeId, "scope_id");
+    validateId(runId, "run_id");
+    const data = await invokeWithRetry(this.config, this.http, "EvaluationsController_getRun", {
+      pathParams: { id: this.scopeId, runId }
+    });
+    return data;
+  }
+};
+
+// src/management/skills/supervision.ts
+var ScopeSupervisionResource = class {
+  constructor(http, config, scopeId) {
+    this.http = http;
+    this.config = config;
+    this.scopeId = scopeId;
+  }
+  async get(options = {}) {
+    validateId(this.scopeId, "scope_id");
+    return await invokeWithRetry(this.config, this.http, "ScopeSupervisionController_get", {
+      pathParams: { id: this.scopeId },
+      query: options.view === void 0 ? void 0 : { view: options.view }
+    });
+  }
+  async set(request) {
+    return this.write("ScopeSupervisionController_set", request);
+  }
+  async setActive(request) {
+    return this.write("ScopeSupervisionController_setActive", request);
+  }
+  async write(operation, request) {
+    validateId(this.scopeId, "scope_id");
+    return await invokeWithRetry(this.config, this.http, operation, {
+      pathParams: { id: this.scopeId },
+      jsonBody: request
+    });
+  }
+};
+
+// src/management/skills/skills.ts
+var MANAGEMENT_SCOPE_OPERATIONS = {
+  list: "ScopesController_list",
+  get: "ScopesController_get",
+  create: "ScopesController_create",
+  update: "ScopesController_update",
+  deploy: "ScopesController_deploy",
+  delete: "ScopesController_delete",
+  restore: "ScopesController_restore",
+  requestOwnershipTransfer: "ScopesController_requestOwnershipTransfer",
+  cancelOwnershipTransfer: "ScopesController_cancelOwnershipTransfer",
+  acceptOwnershipTransfer: "ScopesController_acceptOwnershipTransfer",
+  patchMcpConfig: "ScopesController_patchMcpConfig",
+  getVariation: "ScopesController_getVariation"
+};
+function scopesListParams(pageSize, pageToken, search, view, managerId) {
+  const extra = {};
+  if (search !== void 0) extra.search = search;
+  if (view !== void 0) extra.view = view;
+  if (managerId !== void 0) extra.managerId = managerId;
+  return aipListParams(pageSize, pageToken, extra);
+}
+function parseScope(raw) {
+  return raw;
+}
+var ManagementScopesResource = class {
+  constructor(http, config) {
+    this.http = http;
+    this.config = config;
+    this.ops = MANAGEMENT_SCOPE_OPERATIONS;
+  }
+  conversations(scopeId) {
+    return new ScopeConversationsResource(this.http, this.config, scopeId);
+  }
+  memories(scopeId) {
+    return new ScopeMemoriesResource(this.http, this.config, scopeId);
+  }
+  evaluations(scopeId) {
+    return new ScopeEvaluationsResource(this.http, this.config, scopeId);
+  }
+  supervision(scopeId) {
+    return new ScopeSupervisionResource(this.http, this.config, scopeId);
+  }
+  list(options = {}) {
+    const pageSize = options.pageSize ?? 25;
+    validatePageSize(pageSize);
+    return this.listPage(
+      pageSize,
+      options.pageToken,
+      options.search,
+      options.view,
+      options.managerId
+    );
+  }
+  async listPage(pageSize, pageToken, search, view, managerId) {
+    const data = asRecord(
+      await invokeWithRetry(this.config, this.http, this.ops.list, {
+        query: scopesListParams(pageSize, pageToken, search, view, managerId)
+      })
+    );
+    return buildAipPage(
+      data,
+      "skills",
+      parseScope,
+      (token) => this.listPage(pageSize, token, search, view, managerId)
+    );
+  }
+  async get(scopeId, options = {}) {
+    validateId(scopeId, "scope_id");
+    const query = options.view !== void 0 ? { view: options.view } : void 0;
+    const data = await invokeWithRetry(this.config, this.http, this.ops.get, {
+      pathParams: { id: scopeId },
+      query
+    });
+    return parseScope(data);
+  }
+  async create(options) {
+    const body = omitUndefined({
+      name: options.name,
+      description: options.description,
+      expectedOutput: options.expectedOutput,
+      instructions: options.instructions,
+      toolset: options.toolset,
+      model: options.model,
+      connectionSet: options.connectionSet,
+      contextSelections: options.contextSelections,
+      interfaces: options.interfaces,
+      accessConfig: accessConfigBodyForCreate(options.guardrails)
+    });
+    const data = await invokeWithRetry(this.config, this.http, this.ops.create, {
+      jsonBody: body
+    });
+    return parseScope(data);
+  }
+  async update(scopeId, options = {}) {
+    validateId(scopeId, "scope_id");
+    const accessConfig = await accessConfigBodyForUpdate(
+      options.guardrails,
+      async () => asRecord(
+        await invokeWithRetry(this.config, this.http, this.ops.get, {
+          pathParams: { id: scopeId }
+        })
+      )
+    );
+    const fields = {
+      name: options.name,
+      description: options.description,
+      expectedOutput: options.expectedOutput,
+      instructions: options.instructions,
+      toolset: options.toolset,
+      model: options.model,
+      connectionSet: options.connectionSet,
+      contextSelections: options.contextSelections,
+      interfaces: options.interfaces,
+      accessConfig,
+      managerId: options.managerId,
+      evaluations: options.evaluations,
+      supervisionSubordinateDescriptions: options.supervisionSubordinateDescriptions
+    };
+    const body = options.updateMask !== void 0 ? fields : omitUndefined(fields);
+    const data = await invokeWithRetry(this.config, this.http, this.ops.update, {
+      pathParams: { id: scopeId },
+      query: updateMaskQuery(options.updateMask),
+      jsonBody: body
+    });
+    return parseScope(data);
+  }
+  async deploy(scopeId) {
+    validateId(scopeId, "scope_id");
+    const data = asRecord(
+      await invokeWithRetry(this.config, this.http, this.ops.deploy, {
+        pathParams: { id: scopeId },
+        jsonBody: {}
+      })
+    );
+    return parseScope(data.skill);
+  }
+  async delete(scopeId) {
+    validateId(scopeId, "scope_id");
+    await invokeWithRetry(this.config, this.http, this.ops.delete, {
+      pathParams: { id: scopeId }
+    });
+  }
+  async restore(scopeId) {
+    validateId(scopeId, "scope_id");
+    const data = await invokeWithRetry(this.config, this.http, this.ops.restore, {
+      pathParams: { id: scopeId },
+      jsonBody: {}
+    });
+    return parseScope(data);
+  }
+  async requestOwnershipTransfer(scopeId, options) {
+    validateId(scopeId, "scope_id");
+    const data = await invokeWithRetry(
+      this.config,
+      this.http,
+      this.ops.requestOwnershipTransfer,
+      {
+        pathParams: { id: scopeId },
+        jsonBody: omitUndefined({ newOwnerUserId: options.newOwnerUserId })
+      }
+    );
+    return parseScope(data);
+  }
+  async cancelOwnershipTransfer(scopeId) {
+    validateId(scopeId, "scope_id");
+    const data = await invokeWithRetry(
+      this.config,
+      this.http,
+      this.ops.cancelOwnershipTransfer,
+      { pathParams: { id: scopeId } }
+    );
+    return parseScope(data);
+  }
+  async acceptOwnershipTransfer(scopeId) {
+    validateId(scopeId, "scope_id");
+    const data = await invokeWithRetry(
+      this.config,
+      this.http,
+      this.ops.acceptOwnershipTransfer,
+      { pathParams: { id: scopeId }, jsonBody: {} }
+    );
+    return parseScope(data);
+  }
+  async patchMcpConfig(scopeId, options) {
+    validateId(scopeId, "scope_id");
+    await invokeWithRetry(this.config, this.http, this.ops.patchMcpConfig, {
+      pathParams: { id: scopeId },
+      jsonBody: omitUndefined({ config: options.mcpConfig })
+    });
+  }
+  async getVariation(scopeId, options) {
+    validateId(scopeId, "scope_id");
+    validateId(options.variationUid, "variation_uid");
+    const data = await invokeWithRetry(this.config, this.http, this.ops.getVariation, {
+      pathParams: { id: scopeId, variationUid: options.variationUid }
+    });
+    return parseScope(data);
+  }
+};
+
+// src/management/usage.ts
+var ManagementUsageResource = class {
+  constructor(http, config) {
+    this.http = http;
+    this.config = config;
+  }
+  async list(options) {
+    const query = {
+      since: options.since,
+      until: options.until,
+      rollup: options.rollup
+    };
+    if (options.model !== void 0) query.model = options.model;
+    const data = await invokeWithRetry(this.config, this.http, "UsageController_list", { query });
+    return data;
+  }
+};
+
+// src/management/users.ts
+var ManagementUsersResource = class {
+  constructor(http, config) {
+    this.http = http;
+    this.config = config;
+  }
+  async listMemberGroups() {
+    const data = await invokeWithRetry(
+      this.config,
+      this.http,
+      "MemberGroupsController_list"
+    );
+    return data.groups;
+  }
+  async listOrgMembers() {
+    const data = await invokeWithRetry(
+      this.config,
+      this.http,
+      "OrgMembersController_list"
+    );
+    return data.members;
+  }
+};
+
+// src/management/index.ts
+var ModusManagement = class extends ModusClientBase {
+  constructor(options = {}) {
+    super(options);
+    this.scopes = new ManagementScopesResource(this.http, this.config);
+    this.workflows = new ManagementWorkflowsResource(this.http, this.config);
+    this.context = new ManagementContextResource(this.http, this.config);
+    this.usage = new ManagementUsageResource(this.http, this.config);
+    this.organization = new ManagementOrganizationResource(this.http, this.config);
+    this.users = new ManagementUsersResource(this.http, this.config);
+  }
+};
+export {
+  ModusManagement
+};
+//# sourceMappingURL=index.js.map