@getmodus/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2546 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  APIConnectionError: () => APIConnectionError,
+  AuthenticationError: () => AuthenticationError,
+  ChatStream: () => ChatStream,
+  ConflictError: () => ConflictError,
+  InternalServerError: () => InternalServerError,
+  Modus: () => Modus,
+  ModusError: () => ModusError,
+  NotFoundError: () => NotFoundError,
+  OPERATIONS: () => OPERATIONS,
+  Page: () => Page,
+  PermissionDeniedError: () => PermissionDeniedError,
+  RateLimitError: () => RateLimitError,
+  RunCancelledError: () => RunCancelledError,
+  StreamTimeoutError: () => StreamTimeoutError,
+  UnprocessableError: () => UnprocessableError,
+  ValidationError: () => ValidationError,
+  conversationSkillId: () => conversationSkillId
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/_generated/operations.ts
+var OPERATIONS = {
+  "ConnectionsController_list": {
+    method: "GET",
+    path: "/api/v1/connections",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: [],
+    queryParams: ["pageToken", "pageSize", "type"],
+    requestSchema: null,
+    responseSchema: "ListConnectionsResponseDto"
+  },
+  "ContextCreatorsController_createLink": {
+    method: "POST",
+    path: "/api/v1/context/links",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: [],
+    queryParams: [],
+    requestSchema: "CreateLinkDto",
+    responseSchema: "CreatedContextItemResponseDto"
+  },
+  "ContextCreatorsController_createNote": {
+    method: "POST",
+    path: "/api/v1/context/notes",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: [],
+    queryParams: [],
+    requestSchema: "CreateNoteDto",
+    responseSchema: "CreatedContextItemResponseDto"
+  },
+  "ContextCreatorsController_createSavedQuery": {
+    method: "POST",
+    path: "/api/v1/context/saved-queries",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: [],
+    queryParams: [],
+    requestSchema: "CreateSavedQueryDto",
+    responseSchema: "CreatedContextItemResponseDto"
+  },
+  "ContextItemsController_delete": {
+    method: "DELETE",
+    path: "/api/v1/context/items/{uid}",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["uid"],
+    queryParams: [],
+    requestSchema: null,
+    responseSchema: "DeleteContextItemResponseDto"
+  },
+  "ContextItemsController_get": {
+    method: "GET",
+    path: "/api/v1/context/items/{uid}",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["uid"],
+    queryParams: [],
+    requestSchema: null,
+    responseSchema: "ContextItemDto"
+  },
+  "ContextItemsController_list": {
+    method: "GET",
+    path: "/api/v1/context/items",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: [],
+    queryParams: ["pageToken", "pageSize", "contextTypes", "verificationStatuses", "searchQuery", "topics"],
+    requestSchema: null,
+    responseSchema: "ListContextItemsResponseDto"
+  },
+  "ContextItemsController_listValues": {
+    method: "GET",
+    path: "/api/v1/context/items/{uid}/values",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["uid"],
+    queryParams: ["contextType", "contentKeyPath", "pageSize", "offset", "pageToken", "searchQuery", "dataPathPrefix"],
+    requestSchema: null,
+    responseSchema: "ListContextItemValuesResponseDto"
+  },
+  "ContextItemsController_lookup": {
+    method: "POST",
+    path: "/api/v1/context/items/lookup",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: [],
+    queryParams: [],
+    requestSchema: "LookupContextItemDto",
+    responseSchema: "LookupContextItemResponseDto"
+  },
+  "ContextItemsController_update": {
+    method: "PATCH",
+    path: "/api/v1/context/items/{uid}",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["uid"],
+    queryParams: ["updateMask"],
+    requestSchema: "UpdateContextItemDto",
+    responseSchema: null
+  },
+  "CustomContextItemsController_batchCreate": {
+    method: "POST",
+    path: "/api/v1/context/custom-items/batch",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: [],
+    queryParams: [],
+    requestSchema: "BatchCreateCustomContextItemsDto",
+    responseSchema: "BatchCreateCustomContextItemsResponseDto"
+  },
+  "CustomContextItemsController_create": {
+    method: "POST",
+    path: "/api/v1/context/custom-items",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: [],
+    queryParams: [],
+    requestSchema: "CreateCustomContextItemDto",
+    responseSchema: "CreatedCustomContextItemResponseDto"
+  },
+  "CustomContextItemsController_delete": {
+    method: "DELETE",
+    path: "/api/v1/context/custom-items/{uid}",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["uid"],
+    queryParams: [],
+    requestSchema: null,
+    responseSchema: "DeleteContextItemResponseDto"
+  },
+  "CustomContextItemsController_get": {
+    method: "GET",
+    path: "/api/v1/context/custom-items/{uid}",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["uid"],
+    queryParams: [],
+    requestSchema: null,
+    responseSchema: "ContextItemDto"
+  },
+  "CustomContextItemsController_list": {
+    method: "GET",
+    path: "/api/v1/context/custom-items",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: [],
+    queryParams: ["pageToken", "pageSize", "contextTypes", "verificationStatuses", "searchQuery", "topics"],
+    requestSchema: null,
+    responseSchema: "ListCustomContextItemsResponseDto"
+  },
+  "CustomContextItemsController_update": {
+    method: "PATCH",
+    path: "/api/v1/context/custom-items/{uid}",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["uid"],
+    queryParams: [],
+    requestSchema: "UpdateCustomContextItemDto",
+    responseSchema: null
+  },
+  "EvaluationsController_getConfig": {
+    method: "GET",
+    path: "/api/v1/scopes/{id}/evaluations/config",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: [],
+    requestSchema: null,
+    responseSchema: "EvaluationConfigDto"
+  },
+  "EvaluationsController_getRun": {
+    method: "GET",
+    path: "/api/v1/scopes/{id}/evaluations/runs/{runId}",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id", "runId"],
+    queryParams: [],
+    requestSchema: null,
+    responseSchema: "EvaluationRunWithResultsDto"
+  },
+  "EvaluationsController_listRuns": {
+    method: "GET",
+    path: "/api/v1/scopes/{id}/evaluations/runs",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: ["pageSize", "pageToken"],
+    requestSchema: null,
+    responseSchema: "ListEvaluationRunsResponseDto"
+  },
+  "EvaluationsController_triggerRun": {
+    method: "POST",
+    path: "/api/v1/scopes/{id}/evaluations/runs",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: [],
+    requestSchema: null,
+    responseSchema: "TriggerEvaluationRunResponseDto"
+  },
+  "EvaluationsController_updateConfig": {
+    method: "PUT",
+    path: "/api/v1/scopes/{id}/evaluations/config",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: [],
+    requestSchema: "UpdateEvaluationConfigDto",
+    responseSchema: "EvaluationConfigDto"
+  },
+  "MemberGroupsController_list": {
+    method: "GET",
+    path: "/api/v1/users/member-groups",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: [],
+    queryParams: ["pageSize", "pageToken"],
+    requestSchema: null,
+    responseSchema: "ListMemberGroupsResponseDto"
+  },
+  "ModusChatController_chat": {
+    method: "POST",
+    path: "/api/v1/modus/chat",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: [],
+    queryParams: [],
+    requestSchema: "ModusChatRequestDto",
+    responseSchema: "ModusChatResponseDto"
+  },
+  "ModusChatController_chatContinue": {
+    method: "POST",
+    path: "/api/v1/modus/conversations/{threadId}/chat",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["threadId"],
+    queryParams: [],
+    requestSchema: "ModusChatRequestDto",
+    responseSchema: "ModusChatResponseDto"
+  },
+  "ModusContextController_compose": {
+    method: "POST",
+    path: "/api/v1/modus/context",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: [],
+    queryParams: [],
+    requestSchema: "ModusContextRequestDto",
+    responseSchema: "ModusContextResponseDto"
+  },
+  "ModusConversationsController_get": {
+    method: "GET",
+    path: "/api/v1/modus/conversations/{threadId}",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["threadId"],
+    queryParams: [],
+    requestSchema: null,
+    responseSchema: "ConversationDto"
+  },
+  "ModusConversationsController_list": {
+    method: "GET",
+    path: "/api/v1/modus/conversations",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: [],
+    queryParams: ["pageToken", "page", "pageSize", "userId", "toolName", "timeframe", "includeTools", "kind"],
+    requestSchema: null,
+    responseSchema: "ListConversationsResponseDto"
+  },
+  "ModusRunsController_create": {
+    method: "POST",
+    path: "/agent/v1/modus/runs",
+    service: "agent-service",
+    serverUrl: "https://agent.modus.com",
+    pathParams: [],
+    queryParams: [],
+    requestSchema: "ModusRunDto",
+    responseSchema: null
+  },
+  "OrgMembersController_list": {
+    method: "GET",
+    path: "/api/v1/users/org-members",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: [],
+    queryParams: ["pageSize", "pageToken"],
+    requestSchema: null,
+    responseSchema: "ListOrgMembersResponseDto"
+  },
+  "OrganizationController_deleteOrganization": {
+    method: "DELETE",
+    path: "/api/v1/users/organization",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: [],
+    queryParams: [],
+    requestSchema: null,
+    responseSchema: null
+  },
+  "ResumeRunsController_create": {
+    method: "POST",
+    path: "/agent/v1/runs/{runId}/resume",
+    service: "agent-service",
+    serverUrl: "https://agent.modus.com",
+    pathParams: ["runId"],
+    queryParams: [],
+    requestSchema: "ResumeRunDto",
+    responseSchema: null
+  },
+  "RunLifecycleController_active": {
+    method: "GET",
+    path: "/agent/v1/runs/active",
+    service: "agent-service",
+    serverUrl: "https://agent.modus.com",
+    pathParams: [],
+    queryParams: ["pageToken", "pageSize"],
+    requestSchema: null,
+    responseSchema: "ActiveRunsResponseDto"
+  },
+  "RunLifecycleController_activeBySession": {
+    method: "POST",
+    path: "/agent/v1/runs/active-by-session",
+    service: "agent-service",
+    serverUrl: "https://agent.modus.com",
+    pathParams: [],
+    queryParams: [],
+    requestSchema: "ActiveRunsBySessionDto",
+    responseSchema: "ActiveRunsBySessionResponseDto"
+  },
+  "RunLifecycleController_cancel": {
+    method: "POST",
+    path: "/agent/v1/runs/{runId}/cancel",
+    service: "agent-service",
+    serverUrl: "https://agent.modus.com",
+    pathParams: ["runId"],
+    queryParams: [],
+    requestSchema: "CancelRunDto",
+    responseSchema: null
+  },
+  "RunLifecycleController_editQueued": {
+    method: "POST",
+    path: "/agent/v1/runs/{runId}/queue-edit",
+    service: "agent-service",
+    serverUrl: "https://agent.modus.com",
+    pathParams: ["runId"],
+    queryParams: [],
+    requestSchema: "EditQueuedRunDto",
+    responseSchema: null
+  },
+  "RunLifecycleController_events": {
+    method: "GET",
+    path: "/agent/v1/runs/{runId}/events",
+    service: "agent-service",
+    serverUrl: "https://agent.modus.com",
+    pathParams: ["runId"],
+    queryParams: [],
+    requestSchema: null,
+    responseSchema: null
+  },
+  "RunLifecycleController_interrupt": {
+    method: "POST",
+    path: "/agent/v1/runs/{runId}/interrupt",
+    service: "agent-service",
+    serverUrl: "https://agent.modus.com",
+    pathParams: ["runId"],
+    queryParams: [],
+    requestSchema: "InterruptRunDto",
+    responseSchema: null
+  },
+  "RunLifecycleController_stream": {
+    method: "GET",
+    path: "/agent/v1/runs/{runId}/stream",
+    service: "agent-service",
+    serverUrl: "https://agent.modus.com",
+    pathParams: ["runId"],
+    queryParams: [],
+    requestSchema: null,
+    responseSchema: null
+  },
+  "ScopeChatController_chat": {
+    method: "POST",
+    path: "/api/v1/scopes/{id}/chat",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: [],
+    requestSchema: "SkillChatRequestDto",
+    responseSchema: "SkillChatResponseDto"
+  },
+  "ScopeChatController_chatContinue": {
+    method: "POST",
+    path: "/api/v1/scopes/{id}/conversations/{threadId}/chat",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id", "threadId"],
+    queryParams: [],
+    requestSchema: "SkillChatRequestDto",
+    responseSchema: "SkillChatResponseDto"
+  },
+  "ScopeContextController_compose": {
+    method: "POST",
+    path: "/api/v1/scopes/{id}/context",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: [],
+    requestSchema: "ComposeSkillContextRequestDto",
+    responseSchema: "ComposeSkillContextResponseDto"
+  },
+  "ScopeConversationsController_get": {
+    method: "GET",
+    path: "/api/v1/scopes/{id}/conversations/{threadId}",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id", "threadId"],
+    queryParams: ["messageLimit", "beforeMessageIndex"],
+    requestSchema: null,
+    responseSchema: "ConversationDto"
+  },
+  "ScopeConversationsController_list": {
+    method: "GET",
+    path: "/api/v1/scopes/{id}/conversations",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: ["pageToken", "page", "pageSize", "userId", "toolName", "timeframe", "includeTools"],
+    requestSchema: null,
+    responseSchema: "ListConversationsResponseDto"
+  },
+  "ScopeMemoriesController_delete": {
+    method: "DELETE",
+    path: "/api/v1/scopes/{id}/memories/{memoryId}",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id", "memoryId"],
+    queryParams: [],
+    requestSchema: null,
+    responseSchema: null
+  },
+  "ScopeMemoriesController_list": {
+    method: "GET",
+    path: "/api/v1/scopes/{id}/memories",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: ["pageToken", "pageSize", "userId", "limit"],
+    requestSchema: null,
+    responseSchema: "ListMemoriesResponseDto"
+  },
+  "ScopeMemoriesController_search": {
+    method: "POST",
+    path: "/api/v1/scopes/{id}/memories/search",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: [],
+    requestSchema: "SearchMemoriesRequestDto",
+    responseSchema: "ListMemoriesResponseDto"
+  },
+  "ScopeMemoriesController_update": {
+    method: "PATCH",
+    path: "/api/v1/scopes/{id}/memories/{memoryId}",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id", "memoryId"],
+    queryParams: ["updateMask"],
+    requestSchema: "UpdateMemoryRequestDto",
+    responseSchema: null
+  },
+  "ScopeRunsController_create": {
+    method: "POST",
+    path: "/agent/v1/scopes/{id}/runs",
+    service: "agent-service",
+    serverUrl: "https://agent.modus.com",
+    pathParams: ["id"],
+    queryParams: [],
+    requestSchema: "SkillRunDto",
+    responseSchema: null
+  },
+  "ScopeSupervisionController_get": {
+    method: "GET",
+    path: "/api/v1/scopes/{id}/supervision",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: ["view"],
+    requestSchema: null,
+    responseSchema: "SupervisionDto"
+  },
+  "ScopeSupervisionController_set": {
+    method: "PUT",
+    path: "/api/v1/scopes/{id}/supervision",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: [],
+    requestSchema: "SetSupervisionRequestDto",
+    responseSchema: "SupervisionDto"
+  },
+  "ScopeSupervisionController_setActive": {
+    method: "PUT",
+    path: "/api/v1/scopes/{id}/supervision/active",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: [],
+    requestSchema: "SetSupervisionRequestDto",
+    responseSchema: "SupervisionDto"
+  },
+  "ScopesController_acceptOwnershipTransfer": {
+    method: "POST",
+    path: "/api/v1/scopes/{id}/transfer-ownership/accept",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: [],
+    requestSchema: null,
+    responseSchema: "SkillDto"
+  },
+  "ScopesController_cancelOwnershipTransfer": {
+    method: "DELETE",
+    path: "/api/v1/scopes/{id}/transfer-ownership",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: [],
+    requestSchema: null,
+    responseSchema: "SkillDto"
+  },
+  "ScopesController_create": {
+    method: "POST",
+    path: "/api/v1/scopes",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: [],
+    queryParams: [],
+    requestSchema: "CreateSkillDto",
+    responseSchema: "SkillDto"
+  },
+  "ScopesController_delete": {
+    method: "DELETE",
+    path: "/api/v1/scopes/{id}",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: [],
+    requestSchema: null,
+    responseSchema: null
+  },
+  "ScopesController_deploy": {
+    method: "POST",
+    path: "/api/v1/scopes/{id}/deploy",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: [],
+    requestSchema: "DeploySkillDto",
+    responseSchema: "DeployResponseDto"
+  },
+  "ScopesController_get": {
+    method: "GET",
+    path: "/api/v1/scopes/{id}",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: ["view"],
+    requestSchema: null,
+    responseSchema: "SkillDto"
+  },
+  "ScopesController_getVariation": {
+    method: "GET",
+    path: "/api/v1/scopes/{id}/variations/{variationUid}",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id", "variationUid"],
+    queryParams: [],
+    requestSchema: null,
+    responseSchema: "SkillDto"
+  },
+  "ScopesController_list": {
+    method: "GET",
+    path: "/api/v1/scopes",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: [],
+    queryParams: ["pageToken", "pageSize", "view", "search", "managerId", "includeVariation"],
+    requestSchema: null,
+    responseSchema: "ListSkillsResponseDto"
+  },
+  "ScopesController_patchMcpConfig": {
+    method: "PATCH",
+    path: "/api/v1/scopes/{id}/mcp-config",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: [],
+    requestSchema: "PatchSkillMcpConfigDto",
+    responseSchema: "PatchSkillMcpConfigResponseDto"
+  },
+  "ScopesController_requestOwnershipTransfer": {
+    method: "POST",
+    path: "/api/v1/scopes/{id}/transfer-ownership",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: [],
+    requestSchema: "TransferOwnershipDto",
+    responseSchema: "SkillDto"
+  },
+  "ScopesController_restore": {
+    method: "POST",
+    path: "/api/v1/scopes/{id}/restore",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: [],
+    requestSchema: null,
+    responseSchema: "SkillDto"
+  },
+  "ScopesController_update": {
+    method: "PATCH",
+    path: "/api/v1/scopes/{id}",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: ["updateMask"],
+    requestSchema: "UpdateSkillDto",
+    responseSchema: "SkillDto"
+  },
+  "SuggestionsController_listApproved": {
+    method: "GET",
+    path: "/api/v1/suggestions/questions",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: [],
+    queryParams: ["pageToken", "pageSize", "skill_id", "skill_ids"],
+    requestSchema: null,
+    responseSchema: "ListSuggestionQuestionsResponseDto"
+  },
+  "SuggestionsController_recordEvent": {
+    method: "POST",
+    path: "/api/v1/suggestions/questions/{id}/events",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: [],
+    requestSchema: "RecordSuggestionEventDto",
+    responseSchema: null
+  },
+  "UsageController_list": {
+    method: "GET",
+    path: "/api/v1/usage",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: [],
+    queryParams: ["since", "until", "rollup", "model", "group_by", "skill_id", "agent_id", "user_id", "interface"],
+    requestSchema: null,
+    responseSchema: "ListUsageResponseDto"
+  },
+  "WorkflowActionsController_cancel": {
+    method: "POST",
+    path: "/agent/v1/workflow-actions/{runId}/cancel",
+    service: "agent-service",
+    serverUrl: "https://agent.modus.com",
+    pathParams: ["runId"],
+    queryParams: [],
+    requestSchema: "CancelRunDto",
+    responseSchema: null
+  },
+  "WorkflowActionsController_execute": {
+    method: "POST",
+    path: "/agent/v1/workflow-actions",
+    service: "agent-service",
+    serverUrl: "https://agent.modus.com",
+    pathParams: [],
+    queryParams: [],
+    requestSchema: "WorkflowActionDto",
+    responseSchema: null
+  },
+  "WorkflowInterfacesController_add": {
+    method: "POST",
+    path: "/api/v1/workflows/{id}/interfaces",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: [],
+    requestSchema: "AddAgentInterfaceDto",
+    responseSchema: "AgentInterfaceDto"
+  },
+  "WorkflowInterfacesController_delete": {
+    method: "DELETE",
+    path: "/api/v1/workflows/{id}/interfaces/{interfaceId}",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id", "interfaceId"],
+    queryParams: [],
+    requestSchema: null,
+    responseSchema: null
+  },
+  "WorkflowInterfacesController_deleteAll": {
+    method: "DELETE",
+    path: "/api/v1/workflows/{id}/interfaces",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: [],
+    requestSchema: null,
+    responseSchema: null
+  },
+  "WorkflowInterfacesController_list": {
+    method: "GET",
+    path: "/api/v1/workflows/{id}/interfaces",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: ["pageSize", "pageToken"],
+    requestSchema: null,
+    responseSchema: "ListAgentInterfacesResponseDto"
+  },
+  "WorkflowInterfacesController_update": {
+    method: "PATCH",
+    path: "/api/v1/workflows/{id}/interfaces/{interfaceId}",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id", "interfaceId"],
+    queryParams: ["updateMask"],
+    requestSchema: "UpdateAgentInterfaceDto",
+    responseSchema: "AgentInterfaceDto"
+  },
+  "WorkflowRunsController_create": {
+    method: "POST",
+    path: "/agent/v1/workflows/{id}/runs",
+    service: "agent-service",
+    serverUrl: "https://agent.modus.com",
+    pathParams: ["id"],
+    queryParams: [],
+    requestSchema: "AgentRunDto",
+    responseSchema: null
+  },
+  "WorkflowRunsController_get": {
+    method: "GET",
+    path: "/api/v1/workflows/{id}/runs/{runId}",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id", "runId"],
+    queryParams: ["temporalRunId"],
+    requestSchema: null,
+    responseSchema: "GetAutomationRunResponseDto"
+  },
+  "WorkflowRunsController_list": {
+    method: "GET",
+    path: "/api/v1/workflows/{id}/runs",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: ["status", "timeframe", "approvalScope", "search", "pageSize", "pageToken"],
+    requestSchema: null,
+    responseSchema: "ListAutomationRunsResponseDto"
+  },
+  "WorkflowsController_acceptOwnershipTransfer": {
+    method: "POST",
+    path: "/api/v1/workflows/{id}/transfer-ownership/accept",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: [],
+    requestSchema: null,
+    responseSchema: "AgentDto"
+  },
+  "WorkflowsController_cancelOwnershipTransfer": {
+    method: "DELETE",
+    path: "/api/v1/workflows/{id}/transfer-ownership",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: [],
+    requestSchema: null,
+    responseSchema: "AgentDto"
+  },
+  "WorkflowsController_create": {
+    method: "POST",
+    path: "/api/v1/workflows",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: [],
+    queryParams: [],
+    requestSchema: "CreateAgentDto",
+    responseSchema: "AgentDto"
+  },
+  "WorkflowsController_delete": {
+    method: "DELETE",
+    path: "/api/v1/workflows/{id}",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: [],
+    requestSchema: null,
+    responseSchema: null
+  },
+  "WorkflowsController_deploy": {
+    method: "POST",
+    path: "/api/v1/workflows/{id}/deploy",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: [],
+    requestSchema: "DeployAgentDto",
+    responseSchema: "AgentDeployResponseDto"
+  },
+  "WorkflowsController_get": {
+    method: "GET",
+    path: "/api/v1/workflows/{id}",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: ["view"],
+    requestSchema: null,
+    responseSchema: "AgentDto"
+  },
+  "WorkflowsController_list": {
+    method: "GET",
+    path: "/api/v1/workflows",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: [],
+    queryParams: ["pageToken", "pageSize", "view", "type", "search", "includeVariation"],
+    requestSchema: null,
+    responseSchema: "ListAgentsResponseDto"
+  },
+  "WorkflowsController_requestOwnershipTransfer": {
+    method: "POST",
+    path: "/api/v1/workflows/{id}/transfer-ownership",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: [],
+    requestSchema: "TransferOwnershipDto",
+    responseSchema: "AgentDto"
+  },
+  "WorkflowsController_restore": {
+    method: "POST",
+    path: "/api/v1/workflows/{id}/restore",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: [],
+    requestSchema: null,
+    responseSchema: "AgentDto"
+  },
+  "WorkflowsController_toggle": {
+    method: "POST",
+    path: "/api/v1/workflows/{id}/toggle",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: [],
+    requestSchema: "ToggleAgentDto",
+    responseSchema: "AgentDto"
+  },
+  "WorkflowsController_update": {
+    method: "PATCH",
+    path: "/api/v1/workflows/{id}",
+    service: "modus-api",
+    serverUrl: "https://api.modus.com",
+    pathParams: ["id"],
+    queryParams: ["updateMask"],
+    requestSchema: "UpdateAgentDto",
+    responseSchema: "AgentDto"
+  }
+};
+
+// src/_exceptions.ts
+var ModusError = class extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "ModusError";
+    this.message = message;
+    this.statusCode = options.statusCode;
+    this.requestId = options.requestId;
+    this.responseHeaders = options.responseHeaders;
+    this.body = options.body;
+    this.code = options.code;
+  }
+};
+var APIConnectionError = class extends ModusError {
+  constructor(message) {
+    super(message);
+    this.name = "APIConnectionError";
+  }
+};
+var AuthenticationError = class extends ModusError {
+  constructor(message, options = {}) {
+    super(message, { ...options, statusCode: 401 });
+    this.name = "AuthenticationError";
+  }
+};
+var PermissionDeniedError = class extends ModusError {
+  constructor(message, options = {}) {
+    super(message, { ...options, statusCode: 403 });
+    this.name = "PermissionDeniedError";
+  }
+};
+var NotFoundError = class extends ModusError {
+  constructor(message, options = {}) {
+    super(message, { ...options, statusCode: 404 });
+    this.name = "NotFoundError";
+  }
+};
+var ConflictError = class extends ModusError {
+  constructor(message, options = {}) {
+    super(message, { ...options, statusCode: 409 });
+    this.name = "ConflictError";
+  }
+};
+var UnprocessableError = class extends ModusError {
+  constructor(message, options = {}) {
+    super(message, { ...options, statusCode: 422 });
+    this.name = "UnprocessableError";
+    this.errors = options.errors;
+  }
+};
+var RateLimitError = class extends ModusError {
+  constructor(message, options = {}) {
+    super(message, { ...options, statusCode: 429 });
+    this.name = "RateLimitError";
+    this.retryAfter = options.retryAfter;
+  }
+};
+var InternalServerError = class extends ModusError {
+  constructor(message, statusCode, options = {}) {
+    super(message, { ...options, statusCode });
+    this.name = "InternalServerError";
+  }
+};
+var RunCancelledError = class extends ModusError {
+  constructor(message = "Run was cancelled.") {
+    super(message);
+    this.name = "RunCancelledError";
+  }
+};
+var StreamTimeoutError = class extends ModusError {
+  constructor(message = "Stream timed out.") {
+    super(message);
+    this.name = "StreamTimeoutError";
+  }
+};
+var ValidationError = class extends ModusError {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+  }
+};
+
+// src/_streaming.ts
+var SILENTLY_IGNORED = /* @__PURE__ */ new Set([
+  "heartbeat",
+  "ws_chunk",
+  "unknown",
+  "tool_start",
+  "tool_end",
+  "tool_chunk",
+  "agent_thinking",
+  "warning",
+  "selected_final_content"
+]);
+function parseLine(line) {
+  if (!line.startsWith("data:")) return void 0;
+  const raw = line.slice(5).trimStart();
+  if (!raw || raw === "[DONE]") return void 0;
+  try {
+    const data = JSON.parse(raw);
+    if (data && typeof data === "object" && !Array.isArray(data)) {
+      return data;
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+function isAsyncIterable(value) {
+  return Symbol.asyncIterator in Object(value);
+}
+function* parseData(data) {
+  const eventType = typeof data.type === "string" ? data.type : "unknown";
+  if (eventType === "token") {
+    const event = {
+      type: "token",
+      content: typeof data.content === "string" ? data.content : ""
+    };
+    yield event;
+  } else if (eventType === "done") {
+    const event = {
+      type: "done",
+      runId: typeof data.runId === "string" ? data.runId : "",
+      threadId: typeof data.threadId === "string" ? data.threadId : ""
+    };
+    yield event;
+  } else if (eventType === "error") {
+    const msg = data.error ?? data.message ?? data.content ?? "Unknown run error";
+    const event = { type: "error", message: String(msg) };
+    yield event;
+  } else if (eventType === "cancelled") {
+    const event = { type: "cancelled" };
+    yield event;
+  } else if (eventType === "stream_timeout") {
+    const event = { type: "stream_timeout" };
+    yield event;
+  } else if (eventType === "assistant_content_reset") {
+    if (typeof data.content !== "string") return;
+    const event = {
+      type: "assistant_content_reset",
+      content: data.content,
+      ...typeof data.visibleContent === "string" ? { visibleContent: data.visibleContent } : {},
+      attempt: typeof data.attempt === "number" ? data.attempt : 1,
+      reason: "provider_stream_failed"
+    };
+    yield event;
+  } else if (!SILENTLY_IGNORED.has(eventType)) {
+    return;
+  }
+}
+function* parseSyncSseLines(lines) {
+  for (const line of lines) {
+    const data = parseLine(line);
+    if (data !== void 0) yield* parseData(data);
+  }
+}
+async function* parseAsyncSseLines(lines) {
+  for await (const line of lines) {
+    const data = parseLine(line);
+    if (data !== void 0) yield* parseData(data);
+  }
+}
+function parseSseStream(lines) {
+  return isAsyncIterable(lines) ? parseAsyncSseLines(lines) : parseSyncSseLines(lines);
+}
+
+// src/_generated/write-body-keys.ts
+var WRITE_BODY_ALLOWED_KEYS = {
+  ContextCreatorsController_createLink: ["url", "title", "isCrawl", "pageLimit"],
+  ContextCreatorsController_createNote: ["title", "content"],
+  ContextCreatorsController_createSavedQuery: ["name", "connectionId", "query", "description", "path"],
+  ContextItemsController_lookup: ["contextType", "dataPath", "contentProjection"],
+  ContextItemsController_update: ["contextType", "content", "description", "userFeedback", "topics"],
+  CustomContextItemsController_batchCreate: ["items"],
+  CustomContextItemsController_create: ["kind", "sourceId", "sourceName", "collectionId", "collectionName", "externalId", "fieldName", "name", "entityType", "description", "content", "url", "attributes", "dataType", "value", "samples", "raw", "topics", "idempotencyKey", "access"],
+  CustomContextItemsController_update: ["name", "entityType", "description", "content", "url", "attributes", "dataType", "value", "samples", "raw", "topics"],
+  EvaluationsController_updateConfig: ["enabled", "cadence", "judgeModel", "judgeGuidance", "notifications"],
+  ModusChatController_chat: ["message", "model"],
+  ModusContextController_compose: ["message", "limit"],
+  ModusRunsController_create: ["message", "sessionId", "organizationId", "version", "fileThreadId", "config", "attachments", "userContext", "source", "runId", "subordinateSkillIds"],
+  ResumeRunsController_create: ["message", "sessionId", "organizationId", "version", "fileThreadId", "config", "attachments", "userContext", "source", "runId", "decision"],
+  RunLifecycleController_activeBySession: ["sessionIds"],
+  RunLifecycleController_cancel: [],
+  RunLifecycleController_editQueued: [],
+  RunLifecycleController_interrupt: [],
+  ScopeChatController_chat: ["message", "model"],
+  ScopeContextController_compose: ["message", "limit"],
+  ScopeMemoriesController_search: ["query", "userId", "limit"],
+  ScopeMemoriesController_update: ["memory", "metadata"],
+  ScopeRunsController_create: ["message", "sessionId", "organizationId", "version", "fileThreadId", "config", "attachments", "userContext", "source", "runId", "subordinateSkillIds"],
+  ScopesController_acceptOwnershipTransfer: [],
+  ScopesController_create: ["name", "description", "expectedOutput", "instructions", "toolset", "model", "connectionSet", "contextSelections", "interfaces", "accessConfig"],
+  ScopesController_deploy: [],
+  ScopesController_patchMcpConfig: ["config"],
+  ScopesController_requestOwnershipTransfer: ["newOwnerUserId"],
+  ScopesController_restore: [],
+  ScopesController_update: ["name", "description", "expectedOutput", "instructions", "toolset", "model", "connectionSet", "contextSelections", "interfaces", "accessConfig", "managerId", "evaluations", "supervisionSubordinateDescriptions"],
+  ScopeSupervisionController_set: ["subordinateAgentIds"],
+  ScopeSupervisionController_setActive: ["subordinateAgentIds"],
+  SuggestionsController_recordEvent: ["event_type", "source", "skill_id", "thread_id", "metadata"],
+  WorkflowActionsController_cancel: [],
+  WorkflowActionsController_execute: ["organizationId", "sessionId", "fileThreadId", "workflowAction", "previousOutputs", "userTimezone", "runId", "automationId", "source"],
+  WorkflowInterfacesController_add: ["type", "name", "config"],
+  WorkflowInterfacesController_update: ["name", "config"],
+  WorkflowRunsController_create: ["message", "sessionId", "organizationId", "version", "fileThreadId", "config", "attachments", "userContext", "source", "runId"],
+  WorkflowsController_acceptOwnershipTransfer: [],
+  WorkflowsController_create: ["name", "type", "description", "trigger", "agentSelection", "workflowStructure", "accessConfig"],
+  WorkflowsController_deploy: [],
+  WorkflowsController_requestOwnershipTransfer: ["newOwnerUserId"],
+  WorkflowsController_restore: [],
+  WorkflowsController_toggle: ["active"],
+  WorkflowsController_update: ["name", "type", "description", "trigger", "agentSelection", "workflowStructure", "accessConfig"]
+};
+
+// src/_validation.ts
+var DEFAULT_MAX_PAGE_SIZE = 200;
+function validatePageSize(pageSize, maxPageSize) {
+  if (!Number.isInteger(pageSize) || pageSize < 1) {
+    throw new Error(`page_size must be a positive int, got ${pageSize}`);
+  }
+  if (maxPageSize !== void 0 && pageSize > maxPageSize) {
+    throw new Error(`page_size must be <= ${maxPageSize}, got ${pageSize}`);
+  }
+}
+function validateId(resourceId, name = "id") {
+  if (typeof resourceId === "string" && !resourceId.trim()) {
+    throw new Error(`${name} must be a non-empty string or int`);
+  }
+}
+var ALLOWED_CHAT_MODELS = /* @__PURE__ */ new Set([
+  "claude-sonnet-5",
+  "claude-sonnet-4.6",
+  "claude-opus-4.8",
+  "gpt-5.2",
+  "gpt-5.5",
+  "gpt-5-mini",
+  "gpt-oss-120b",
+  "gpt-oss-20b",
+  "qwen3-235b-a22b-2507",
+  "qwen3-coder",
+  "qwen3-32b",
+  "deepseek-chat-v3.1",
+  "minimax-m2.7",
+  "llama-4-maverick",
+  "llama-4-scout",
+  "llama-3.3-70b-instruct",
+  "gemini-3.1-pro-preview",
+  "gemini-3-flash-preview",
+  "grok-4.3-fast",
+  "grok-4.3"
+]);
+function validateChatModel(model) {
+  if (!ALLOWED_CHAT_MODELS.has(model)) {
+    const supported = [...ALLOWED_CHAT_MODELS].sort().join(", ");
+    throw new Error(`Unsupported model ${JSON.stringify(model)}. Choose one of: ${supported}.`);
+  }
+}
+function assertWriteBodyKeys(operationId, body) {
+  const allowed = WRITE_BODY_ALLOWED_KEYS[operationId];
+  if (allowed === void 0) return;
+  if (body === void 0 || body === null) return;
+  if (typeof body !== "object" || Array.isArray(body)) {
+    throw new ValidationError(`Request body must be a plain object for ${operationId}`);
+  }
+  const allowedSet = new Set(allowed);
+  const extra = Object.keys(body).filter((k) => !allowedSet.has(k));
+  if (extra.length > 0) {
+    throw new ValidationError(
+      `${operationId}: disallowed request body field(s): ${extra.sort().join(", ")}`
+    );
+  }
+}
+
+// src/_chat.ts
+function effectiveThreadId(threadId) {
+  if (threadId === void 0) return void 0;
+  if (!threadId.trim()) return void 0;
+  return threadId;
+}
+function chatPath(resource, resourceId, options) {
+  const safeId = encodeURIComponent(String(resourceId));
+  const suffix = options.stream ? "/stream" : "";
+  const tid = effectiveThreadId(options.threadId);
+  if (tid !== void 0) {
+    const safeTid = encodeURIComponent(tid);
+    return `/api/v1/${resource}/${safeId}/conversations/${safeTid}/chat${suffix}`;
+  }
+  return `/api/v1/${resource}/${safeId}/chat${suffix}`;
+}
+function modusChatPath(options) {
+  const suffix = options.stream ? "/stream" : "";
+  const tid = effectiveThreadId(options.threadId);
+  if (tid !== void 0) {
+    validateId(tid, "thread_id");
+    return `/api/v1/modus/conversations/${encodeURIComponent(tid)}/chat${suffix}`;
+  }
+  return `/api/v1/modus/chat${suffix}`;
+}
+function chatBody(message, model) {
+  return { message, model };
+}
+function raiseForEvent(event) {
+  if (event.type === "error") throw new ModusError(event.message);
+  if (event.type === "cancelled") throw new RunCancelledError();
+  if (event.type === "stream_timeout") throw new StreamTimeoutError();
+  return event;
+}
+var ChatStream = class {
+  constructor(http, path, body) {
+    this.http = http;
+    this.path = path;
+    this.body = body;
+    this.textParts = [];
+  }
+  async *textStream() {
+    for await (const event of this.events(false)) {
+      if (event.type === "token") yield event.content;
+    }
+  }
+  async *eventStream() {
+    yield* this.events(true);
+  }
+  async *events(supportsReset) {
+    const body = supportsReset ? { ...this.body, streamProtocolVersion: 2 } : this.body;
+    for await (const line of this.http.streamPost(this.path, body)) {
+      for (const event of parseSseStream([line])) {
+        const normalized = raiseForEvent(event);
+        if (normalized.type === "token") this.textParts.push(normalized.content);
+        if (normalized.type === "assistant_content_reset") {
+          this.textParts.length = 0;
+          this.textParts.push(normalized.content);
+        }
+        if (normalized.type === "done") {
+          this.final = {
+            content: this.textParts.join(""),
+            threadId: normalized.threadId,
+            runId: normalized.runId
+          };
+          yield normalized;
+          return;
+        }
+        yield normalized;
+      }
+    }
+  }
+  getFinalResult() {
+    if (this.final === void 0) {
+      throw new ModusError(
+        "Stream ended without a done event; call getFinalResult() only after consuming textStream() or eventStream()."
+      );
+    }
+    return this.final;
+  }
+};
+async function chatBuffered(http, resource, resourceId, message, options) {
+  validateId(resourceId, `${resource}_id`);
+  validateChatModel(options.model);
+  const path = chatPath(resource, resourceId, {
+    threadId: options.threadId,
+    stream: false
+  });
+  const data = await http.post(path, chatBody(message, options.model));
+  return data;
+}
+function chatStreamSession(http, resource, resourceId, message, options) {
+  validateId(resourceId, `${resource}_id`);
+  validateChatModel(options.model);
+  const path = chatPath(resource, resourceId, {
+    threadId: options.threadId,
+    stream: true
+  });
+  return new ChatStream(http, path, chatBody(message, options.model));
+}
+async function modusChatBuffered(http, message, options) {
+  validateChatModel(options.model);
+  const path = modusChatPath({ threadId: options.threadId, stream: false });
+  const data = await http.post(path, chatBody(message, options.model));
+  return data;
+}
+function modusChatStreamSession(http, message, options) {
+  validateChatModel(options.model);
+  const path = modusChatPath({ threadId: options.threadId, stream: true });
+  return new ChatStream(http, path, chatBody(message, options.model));
+}
+
+// src/_pagination.ts
+var Page = class {
+  constructor(items, nextPageToken, fetchPage) {
+    this.items = items;
+    this.nextPageToken = normalizePageToken(nextPageToken);
+    this.fetchPage = fetchPage;
+  }
+  hasNextPage() {
+    return this.nextPageToken !== void 0;
+  }
+  async getNextPage() {
+    if (this.nextPageToken === void 0) {
+      throw new Error(
+        "No next page available. Check hasNextPage() before calling getNextPage()."
+      );
+    }
+    return this.fetchPage(this.nextPageToken);
+  }
+  async *autoPagingIter() {
+    for (const item of this.items) yield item;
+    let nextPageToken = this.nextPageToken;
+    while (nextPageToken !== void 0) {
+      const page = await this.fetchPage(nextPageToken);
+      for (const item of page.items) yield item;
+      nextPageToken = page.nextPageToken;
+    }
+  }
+  [Symbol.iterator]() {
+    return this.items[Symbol.iterator]();
+  }
+};
+function normalizePageToken(token) {
+  if (token === void 0 || token === null || !String(token).trim()) return void 0;
+  return token;
+}
+function aipListParams(pageSize, pageToken, extra = {}) {
+  const params = { pageSize, ...extra };
+  const token = normalizePageToken(pageToken);
+  if (token !== void 0) params.pageToken = token;
+  return params;
+}
+function nextPageTokenFromResponse(data) {
+  return normalizePageToken(
+    typeof data.nextPageToken === "string" ? data.nextPageToken : void 0
+  );
+}
+function requireItemsList(data, itemsKey) {
+  const value = data[itemsKey];
+  if (!Array.isArray(value)) {
+    throw new ModusError(
+      `Unexpected list response shape: ${itemsKey} must be a list, got ${typeof value}. This is likely a backend error.`
+    );
+  }
+  return value;
+}
+function buildAipPage(data, itemsKey, mapItem, fetchPage) {
+  if (typeof data !== "object" || data === null || !(itemsKey in data)) {
+    throw new ModusError(
+      `Unexpected list response shape: missing ${itemsKey}. Got: ${typeof data}. This is likely a backend error.`
+    );
+  }
+  const items = requireItemsList(data, itemsKey).map(mapItem);
+  return new Page(items, nextPageTokenFromResponse(data), fetchPage);
+}
+
+// src/types/conversations.ts
+function conversationSkillId(item) {
+  return item.skillId === 0 ? void 0 : item.skillId;
+}
+
+// src/_auth.ts
+var ENV_API_KEY = "MODUS_API_KEY";
+var ENV_BASE_URL = "MODUS_BASE_URL";
+var ENV_TIMEOUT = "MODUS_TIMEOUT";
+var ENV_MAX_RETRIES = "MODUS_MAX_RETRIES";
+var KEY_PREFIX = "modus_";
+function resolveApiKey(apiKey) {
+  const key = apiKey ?? process.env[ENV_API_KEY];
+  if (!key) {
+    throw new AuthenticationError(
+      `No API key provided. Pass apiKey or set the ${ENV_API_KEY} environment variable. Create a token at app.modus.com \u2192 Settings \u2192 API Tokens.`
+    );
+  }
+  if (!key.startsWith(KEY_PREFIX)) {
+    throw new AuthenticationError(
+      `Invalid API key format. Modus API keys start with '${KEY_PREFIX}'. Create a token at app.modus.com \u2192 Settings \u2192 API Tokens.`
+    );
+  }
+  return key;
+}
+function resolveBaseUrl(baseUrl) {
+  return baseUrl ?? process.env[ENV_BASE_URL] ?? void 0;
+}
+function resolveTimeoutMs(explicitMs) {
+  if (explicitMs !== void 0) return explicitMs;
+  const raw = process.env[ENV_TIMEOUT];
+  if (raw === void 0) return void 0;
+  const seconds = Number(raw);
+  return Number.isFinite(seconds) ? seconds * 1e3 : void 0;
+}
+function resolveMaxRetries(explicit) {
+  if (explicit !== void 0) {
+    if (explicit < 0) throw new Error(`max_retries must be >= 0, got ${explicit}`);
+    return explicit;
+  }
+  const raw = process.env[ENV_MAX_RETRIES];
+  if (raw === void 0) return void 0;
+  const value = Number.parseInt(raw, 10);
+  return Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function authHeaders(apiKey) {
+  return { Authorization: `Bearer ${apiKey}` };
+}
+
+// src/_config.ts
+var DEFAULT_BASE_URL = "https://api.modus.com";
+var DEFAULT_TIMEOUT_MS = 3e5;
+var DEFAULT_MAX_RETRIES = 2;
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/$/, "");
+}
+function normalizeBaseUrls(baseUrls) {
+  return Object.fromEntries(
+    Object.entries(baseUrls ?? {}).map(([service, baseUrl]) => [
+      service,
+      normalizeBaseUrl(baseUrl)
+    ])
+  );
+}
+function createModusConfig(options = {}) {
+  const maxRetries = resolveMaxRetries(options.maxRetries) ?? DEFAULT_MAX_RETRIES;
+  if (!Number.isInteger(maxRetries) || maxRetries < 0) {
+    throw new Error(`max_retries must be a non-negative int, got ${maxRetries}`);
+  }
+  const baseUrl = normalizeBaseUrl(resolveBaseUrl(options.baseUrl) ?? DEFAULT_BASE_URL);
+  return Object.freeze({
+    apiKey: resolveApiKey(options.apiKey),
+    baseUrl,
+    baseUrls: Object.freeze({ "modus-api": baseUrl, ...normalizeBaseUrls(options.baseUrls) }),
+    timeoutMs: resolveTimeoutMs(options.timeoutMs) ?? DEFAULT_TIMEOUT_MS,
+    maxRetries,
+    fetch: options.fetch ?? globalThis.fetch.bind(globalThis)
+  });
+}
+function resolveServiceBaseUrl(config, service, generatedBaseUrl) {
+  return config.baseUrls[service] ?? generatedBaseUrl ?? config.baseUrl;
+}
+function formatConfigForLog(config) {
+  const masked = config.apiKey.length > 10 ? `${config.apiKey.slice(0, 10)}***` : "***";
+  return `ModusConfig(apiKey=${JSON.stringify(masked)}, baseUrl=${JSON.stringify(config.baseUrl)}, timeoutMs=${config.timeoutMs}, maxRetries=${config.maxRetries})`;
+}
+
+// src/_http.ts
+var USER_AGENT = `modus-typescript/${"0.1.0"} (node/${process.version}; ${process.platform})`;
+function buildUrl(baseUrl, path, params) {
+  const url = new URL(path.startsWith("/") ? path : `/${path}`, baseUrl);
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      if (value === void 0 || value === null) continue;
+      if (Array.isArray(value)) {
+        for (const item of value) url.searchParams.append(key, String(item));
+      } else {
+        url.searchParams.set(key, String(value));
+      }
+    }
+  }
+  return url.toString();
+}
+function headersToRecord(headers) {
+  const out = {};
+  headers.forEach((value, key) => {
+    out[key] = value;
+  });
+  return out;
+}
+function messageFromBody(raw, statusCode) {
+  if (!raw) return `HTTP ${statusCode}`;
+  try {
+    const body = JSON.parse(raw);
+    if (body && typeof body === "object") {
+      const record = body;
+      const envelope = record.error;
+      if (envelope && typeof envelope === "object") {
+        const msg2 = envelope.message;
+        if (typeof msg2 === "string" && msg2) return msg2;
+      }
+      const msg = record.message ?? record.error;
+      if (Array.isArray(msg)) return msg.map(String).join("; ");
+      if (typeof msg === "string" && msg) return msg;
+    }
+  } catch {
+  }
+  return raw;
+}
+function errorCodeFromBody(raw) {
+  try {
+    const body = JSON.parse(raw);
+    return typeof body.error?.code === "string" ? body.error.code : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function raiseForStatus(response, body) {
+  if (response.ok) return;
+  const message = messageFromBody(body, response.status);
+  const requestId = response.headers.get("x-request-id") ?? response.headers.get("X-Request-ID") ?? void 0;
+  const headers = headersToRecord(response.headers);
+  const code = errorCodeFromBody(body);
+  const base = { requestId, responseHeaders: headers, body, code };
+  switch (response.status) {
+    case 401:
+      throw new AuthenticationError(message, base);
+    case 403:
+      throw new PermissionDeniedError(message, base);
+    case 404:
+      throw new NotFoundError(message, base);
+    case 409:
+      throw new ConflictError(message, base);
+    case 422: {
+      let errors;
+      try {
+        errors = JSON.parse(body);
+      } catch {
+        errors = void 0;
+      }
+      throw new UnprocessableError(message, { ...base, errors });
+    }
+    case 429: {
+      const retryHeader = response.headers.get("retry-after") ?? "";
+      const retryAfter = /^\d+$/.test(retryHeader) ? Number.parseInt(retryHeader, 10) : void 0;
+      throw new RateLimitError(message, { ...base, retryAfter });
+    }
+    default:
+      if (response.status >= 500) {
+        throw new InternalServerError(message, response.status, base);
+      }
+      throw new ModusError(message, { ...base, statusCode: response.status });
+  }
+}
+function wrapNetworkError(error, baseUrl) {
+  const detail = error instanceof Error ? error.message : String(error);
+  return new APIConnectionError(
+    `Network error communicating with Modus API at ${JSON.stringify(baseUrl)}: ${detail}. Check connectivity and that baseUrl is correct.`
+  );
+}
+async function readBody(response) {
+  return response.text();
+}
+var HttpClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  defaultHeaders() {
+    return {
+      ...authHeaders(this.config.apiKey),
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      "User-Agent": USER_AGENT
+    };
+  }
+  async request(method, path, options = {}) {
+    const baseUrl = options.baseUrl ?? this.config.baseUrl;
+    const url = buildUrl(baseUrl, path, options.params);
+    try {
+      const response = await this.config.fetch(url, {
+        method,
+        headers: { ...this.defaultHeaders(), ...options.headers },
+        body: options.json !== void 0 ? JSON.stringify(options.json) : void 0,
+        signal: AbortSignal.timeout(this.config.timeoutMs)
+      });
+      const body = await readBody(response);
+      raiseForStatus(response, body);
+      if (response.status === 204 || !body) return null;
+      return JSON.parse(body);
+    } catch (error) {
+      if (error instanceof ModusError) throw error;
+      if (error instanceof DOMException && error.name === "AbortError") {
+        throw wrapNetworkError(new Error("Request timed out"), baseUrl);
+      }
+      throw wrapNetworkError(error, baseUrl);
+    }
+  }
+  get(path, params, options = {}) {
+    return this.request("GET", path, { params, ...options });
+  }
+  post(path, json, options = {}) {
+    return this.request("POST", path, { json, ...options });
+  }
+  patch(path, json, params, options = {}) {
+    return this.request("PATCH", path, { json, params, ...options });
+  }
+  delete(path, options = {}) {
+    return this.request("DELETE", path, options);
+  }
+  async *stream(method, path, options = {}) {
+    const baseUrl = options.baseUrl ?? this.config.baseUrl;
+    const url = buildUrl(baseUrl, path, options.params);
+    try {
+      const response = await this.config.fetch(url, {
+        method,
+        headers: { ...this.defaultHeaders(), ...options.headers },
+        body: options.json !== void 0 ? JSON.stringify(options.json) : void 0,
+        signal: AbortSignal.timeout(this.config.timeoutMs)
+      });
+      if (!response.ok) {
+        const body = await readBody(response);
+        raiseForStatus(response, body);
+        return;
+      }
+      if (!response.body) return;
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (line.trim()) yield line;
+        }
+      }
+      if (buffer.trim()) yield buffer;
+    } catch (error) {
+      if (error instanceof ModusError) throw error;
+      if (error instanceof DOMException && error.name === "AbortError") {
+        throw wrapNetworkError(new Error("Request timed out"), baseUrl);
+      }
+      throw wrapNetworkError(error, baseUrl);
+    }
+  }
+  streamGet(path, params, options = {}) {
+    return this.stream("GET", path, { params, ...options });
+  }
+  streamPost(path, json, options = {}) {
+    return this.stream("POST", path, { json, ...options });
+  }
+};
+
+// src/_client-base.ts
+var ModusClientBase = class {
+  constructor(options = {}) {
+    this._config = createModusConfig(options);
+    this._http = new HttpClient(this._config);
+  }
+  get config() {
+    return this._config;
+  }
+  /** @internal */
+  get http() {
+    return this._http;
+  }
+  toString() {
+    return formatConfigForLog(this._config);
+  }
+};
+
+// src/_openapi-invoke.ts
+function getOperation(operationId) {
+  if (!(operationId in OPERATIONS)) {
+    throw new Error(
+      `Unknown API operation ${JSON.stringify(operationId)}. Upgrade @getmodus/sdk or report a version mismatch.`
+    );
+  }
+  return OPERATIONS[operationId];
+}
+function formatPath(template, pathParams) {
+  return template.split("/").map((segment) => {
+    if (!segment.startsWith("{") || !segment.endsWith("}")) return segment;
+    const key = segment.slice(1, -1);
+    if (!(key in pathParams)) {
+      throw new Error(`Missing path parameter ${JSON.stringify(key)} for ${JSON.stringify(template)}`);
+    }
+    return encodeURIComponent(String(pathParams[key]));
+  }).join("/");
+}
+function operationBaseUrl(http, operation) {
+  return resolveServiceBaseUrl(http.config, operation.service, operation.serverUrl);
+}
+function formatOperationPath(operationId, pathParams = {}) {
+  return formatPath(getOperation(operationId).path, pathParams);
+}
+async function invokeOperation(http, operationId, options = {}) {
+  const op = getOperation(operationId);
+  const path = formatPath(op.path, options.pathParams ?? {});
+  const params = options.query;
+  const requestOptions = {
+    baseUrl: operationBaseUrl(http, op),
+    headers: options.headers
+  };
+  switch (op.method) {
+    case "GET":
+      return http.get(path, params, requestOptions);
+    case "POST":
+      return http.post(path, options.jsonBody, requestOptions);
+    case "PATCH":
+      return http.patch(path, options.jsonBody, params, requestOptions);
+    case "DELETE":
+      return http.delete(path, requestOptions);
+    default:
+      throw new Error(`Unsupported HTTP method ${JSON.stringify(op.method)}`);
+  }
+}
+
+// src/_retry.ts
+var DEPLOY_NOT_FOUND_BACKOFF_MS = 500;
+var MAX_DEPLOY_NOT_FOUND_RETRIES = 1;
+var RETRYABLE = [RateLimitError, InternalServerError, APIConnectionError];
+function isRetryable(error) {
+  return RETRYABLE.some((Cls) => error instanceof Cls);
+}
+function backoffSeconds(attempt, error) {
+  if (error instanceof RateLimitError && error.retryAfter !== void 0) {
+    return Math.max(0, error.retryAfter);
+  }
+  if (attempt === 0) return 0;
+  return Math.max(0.5, 2 ** (attempt - 1) + (Math.random() * 0.6 - 0.3));
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withRetry(fn, maxRetries, options = {}) {
+  let deployNotFoundRetries = 0;
+  let attempt = 0;
+  while (true) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (options.retryNotFoundOnDeploy && error instanceof NotFoundError && deployNotFoundRetries < MAX_DEPLOY_NOT_FOUND_RETRIES) {
+        deployNotFoundRetries++;
+        await sleep(DEPLOY_NOT_FOUND_BACKOFF_MS);
+        continue;
+      }
+      if (!isRetryable(error) || attempt >= maxRetries) throw error;
+      await sleep(backoffSeconds(attempt, error) * 1e3);
+      attempt++;
+    }
+  }
+}
+
+// src/_request.ts
+async function invokeWithRetry(config, http, operationId, options = {}) {
+  if (options.jsonBody !== void 0) {
+    assertWriteBodyKeys(operationId, options.jsonBody);
+  }
+  return withRetry(() => invokeOperation(http, operationId, options), config.maxRetries, {
+    retryNotFoundOnDeploy: operationId.endsWith("_deploy")
+  });
+}
+function omitUndefined(obj) {
+  return Object.fromEntries(
+    Object.entries(obj).filter((entry) => entry[1] !== void 0)
+  );
+}
+function asRecord(data) {
+  if (typeof data === "object" && data !== null && !Array.isArray(data)) {
+    return data;
+  }
+  throw new Error(`Expected object response, got ${typeof data}`);
+}
+
+// src/resources/agents/runs.ts
+var RUNS_MAX_PAGE_SIZE = 100;
+function runsListParams(pageSize, pageToken, status, timeframe, approvalScope, search) {
+  const params = { pageSize };
+  const token = normalizePageToken(pageToken);
+  if (token !== void 0) params.pageToken = token;
+  if (status !== void 0) params.status = status;
+  if (timeframe !== void 0) params.timeframe = timeframe;
+  if (approvalScope !== void 0) params.approvalScope = approvalScope;
+  if (search !== void 0) params.search = search;
+  return params;
+}
+function activeRunsParams(pageSize, pageToken) {
+  const params = { pageSize };
+  const token = normalizePageToken(pageToken);
+  if (token !== void 0) params.pageToken = token;
+  return params;
+}
+function parseRun(raw) {
+  return raw;
+}
+function parseActiveRunsArray(raw) {
+  const data = asRecord(raw);
+  const runs = data.runs;
+  if (!Array.isArray(runs)) {
+    throw new ModusError(
+      `Unexpected active runs response shape: runs must be a list, got ${typeof runs}.`
+    );
+  }
+  return runs;
+}
+function parseActiveRunsPage(raw, fetchPage) {
+  const data = asRecord(raw);
+  const runs = data.runs;
+  if (!Array.isArray(runs)) {
+    throw new ModusError(
+      `Unexpected active runs response shape: runs must be a list, got ${typeof runs}.`
+    );
+  }
+  return new Page(
+    runs,
+    normalizePageToken(
+      typeof data.nextPageToken === "string" ? data.nextPageToken : void 0
+    ),
+    fetchPage
+  );
+}
+function randomRunId() {
+  return crypto.randomUUID();
+}
+var WorkflowRunsResource = class {
+  constructor(http, config) {
+    this.http = http;
+    this.config = config;
+  }
+  list(workflowId, options = {}) {
+    validateId(workflowId, "workflow_id");
+    const pageSize = options.pageSize ?? 25;
+    validatePageSize(pageSize, RUNS_MAX_PAGE_SIZE);
+    return this.listPage(workflowId, pageSize, options.pageToken, options);
+  }
+  async listPage(workflowId, pageSize, pageToken, filters) {
+    const data = asRecord(
+      await invokeWithRetry(this.config, this.http, "WorkflowRunsController_list", {
+        pathParams: { id: workflowId },
+        query: runsListParams(
+          pageSize,
+          pageToken,
+          filters.status,
+          filters.timeframe,
+          filters.approvalScope,
+          filters.search
+        )
+      })
+    );
+    const runs = data.runs;
+    if (!Array.isArray(runs)) {
+      throw new ModusError(
+        `Unexpected list response shape: runs must be a list, got ${typeof runs}.`
+      );
+    }
+    return new Page(
+      runs,
+      normalizePageToken(
+        typeof data.nextPageToken === "string" ? data.nextPageToken : void 0
+      ),
+      (token) => this.listPage(workflowId, pageSize, token, filters)
+    );
+  }
+  async get(workflowId, runId, options = {}) {
+    validateId(workflowId, "workflow_id");
+    if (!runId.trim()) throw new Error("run_id must be a non-empty string");
+    const query = options.temporalRunId !== void 0 ? { temporalRunId: options.temporalRunId } : void 0;
+    const data = await invokeWithRetry(this.config, this.http, "WorkflowRunsController_get", {
+      pathParams: { id: workflowId, runId },
+      query
+    });
+    return parseRun(data);
+  }
+  async create(workflowId, body, options = {}) {
+    validateId(workflowId, "workflow_id");
+    return this.createRun("WorkflowRunsController_create", body, { id: workflowId }, options);
+  }
+  async createScope(scopeId, body, options = {}) {
+    validateId(scopeId, "scope_id");
+    return this.createRun("ScopeRunsController_create", body, { id: scopeId }, options);
+  }
+  async createModus(body, options = {}) {
+    return this.createRun("ModusRunsController_create", body, {}, options);
+  }
+  async resume(runId, body, options = {}) {
+    validateId(runId, "run_id");
+    return this.createRun("ResumeRunsController_create", body, { runId }, options);
+  }
+  async cancel(runId) {
+    validateId(runId, "run_id");
+    await invokeWithRetry(this.config, this.http, "RunLifecycleController_cancel", {
+      pathParams: { runId },
+      jsonBody: {}
+    });
+  }
+  async events(runId) {
+    validateId(runId, "run_id");
+    return invokeWithRetry(this.config, this.http, "RunLifecycleController_events", {
+      pathParams: { runId }
+    });
+  }
+  async interrupt(runId) {
+    validateId(runId, "run_id");
+    await invokeWithRetry(this.config, this.http, "RunLifecycleController_interrupt", {
+      pathParams: { runId },
+      jsonBody: {}
+    });
+  }
+  async editQueued(runId) {
+    validateId(runId, "run_id");
+    await invokeWithRetry(this.config, this.http, "RunLifecycleController_editQueued", {
+      pathParams: { runId },
+      jsonBody: {}
+    });
+  }
+  active(options = {}) {
+    const pageSize = options.pageSize ?? 50;
+    validatePageSize(pageSize, RUNS_MAX_PAGE_SIZE);
+    return this.activePage(pageSize, options.pageToken);
+  }
+  async activePage(pageSize, pageToken) {
+    return parseActiveRunsPage(
+      await invokeWithRetry(this.config, this.http, "RunLifecycleController_active", {
+        query: activeRunsParams(pageSize, pageToken)
+      }),
+      (token) => this.activePage(pageSize, token)
+    );
+  }
+  async activeBySession(sessionIds) {
+    const uniqueSessionIds = [...new Set(sessionIds.map((id) => id.trim()).filter(Boolean))];
+    if (uniqueSessionIds.length > 100) {
+      throw new Error("sessionIds must contain at most 100 ids");
+    }
+    return parseActiveRunsArray(
+      await invokeWithRetry(this.config, this.http, "RunLifecycleController_activeBySession", {
+        jsonBody: { sessionIds: uniqueSessionIds }
+      })
+    );
+  }
+  stream(runId, options = {}) {
+    validateId(runId, "run_id");
+    const op = getOperation("RunLifecycleController_stream");
+    const path = formatOperationPath("RunLifecycleController_stream", { runId });
+    const lines = this.http.streamGet(path, void 0, {
+      baseUrl: operationBaseUrl(this.http, op),
+      headers: options.lastEventId ? { "Last-Event-ID": options.lastEventId } : void 0
+    });
+    return { runId, events: this.parseEvents(lines) };
+  }
+  createRun(operationId, body, pathParams, options) {
+    const runId = options.idempotencyKey?.trim() || body.runId?.trim() || randomRunId();
+    const op = getOperation(operationId);
+    const path = formatOperationPath(operationId, pathParams);
+    const lines = this.http.streamPost(path, {
+      ...body,
+      streamProtocolVersion: 2
+    }, {
+      baseUrl: operationBaseUrl(this.http, op),
+      headers: { "Idempotency-Key": runId }
+    });
+    return { runId, events: this.parseEvents(lines) };
+  }
+  async *parseEvents(lines) {
+    yield* parseSseStream(lines);
+  }
+};
+
+// src/resources/agents/workflow-actions.ts
+function randomRunId2() {
+  return crypto.randomUUID();
+}
+var AgentWorkflowActionsResource = class {
+  constructor(http, config) {
+    this.http = http;
+    this.config = config;
+  }
+  async execute(body, options = {}) {
+    const runId = options.idempotencyKey?.trim() || body.runId?.trim() || randomRunId2();
+    const op = getOperation("WorkflowActionsController_execute");
+    const path = formatOperationPath("WorkflowActionsController_execute");
+    const lines = this.http.streamPost(path, body, {
+      baseUrl: operationBaseUrl(this.http, op),
+      headers: { "Idempotency-Key": runId }
+    });
+    return { runId, events: this.parseEvents(lines) };
+  }
+  async cancel(runId) {
+    validateId(runId, "run_id");
+    await invokeWithRetry(this.config, this.http, "WorkflowActionsController_cancel", {
+      pathParams: { runId },
+      jsonBody: {}
+    });
+  }
+  async *parseEvents(lines) {
+    yield* parseSseStream(lines);
+  }
+};
+
+// src/resources/agents.ts
+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 WorkflowsResource = class {
+  constructor(http, config) {
+    this.http = http;
+    this.config = config;
+    this.runs = new WorkflowRunsResource(http, config);
+    this.workflowActions = new AgentWorkflowActionsResource(http, config);
+  }
+  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, "WorkflowsController_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 = {};
+    if (options.view !== void 0) query.view = options.view;
+    if (options.includeVariation !== void 0) {
+      query.includeVariation = options.includeVariation;
+    }
+    const data = await invokeWithRetry(this.config, this.http, "WorkflowsController_get", {
+      pathParams: { id: workflowId },
+      query: Object.keys(query).length > 0 ? query : void 0
+    });
+    return parseWorkflow(data);
+  }
+};
+
+// src/resources/connections.ts
+function connectionsListParams(pageSize, pageToken, type) {
+  const extra = {};
+  if (type !== void 0) extra.type = type;
+  return aipListParams(pageSize, pageToken, extra);
+}
+function parseConnection(raw) {
+  return raw;
+}
+var ConnectionsResource = 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.type);
+  }
+  async listPage(pageSize, pageToken, type) {
+    const data = asRecord(
+      await invokeWithRetry(this.config, this.http, "ConnectionsController_list", {
+        query: connectionsListParams(pageSize, pageToken, type)
+      })
+    );
+    return buildAipPage(
+      data,
+      "connections",
+      parseConnection,
+      (token) => this.listPage(pageSize, token, type)
+    );
+  }
+  async find(options) {
+    const pageSize = options.pageSize ?? 25;
+    validatePageSize(pageSize);
+    const target = options.name.trim().toLowerCase();
+    let token;
+    do {
+      const page = await this.listPage(pageSize, token, options.type);
+      const match = page.items.find((c) => c.name?.toLowerCase() === target);
+      if (match) return match;
+      if (!page.hasNextPage()) break;
+      token = page.nextPageToken;
+    } while (token !== void 0);
+    return void 0;
+  }
+};
+
+// src/resources/context/custom-items.ts
+function parseContextItem(raw) {
+  return raw;
+}
+function parseCreatedCustomContextItem(raw) {
+  return raw;
+}
+function parseDeletion(raw) {
+  return raw;
+}
+var CustomContextItemsResource = 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);
+  }
+  async listPage(pageSize, pageToken, options) {
+    const data = asRecord(
+      await invokeWithRetry(this.config, this.http, "CustomContextItemsController_list", {
+        query: aipListParams(pageSize, pageToken, {
+          searchQuery: options.searchQuery,
+          topics: options.topics
+        })
+      })
+    );
+    return buildAipPage(
+      data,
+      "contextItems",
+      parseContextItem,
+      (token) => this.listPage(pageSize, token, options)
+    );
+  }
+  async get(uid) {
+    return parseContextItem(
+      await invokeWithRetry(this.config, this.http, "CustomContextItemsController_get", {
+        pathParams: { uid }
+      })
+    );
+  }
+  async create(input) {
+    return parseCreatedCustomContextItem(
+      await invokeWithRetry(this.config, this.http, "CustomContextItemsController_create", {
+        jsonBody: omitUndefined(input)
+      })
+    );
+  }
+  async batchCreate(inputs) {
+    const data = asRecord(
+      await invokeWithRetry(this.config, this.http, "CustomContextItemsController_batchCreate", {
+        jsonBody: {
+          items: inputs.map((input) => omitUndefined(input))
+        }
+      })
+    );
+    const items = data.contextItems;
+    return Array.isArray(items) ? items.map(parseCreatedCustomContextItem) : [];
+  }
+  async update(uid, input) {
+    return asRecord(
+      await invokeWithRetry(this.config, this.http, "CustomContextItemsController_update", {
+        pathParams: { uid },
+        jsonBody: omitUndefined(input)
+      })
+    );
+  }
+  async delete(uid) {
+    return parseDeletion(
+      await invokeWithRetry(this.config, this.http, "CustomContextItemsController_delete", {
+        pathParams: { uid }
+      })
+    );
+  }
+};
+
+// src/resources/context/items.ts
+function contextListParams(pageSize, pageToken, contextType) {
+  const extra = {};
+  if (contextType !== void 0) extra.contextTypes = [contextType];
+  return aipListParams(pageSize, pageToken, extra);
+}
+function parseContextItem2(raw) {
+  return raw;
+}
+function parseContextValueRow(raw) {
+  return raw;
+}
+function parseLookupResponse(raw) {
+  const item = raw.item;
+  if (item === null || item === void 0) return void 0;
+  return item;
+}
+var ContextItemsResource = 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",
+      parseContextItem2,
+      (token) => this.listPage(pageSize, token, contextType)
+    );
+  }
+  async get(uid) {
+    const data = await invokeWithRetry(this.config, this.http, "ContextItemsController_get", {
+      pathParams: { uid }
+    });
+    return parseContextItem2(data);
+  }
+  async lookup(options) {
+    const body = omitUndefined({
+      contextType: options.contextType,
+      dataPath: options.dataPath,
+      contentProjection: options.contentProjection
+    });
+    try {
+      const raw = asRecord(
+        await invokeWithRetry(this.config, this.http, "ContextItemsController_lookup", {
+          jsonBody: body
+        })
+      );
+      return parseLookupResponse(raw);
+    } catch (error) {
+      if (error instanceof NotFoundError) return void 0;
+      throw error;
+    }
+  }
+  listValues(uid, contextType, contentKeyPath, options = {}) {
+    const pageSize = options.pageSize ?? 25;
+    validatePageSize(pageSize, DEFAULT_MAX_PAGE_SIZE);
+    return this.listValuesPage(uid, contextType, contentKeyPath, pageSize, options.pageToken);
+  }
+  listValuesFor(item, contentKeyPath, options = {}) {
+    return this.listValues(item.uid, item.contextType, contentKeyPath, options);
+  }
+  async listValuesPage(uid, contextType, contentKeyPath, pageSize, pageToken) {
+    const data = asRecord(
+      await invokeWithRetry(this.config, this.http, "ContextItemsController_listValues", {
+        pathParams: { uid },
+        query: aipListParams(pageSize, pageToken, {
+          contextType,
+          contentKeyPath
+        })
+      })
+    );
+    return buildAipPage(
+      data,
+      "values",
+      parseContextValueRow,
+      (token) => this.listValuesPage(uid, contextType, contentKeyPath, pageSize, token)
+    );
+  }
+};
+
+// src/resources/context/context.ts
+var ContextResource = class {
+  constructor(http, config) {
+    this.items = new ContextItemsResource(http, config);
+    this.customItems = new CustomContextItemsResource(http, config);
+  }
+};
+
+// src/resources/modus/conversations.ts
+var ALLOWED_KINDS = /* @__PURE__ */ new Set(["all", "modus", "skills"]);
+function listParams(pageSize, pageToken, kind) {
+  if (kind !== void 0 && !ALLOWED_KINDS.has(kind)) {
+    throw new Error(
+      `kind must be one of ${[...ALLOWED_KINDS].sort().join(", ")}, got ${JSON.stringify(kind)}`
+    );
+  }
+  const extra = {};
+  if (kind !== void 0) extra.kind = kind;
+  return aipListParams(pageSize, pageToken, extra);
+}
+function parseListItem(raw) {
+  return raw;
+}
+function parseConversation(raw) {
+  return raw;
+}
+var ModusConversationsResource = 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.kind);
+  }
+  async listPage(pageSize, pageToken, kind) {
+    const data = asRecord(
+      await invokeWithRetry(this.config, this.http, "ModusConversationsController_list", {
+        query: listParams(pageSize, pageToken, kind)
+      })
+    );
+    return buildAipPage(
+      data,
+      "conversations",
+      parseListItem,
+      (token) => this.listPage(pageSize, token, kind)
+    );
+  }
+  async get(threadId) {
+    validateId(threadId, "thread_id");
+    const data = await invokeWithRetry(this.config, this.http, "ModusConversationsController_get", {
+      pathParams: { threadId }
+    });
+    return parseConversation(data);
+  }
+};
+
+// src/resources/modus/modus.ts
+var ModusResource = class {
+  constructor(http, config) {
+    this.http = http;
+    this.config = config;
+    this.conversations = new ModusConversationsResource(http, config);
+  }
+  async getContext(message, options = {}) {
+    const data = await invokeWithRetry(this.config, this.http, "ModusContextController_compose", {
+      jsonBody: omitUndefined({ message, limit: options.limit })
+    });
+    return data;
+  }
+  chat(message, options) {
+    return modusChatBuffered(this.http, message, options);
+  }
+  chatStream(message, options) {
+    return modusChatStreamSession(this.http, message, options);
+  }
+};
+
+// src/resources/skills/conversations.ts
+function parseListItem2(raw) {
+  return raw;
+}
+function parseConversation2(raw) {
+  return raw;
+}
+var ScopeConversationsResource = 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);
+  }
+  async listPage(pageSize, pageToken) {
+    validateId(this.scopeId, "scope_id");
+    const data = asRecord(
+      await invokeWithRetry(this.config, this.http, "ScopeConversationsController_list", {
+        pathParams: { id: this.scopeId },
+        query: aipListParams(pageSize, pageToken)
+      })
+    );
+    return buildAipPage(
+      data,
+      "conversations",
+      parseListItem2,
+      (token) => this.listPage(pageSize, token)
+    );
+  }
+  async get(threadId, options = {}) {
+    validateId(this.scopeId, "scope_id");
+    validateId(threadId, "thread_id");
+    if (options.beforeMessageIndex !== void 0 && options.messageLimit === void 0) {
+      throw new Error("beforeMessageIndex requires messageLimit");
+    }
+    const data = await invokeWithRetry(this.config, this.http, "ScopeConversationsController_get", {
+      pathParams: { id: this.scopeId, threadId },
+      query: {
+        messageLimit: options.messageLimit,
+        beforeMessageIndex: options.beforeMessageIndex
+      }
+    });
+    return parseConversation2(data);
+  }
+};
+
+// src/resources/skills.ts
+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 ScopesResource = class {
+  constructor(http, config) {
+    this.http = http;
+    this.config = config;
+  }
+  conversations(scopeId) {
+    return new ScopeConversationsResource(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, "ScopesController_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, "ScopesController_get", {
+      pathParams: { id: scopeId },
+      query
+    });
+    return parseScope(data);
+  }
+  async getContext(scopeId, message, options = {}) {
+    validateId(scopeId, "scope_id");
+    const data = await invokeWithRetry(this.config, this.http, "ScopeContextController_compose", {
+      pathParams: { id: scopeId },
+      jsonBody: omitUndefined({ message, limit: options.limit })
+    });
+    return data;
+  }
+  chat(scopeId, message, options) {
+    return chatBuffered(this.http, "scopes", scopeId, message, options);
+  }
+  chatStream(scopeId, message, options) {
+    return chatStreamSession(this.http, "scopes", scopeId, message, options);
+  }
+};
+
+// src/resources/suggestions.ts
+var DEFAULT_SUGGESTIONS_PAGE_SIZE = 5;
+var MAX_SUGGESTIONS_PAGE_SIZE = 12;
+function parseSuggestion(raw) {
+  return raw;
+}
+function suggestionListParams(options) {
+  return {
+    pageSize: options.pageSize,
+    pageToken: options.pageToken,
+    skill_id: options.skillId,
+    skill_ids: options.skillIds?.join(",")
+  };
+}
+var SuggestionsResource = class {
+  constructor(http, config) {
+    this.http = http;
+    this.config = config;
+  }
+  list(options = {}) {
+    const pageSize = options.pageSize ?? DEFAULT_SUGGESTIONS_PAGE_SIZE;
+    validatePageSize(pageSize, MAX_SUGGESTIONS_PAGE_SIZE);
+    return this.listPage(pageSize, options.pageToken, options.skillId, options.skillIds);
+  }
+  async listPage(pageSize, pageToken, skillId, skillIds) {
+    const data = asRecord(
+      await invokeWithRetry(this.config, this.http, "SuggestionsController_listApproved", {
+        query: suggestionListParams({ pageSize, pageToken, skillId, skillIds })
+      })
+    );
+    return buildAipPage(
+      data,
+      "suggestions",
+      parseSuggestion,
+      (token) => this.listPage(pageSize, token, skillId, skillIds)
+    );
+  }
+  async recordEvent(id, event) {
+    validateId(id, "id");
+    await invokeWithRetry(this.config, this.http, "SuggestionsController_recordEvent", {
+      pathParams: { id },
+      jsonBody: event
+    });
+  }
+};
+
+// src/index.ts
+var Modus = class extends ModusClientBase {
+  constructor(options = {}) {
+    super(options);
+    this.scopes = new ScopesResource(this.http, this.config);
+    this.modus = new ModusResource(this.http, this.config);
+    this.workflows = new WorkflowsResource(this.http, this.config);
+    this.context = new ContextResource(this.http, this.config);
+    this.connections = new ConnectionsResource(this.http, this.config);
+    this.suggestions = new SuggestionsResource(this.http, this.config);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APIConnectionError,
+  AuthenticationError,
+  ChatStream,
+  ConflictError,
+  InternalServerError,
+  Modus,
+  ModusError,
+  NotFoundError,
+  OPERATIONS,
+  Page,
+  PermissionDeniedError,
+  RateLimitError,
+  RunCancelledError,
+  StreamTimeoutError,
+  UnprocessableError,
+  ValidationError,
+  conversationSkillId
+});
+//# sourceMappingURL=index.cjs.map