@automagik/omni 2.260424.3 → 2.260428.1

package/dist/sdk/index.js

@@ -0,0 +1,2199 @@
+// ../../node_modules/.bun/openapi-fetch@0.13.8/node_modules/openapi-fetch/dist/index.js
+var PATH_PARAM_RE = /\{[^{}]+\}/g;
+var supportsRequestInitExt = () => {
+  return typeof process === "object" && Number.parseInt(process?.versions?.node?.substring(0, 2)) >= 18 && process.versions.undici;
+};
+function randomID() {
+  return Math.random().toString(36).slice(2, 11);
+}
+function createClient(clientOptions) {
+  let {
+    baseUrl = "",
+    Request: CustomRequest = globalThis.Request,
+    fetch: baseFetch = globalThis.fetch,
+    querySerializer: globalQuerySerializer,
+    bodySerializer: globalBodySerializer,
+    headers: baseHeaders,
+    requestInitExt = undefined,
+    ...baseOptions
+  } = { ...clientOptions };
+  requestInitExt = supportsRequestInitExt() ? requestInitExt : undefined;
+  baseUrl = removeTrailingSlash(baseUrl);
+  const middlewares = [];
+  async function coreFetch(schemaPath, fetchOptions) {
+    const {
+      baseUrl: localBaseUrl,
+      fetch: fetch2 = baseFetch,
+      Request = CustomRequest,
+      headers,
+      params = {},
+      parseAs = "json",
+      querySerializer: requestQuerySerializer,
+      bodySerializer = globalBodySerializer ?? defaultBodySerializer,
+      body,
+      ...init
+    } = fetchOptions || {};
+    let finalBaseUrl = baseUrl;
+    if (localBaseUrl) {
+      finalBaseUrl = removeTrailingSlash(localBaseUrl) ?? baseUrl;
+    }
+    let querySerializer = typeof globalQuerySerializer === "function" ? globalQuerySerializer : createQuerySerializer(globalQuerySerializer);
+    if (requestQuerySerializer) {
+      querySerializer = typeof requestQuerySerializer === "function" ? requestQuerySerializer : createQuerySerializer({
+        ...typeof globalQuerySerializer === "object" ? globalQuerySerializer : {},
+        ...requestQuerySerializer
+      });
+    }
+    const serializedBody = body === undefined ? undefined : bodySerializer(body, mergeHeaders(baseHeaders, headers, params.header));
+    const finalHeaders = mergeHeaders(serializedBody === undefined || serializedBody instanceof FormData ? {} : {
+      "Content-Type": "application/json"
+    }, baseHeaders, headers, params.header);
+    const requestInit = {
+      redirect: "follow",
+      ...baseOptions,
+      ...init,
+      body: serializedBody,
+      headers: finalHeaders
+    };
+    let id;
+    let options;
+    let request = new CustomRequest(createFinalURL(schemaPath, { baseUrl: finalBaseUrl, params, querySerializer }), requestInit);
+    let response;
+    for (const key in init) {
+      if (!(key in request)) {
+        request[key] = init[key];
+      }
+    }
+    if (middlewares.length) {
+      id = randomID();
+      options = Object.freeze({
+        baseUrl: finalBaseUrl,
+        fetch: fetch2,
+        parseAs,
+        querySerializer,
+        bodySerializer
+      });
+      for (const m of middlewares) {
+        if (m && typeof m === "object" && typeof m.onRequest === "function") {
+          const result = await m.onRequest({
+            request,
+            schemaPath,
+            params,
+            options,
+            id
+          });
+          if (result) {
+            if (result instanceof CustomRequest) {
+              request = result;
+            } else if (result instanceof Response) {
+              response = result;
+              break;
+            } else {
+              throw new Error("onRequest: must return new Request() or Response() when modifying the request");
+            }
+          }
+        }
+      }
+    }
+    if (!response) {
+      try {
+        response = await fetch2(request, requestInitExt);
+      } catch (error2) {
+        let errorAfterMiddleware = error2;
+        if (middlewares.length) {
+          for (let i = middlewares.length - 1;i >= 0; i--) {
+            const m = middlewares[i];
+            if (m && typeof m === "object" && typeof m.onError === "function") {
+              const result = await m.onError({
+                request,
+                error: errorAfterMiddleware,
+                schemaPath,
+                params,
+                options,
+                id
+              });
+              if (result) {
+                if (result instanceof Response) {
+                  errorAfterMiddleware = undefined;
+                  response = result;
+                  break;
+                }
+                if (result instanceof Error) {
+                  errorAfterMiddleware = result;
+                  continue;
+                }
+                throw new Error("onError: must return new Response() or instance of Error");
+              }
+            }
+          }
+        }
+        if (errorAfterMiddleware) {
+          throw errorAfterMiddleware;
+        }
+      }
+      if (middlewares.length) {
+        for (let i = middlewares.length - 1;i >= 0; i--) {
+          const m = middlewares[i];
+          if (m && typeof m === "object" && typeof m.onResponse === "function") {
+            const result = await m.onResponse({
+              request,
+              response,
+              schemaPath,
+              params,
+              options,
+              id
+            });
+            if (result) {
+              if (!(result instanceof Response)) {
+                throw new Error("onResponse: must return new Response() when modifying the response");
+              }
+              response = result;
+            }
+          }
+        }
+      }
+    }
+    if (response.status === 204 || request.method === "HEAD" || response.headers.get("Content-Length") === "0") {
+      return response.ok ? { data: undefined, response } : { error: undefined, response };
+    }
+    if (response.ok) {
+      if (parseAs === "stream") {
+        return { data: response.body, response };
+      }
+      return { data: await response[parseAs](), response };
+    }
+    let error = await response.text();
+    try {
+      error = JSON.parse(error);
+    } catch {}
+    return { error, response };
+  }
+  return {
+    request(method, url, init) {
+      return coreFetch(url, { ...init, method: method.toUpperCase() });
+    },
+    GET(url, init) {
+      return coreFetch(url, { ...init, method: "GET" });
+    },
+    PUT(url, init) {
+      return coreFetch(url, { ...init, method: "PUT" });
+    },
+    POST(url, init) {
+      return coreFetch(url, { ...init, method: "POST" });
+    },
+    DELETE(url, init) {
+      return coreFetch(url, { ...init, method: "DELETE" });
+    },
+    OPTIONS(url, init) {
+      return coreFetch(url, { ...init, method: "OPTIONS" });
+    },
+    HEAD(url, init) {
+      return coreFetch(url, { ...init, method: "HEAD" });
+    },
+    PATCH(url, init) {
+      return coreFetch(url, { ...init, method: "PATCH" });
+    },
+    TRACE(url, init) {
+      return coreFetch(url, { ...init, method: "TRACE" });
+    },
+    use(...middleware) {
+      for (const m of middleware) {
+        if (!m) {
+          continue;
+        }
+        if (typeof m !== "object" || !(("onRequest" in m) || ("onResponse" in m) || ("onError" in m))) {
+          throw new Error("Middleware must be an object with one of `onRequest()`, `onResponse() or `onError()`");
+        }
+        middlewares.push(m);
+      }
+    },
+    eject(...middleware) {
+      for (const m of middleware) {
+        const i = middlewares.indexOf(m);
+        if (i !== -1) {
+          middlewares.splice(i, 1);
+        }
+      }
+    }
+  };
+}
+function serializePrimitiveParam(name, value, options) {
+  if (value === undefined || value === null) {
+    return "";
+  }
+  if (typeof value === "object") {
+    throw new Error("Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.");
+  }
+  return `${name}=${options?.allowReserved === true ? value : encodeURIComponent(value)}`;
+}
+function serializeObjectParam(name, value, options) {
+  if (!value || typeof value !== "object") {
+    return "";
+  }
+  const values = [];
+  const joiner = {
+    simple: ",",
+    label: ".",
+    matrix: ";"
+  }[options.style] || "&";
+  if (options.style !== "deepObject" && options.explode === false) {
+    for (const k in value) {
+      values.push(k, options.allowReserved === true ? value[k] : encodeURIComponent(value[k]));
+    }
+    const final2 = values.join(",");
+    switch (options.style) {
+      case "form": {
+        return `${name}=${final2}`;
+      }
+      case "label": {
+        return `.${final2}`;
+      }
+      case "matrix": {
+        return `;${name}=${final2}`;
+      }
+      default: {
+        return final2;
+      }
+    }
+  }
+  for (const k in value) {
+    const finalName = options.style === "deepObject" ? `${name}[${k}]` : k;
+    values.push(serializePrimitiveParam(finalName, value[k], options));
+  }
+  const final = values.join(joiner);
+  return options.style === "label" || options.style === "matrix" ? `${joiner}${final}` : final;
+}
+function serializeArrayParam(name, value, options) {
+  if (!Array.isArray(value)) {
+    return "";
+  }
+  if (options.explode === false) {
+    const joiner2 = { form: ",", spaceDelimited: "%20", pipeDelimited: "|" }[options.style] || ",";
+    const final = (options.allowReserved === true ? value : value.map((v) => encodeURIComponent(v))).join(joiner2);
+    switch (options.style) {
+      case "simple": {
+        return final;
+      }
+      case "label": {
+        return `.${final}`;
+      }
+      case "matrix": {
+        return `;${name}=${final}`;
+      }
+      default: {
+        return `${name}=${final}`;
+      }
+    }
+  }
+  const joiner = { simple: ",", label: ".", matrix: ";" }[options.style] || "&";
+  const values = [];
+  for (const v of value) {
+    if (options.style === "simple" || options.style === "label") {
+      values.push(options.allowReserved === true ? v : encodeURIComponent(v));
+    } else {
+      values.push(serializePrimitiveParam(name, v, options));
+    }
+  }
+  return options.style === "label" || options.style === "matrix" ? `${joiner}${values.join(joiner)}` : values.join(joiner);
+}
+function createQuerySerializer(options) {
+  return function querySerializer(queryParams) {
+    const search = [];
+    if (queryParams && typeof queryParams === "object") {
+      for (const name in queryParams) {
+        const value = queryParams[name];
+        if (value === undefined || value === null) {
+          continue;
+        }
+        if (Array.isArray(value)) {
+          if (value.length === 0) {
+            continue;
+          }
+          search.push(serializeArrayParam(name, value, {
+            style: "form",
+            explode: true,
+            ...options?.array,
+            allowReserved: options?.allowReserved || false
+          }));
+          continue;
+        }
+        if (typeof value === "object") {
+          search.push(serializeObjectParam(name, value, {
+            style: "deepObject",
+            explode: true,
+            ...options?.object,
+            allowReserved: options?.allowReserved || false
+          }));
+          continue;
+        }
+        search.push(serializePrimitiveParam(name, value, options));
+      }
+    }
+    return search.join("&");
+  };
+}
+function defaultPathSerializer(pathname, pathParams) {
+  let nextURL = pathname;
+  for (const match of pathname.match(PATH_PARAM_RE) ?? []) {
+    let name = match.substring(1, match.length - 1);
+    let explode = false;
+    let style = "simple";
+    if (name.endsWith("*")) {
+      explode = true;
+      name = name.substring(0, name.length - 1);
+    }
+    if (name.startsWith(".")) {
+      style = "label";
+      name = name.substring(1);
+    } else if (name.startsWith(";")) {
+      style = "matrix";
+      name = name.substring(1);
+    }
+    if (!pathParams || pathParams[name] === undefined || pathParams[name] === null) {
+      continue;
+    }
+    const value = pathParams[name];
+    if (Array.isArray(value)) {
+      nextURL = nextURL.replace(match, serializeArrayParam(name, value, { style, explode }));
+      continue;
+    }
+    if (typeof value === "object") {
+      nextURL = nextURL.replace(match, serializeObjectParam(name, value, { style, explode }));
+      continue;
+    }
+    if (style === "matrix") {
+      nextURL = nextURL.replace(match, `;${serializePrimitiveParam(name, value)}`);
+      continue;
+    }
+    nextURL = nextURL.replace(match, style === "label" ? `.${encodeURIComponent(value)}` : encodeURIComponent(value));
+  }
+  return nextURL;
+}
+function defaultBodySerializer(body, headers) {
+  if (body instanceof FormData) {
+    return body;
+  }
+  if (headers) {
+    const contentType = headers.get instanceof Function ? headers.get("Content-Type") ?? headers.get("content-type") : headers["Content-Type"] ?? headers["content-type"];
+    if (contentType === "application/x-www-form-urlencoded") {
+      return new URLSearchParams(body).toString();
+    }
+  }
+  return JSON.stringify(body);
+}
+function createFinalURL(pathname, options) {
+  let finalURL = `${options.baseUrl}${pathname}`;
+  if (options.params?.path) {
+    finalURL = defaultPathSerializer(finalURL, options.params.path);
+  }
+  let search = options.querySerializer(options.params.query ?? {});
+  if (search.startsWith("?")) {
+    search = search.substring(1);
+  }
+  if (search) {
+    finalURL += `?${search}`;
+  }
+  return finalURL;
+}
+function mergeHeaders(...allHeaders) {
+  const finalHeaders = new Headers;
+  for (const h of allHeaders) {
+    if (!h || typeof h !== "object") {
+      continue;
+    }
+    const iterator = h instanceof Headers ? h.entries() : Object.entries(h);
+    for (const [k, v] of iterator) {
+      if (v === null) {
+        finalHeaders.delete(k);
+      } else if (Array.isArray(v)) {
+        for (const v2 of v) {
+          finalHeaders.append(k, v2);
+        }
+      } else if (v !== undefined) {
+        finalHeaders.set(k, v);
+      }
+    }
+  }
+  return finalHeaders;
+}
+function removeTrailingSlash(url) {
+  if (url.endsWith("/")) {
+    return url.substring(0, url.length - 1);
+  }
+  return url;
+}
+
+// src/errors.ts
+function parseErrorObject(error, status) {
+  if (error instanceof Error && !("error" in error)) {
+    return null;
+  }
+  if ("error" in error) {
+    const rawError = error.error;
+    if (typeof rawError === "string") {
+      return new OmniApiError(rawError, "API_ERROR", undefined, status);
+    }
+    if (rawError && typeof rawError === "object") {
+      const apiError = rawError;
+      return new OmniApiError(apiError.message ?? `API error (status ${status ?? "unknown"})`, apiError.code ?? "API_ERROR", apiError.details, status);
+    }
+  }
+  if ("message" in error) {
+    const msg = error.message;
+    if (typeof msg === "string") {
+      return new OmniApiError(msg, "API_ERROR", undefined, status);
+    }
+  }
+  return null;
+}
+
+class OmniApiError extends Error {
+  code;
+  details;
+  status;
+  constructor(message, code, details, status) {
+    super(message);
+    this.name = "OmniApiError";
+    this.code = code;
+    this.details = details;
+    this.status = status;
+  }
+  static from(error, status) {
+    if (error && typeof error === "object") {
+      const result = parseErrorObject(error, status);
+      if (result)
+        return result;
+    }
+    if (error instanceof Error) {
+      return new OmniApiError(error.message, "UNKNOWN_ERROR", undefined, status);
+    }
+    return new OmniApiError(typeof error === "string" ? error : `API error (status ${status ?? "unknown"})`, "UNKNOWN_ERROR", undefined, status);
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      details: this.details,
+      status: this.status
+    };
+  }
+}
+
+class OmniConfigError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OmniConfigError";
+  }
+}
+
+// src/client.ts
+function throwIfError(response, error) {
+  if (!response.ok) {
+    throw OmniApiError.from(error, response.status);
+  }
+}
+function createOmniClient(config) {
+  if (!config.baseUrl) {
+    throw new OmniConfigError("baseUrl is required");
+  }
+  if (!config.apiKey) {
+    throw new OmniConfigError("apiKey is required");
+  }
+  const baseUrl = config.baseUrl.replace(/\/$/, "");
+  const authMiddleware = {
+    async onRequest({ request }) {
+      request.headers.set("x-api-key", config.apiKey);
+      request.headers.set("Accept-Encoding", "identity");
+      if (config.cliVersion) {
+        request.headers.set("x-omni-cli-version", config.cliVersion);
+      }
+      return request;
+    }
+  };
+  const apiFetch = (url, init) => {
+    const headers = new Headers(init?.headers);
+    headers.set("x-api-key", config.apiKey);
+    headers.set("Accept-Encoding", "identity");
+    if (config.cliVersion) {
+      headers.set("x-omni-cli-version", config.cliVersion);
+    }
+    return fetch(url, {
+      ...init,
+      headers
+    });
+  };
+  const client = createClient({ baseUrl: `${baseUrl}/api/v2` });
+  client.use(authMiddleware);
+  return {
+    auth: {
+      async validate() {
+        const resp = await apiFetch(`${baseUrl}/api/v2/auth/validate`, {
+          method: "POST"
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data ?? { valid: false, keyPrefix: "", keyName: "", scopes: [] };
+      }
+    },
+    instances: {
+      async list(params) {
+        const { data, error, response } = await client.GET("/instances", {
+          params: { query: params }
+        });
+        throwIfError(response, error);
+        return {
+          items: data?.items ?? [],
+          meta: data?.meta ?? { hasMore: false }
+        };
+      },
+      async get(id) {
+        const { data, error, response } = await client.GET("/instances/{id}", {
+          params: { path: { id } }
+        });
+        throwIfError(response, error);
+        if (!data?.data)
+          throw new OmniApiError("Instance not found", "NOT_FOUND", undefined, 404);
+        return data.data;
+      },
+      async create(body) {
+        const { data, error, response } = await client.POST("/instances", { body });
+        throwIfError(response, error);
+        if (!data?.data)
+          throw new OmniApiError("Failed to create instance", "CREATE_FAILED", undefined, response.status);
+        return data.data;
+      },
+      async update(id, body) {
+        const { error, response } = await client.PATCH("/instances/{id}", {
+          params: { path: { id } },
+          body
+        });
+        throwIfError(response, error);
+      },
+      async delete(id) {
+        const { error, response } = await client.DELETE("/instances/{id}", {
+          params: { path: { id } }
+        });
+        throwIfError(response, error);
+      },
+      async status(id) {
+        const { data, error, response } = await client.GET("/instances/{id}/status", {
+          params: { path: { id } }
+        });
+        throwIfError(response, error);
+        return data?.data ?? { state: "unknown", isConnected: false };
+      },
+      async qr(id) {
+        const { data, error, response } = await client.GET("/instances/{id}/qr", {
+          params: { path: { id } }
+        });
+        throwIfError(response, error);
+        return data?.data ?? { qr: null, expiresAt: null, message: "No QR code available" };
+      },
+      async connect(id, body) {
+        const { data, error, response } = await client.POST("/instances/{id}/connect", {
+          params: { path: { id } },
+          body: body ?? {}
+        });
+        throwIfError(response, error);
+        return data?.data ?? { status: "connecting", message: "Connection initiated" };
+      },
+      async disconnect(id) {
+        const { error, response } = await client.POST("/instances/{id}/disconnect", {
+          params: { path: { id } }
+        });
+        throwIfError(response, error);
+      },
+      async restart(id, forceNewQr) {
+        const { data, error, response } = await client.POST("/instances/{id}/restart", {
+          params: { path: { id }, query: forceNewQr ? { forceNewQr: "true" } : undefined }
+        });
+        throwIfError(response, error);
+        return data?.data ?? { status: "restarting", message: "Restart initiated" };
+      },
+      async logout(id) {
+        const { error, response } = await client.POST("/instances/{id}/logout", {
+          params: { path: { id } }
+        });
+        throwIfError(response, error);
+      },
+      async pair(id, body) {
+        const { data, error, response } = await client.POST("/instances/{id}/pair", {
+          params: { path: { id } },
+          body
+        });
+        throwIfError(response, error);
+        return data?.data ?? { code: "", phoneNumber: "", message: "", expiresIn: 0 };
+      },
+      async syncProfile(id) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/instances/${id}/sync/profile`, {
+          method: "POST"
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data ?? { type: "profile", status: "unknown", profile: null };
+      },
+      async startSync(id, body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/instances/${id}/sync`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data ?? { jobId: "", instanceId: id, type: body.type, status: "pending", config: {}, message: "" };
+      },
+      async listSyncs(id, params) {
+        const query = new URLSearchParams;
+        if (params?.status)
+          query.set("status", params.status);
+        if (params?.limit)
+          query.set("limit", String(params.limit));
+        const resp = await apiFetch(`${baseUrl}/api/v2/instances/${id}/sync?${query}`, {});
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return { items: json?.items ?? [], meta: json?.meta ?? { hasMore: false, cursor: null } };
+      },
+      async getSyncStatus(id, jobId) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/instances/${id}/sync/${jobId}`, {});
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Sync job not found", "NOT_FOUND", undefined, 404);
+        return json.data;
+      },
+      async listContacts(id, params) {
+        const query = new URLSearchParams;
+        if (params?.limit)
+          query.set("limit", String(params.limit));
+        if (params?.cursor)
+          query.set("cursor", params.cursor);
+        if (params?.guildId)
+          query.set("guildId", params.guildId);
+        if (params?.search)
+          query.set("search", params.search);
+        if (params?.excludeGroups)
+          query.set("excludeGroups", "true");
+        const resp = await apiFetch(`${baseUrl}/api/v2/instances/${id}/contacts?${query}`, {});
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return { items: json?.items ?? [], meta: json?.meta ?? { totalFetched: 0, hasMore: false } };
+      },
+      async listGroups(id, params) {
+        const query = new URLSearchParams;
+        if (params?.limit)
+          query.set("limit", String(params.limit));
+        if (params?.cursor)
+          query.set("cursor", params.cursor);
+        if (params?.search)
+          query.set("search", params.search);
+        const resp = await apiFetch(`${baseUrl}/api/v2/instances/${id}/groups?${query}`, {});
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return { items: json?.items ?? [], meta: json?.meta ?? { totalFetched: 0, hasMore: false } };
+      },
+      async listGroupMembers(id, groupJid) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/instances/${id}/groups/${encodeURIComponent(groupJid)}/members`, {});
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return { members: json?.members ?? [] };
+      },
+      async getUserProfile(id, userId) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/instances/${id}/users/${userId}/profile`, {});
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("User profile not found", "NOT_FOUND", undefined, 404);
+        return json.data;
+      }
+    },
+    chats: {
+      async list(params) {
+        const query = new URLSearchParams;
+        const setIfDefined = (key, value) => {
+          if (value !== undefined)
+            query.set(key, String(value));
+        };
+        setIfDefined("instanceId", params?.instanceId);
+        setIfDefined("channel", params?.channel);
+        setIfDefined("chatType", params?.chatType);
+        setIfDefined("excludeChatTypes", params?.excludeChatTypes);
+        setIfDefined("search", params?.search);
+        setIfDefined("includeArchived", params?.includeArchived);
+        setIfDefined("unreadOnly", params?.unreadOnly);
+        setIfDefined("sort", params?.sort);
+        setIfDefined("limit", params?.limit);
+        setIfDefined("cursor", params?.cursor);
+        setIfDefined("pendingOnly", params?.pendingOnly);
+        setIfDefined("attentionOnly", params?.attentionOnly);
+        setIfDefined("label", params?.label);
+        setIfDefined("includeHidden", params?.includeHidden);
+        const resp = await apiFetch(`${baseUrl}/api/v2/chats?${query}`, {});
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return { items: json?.items ?? [], meta: json?.meta ?? { hasMore: false, cursor: null } };
+      },
+      async get(id) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/chats/${id}`, {});
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Chat not found", "NOT_FOUND", undefined, 404);
+        return json.data;
+      },
+      async create(body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/chats`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Failed to create chat", "CREATE_FAILED", undefined, resp.status);
+        return json.data;
+      },
+      async update(id, body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/chats/${id}`, {
+          method: "PATCH",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Failed to update chat", "UPDATE_FAILED", undefined, resp.status);
+        return json.data;
+      },
+      async delete(id) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/chats/${id}`, {
+          method: "DELETE"
+        });
+        if (!resp.ok)
+          throw OmniApiError.from(await resp.json(), resp.status);
+      },
+      async archive(id) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/chats/${id}/archive`, {
+          method: "POST"
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Failed to archive chat", "ARCHIVE_FAILED", undefined, resp.status);
+        return json.data;
+      },
+      async unarchive(id) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/chats/${id}/unarchive`, {
+          method: "POST"
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Failed to unarchive chat", "UNARCHIVE_FAILED", undefined, resp.status);
+        return json.data;
+      },
+      async getMessages(id, params) {
+        const query = new URLSearchParams;
+        if (params?.limit)
+          query.set("limit", String(params.limit));
+        if (params?.before)
+          query.set("before", params.before);
+        if (params?.after)
+          query.set("after", params.after);
+        if (params?.mediaOnly)
+          query.set("mediaOnly", "true");
+        const resp = await apiFetch(`${baseUrl}/api/v2/chats/${id}/messages?${query}`, {});
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.items ?? [];
+      },
+      async listParticipants(id) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/chats/${id}/participants`, {});
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.items ?? [];
+      },
+      async addParticipant(id, body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/chats/${id}/participants`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Failed to add participant", "ADD_FAILED", undefined, resp.status);
+        return json.data;
+      },
+      async removeParticipant(id, platformUserId) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/chats/${id}/participants/${platformUserId}`, {
+          method: "DELETE"
+        });
+        if (!resp.ok)
+          throw OmniApiError.from(await resp.json(), resp.status);
+      },
+      async hide(id) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/chats/${id}/hide`, {
+          method: "POST"
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Failed to hide chat", "HIDE_FAILED", undefined, resp.status);
+        return json.data;
+      },
+      async unhide(id) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/chats/${id}/unhide`, {
+          method: "POST"
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Failed to unhide chat", "UNHIDE_FAILED", undefined, resp.status);
+        return json.data;
+      },
+      async addLabel(id, label) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/chats/${id}/label`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ label })
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Failed to add label", "LABEL_FAILED", undefined, resp.status);
+        return json.data;
+      },
+      async removeLabel(id, label) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/chats/${id}/label`, {
+          method: "DELETE",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ label })
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Failed to remove label", "UNLABEL_FAILED", undefined, resp.status);
+        return json.data;
+      },
+      async markRead(id, body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/chats/${id}/read`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data ?? { chatId: id, instanceId: body.instanceId };
+      }
+    },
+    messages: {
+      async get(messageId) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/messages/${messageId}`, {});
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data;
+      },
+      async send(body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/messages/send`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data ?? { messageId: "", status: "sent" };
+      },
+      async sendMedia(body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/messages/send/media`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data ?? { messageId: "", status: "sent" };
+      },
+      async sendReaction(body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/messages/send/reaction`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return { success: json?.success ?? true, messageId: json?.data?.messageId };
+      },
+      async sendSticker(body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/messages/send/sticker`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data ?? { messageId: "", status: "sent" };
+      },
+      async sendContact(body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/messages/send/contact`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data ?? { messageId: "", status: "sent" };
+      },
+      async sendLocation(body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/messages/send/location`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data ?? { messageId: "", status: "sent" };
+      },
+      async sendPoll(body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/messages/send/poll`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data ?? { messageId: "", status: "sent" };
+      },
+      async sendEmbed(body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/messages/send/embed`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data ?? { messageId: "", status: "sent" };
+      },
+      async sendPresence(body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/messages/send/presence`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data ?? {
+          instanceId: body.instanceId,
+          chatId: body.to,
+          type: body.type,
+          duration: body.duration ?? 5000
+        };
+      },
+      async markRead(messageId, body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/messages/${messageId}/read`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data ?? { messageId };
+      },
+      async batchMarkRead(body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/messages/read`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data ?? { chatId: body.chatId, instanceId: body.instanceId, messageCount: body.messageIds.length };
+      },
+      async listVoices() {
+        const resp = await apiFetch(`${baseUrl}/api/v2/messages/tts/voices`, {});
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data?.voices ?? [];
+      },
+      async sendTts(body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/messages/send/tts`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data ?? { messageId: "", status: "sent", audioSizeKb: 0, durationMs: 0, timestamp: Date.now() };
+      },
+      async sendForward(body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/messages/send/forward`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data ?? { messageId: "", status: "sent" };
+      },
+      async removeReaction(id, body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/messages/${id}/reactions`, {
+          method: "DELETE",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return { success: json?.success ?? true };
+      }
+    },
+    events: {
+      async list(params) {
+        const { data, error, response } = await client.GET("/events", {
+          params: { query: params }
+        });
+        throwIfError(response, error);
+        return {
+          items: data?.items ?? [],
+          meta: data?.meta ?? { hasMore: false }
+        };
+      },
+      async get(id) {
+        const { data, error, response } = await client.GET("/events/{id}", {
+          params: { path: { id } }
+        });
+        throwIfError(response, error);
+        if (!data?.data)
+          throw new OmniApiError("Event not found", "NOT_FOUND", undefined, 404);
+        return data.data;
+      },
+      async analytics(params) {
+        const { data, error, response } = await client.GET("/events/analytics", {
+          params: { query: params }
+        });
+        throwIfError(response, error);
+        if (!data)
+          throw new OmniApiError("Analytics data not found", "NOT_FOUND", undefined, 404);
+        return data;
+      }
+    },
+    persons: {
+      async search(params) {
+        const { data, error, response } = await client.GET("/persons", {
+          params: { query: params }
+        });
+        throwIfError(response, error);
+        return data?.items ?? [];
+      },
+      async get(id) {
+        const { data, error, response } = await client.GET("/persons/{id}", {
+          params: { path: { id } }
+        });
+        throwIfError(response, error);
+        if (!data?.data)
+          throw new OmniApiError("Person not found", "NOT_FOUND", undefined, 404);
+        return data.data;
+      },
+      async presence(id) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/persons/${id}/presence`, {});
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Person not found", "NOT_FOUND", undefined, 404);
+        return json.data;
+      },
+      async update(id, data) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/persons/${id}`, {
+          method: "PATCH",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(data)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Person not found", "NOT_FOUND", undefined, 404);
+        return json.data;
+      },
+      async link(identityA, identityB) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/persons/link`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ identityA, identityB })
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Link failed", "INTERNAL_ERROR", undefined, 500);
+        return json.data;
+      },
+      async unlink(identityId, reason) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/persons/unlink`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ identityId, reason })
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Unlink failed", "INTERNAL_ERROR", undefined, 500);
+        return json.data;
+      },
+      async merge(sourcePersonId, targetPersonId, reason) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/persons/merge`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ sourcePersonId, targetPersonId, reason })
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Merge failed", "INTERNAL_ERROR", undefined, 500);
+        return json.data;
+      }
+    },
+    access: {
+      async listRules(params) {
+        const { data, error, response } = await client.GET("/access/rules", {
+          params: { query: params }
+        });
+        throwIfError(response, error);
+        return data?.items ?? [];
+      },
+      async createRule(body) {
+        const { error, response } = await client.POST("/access/rules", { body });
+        throwIfError(response, error);
+      },
+      async deleteRule(id) {
+        const { error, response } = await client.DELETE("/access/rules/{id}", {
+          params: { path: { id } }
+        });
+        throwIfError(response, error);
+      },
+      async checkAccess(params) {
+        const { data, error, response } = await client.POST("/access/check", {
+          body: params
+        });
+        throwIfError(response, error);
+        return data?.data ?? { allowed: true, reason: "Default allow" };
+      },
+      async listPairingRequests(instanceId) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/instances/${instanceId}/pairing-requests`, {});
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.items ?? [];
+      },
+      async actionPairingRequest(instanceId, requestId, body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/instances/${instanceId}/pairing-requests/${requestId}/action`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data ?? { action: body.action };
+      }
+    },
+    settings: {
+      async list(params) {
+        const { data, error, response } = await client.GET("/settings", {
+          params: { query: params }
+        });
+        throwIfError(response, error);
+        return data?.items ?? [];
+      },
+      async get(key) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/settings/${encodeURIComponent(key)}`, {});
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Setting not found", "NOT_FOUND", undefined, 404);
+        return json.data;
+      },
+      async set(key, value, reason) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/settings/${encodeURIComponent(key)}`, {
+          method: "PUT",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ value, reason })
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Failed to set setting", "UPDATE_FAILED", undefined, resp.status);
+        return json.data;
+      }
+    },
+    providers: {
+      async list(params) {
+        const { data, error, response } = await client.GET("/providers", {
+          params: { query: params }
+        });
+        throwIfError(response, error);
+        return data?.items ?? [];
+      },
+      async get(id) {
+        const { data, error, response } = await client.GET("/providers/{id}", {
+          params: { path: { id } }
+        });
+        throwIfError(response, error);
+        if (!data?.data)
+          throw new OmniApiError("Provider not found", "NOT_FOUND", undefined, 404);
+        return data.data;
+      },
+      async create(body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/providers`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        if (!resp.ok) {
+          const errorData = await resp.json().catch(() => ({}));
+          throw new OmniApiError(errorData.error ?? resp.statusText, "CREATE_FAILED", undefined, resp.status);
+        }
+        const data = await resp.json();
+        return data.data;
+      },
+      async update(id, body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/providers/${id}`, {
+          method: "PATCH",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        if (!resp.ok) {
+          const errorData = await resp.json().catch(() => ({}));
+          throw new OmniApiError(errorData.error ?? resp.statusText, "UPDATE_FAILED", undefined, resp.status);
+        }
+        const data = await resp.json();
+        return data.data;
+      },
+      async delete(id) {
+        const { error, response } = await client.DELETE("/providers/{id}", {
+          params: { path: { id } }
+        });
+        throwIfError(response, error);
+      },
+      async checkHealth(id) {
+        const { data, error, response } = await client.POST("/providers/{id}/health", {
+          params: { path: { id } }
+        });
+        throwIfError(response, error);
+        return {
+          healthy: data?.healthy ?? false,
+          latency: data?.latency ?? 0,
+          error: data?.error ?? undefined
+        };
+      },
+      async listAgents(id) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/providers/${id}/agents`, {
+          method: "GET"
+        });
+        if (!resp.ok) {
+          throw new OmniApiError(`Failed to list agents: ${resp.statusText}`, "FETCH_ERROR", undefined, resp.status);
+        }
+        const data = await resp.json();
+        return data.items ?? [];
+      },
+      async listTeams(id) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/providers/${id}/teams`, {
+          method: "GET"
+        });
+        if (!resp.ok) {
+          throw new OmniApiError(`Failed to list teams: ${resp.statusText}`, "FETCH_ERROR", undefined, resp.status);
+        }
+        const data = await resp.json();
+        return data.items ?? [];
+      },
+      async listWorkflows(id) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/providers/${id}/workflows`, {
+          method: "GET"
+        });
+        if (!resp.ok) {
+          throw new OmniApiError(`Failed to list workflows: ${resp.statusText}`, "FETCH_ERROR", undefined, resp.status);
+        }
+        const data = await resp.json();
+        return data.items ?? [];
+      }
+    },
+    routes: {
+      async list(instanceId, params) {
+        const { data, error, response } = await client.GET("/instances/{instanceId}/routes", {
+          params: { path: { instanceId }, query: params }
+        });
+        throwIfError(response, error);
+        return data?.items ?? [];
+      },
+      async get(instanceId, id) {
+        const { data, error, response } = await client.GET("/instances/{instanceId}/routes/{id}", {
+          params: { path: { instanceId, id } }
+        });
+        throwIfError(response, error);
+        if (!data?.data)
+          throw new OmniApiError("Route not found", "NOT_FOUND", undefined, 404);
+        return data.data;
+      },
+      async create(instanceId, body) {
+        const { data, error, response } = await client.POST("/instances/{instanceId}/routes", {
+          params: { path: { instanceId } },
+          body
+        });
+        throwIfError(response, error);
+        if (!data?.data)
+          throw new OmniApiError("Failed to create route", "CREATE_FAILED", undefined, response.status);
+        return data.data;
+      },
+      async update(instanceId, id, body) {
+        const { data, error, response } = await client.PATCH("/instances/{instanceId}/routes/{id}", {
+          params: { path: { instanceId, id } },
+          body
+        });
+        throwIfError(response, error);
+        if (!data?.data)
+          throw new OmniApiError("Failed to update route", "UPDATE_FAILED", undefined, response.status);
+        return data.data;
+      },
+      async delete(instanceId, id) {
+        const { error, response } = await client.DELETE("/instances/{instanceId}/routes/{id}", {
+          params: { path: { instanceId, id } }
+        });
+        throwIfError(response, error);
+      },
+      async getMetrics() {
+        const { data, error, response } = await client.GET("/routes/metrics");
+        throwIfError(response, error);
+        if (!data?.data)
+          throw new OmniApiError("Failed to get metrics", "FETCH_ERROR", undefined, response.status);
+        return data.data;
+      }
+    },
+    logs: {
+      async recent(params) {
+        const { data, error, response } = await client.GET("/logs/recent", {
+          params: { query: params }
+        });
+        throwIfError(response, error);
+        return { items: data?.items ?? [], meta: data?.meta ?? { total: 0, bufferSize: 0, limit: 100 } };
+      }
+    },
+    automations: {
+      async list(params) {
+        const { data, error, response } = await client.GET("/automations", {
+          params: { query: params }
+        });
+        throwIfError(response, error);
+        return data?.items ?? [];
+      },
+      async get(id) {
+        const { data, error, response } = await client.GET("/automations/{id}", {
+          params: { path: { id } }
+        });
+        throwIfError(response, error);
+        if (!data?.data)
+          throw new OmniApiError("Automation not found", "NOT_FOUND", undefined, 404);
+        return data.data;
+      },
+      async create(body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/automations`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Failed to create automation", "CREATE_FAILED", undefined, resp.status);
+        return json.data;
+      },
+      async update(id, body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/automations/${id}`, {
+          method: "PATCH",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Failed to update automation", "UPDATE_FAILED", undefined, resp.status);
+        return json.data;
+      },
+      async delete(id) {
+        const { error, response } = await client.DELETE("/automations/{id}", {
+          params: { path: { id } }
+        });
+        throwIfError(response, error);
+      },
+      async enable(id) {
+        const { data, error, response } = await client.POST("/automations/{id}/enable", {
+          params: { path: { id } }
+        });
+        throwIfError(response, error);
+        if (!data?.data)
+          throw new OmniApiError("Failed to enable automation", "ENABLE_FAILED", undefined, response.status);
+        return data.data;
+      },
+      async disable(id) {
+        const { data, error, response } = await client.POST("/automations/{id}/disable", {
+          params: { path: { id } }
+        });
+        throwIfError(response, error);
+        if (!data?.data)
+          throw new OmniApiError("Failed to disable automation", "DISABLE_FAILED", undefined, response.status);
+        return data.data;
+      },
+      async test(id, body) {
+        const { data, error, response } = await client.POST("/automations/{id}/test", {
+          params: { path: { id } },
+          body
+        });
+        throwIfError(response, error);
+        return data ?? { matched: false };
+      },
+      async execute(id, body) {
+        const { data, error, response } = await client.POST("/automations/{id}/execute", {
+          params: { path: { id } },
+          body
+        });
+        throwIfError(response, error);
+        return data ?? { automationId: id, triggered: false, results: [] };
+      },
+      async getLogs(id, params) {
+        const { data, error, response } = await client.GET("/automations/{id}/logs", {
+          params: { path: { id }, query: params }
+        });
+        throwIfError(response, error);
+        return { items: data?.items ?? [], meta: data?.meta ?? { hasMore: false } };
+      }
+    },
+    deadLetters: {
+      async list(params) {
+        const { data, error, response } = await client.GET("/dead-letters", {
+          params: { query: params }
+        });
+        throwIfError(response, error);
+        return { items: data?.items ?? [], meta: data?.meta ?? { hasMore: false } };
+      },
+      async get(id) {
+        const { data, error, response } = await client.GET("/dead-letters/{id}", {
+          params: { path: { id } }
+        });
+        throwIfError(response, error);
+        if (!data?.data)
+          throw new OmniApiError("Dead letter not found", "NOT_FOUND", undefined, 404);
+        return data.data;
+      },
+      async stats() {
+        const { data, error, response } = await client.GET("/dead-letters/stats");
+        throwIfError(response, error);
+        return data?.data ?? { pending: 0, retrying: 0, resolved: 0, abandoned: 0, total: 0 };
+      },
+      async retry(id) {
+        const { data, error, response } = await client.POST("/dead-letters/{id}/retry", {
+          params: { path: { id } }
+        });
+        throwIfError(response, error);
+        return data ?? { success: true };
+      },
+      async resolve(id, body) {
+        const { data, error, response } = await client.POST("/dead-letters/{id}/resolve", {
+          params: { path: { id } },
+          body
+        });
+        throwIfError(response, error);
+        if (!data?.data)
+          throw new OmniApiError("Failed to resolve dead letter", "RESOLVE_FAILED", undefined, response.status);
+        return data.data;
+      },
+      async abandon(id) {
+        const { data, error, response } = await client.POST("/dead-letters/{id}/abandon", {
+          params: { path: { id } }
+        });
+        throwIfError(response, error);
+        if (!data?.data)
+          throw new OmniApiError("Failed to abandon dead letter", "ABANDON_FAILED", undefined, response.status);
+        return data.data;
+      }
+    },
+    eventOps: {
+      async metrics() {
+        const { data, error, response } = await client.GET("/event-ops/metrics");
+        throwIfError(response, error);
+        return data?.data ?? {};
+      },
+      async startReplay(body) {
+        const { data, error, response } = await client.POST("/event-ops/replay", { body });
+        throwIfError(response, error);
+        if (!data?.data)
+          throw new OmniApiError("Failed to start replay", "REPLAY_FAILED", undefined, response.status);
+        return data.data;
+      },
+      async listReplays() {
+        const { data, error, response } = await client.GET("/event-ops/replay");
+        throwIfError(response, error);
+        return data?.items ?? [];
+      },
+      async getReplay(id) {
+        const { data, error, response } = await client.GET("/event-ops/replay/{id}", {
+          params: { path: { id } }
+        });
+        throwIfError(response, error);
+        if (!data?.data)
+          throw new OmniApiError("Replay session not found", "NOT_FOUND", undefined, 404);
+        return data.data;
+      },
+      async cancelReplay(id) {
+        const { error, response } = await client.DELETE("/event-ops/replay/{id}", {
+          params: { path: { id } }
+        });
+        throwIfError(response, error);
+      }
+    },
+    webhooks: {
+      async listSources(params) {
+        const { data, error, response } = await client.GET("/webhook-sources", {
+          params: { query: params }
+        });
+        throwIfError(response, error);
+        return data?.items ?? [];
+      },
+      async getSource(id) {
+        const { data, error, response } = await client.GET("/webhook-sources/{id}", {
+          params: { path: { id } }
+        });
+        throwIfError(response, error);
+        if (!data?.data)
+          throw new OmniApiError("Webhook source not found", "NOT_FOUND", undefined, 404);
+        return data.data;
+      },
+      async createSource(body) {
+        const { data, error, response } = await client.POST("/webhook-sources", { body });
+        throwIfError(response, error);
+        if (!data?.data)
+          throw new OmniApiError("Failed to create webhook source", "CREATE_FAILED", undefined, response.status);
+        return data.data;
+      },
+      async updateSource(id, body) {
+        const { data, error, response } = await client.PATCH("/webhook-sources/{id}", {
+          params: { path: { id } },
+          body
+        });
+        throwIfError(response, error);
+        if (!data?.data)
+          throw new OmniApiError("Failed to update webhook source", "UPDATE_FAILED", undefined, response.status);
+        return data.data;
+      },
+      async deleteSource(id) {
+        const { error, response } = await client.DELETE("/webhook-sources/{id}", {
+          params: { path: { id } }
+        });
+        throwIfError(response, error);
+      },
+      async trigger(body) {
+        const { data, error, response } = await client.POST("/events/trigger", { body });
+        throwIfError(response, error);
+        return data ?? { eventId: "", eventType: body.eventType };
+      }
+    },
+    payloads: {
+      async listForEvent(eventId) {
+        const { data, error, response } = await client.GET("/events/{eventId}/payloads", {
+          params: { path: { eventId } }
+        });
+        throwIfError(response, error);
+        return data?.items ?? [];
+      },
+      async getStage(eventId, stage) {
+        const { data, error, response } = await client.GET("/events/{eventId}/payloads/{stage}", {
+          params: { path: { eventId, stage } }
+        });
+        throwIfError(response, error);
+        if (!data?.data)
+          throw new OmniApiError("Payload not found", "NOT_FOUND", undefined, 404);
+        return data.data;
+      },
+      async delete(eventId, body) {
+        const { data, error, response } = await client.DELETE("/events/{eventId}/payloads", {
+          params: { path: { eventId } },
+          body
+        });
+        throwIfError(response, error);
+        return data ?? { deleted: 0 };
+      },
+      async listConfigs() {
+        const { data, error, response } = await client.GET("/payload-config");
+        throwIfError(response, error);
+        return data?.items ?? [];
+      },
+      async updateConfig(eventType, body) {
+        const { data, error, response } = await client.PUT("/payload-config/{eventType}", {
+          params: { path: { eventType } },
+          body
+        });
+        throwIfError(response, error);
+        if (!data?.data)
+          throw new OmniApiError("Failed to update payload config", "UPDATE_FAILED", undefined, response.status);
+        return data.data;
+      },
+      async stats() {
+        const { data, error, response } = await client.GET("/payload-stats");
+        throwIfError(response, error);
+        return data?.data ?? { totalPayloads: 0, totalSizeBytes: 0, byStage: {} };
+      }
+    },
+    batchJobs: {
+      async create(body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/batch-jobs`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Failed to create batch job", "CREATE_FAILED", undefined, resp.status);
+        return json.data;
+      },
+      async get(id) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/batch-jobs/${id}`, {});
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Batch job not found", "NOT_FOUND", undefined, 404);
+        return json.data;
+      },
+      async getStatus(id) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/batch-jobs/${id}/status`, {});
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Batch job not found", "NOT_FOUND", undefined, 404);
+        return json.data;
+      },
+      async list(params) {
+        const query = new URLSearchParams;
+        if (params?.instanceId)
+          query.set("instanceId", params.instanceId);
+        if (params?.status)
+          query.set("status", params.status.join(","));
+        if (params?.jobType)
+          query.set("jobType", params.jobType.join(","));
+        if (params?.limit)
+          query.set("limit", String(params.limit));
+        if (params?.cursor)
+          query.set("cursor", params.cursor);
+        const resp = await apiFetch(`${baseUrl}/api/v2/batch-jobs?${query}`, {});
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return { items: json?.items ?? [], meta: json?.meta ?? { hasMore: false, cursor: null } };
+      },
+      async cancel(id) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/batch-jobs/${id}/cancel`, {
+          method: "POST"
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Failed to cancel batch job", "CANCEL_FAILED", undefined, resp.status);
+        return json.data;
+      },
+      async estimate(body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/batch-jobs/estimate`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Failed to estimate", "ESTIMATE_FAILED", undefined, resp.status);
+        return json.data;
+      }
+    },
+    keys: {
+      async create(body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/keys`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Failed to create API key", "CREATE_FAILED", undefined, resp.status);
+        return json.data;
+      },
+      async list(params) {
+        const query = new URLSearchParams;
+        if (params?.status)
+          query.set("status", params.status);
+        if (params?.limit)
+          query.set("limit", String(params.limit));
+        const resp = await apiFetch(`${baseUrl}/api/v2/keys?${query}`, {});
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return { items: json?.items ?? [], meta: json?.meta ?? { total: 0 } };
+      },
+      async get(id) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/keys/${id}`, {});
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("API key not found", "NOT_FOUND", undefined, 404);
+        return json.data;
+      },
+      async update(id, body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/keys/${id}`, {
+          method: "PATCH",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Failed to update API key", "UPDATE_FAILED", undefined, resp.status);
+        return json.data;
+      },
+      async revoke(id, body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/keys/${id}/revoke`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body ?? {})
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Failed to revoke API key", "REVOKE_FAILED", undefined, resp.status);
+        return json.data;
+      },
+      async delete(id) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/keys/${id}`, {
+          method: "DELETE"
+        });
+        if (!resp.ok)
+          throw OmniApiError.from(await resp.json(), resp.status);
+      }
+    },
+    context: {
+      async get() {
+        const resp = await apiFetch(`${baseUrl}/api/v2/context`, {});
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data ?? { instanceId: null, chatId: null, messageId: null, activeInstanceId: null, updatedAt: null };
+      },
+      async set(body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/context`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        if (!resp.ok)
+          throw OmniApiError.from(await resp.json(), resp.status);
+      },
+      async use(instanceId) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/context/use`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ instanceId })
+        });
+        if (!resp.ok)
+          throw OmniApiError.from(await resp.json(), resp.status);
+      },
+      async clear() {
+        const resp = await apiFetch(`${baseUrl}/api/v2/context`, {
+          method: "DELETE"
+        });
+        if (!resp.ok)
+          throw OmniApiError.from(await resp.json(), resp.status);
+      }
+    },
+    media: {
+      async tts(body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/media/tts`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        const data = json?.data;
+        if (!data) {
+          throw new OmniApiError("TTS response missing data", "INVALID_RESPONSE", undefined, 500);
+        }
+        return {
+          provider: data.provider,
+          mimeType: data.mimeType,
+          durationMs: data.durationMs,
+          sizeBytes: data.sizeBytes,
+          audio: Buffer.from(data.audioBase64, "base64")
+        };
+      },
+      async stt(body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/media/stt`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            audioBase64: body.audio.toString("base64"),
+            mimeType: body.mimeType,
+            provider: body.provider,
+            language: body.language,
+            timestamps: body.timestamps,
+            model: body.model
+          })
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        const data = json?.data;
+        if (!data) {
+          throw new OmniApiError("STT response missing data", "INVALID_RESPONSE", undefined, 500);
+        }
+        return {
+          provider: data.provider,
+          text: data.text,
+          segments: data.segments,
+          detectedLanguage: data.detectedLanguage,
+          processingMs: data.processingMs
+        };
+      },
+      async imagine(body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/media/imagine`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        const data = json?.data;
+        if (!data) {
+          throw new OmniApiError("Imagine response missing data", "INVALID_RESPONSE", undefined, 500);
+        }
+        return data;
+      },
+      async vision(body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/media/vision`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            mediaBase64: body.media.toString("base64"),
+            mimeType: body.mimeType,
+            provider: body.provider,
+            prompt: body.prompt,
+            language: body.language,
+            maxTokens: body.maxTokens
+          })
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        const data = json?.data;
+        if (!data) {
+          throw new OmniApiError("Vision response missing data", "INVALID_RESPONSE", undefined, 500);
+        }
+        return {
+          provider: data.provider,
+          text: data.text,
+          processingMs: data.processingMs
+        };
+      },
+      async film(body) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/media/film`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        const data = json?.data;
+        if (!data) {
+          throw new OmniApiError("Film response missing data", "INVALID_RESPONSE", undefined, 500);
+        }
+        return data;
+      }
+    },
+    turns: {
+      async close(body, extraHeaders) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/turns/close`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", ...extraHeaders },
+          body: JSON.stringify(body)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data ?? {};
+      },
+      async list(params) {
+        const qs = new URLSearchParams;
+        if (params?.status)
+          qs.set("status", params.status);
+        if (params?.instanceId)
+          qs.set("instanceId", params.instanceId);
+        if (params?.chatId)
+          qs.set("chatId", params.chatId);
+        if (params?.agentId)
+          qs.set("agentId", params.agentId);
+        if (params?.limit !== undefined)
+          qs.set("limit", String(params.limit));
+        if (params?.offset !== undefined)
+          qs.set("offset", String(params.offset));
+        const query = qs.toString();
+        const url = `${baseUrl}/api/v2/turns${query ? `?${query}` : ""}`;
+        const resp = await apiFetch(url);
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data ?? { items: [], total: 0, limit: 50, offset: 0 };
+      },
+      async get(id) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/turns/${id}`);
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Turn not found", "NOT_FOUND", undefined, 404);
+        return json.data;
+      },
+      async forceClose(id, reason) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/turns/${id}/close`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ reason })
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Turn not found or already closed", "NOT_FOUND", undefined, 404);
+        return json.data;
+      },
+      async bulkClose(reason) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/turns/close-all`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ confirm: true, reason })
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Bulk close failed", "INTERNAL_ERROR", undefined, 500);
+        return json.data;
+      },
+      async stats() {
+        const resp = await apiFetch(`${baseUrl}/api/v2/turns/stats`);
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Stats unavailable", "INTERNAL_ERROR", undefined, 500);
+        return json.data;
+      }
+    },
+    agents: {
+      async list(params) {
+        const { data, error, response } = await client.GET("/agents", {
+          params: { query: params }
+        });
+        throwIfError(response, error);
+        return {
+          items: data?.items ?? [],
+          meta: data?.meta ?? { hasMore: false, cursor: null }
+        };
+      },
+      async get(id) {
+        const { data, error, response } = await client.GET("/agents/{id}", {
+          params: { path: { id } }
+        });
+        throwIfError(response, error);
+        if (!data?.data)
+          throw new OmniApiError("Agent not found", "NOT_FOUND", undefined, 404);
+        return data.data;
+      },
+      async create(body) {
+        const { data, error, response } = await client.POST("/agents", {
+          body
+        });
+        throwIfError(response, error);
+        if (!data?.data)
+          throw new OmniApiError("Failed to create agent", "CREATE_FAILED", undefined, response.status);
+        return data.data;
+      },
+      async update(id, body) {
+        const { data, error, response } = await client.PATCH("/agents/{id}", {
+          params: { path: { id } },
+          body
+        });
+        throwIfError(response, error);
+        if (!data?.data)
+          throw new OmniApiError("Failed to update agent", "UPDATE_FAILED", undefined, response.status);
+        return data.data;
+      },
+      async delete(id) {
+        const { error, response } = await client.DELETE("/agents/{id}", {
+          params: { path: { id } }
+        });
+        throwIfError(response, error);
+      }
+    },
+    followUp: {
+      async getAgent(id) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/follow-up/agents/${id}`);
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data ?? null;
+      },
+      async setAgent(id, config2) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/follow-up/agents/${id}`, {
+          method: "PUT",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(config2)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data ?? null;
+      },
+      async unsetAgent(id) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/follow-up/agents/${id}`, { method: "DELETE" });
+        if (!resp.ok)
+          throw OmniApiError.from(await resp.json().catch(() => ({})), resp.status);
+      },
+      async getInstance(id) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/follow-up/instances/${id}`);
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data ?? null;
+      },
+      async setInstance(id, config2) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/follow-up/instances/${id}`, {
+          method: "PUT",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(config2)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data ?? null;
+      },
+      async unsetInstance(id) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/follow-up/instances/${id}`, { method: "DELETE" });
+        if (!resp.ok)
+          throw OmniApiError.from(await resp.json().catch(() => ({})), resp.status);
+      },
+      async getChat(id) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/follow-up/chats/${id}`);
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data ?? null;
+      },
+      async setChat(id, config2) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/follow-up/chats/${id}`, {
+          method: "PUT",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(config2)
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data ?? null;
+      },
+      async unsetChat(id) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/follow-up/chats/${id}`, { method: "DELETE" });
+        if (!resp.ok)
+          throw OmniApiError.from(await resp.json().catch(() => ({})), resp.status);
+      }
+    },
+    system: {
+      async health() {
+        const healthClient = createClient({ baseUrl: `${baseUrl}/api/v2` });
+        const noCompressionMiddleware = {
+          async onRequest({ request }) {
+            request.headers.set("Accept-Encoding", "identity");
+            if (config.cliVersion) {
+              request.headers.set("x-omni-cli-version", config.cliVersion);
+            }
+            return request;
+          }
+        };
+        healthClient.use(noCompressionMiddleware);
+        const { data, error, response } = await healthClient.GET("/health");
+        throwIfError(response, error);
+        return data ?? { status: "unhealthy" };
+      }
+    },
+    raw: client
+  };
+}
+
+// src/index.ts
+var VERSION = "0.0.1";
+export {
+  createOmniClient,
+  VERSION,
+  OmniConfigError,
+  OmniApiError
+};