@getmodus/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,888 @@
+import {
+  APIConnectionError,
+  AuthenticationError,
+  ConflictError,
+  CustomContextItemsResource,
+  DEFAULT_MAX_PAGE_SIZE,
+  InternalServerError,
+  ModusClientBase,
+  ModusError,
+  NotFoundError,
+  OPERATIONS,
+  Page,
+  PermissionDeniedError,
+  RateLimitError,
+  RunCancelledError,
+  ScopeConversationsResource,
+  StreamTimeoutError,
+  UnprocessableError,
+  ValidationError,
+  aipListParams,
+  asRecord,
+  buildAipPage,
+  formatOperationPath,
+  getOperation,
+  invokeWithRetry,
+  normalizePageToken,
+  omitUndefined,
+  operationBaseUrl,
+  validateChatModel,
+  validateId,
+  validatePageSize
+} from "./chunk-VLHNZJBG.js";
+
+// 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/_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/types/conversations.ts
+function conversationSkillId(item) {
+  return item.skillId === 0 ? void 0 : item.skillId;
+}
+
+// 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/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;
+}
+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",
+      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 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.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);
+  }
+};
+export {
+  APIConnectionError,
+  AuthenticationError,
+  ChatStream,
+  ConflictError,
+  InternalServerError,
+  Modus,
+  ModusError,
+  NotFoundError,
+  OPERATIONS,
+  Page,
+  PermissionDeniedError,
+  RateLimitError,
+  RunCancelledError,
+  StreamTimeoutError,
+  UnprocessableError,
+  ValidationError,
+  conversationSkillId
+};
+//# sourceMappingURL=index.js.map