@amigo-ai/platform-sdk 0.1.0 → 0.2.1

package/dist/index.mjs

@@ -1,9 +1,39 @@
 // src/core/errors.ts
+var SENSITIVE_FIELDS = /* @__PURE__ */ new Set([
+  "id_token",
+  "access_token",
+  "refresh_token",
+  "authorization",
+  "api_key",
+  "apikey",
+  "token",
+  "secret",
+  "password",
+  "x-api-key",
+  "cookie",
+  "set-cookie"
+]);
+function sanitizeErrorContext(obj) {
+  if (typeof obj !== "object" || !obj) return obj;
+  if (Array.isArray(obj)) return obj.map(sanitizeErrorContext);
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (SENSITIVE_FIELDS.has(key.toLowerCase())) {
+      result[key] = "[REDACTED]";
+    } else if (typeof value === "object" && value !== null) {
+      result[key] = sanitizeErrorContext(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
 var AmigoError = class extends Error {
   statusCode;
   errorCode;
   requestId;
   detail;
+  context;
   constructor(message, ctx = {}) {
     super(message);
     this.name = this.constructor.name;
@@ -11,7 +41,23 @@ var AmigoError = class extends Error {
     this.errorCode = ctx.errorCode;
     this.requestId = ctx.requestId;
     this.detail = ctx.detail;
+    this.context = ctx.context ? sanitizeErrorContext(ctx.context) : void 0;
     Object.setPrototypeOf(this, new.target.prototype);
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      statusCode: this.statusCode,
+      errorCode: this.errorCode,
+      requestId: this.requestId,
+      detail: this.detail,
+      context: this.context,
+      stack: this.stack
+    };
   }
 };
 var BadRequestError = class extends AmigoError {
@@ -65,8 +111,7 @@ var NetworkError = class extends AmigoError {
   constructor(message, cause) {
     super(message);
     if (cause !== void 0) {
-      ;
-      this.cause = cause;
+      Object.defineProperty(this, "cause", { value: cause, writable: false, enumerable: true });
     }
   }
 };
@@ -94,7 +139,8 @@ async function createApiError(response) {
     statusCode: response.status,
     errorCode: body.error_code,
     requestId: body.request_id,
-    detail: body.detail
+    detail: body.detail,
+    context: { url: response.url, response: body }
   };
   const message = body.message ?? body.detail ?? response.statusText ?? `HTTP ${response.status}`;
   switch (response.status) {
@@ -144,95 +190,200 @@ function isAuthenticationError(err) {
   return err instanceof AuthenticationError;
 }
 
-// src/resources/base.ts
-var WorkspaceScopedResource = class {
-  constructor(config) {
-    this.config = config;
-  }
-  get headers() {
-    return {
-      Authorization: `Bearer ${this.config.apiKey}`,
-      "Content-Type": "application/json"
-    };
-  }
-  workspaceUrl(path) {
-    return `${this.config.baseUrl}/v1/${this.config.workspaceId}${path}`;
-  }
-  async fetch(path, init = {}) {
-    const url = this.workspaceUrl(path);
-    const response = await globalThis.fetch(url, {
-      ...init,
-      headers: {
-        ...this.headers,
-        ...init.headers
+// src/core/openapi-client.ts
+import createClientImport from "openapi-fetch";
+
+// src/core/auth.ts
+function createAuthMiddleware(config) {
+  return {
+    async onRequest({ request }) {
+      request.headers.set("Authorization", `Bearer ${config.apiKey}`);
+      return request;
+    },
+    async onResponse({ response }) {
+      if (response.status === 401) {
+        throw new AuthenticationError("Invalid or expired API key. Check your credentials.", {
+          statusCode: 401
+        });
       }
-    });
-    if (!response.ok) {
-      throw await createApiError(response);
+      return response;
     }
-    if (response.status === 204) return void 0;
-    return response.json();
+  };
+}
+
+// src/core/retry.ts
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+var POST_RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([429]);
+function shouldRetry(ctx) {
+  const { method, attempt, response, options } = ctx;
+  if (attempt >= options.maxAttempts) return false;
+  const status = response.status;
+  if (method === "GET" || method === "HEAD") {
+    return RETRYABLE_STATUS_CODES.has(status);
+  }
+  if (method === "POST" && POST_RETRYABLE_STATUS_CODES.has(status)) {
+    return response.headers.has("Retry-After");
+  }
+  return false;
+}
+function computeDelay(attempt, response, options) {
+  const retryAfterHeader = response.headers.get("Retry-After");
+  if (retryAfterHeader) {
+    const seconds = parseRetryAfterHeader(retryAfterHeader);
+    if (seconds !== void 0) return seconds * 1e3;
+  }
+  const exponential = Math.min(options.maxDelayMs, options.baseDelayMs * Math.pow(2, attempt));
+  return Math.random() * exponential;
+}
+function parseRetryAfterHeader(header) {
+  const seconds = Number(header);
+  if (!isNaN(seconds)) return seconds;
+  const date = new Date(header);
+  if (!isNaN(date.getTime())) {
+    return Math.max(0, Math.ceil((date.getTime() - Date.now()) / 1e3));
   }
-};
-function buildQuery(params) {
-  if (!params) return "";
-  const entries = Object.entries(params).filter(
-    ([, v]) => v !== void 0 && v !== null
+  return void 0;
+}
+function resolveRetryOptions(opts) {
+  return {
+    maxAttempts: opts?.maxAttempts ?? 3,
+    baseDelayMs: opts?.baseDelayMs ?? 250,
+    maxDelayMs: opts?.maxDelayMs ?? 3e4
+  };
+}
+
+// src/core/openapi-client.ts
+var createClient = typeof createClientImport === "function" ? createClientImport : createClientImport.default;
+function createPlatformClient(config) {
+  const retryOpts = resolveRetryOptions(config.retry);
+  const baseFetch = config.fetch ?? globalThis.fetch;
+  const retryingFetch = async (input, init) => {
+    const method = (init?.method ?? "GET").toUpperCase();
+    const signal = init?.signal;
+    const isIdempotent = method === "GET" || method === "HEAD" || method === "OPTIONS";
+    for (let attempt = 0; attempt < retryOpts.maxAttempts; attempt++) {
+      let response;
+      let error;
+      try {
+        response = await baseFetch(input, init);
+      } catch (err) {
+        error = err;
+      }
+      if (!error && response && response.ok) return response;
+      const ctx = { method, attempt, response, options: retryOpts };
+      const attemptsRemain = attempt + 1 < retryOpts.maxAttempts;
+      if (error) {
+        if (isIdempotent && attemptsRemain) {
+          await sleep(computeDelay(attempt, new Response(), retryOpts));
+          continue;
+        }
+        throw new NetworkError(
+          `Network error: ${error instanceof Error ? error.message : String(error)}`,
+          error
+        );
+      }
+      if (response && attemptsRemain && shouldRetry(ctx)) {
+        const delay = computeDelay(attempt, response, retryOpts);
+        if (signal?.aborted) return response;
+        await sleep(delay);
+        continue;
+      }
+      return response;
+    }
+    throw new NetworkError("Retry loop exhausted");
+  };
+  const client = createClient({
+    baseUrl: config.baseUrl,
+    fetch: retryingFetch
+  });
+  const errorMiddleware = {
+    async onResponse({ response }) {
+      if (!response.ok) {
+        throw await createApiError(response);
+      }
+      return response;
+    }
+  };
+  const authMiddleware = createAuthMiddleware({ apiKey: config.apiKey });
+  client.use(authMiddleware);
+  client.use(errorMiddleware);
+  return client;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/core/utils.ts
+function extractData(result) {
+  if (result.data !== void 0) return result.data;
+  throw new ParseError(
+    "Unexpected empty response from API",
+    result.error !== void 0 ? JSON.stringify(result.error) : void 0
   );
-  if (entries.length === 0) return "";
-  const searchParams = new URLSearchParams();
-  for (const [k, v] of entries) {
-    searchParams.set(k, String(v));
+}
+async function* paginate(fetcher) {
+  let token = void 0;
+  while (true) {
+    const page = await fetcher(token);
+    for (const item of page.items) {
+      yield item;
+    }
+    if (!page.has_more || page.continuation_token === null) break;
+    token = page.continuation_token;
   }
-  return "?" + searchParams.toString();
 }
 
-// src/resources/workspaces.ts
-var WorkspacesResource = class {
-  constructor(config) {
-    this.config = config;
-  }
-  get headers() {
-    return {
-      Authorization: `Bearer ${this.config.apiKey}`,
-      "Content-Type": "application/json"
-    };
-  }
-  async request(path, init = {}) {
-    const url = `${this.config.baseUrl}/v1/workspaces${path}`;
-    const response = await globalThis.fetch(url, {
-      ...init,
-      headers: { ...this.headers, ...init.headers }
-    });
-    if (!response.ok) throw await createApiError(response);
-    if (response.status === 204) return void 0;
-    return response.json();
+// src/resources/base.ts
+var WorkspaceScopedResource = class {
+  constructor(client, workspaceId2) {
+    this.client = client;
+    this.workspaceId = workspaceId2;
   }
+};
+
+// src/resources/workspaces.ts
+var WorkspacesResource = class extends WorkspaceScopedResource {
   /** Create a new workspace */
   async create(body) {
-    return this.request("", {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
+    return extractData(
+      await this.client.POST("/v1/workspaces", {
+        body
+      })
+    );
   }
   /** List workspaces accessible to the current API key */
   async list(params) {
-    return this.request(buildQuery(params));
+    return extractData(
+      await this.client.GET("/v1/workspaces", {
+        params: { query: params }
+      })
+    );
   }
   /** Get a single workspace by ID */
   async get(id) {
-    return this.request(`/${id}`);
+    return extractData(
+      await this.client.GET("/v1/workspaces/{workspace_id}", {
+        params: { path: { workspace_id: id ?? this.workspaceId } }
+      })
+    );
   }
   /** Update workspace metadata */
-  async update(id, body) {
-    return this.request(`/${id}`, {
-      method: "PUT",
-      body: JSON.stringify(body)
-    });
+  async update(body, id) {
+    return extractData(
+      await this.client.PATCH("/v1/workspaces/{workspace_id}", {
+        params: { path: { workspace_id: id ?? this.workspaceId } },
+        body
+      })
+    );
   }
   /** Archive (soft-delete) a workspace */
-  async delete(id) {
-    return this.request(`/${id}`, { method: "DELETE" });
+  async archive(body, id) {
+    return extractData(
+      await this.client.POST("/v1/workspaces/{workspace_id}/archive", {
+        params: { path: { workspace_id: id ?? this.workspaceId } },
+        body
+      })
+    );
   }
 };
 
@@ -243,80 +394,102 @@ var ApiKeysResource = class extends WorkspaceScopedResource {
    * Does not require a workspace ID in the path.
    */
   async me() {
-    const url = `${this.config.baseUrl}/v1/auth/me`;
-    const response = await globalThis.fetch(url, { headers: this.headers });
-    if (!response.ok) throw await createApiError(response);
-    return response.json();
+    return extractData(await this.client.GET("/v1/auth/me", {}));
   }
   /** Create a new API key */
   async create(body) {
-    return this.fetch("/api-keys", {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/api-keys", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
   }
   /** List API keys in the workspace */
   async list(params) {
-    return this.fetch(`/api-keys${buildQuery(params)}`);
-  }
-  /** Get a specific API key */
-  async get(keyId) {
-    return this.fetch(`/api-keys/${keyId}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/api-keys", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
   }
   /** Revoke an API key */
   async revoke(keyId) {
-    return this.fetch(`/api-keys/${keyId}`, { method: "DELETE" });
+    await this.client.DELETE("/v1/{workspace_id}/api-keys/{key_id}", {
+      params: { path: { workspace_id: this.workspaceId, key_id: keyId } }
+    });
   }
   /** Rotate an API key — invalidates the old key and issues a new one */
-  async rotate(keyId) {
-    return this.fetch(`/api-keys/${keyId}/rotate`, { method: "POST" });
+  async rotate(keyId, body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/api-keys/{key_id}/rotate", {
+        params: { path: { workspace_id: this.workspaceId, key_id: keyId } },
+        body
+      })
+    );
   }
 };
 
 // src/resources/agents.ts
 var AgentsResource = class extends WorkspaceScopedResource {
-  /** Create a new agent */
   async create(body) {
-    return this.fetch("/agents", {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/agents", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
   }
-  /** List agents in the workspace */
   async list(params) {
-    return this.fetch(`/agents${buildQuery(params)}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/agents", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
   }
-  /** Get a single agent */
   async get(agentId2) {
-    return this.fetch(`/agents/${agentId2}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/agents/{agent_id}", {
+        params: { path: { workspace_id: this.workspaceId, agent_id: agentId2 } }
+      })
+    );
   }
-  /** Update an agent's configuration */
   async update(agentId2, body) {
-    return this.fetch(`/agents/${agentId2}`, {
-      method: "PUT",
-      body: JSON.stringify(body)
-    });
+    return extractData(
+      await this.client.PUT("/v1/{workspace_id}/agents/{agent_id}", {
+        params: { path: { workspace_id: this.workspaceId, agent_id: agentId2 } },
+        body
+      })
+    );
   }
-  /** Delete an agent */
   async delete(agentId2) {
-    return this.fetch(`/agents/${agentId2}`, { method: "DELETE" });
+    await this.client.DELETE("/v1/{workspace_id}/agents/{agent_id}", {
+      params: { path: { workspace_id: this.workspaceId, agent_id: agentId2 } }
+    });
   }
-  /** List all versions of an agent */
   async listVersions(agentId2, params) {
-    return this.fetch(
-      `/agents/${agentId2}/versions${buildQuery(params)}`
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/agents/{agent_id}/versions", {
+        params: { path: { workspace_id: this.workspaceId, agent_id: agentId2 }, query: params }
+      })
     );
   }
-  /** Get a specific version of an agent — pass `"latest"` to get the most recent */
   async getVersion(agentId2, version) {
-    return this.fetch(`/agents/${agentId2}/versions/${version}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/agents/{agent_id}/versions/{version}", {
+        params: {
+          path: { workspace_id: this.workspaceId, agent_id: agentId2, version: String(version) }
+        }
+      })
+    );
   }
-  /** Create a new version of an agent */
   async createVersion(agentId2, body) {
-    return this.fetch(`/agents/${agentId2}/versions`, {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/agents/{agent_id}/versions", {
+        params: { path: { workspace_id: this.workspaceId, agent_id: agentId2 } },
+        body
+      })
+    );
   }
 };
 
@@ -324,254 +497,652 @@ var AgentsResource = class extends WorkspaceScopedResource {
 var SkillsResource = class extends WorkspaceScopedResource {
   /** Create a new skill */
   async create(body) {
-    return this.fetch("/skills", {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/skills", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
   }
   /** List skills in the workspace */
   async list(params) {
-    return this.fetch(`/skills${buildQuery(params)}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/skills", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
   }
   /** Get a single skill */
   async get(skillId2) {
-    return this.fetch(`/skills/${skillId2}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/skills/{skill_id}", {
+        params: { path: { workspace_id: this.workspaceId, skill_id: skillId2 } }
+      })
+    );
   }
   /** Update a skill */
   async update(skillId2, body) {
-    return this.fetch(`/skills/${skillId2}`, {
-      method: "PUT",
-      body: JSON.stringify(body)
-    });
+    return extractData(
+      await this.client.PUT("/v1/{workspace_id}/skills/{skill_id}", {
+        params: { path: { workspace_id: this.workspaceId, skill_id: skillId2 } },
+        body
+      })
+    );
   }
   /** Delete a skill */
   async delete(skillId2) {
-    return this.fetch(`/skills/${skillId2}`, { method: "DELETE" });
+    await this.client.DELETE("/v1/{workspace_id}/skills/{skill_id}", {
+      params: { path: { workspace_id: this.workspaceId, skill_id: skillId2 } }
+    });
   }
   /**
    * Test a skill with a sample input.
    * Executes the skill in a sandbox and returns the result.
    */
   async test(skillId2, body) {
-    return this.fetch(`/skills/${skillId2}/test`, {
-      method: "POST",
-      body: JSON.stringify(body)
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/skills/{skill_id}/test", {
+        params: { path: { workspace_id: this.workspaceId, skill_id: skillId2 } },
+        body
+      })
+    );
+  }
+};
+
+// src/resources/actions.ts
+var ActionsResource = class extends WorkspaceScopedResource {
+  /** Create a new action */
+  async create(body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/skills", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
+  }
+  /** List actions in the workspace */
+  async list(params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/skills", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+  /** Get a single action */
+  async get(actionId2) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/skills/{skill_id}", {
+        params: { path: { workspace_id: this.workspaceId, skill_id: actionId2 } }
+      })
+    );
+  }
+  /** Update an action */
+  async update(actionId2, body) {
+    return extractData(
+      await this.client.PUT("/v1/{workspace_id}/skills/{skill_id}", {
+        params: { path: { workspace_id: this.workspaceId, skill_id: actionId2 } },
+        body
+      })
+    );
+  }
+  /** Delete an action */
+  async delete(actionId2) {
+    await this.client.DELETE("/v1/{workspace_id}/skills/{skill_id}", {
+      params: { path: { workspace_id: this.workspaceId, skill_id: actionId2 } }
     });
   }
+  /**
+   * Test an action with a sample input.
+   * Executes the action in a sandbox and returns the result.
+   */
+  async test(actionId2, body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/skills/{skill_id}/test", {
+        params: { path: { workspace_id: this.workspaceId, skill_id: actionId2 } },
+        body
+      })
+    );
+  }
+};
+
+// src/resources/operators.ts
+var OperatorsResource = class extends WorkspaceScopedResource {
+  async list(params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/operators", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+  async create(body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/operators", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
+  }
+  async get(operatorId) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/operators/{operator_id}", {
+        params: { path: { workspace_id: this.workspaceId, operator_id: operatorId } }
+      })
+    );
+  }
+  async getDashboard() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/operators/dashboard", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  async getQueue() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/operators/queue", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  async getEscalations(params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/operators/escalations", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+  async getActiveEscalations() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/operators/escalations/active", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  async getEscalationStats(params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/operators/escalations/stats", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+  async getPerformance(params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/operators/performance", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+  async getAccessToken(operatorId, body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/operators/{operator_id}/access-token", {
+        params: { path: { workspace_id: this.workspaceId, operator_id: operatorId } },
+        body
+      })
+    );
+  }
+  async joinCall(operatorId, body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/operators/{operator_id}/join-call", {
+        params: { path: { workspace_id: this.workspaceId, operator_id: operatorId } },
+        body
+      })
+    );
+  }
+  async leaveCall(operatorId, body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/operators/{operator_id}/leave-call", {
+        params: { path: { workspace_id: this.workspaceId, operator_id: operatorId } },
+        body
+      })
+    );
+  }
+  async switchMode(operatorId, body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/operators/{operator_id}/switch-mode", {
+        params: { path: { workspace_id: this.workspaceId, operator_id: operatorId } },
+        body
+      })
+    );
+  }
+  async sendGuidance(operatorId, body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/operators/{operator_id}/send-guidance", {
+        params: { path: { workspace_id: this.workspaceId, operator_id: operatorId } },
+        body
+      })
+    );
+  }
+  async createBriefing(operatorId, body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/operators/{operator_id}/briefing", {
+        params: { path: { workspace_id: this.workspaceId, operator_id: operatorId } },
+        body
+      })
+    );
+  }
+  async wrapUp(operatorId, body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/operators/{operator_id}/wrap-up", {
+        params: { path: { workspace_id: this.workspaceId, operator_id: operatorId } },
+        body
+      })
+    );
+  }
+  async getCallTranscript(callSid) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/operators/calls/{call_sid}/transcript", {
+        params: { path: { workspace_id: this.workspaceId, call_sid: callSid } }
+      })
+    );
+  }
+  async getAuditLog(params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/operators/audit-log", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+};
+
+// src/resources/triggers.ts
+var TriggersResource = class extends WorkspaceScopedResource {
+  async list(params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/triggers", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+  async create(body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/triggers", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
+  }
+  async get(triggerId) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/triggers/{trigger_id}", {
+        params: { path: { workspace_id: this.workspaceId, trigger_id: triggerId } }
+      })
+    );
+  }
+  async update(triggerId, body) {
+    return extractData(
+      await this.client.PUT("/v1/{workspace_id}/triggers/{trigger_id}", {
+        params: { path: { workspace_id: this.workspaceId, trigger_id: triggerId } },
+        body
+      })
+    );
+  }
+  async delete(triggerId) {
+    await this.client.DELETE("/v1/{workspace_id}/triggers/{trigger_id}", {
+      params: { path: { workspace_id: this.workspaceId, trigger_id: triggerId } }
+    });
+  }
+  async fire(triggerId) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/triggers/{trigger_id}/fire", {
+        params: { path: { workspace_id: this.workspaceId, trigger_id: triggerId } }
+      })
+    );
+  }
+  async pause(triggerId) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/triggers/{trigger_id}/pause", {
+        params: { path: { workspace_id: this.workspaceId, trigger_id: triggerId } }
+      })
+    );
+  }
+  async resume(triggerId) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/triggers/{trigger_id}/resume", {
+        params: { path: { workspace_id: this.workspaceId, trigger_id: triggerId } }
+      })
+    );
+  }
+  async listRuns(triggerId, params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/triggers/{trigger_id}/runs", {
+        params: { path: { workspace_id: this.workspaceId, trigger_id: triggerId }, query: params }
+      })
+    );
+  }
 };
 
 // src/resources/services.ts
 var ServicesResource = class extends WorkspaceScopedResource {
   async create(body) {
-    return this.fetch("/services", {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/services", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
   }
   async list(params) {
-    return this.fetch(`/services${buildQuery(params)}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/services", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
   }
   async get(serviceId2) {
-    return this.fetch(`/services/${serviceId2}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/services/{service_id}", {
+        params: { path: { workspace_id: this.workspaceId, service_id: serviceId2 } }
+      })
+    );
   }
   async update(serviceId2, body) {
-    return this.fetch(`/services/${serviceId2}`, {
-      method: "PUT",
-      body: JSON.stringify(body)
-    });
+    return extractData(
+      await this.client.PUT("/v1/{workspace_id}/services/{service_id}", {
+        params: { path: { workspace_id: this.workspaceId, service_id: serviceId2 } },
+        body
+      })
+    );
   }
   async delete(serviceId2) {
-    return this.fetch(`/services/${serviceId2}`, { method: "DELETE" });
+    await this.client.DELETE("/v1/{workspace_id}/services/{service_id}", {
+      params: { path: { workspace_id: this.workspaceId, service_id: serviceId2 } }
+    });
   }
 };
 
 // src/resources/context-graphs.ts
 var ContextGraphsResource = class extends WorkspaceScopedResource {
   async create(body) {
-    return this.fetch("/context-graphs", {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/context-graphs", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
   }
   async list(params) {
-    return this.fetch(`/context-graphs${buildQuery(params)}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/context-graphs", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
   }
   async get(contextGraphId2) {
-    return this.fetch(`/context-graphs/${contextGraphId2}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/context-graphs/{context_graph_id}", {
+        params: {
+          path: { workspace_id: this.workspaceId, context_graph_id: contextGraphId2 }
+        }
+      })
+    );
   }
   async update(contextGraphId2, body) {
-    return this.fetch(`/context-graphs/${contextGraphId2}`, {
-      method: "PUT",
-      body: JSON.stringify(body)
-    });
+    return extractData(
+      await this.client.PUT("/v1/{workspace_id}/context-graphs/{context_graph_id}", {
+        params: {
+          path: { workspace_id: this.workspaceId, context_graph_id: contextGraphId2 }
+        },
+        body
+      })
+    );
   }
   async delete(contextGraphId2) {
-    return this.fetch(`/context-graphs/${contextGraphId2}`, { method: "DELETE" });
+    await this.client.DELETE("/v1/{workspace_id}/context-graphs/{context_graph_id}", {
+      params: {
+        path: { workspace_id: this.workspaceId, context_graph_id: contextGraphId2 }
+      }
+    });
   }
   /** Create a version snapshot of the current context graph */
-  async createVersion(contextGraphId2) {
-    return this.fetch(`/context-graphs/${contextGraphId2}/versions`, {
-      method: "POST"
-    });
+  async createVersion(contextGraphId2, body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/context-graphs/{context_graph_id}/versions", {
+        params: {
+          path: { workspace_id: this.workspaceId, context_graph_id: contextGraphId2 }
+        },
+        body
+      })
+    );
   }
   /** List all versions of a context graph */
   async listVersions(contextGraphId2, params) {
-    return this.fetch(
-      `/context-graphs/${contextGraphId2}/versions${buildQuery(params)}`
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/context-graphs/{context_graph_id}/versions", {
+        params: {
+          path: { workspace_id: this.workspaceId, context_graph_id: contextGraphId2 },
+          query: params
+        }
+      })
     );
   }
   /** Get a specific version */
   async getVersion(contextGraphId2, version) {
-    return this.fetch(`/context-graphs/${contextGraphId2}/versions/${version}`);
+    return extractData(
+      await this.client.GET(
+        "/v1/{workspace_id}/context-graphs/{context_graph_id}/versions/{version}",
+        {
+          params: {
+            path: {
+              workspace_id: this.workspaceId,
+              context_graph_id: contextGraphId2,
+              version
+            }
+          }
+        }
+      )
+    );
   }
 };
 
 // src/resources/data-sources.ts
 var DataSourcesResource = class extends WorkspaceScopedResource {
   async create(body) {
-    return this.fetch("/data-sources", {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/data-sources", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
   }
   async list(params) {
-    return this.fetch(`/data-sources${buildQuery(params)}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/data-sources", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
   }
   async get(dataSourceId2) {
-    return this.fetch(`/data-sources/${dataSourceId2}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/data-sources/{data_source_id}", {
+        params: { path: { workspace_id: this.workspaceId, data_source_id: dataSourceId2 } }
+      })
+    );
   }
   async update(dataSourceId2, body) {
-    return this.fetch(`/data-sources/${dataSourceId2}`, {
-      method: "PUT",
-      body: JSON.stringify(body)
-    });
+    return extractData(
+      await this.client.PATCH("/v1/{workspace_id}/data-sources/{data_source_id}", {
+        params: { path: { workspace_id: this.workspaceId, data_source_id: dataSourceId2 } },
+        body
+      })
+    );
   }
   async delete(dataSourceId2) {
-    return this.fetch(`/data-sources/${dataSourceId2}`, { method: "DELETE" });
+    await this.client.DELETE("/v1/{workspace_id}/data-sources/{data_source_id}", {
+      params: { path: { workspace_id: this.workspaceId, data_source_id: dataSourceId2 } }
+    });
+  }
+  /** Get event counts, sync status, and health for a data source */
+  async getStatus(dataSourceId2) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/data-sources/{data_source_id}/status", {
+        params: { path: { workspace_id: this.workspaceId, data_source_id: dataSourceId2 } }
+      })
+    );
+  }
+  /** Get daily event timeline + recent sync failures for a data source */
+  async getSyncHistory(dataSourceId2) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/data-sources/{data_source_id}/sync-history", {
+        params: { path: { workspace_id: this.workspaceId, data_source_id: dataSourceId2 } }
+      })
+    );
   }
 };
 
 // src/resources/world.ts
 var WorldResource = class extends WorkspaceScopedResource {
   // ---- Entities ----
-  /** Create a new entity */
-  async createEntity(body) {
-    return this.fetch("/world/entities", {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
-  }
   /** List entities with optional filtering */
   async listEntities(params) {
-    return this.fetch(`/world/entities${buildQuery(params)}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/world/entities", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
   }
   /** Get a single entity */
   async getEntity(entityId2) {
-    return this.fetch(`/world/entities/${entityId2}`);
-  }
-  /** Update entity properties */
-  async updateEntity(entityId2, body) {
-    return this.fetch(`/world/entities/${entityId2}`, {
-      method: "PUT",
-      body: JSON.stringify(body)
-    });
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/world/entities/{entity_id}", {
+        params: { path: { workspace_id: this.workspaceId, entity_id: entityId2 } }
+      })
+    );
   }
   /** Get all relationships for an entity */
   async getRelationships(entityId2) {
-    return this.fetch(`/world/entities/${entityId2}/relationships`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/world/entities/{entity_id}/relationships", {
+        params: { path: { workspace_id: this.workspaceId, entity_id: entityId2 } }
+      })
+    );
   }
   /** Get the knowledge graph centered on an entity (entity + neighbors + edges) */
   async getGraph(entityId2) {
-    return this.fetch(`/world/entities/${entityId2}/graph`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/world/entities/{entity_id}/graph", {
+        params: { path: { workspace_id: this.workspaceId, entity_id: entityId2 } }
+      })
+    );
   }
   /** Get provenance — which source systems contributed data for an entity */
   async getProvenance(entityId2) {
-    return this.fetch(`/world/entities/${entityId2}/provenance`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/world/entities/{entity_id}/provenance", {
+        params: { path: { workspace_id: this.workspaceId, entity_id: entityId2 } }
+      })
+    );
   }
   /** Get lineage — merge history and canonical identity for an entity */
   async getLineage(entityId2) {
-    return this.fetch(`/world/entities/${entityId2}/lineage`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/world/entities/{entity_id}/lineage", {
+        params: { path: { workspace_id: this.workspaceId, entity_id: entityId2 } }
+      })
+    );
   }
   /** Get merged entities for a canonical entity */
   async getMerged(entityId2) {
-    return this.fetch(`/world/entities/${entityId2}/merged`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/world/entities/{entity_id}/merged", {
+        params: { path: { workspace_id: this.workspaceId, entity_id: entityId2 } }
+      })
+    );
   }
   // ---- Entity Types ----
   /** List registered entity types with counts and schemas */
   async listEntityTypes() {
-    return this.fetch("/world/entity-types");
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/world/entity-types", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
   }
   // ---- Duplicate Detection ----
   /** List potential duplicate entity pairs for review or merging */
   async listDuplicates(params) {
-    return this.fetch(`/world/entities/duplicates${buildQuery(params)}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/world/entities/duplicates", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
   }
   // ---- Semantic Search ----
   /** Semantic (vector) search over entities */
   async search(params) {
-    return this.fetch(`/world/search${buildQuery(params)}`);
-  }
-  // ---- Events ----
-  /**
-   * Emit an event for an entity.
-   * Events flow to Delta via ZeroBus for downstream analytics.
-   */
-  async emitEvent(body) {
-    return this.fetch("/world/events", {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/world/search", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
   }
   // ---- Timeline ----
   /** Get the event timeline for an entity (reverse-chronological) */
   async getTimeline(entityId2, params) {
-    return this.fetch(`/world/timeline/${entityId2}${buildQuery(params)}`);
-  }
-  // ---- Intelligence ----
-  /** Get AI-derived intelligence for an entity */
-  async getIntelligence(entityId2) {
-    return this.fetch(`/world/intelligence/${entityId2}`);
-  }
-  /** Find entities similar to a given entity using vector similarity */
-  async getSimilar(entityId2, limit) {
-    return this.fetch(`/world/similar/${entityId2}${buildQuery({ limit })}`);
-  }
-  /** Merge multiple entities into one canonical entity */
-  async merge(body) {
-    return this.fetch("/world/merge", {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/world/entities/{entity_id}/timeline", {
+        params: {
+          path: { workspace_id: this.workspaceId, entity_id: entityId2 },
+          query: params
+        }
+      })
+    );
   }
   // ---- Sync ----
   /** Get sync status grouped by sink (Lakebase, Delta, etc.) */
   async getSyncStatusBySink() {
-    return this.fetch("/world/sync/by-sink");
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/world/sync/by-sink", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
   }
   /** List sync events with status filtering */
   async listSyncEvents(params) {
-    return this.fetch(`/world/sync/events${buildQuery(params)}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/world/sync/events", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
   }
   /** Get current sync queue depth */
   async getSyncQueueDepth() {
-    return this.fetch("/world/sync/queue");
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/world/sync/queue", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
   }
   /** Retry a single failed sync event */
   async retrySyncEvent(eventId2) {
-    return this.fetch(`/world/sync/retry/${eventId2}`, { method: "POST" });
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/world/sync/retry/{event_id}", {
+        params: { path: { workspace_id: this.workspaceId, event_id: eventId2 } }
+      })
+    );
   }
   /** Retry all failed sync events */
   async retryAllSyncEvents() {
-    return this.fetch("/world/sync/retry-all", { method: "POST" });
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/world/sync/retry-all", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
   }
   // ---- Statistics ----
   /** Get aggregate entity and event statistics */
   async getStats() {
-    return this.fetch("/world/entity-stats");
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/world/entity-stats", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
   }
   /** Get entity counts broken down by source system */
   async getSourceBreakdown() {
-    return this.fetch("/world/source-breakdown");
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/world/source-breakdown", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
   }
 };
 
@@ -579,104 +1150,183 @@ var WorldResource = class extends WorkspaceScopedResource {
 var CallsResource = class extends WorkspaceScopedResource {
   /** List calls with optional filtering */
   async list(params) {
-    return this.fetch(`/calls/${buildQuery(params)}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/calls", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
   }
-  /** Get full call detail including transcript and intelligence */
-  async get(callSid) {
-    return this.fetch(`/calls/${callSid}`);
+  /** Get full call detail including turns, escalation, safety, and recording info */
+  async get(callId2) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/calls/{call_id}", {
+        params: { path: { workspace_id: this.workspaceId, call_id: callId2 } }
+      })
+    );
   }
   /** Get AI intelligence for a call */
-  async getIntelligence(callSid) {
-    return this.fetch(`/calls/${callSid}/intelligence`);
+  async getIntelligence(callId2) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/calls/{call_id}/intelligence", {
+        params: { path: { workspace_id: this.workspaceId, call_id: callId2 } }
+      })
+    );
   }
   /** Get active intelligence across all in-progress calls */
   async getActiveIntelligence() {
-    return this.fetch("/calls/active/intelligence");
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/calls/active/intelligence", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
   }
   /** Get performance benchmarks for a time period */
   async getBenchmarks(params) {
-    return this.fetch(`/calls/benchmarks${buildQuery(params)}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/calls/benchmarks", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+  /** Get deep call trace analysis */
+  async getTraceAnalysis(callId2) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/calls/{call_id}/trace-analysis", {
+        params: { path: { workspace_id: this.workspaceId, call_id: callId2 } }
+      })
+    );
   }
 };
 
 // src/resources/phone-numbers.ts
 var PhoneNumbersResource = class extends WorkspaceScopedResource {
-  /** Provision a new phone number (area code or specific number) */
+  /** Create a new phone number */
   async provision(body) {
-    return this.fetch("/phone-numbers", {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/phone-numbers", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
   }
   /** List phone numbers in the workspace */
   async list(params) {
-    return this.fetch(`/phone-numbers${buildQuery(params)}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/phone-numbers", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
   }
   /** Get a phone number */
   async get(phoneNumberId2) {
-    return this.fetch(`/phone-numbers/${phoneNumberId2}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/phone-numbers/{phone_number_id}", {
+        params: { path: { workspace_id: this.workspaceId, phone_number_id: phoneNumberId2 } }
+      })
+    );
   }
   /** Update a phone number (assign to agent, rename) */
   async update(phoneNumberId2, body) {
-    return this.fetch(`/phone-numbers/${phoneNumberId2}`, {
-      method: "PUT",
-      body: JSON.stringify(body)
-    });
+    return extractData(
+      await this.client.PUT("/v1/{workspace_id}/phone-numbers/{phone_number_id}", {
+        params: { path: { workspace_id: this.workspaceId, phone_number_id: phoneNumberId2 } },
+        body
+      })
+    );
   }
   /** Release a phone number back to the carrier */
   async release(phoneNumberId2) {
-    return this.fetch(`/phone-numbers/${phoneNumberId2}`, { method: "DELETE" });
+    await this.client.DELETE("/v1/{workspace_id}/phone-numbers/{phone_number_id}", {
+      params: { path: { workspace_id: this.workspaceId, phone_number_id: phoneNumberId2 } }
+    });
   }
-  /** Send a test call to a phone number to verify it's working */
-  async test(phoneNumberId2) {
-    return this.fetch(
-      `/phone-numbers/${phoneNumberId2}/test`,
-      { method: "POST" }
+  /** Set call forwarding for a phone number */
+  async setForwarding(phoneNumberId2, body) {
+    return extractData(
+      await this.client.PUT("/v1/{workspace_id}/phone-numbers/{phone_number_id}/forwarding", {
+        params: { path: { workspace_id: this.workspaceId, phone_number_id: phoneNumberId2 } },
+        body
+      })
     );
   }
+  /** Clear call forwarding for a phone number */
+  async clearForwarding(phoneNumberId2) {
+    await this.client.DELETE("/v1/{workspace_id}/phone-numbers/{phone_number_id}/forwarding", {
+      params: { path: { workspace_id: this.workspaceId, phone_number_id: phoneNumberId2 } }
+    });
+  }
 };
 
 // src/resources/integrations.ts
 var IntegrationsResource = class extends WorkspaceScopedResource {
   /** Create a new integration */
   async create(body) {
-    return this.fetch("/integrations", {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/integrations", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
   }
   /** List integrations */
   async list(params) {
-    return this.fetch(`/integrations${buildQuery(params)}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/integrations", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
   }
   /** Get a single integration */
   async get(integrationId2) {
-    return this.fetch(`/integrations/${integrationId2}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/integrations/{integration_id}", {
+        params: { path: { workspace_id: this.workspaceId, integration_id: integrationId2 } }
+      })
+    );
   }
   /** Update integration configuration */
   async update(integrationId2, body) {
-    return this.fetch(`/integrations/${integrationId2}`, {
-      method: "PUT",
-      body: JSON.stringify(body)
-    });
+    return extractData(
+      await this.client.PUT("/v1/{workspace_id}/integrations/{integration_id}", {
+        params: { path: { workspace_id: this.workspaceId, integration_id: integrationId2 } },
+        body
+      })
+    );
   }
   /** Delete an integration */
   async delete(integrationId2) {
-    return this.fetch(`/integrations/${integrationId2}`, { method: "DELETE" });
+    await this.client.DELETE("/v1/{workspace_id}/integrations/{integration_id}", {
+      params: { path: { workspace_id: this.workspaceId, integration_id: integrationId2 } }
+    });
   }
   /**
    * Test a specific endpoint on an integration with given params.
    * Used in the developer console to validate integration config.
    */
-  async testEndpoint(integrationId2, endpointName, params) {
-    return this.fetch(
-      `/integrations/${integrationId2}/endpoints/${endpointName}/test`,
-      { method: "POST", body: JSON.stringify({ params }) }
+  async testEndpoint(integrationId2, endpointName, body) {
+    return extractData(
+      await this.client.POST(
+        "/v1/{workspace_id}/integrations/{integration_id}/endpoints/{endpoint_name}/test",
+        {
+          params: {
+            path: {
+              workspace_id: this.workspaceId,
+              integration_id: integrationId2,
+              endpoint_name: endpointName
+            }
+          },
+          body
+        }
+      )
     );
   }
   /** Check health of all integrations in the workspace */
   async getHealthCheck() {
-    return this.fetch("/integrations/health-check");
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/integrations/health-check", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
   }
 };
 
@@ -684,47 +1334,91 @@ var IntegrationsResource = class extends WorkspaceScopedResource {
 var AnalyticsResource = class extends WorkspaceScopedResource {
   /** High-level dashboard summary — pass `days` (default: 7) for the lookback window */
   async getDashboard(params) {
-    return this.fetch(`/analytics/dashboard${buildQuery(params)}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/analytics/dashboard", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
   }
   /** Call volume and duration metrics */
   async getCalls(params) {
-    return this.fetch(`/analytics/calls${buildQuery(params)}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/analytics/calls", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
   }
   /** Per-agent performance breakdown */
   async getAgents(params) {
-    return this.fetch(`/analytics/agents${buildQuery(params)}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/analytics/agents", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
   }
   /** Call quality — sentiment, transcription confidence, flagged calls */
   async getCallQuality(params) {
-    return this.fetch(`/analytics/call-quality${buildQuery(params)}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/analytics/call-quality", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
   }
   /** Emotion trend data over time */
   async getEmotionTrends(params) {
-    return this.fetch(`/analytics/emotion-trends${buildQuery(params)}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/analytics/emotion-trends", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
   }
   /** Voice pipeline latency metrics (TTFB, response time) */
   async getLatency(params) {
-    return this.fetch(`/analytics/latency${buildQuery(params)}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/analytics/latency", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
   }
   /** Tool call performance — success rates and latency per tool */
   async getToolPerformance(params) {
-    return this.fetch(`/analytics/tool-performance${buildQuery(params)}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/analytics/tool-performance", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
   }
   /** Data quality metrics for the workspace world model */
   async getDataQuality(params) {
-    return this.fetch(`/analytics/data-quality${buildQuery(params)}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/analytics/data-quality", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
   }
   /** Usage summary — API requests, call minutes, storage */
   async getUsage(params) {
-    return this.fetch(`/analytics/usage${buildQuery(params)}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/analytics/usage", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
   }
   /** Advanced call statistics (abandonment, transfers, silence, hour-of-day) */
   async getAdvancedCallStats(params) {
-    return this.fetch(`/analytics/calls/advanced${buildQuery(params)}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/analytics/calls/advanced", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
   }
   /** Compare two time periods side by side */
   async compareCallPeriods(params) {
-    return this.fetch(`/analytics/calls/comparison${buildQuery(params)}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/analytics/calls/comparison", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
   }
 };
 
@@ -732,95 +1426,207 @@ var AnalyticsResource = class extends WorkspaceScopedResource {
 var SimulationsResource = class extends WorkspaceScopedResource {
   /** Start a simulation session — returns the agent's greeting and initial snapshot */
   async createSession(body) {
-    return this.fetch("/simulations/sessions", {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/simulations/sessions", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
   }
   /** Get the current snapshot of a session */
   async getSession(sessionId) {
-    return this.fetch(`/simulations/sessions/${sessionId}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/simulations/sessions/{session_id}", {
+        params: { path: { workspace_id: this.workspaceId, session_id: sessionId } }
+      })
+    );
   }
   /** Delete a simulation session */
   async deleteSession(sessionId) {
-    return this.fetch(`/simulations/sessions/${sessionId}`, { method: "DELETE" });
+    return extractData(
+      await this.client.DELETE("/v1/{workspace_id}/simulations/sessions/{session_id}", {
+        params: { path: { workspace_id: this.workspaceId, session_id: sessionId } }
+      })
+    );
   }
   /**
    * Send a caller utterance and advance the session by one turn.
    * Returns the agent's response observation and updated snapshot.
    */
   async step(body) {
-    return this.fetch("/simulations/sessions/step", {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/simulations/sessions/step", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
   }
   /**
    * Get LLM-generated caller message suggestions for the current session state.
    * Helps exploratory testing by suggesting realistic next caller turns.
    */
-  async recommend(sessionId, n) {
-    return this.fetch("/simulations/sessions/recommend", {
-      method: "POST",
-      body: JSON.stringify({ session_id: sessionId, n })
-    });
+  async recommend(body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/simulations/sessions/recommend", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
   }
   /** Get AI-generated call intelligence for a completed session */
   async getIntelligence(sessionId) {
-    return this.fetch(`/simulations/sessions/${sessionId}/intelligence`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/simulations/sessions/{session_id}/intelligence", {
+        params: { path: { workspace_id: this.workspaceId, session_id: sessionId } }
+      })
+    );
   }
 };
 
 // src/resources/settings.ts
 var SettingsResource = class extends WorkspaceScopedResource {
-  async getSettings(key) {
-    return this.fetch(`/settings/${key}`);
-  }
-  async updateSettings(key, body) {
-    return this.fetch(`/settings/${key}`, {
-      method: "PUT",
-      body: JSON.stringify(body)
-    });
-  }
   voice = {
-    get: () => this.getSettings("voice"),
-    update: (body) => this.updateSettings("voice", body)
+    get: async () => extractData(
+      await this.client.GET("/v1/{workspace_id}/settings/voice", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    ),
+    update: async (body) => extractData(
+      await this.client.PUT("/v1/{workspace_id}/settings/voice", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    )
   };
   branding = {
-    get: () => this.getSettings("branding"),
-    update: (body) => this.updateSettings("branding", body)
+    get: async () => extractData(
+      await this.client.GET("/v1/{workspace_id}/settings/branding", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    ),
+    update: async (body) => extractData(
+      await this.client.PUT("/v1/{workspace_id}/settings/branding", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    )
   };
   outreach = {
-    get: () => this.getSettings("outreach"),
-    update: (body) => this.updateSettings("outreach", body)
+    get: async () => extractData(
+      await this.client.GET("/v1/{workspace_id}/settings/outreach", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    ),
+    update: async (body) => extractData(
+      await this.client.PUT("/v1/{workspace_id}/settings/outreach", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    )
   };
   memory = {
-    get: () => this.getSettings("memory"),
-    update: (body) => this.updateSettings("memory", body)
+    get: async () => extractData(
+      await this.client.GET("/v1/{workspace_id}/settings/memory", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    ),
+    update: async (body) => extractData(
+      await this.client.PUT("/v1/{workspace_id}/settings/memory", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    )
   };
   security = {
-    get: () => this.getSettings("security"),
-    update: (body) => this.updateSettings("security", body)
+    get: async () => extractData(
+      await this.client.GET("/v1/{workspace_id}/settings/security", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    ),
+    update: async (body) => extractData(
+      await this.client.PUT("/v1/{workspace_id}/settings/security", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    )
   };
   retention = {
-    get: () => this.getSettings("retention"),
-    update: (body) => this.updateSettings("retention", body)
+    get: async () => extractData(
+      await this.client.GET("/v1/{workspace_id}/settings/retention", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    ),
+    update: async (body) => extractData(
+      await this.client.PUT("/v1/{workspace_id}/settings/retention", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    )
   };
   workflows = {
-    get: () => this.getSettings("workflows"),
-    update: (body) => this.updateSettings("workflows", body)
+    get: async () => extractData(
+      await this.client.GET("/v1/{workspace_id}/settings/workflows", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    ),
+    update: async (body) => extractData(
+      await this.client.PUT("/v1/{workspace_id}/settings/workflows", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    )
   };
 };
 
 // src/resources/billing.ts
 var BillingResource = class extends WorkspaceScopedResource {
-  /** Get usage summary for a time period */
-  async getUsage(params) {
-    return this.fetch(`/billing/usage${buildQuery(params)}`);
+  /** Get composite billing dashboard — KPIs, period comparison, top meters, invoice summary */
+  async getDashboard() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/billing/dashboard", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  /** Get usage summary for the workspace */
+  async getUsage() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/billing/usage", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
   }
-  /** List invoices */
+  /** Get usage time-series per meter for trend charts */
+  async getUsageTrends(params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/billing/usage/trends", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+  /** List invoices for the workspace */
   async listInvoices(params) {
-    return this.fetch(`/billing/invoices${buildQuery(params)}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/billing/invoices", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+  /** Get invoice detail */
+  async getInvoice(invoiceId) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/billing/invoices/{invoice_id}", {
+        params: { path: { workspace_id: this.workspaceId, invoice_id: invoiceId } }
+      })
+    );
+  }
+  /** Get presigned S3 URL for invoice PDF download */
+  async getInvoicePdf(invoiceId) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/billing/invoices/{invoice_id}/pdf", {
+        params: { path: { workspace_id: this.workspaceId, invoice_id: invoiceId } }
+      })
+    );
   }
 };
 
@@ -831,20 +1637,456 @@ var MemoryResource = class extends WorkspaceScopedResource {
    * Scores reflect how complete and confident each dimension's facts are.
    */
   async getEntityDimensions(entityId2) {
-    return this.fetch(`/memory/${entityId2}/dimensions`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/memory/{entity_id}/dimensions", {
+        params: { path: { workspace_id: this.workspaceId, entity_id: entityId2 } }
+      })
+    );
   }
   /**
    * Get individual memory facts for an entity, optionally filtered by dimension.
    */
   async getEntityFacts(entityId2, params) {
-    return this.fetch(`/memory/${entityId2}/facts${buildQuery(params)}`);
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/memory/{entity_id}/facts", {
+        params: {
+          path: { workspace_id: this.workspaceId, entity_id: entityId2 },
+          query: params
+        }
+      })
+    );
   }
   /**
    * Get workspace-level memory analytics — coverage rates, dimension health,
    * and fact ingestion trends.
    */
   async getAnalytics() {
-    return this.fetch("/memory/analytics");
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/memory/analytics", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+};
+
+// src/resources/personas.ts
+var PersonasResource = class extends WorkspaceScopedResource {
+  async list(params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/personas", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+  async create(body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/personas", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
+  }
+  async get(personaId2) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/personas/{persona_id}", {
+        params: { path: { workspace_id: this.workspaceId, persona_id: personaId2 } }
+      })
+    );
+  }
+  async update(personaId2, body) {
+    return extractData(
+      await this.client.PATCH("/v1/{workspace_id}/personas/{persona_id}", {
+        params: { path: { workspace_id: this.workspaceId, persona_id: personaId2 } },
+        body
+      })
+    );
+  }
+  async delete(personaId2) {
+    await this.client.DELETE("/v1/{workspace_id}/personas/{persona_id}", {
+      params: { path: { workspace_id: this.workspaceId, persona_id: personaId2 } }
+    });
+  }
+};
+
+// src/resources/review-queue.ts
+var ReviewQueueResource = class extends WorkspaceScopedResource {
+  async list(params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/review-queue", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+  async get(itemId) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/review-queue/{item_id}", {
+        params: { path: { workspace_id: this.workspaceId, item_id: itemId } }
+      })
+    );
+  }
+  async getStats() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/review-queue/stats", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  async getDashboard() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/review-queue/dashboard", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  async getMyQueue(params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/review-queue/my-queue", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+  async approve(itemId, body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/review-queue/{item_id}/approve", {
+        params: { path: { workspace_id: this.workspaceId, item_id: itemId } },
+        body
+      })
+    );
+  }
+  async reject(itemId, body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/review-queue/{item_id}/reject", {
+        params: { path: { workspace_id: this.workspaceId, item_id: itemId } },
+        body
+      })
+    );
+  }
+  async claim(itemId) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/review-queue/{item_id}/claim", {
+        params: { path: { workspace_id: this.workspaceId, item_id: itemId } }
+      })
+    );
+  }
+  async unclaim(itemId) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/review-queue/{item_id}/unclaim", {
+        params: { path: { workspace_id: this.workspaceId, item_id: itemId } }
+      })
+    );
+  }
+  async correct(itemId, body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/review-queue/{item_id}/correct", {
+        params: { path: { workspace_id: this.workspaceId, item_id: itemId } },
+        body
+      })
+    );
+  }
+  async batchApprove(body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/review-queue/batch-approve", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
+  }
+  async batchReject(body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/review-queue/batch-reject", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
+  }
+  async getHistory(params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/review-queue/history", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+  async getTrends(params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/review-queue/trends", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+  async getPerformance(params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/review-queue/performance", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+  async getCorrectionSchema(itemId) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/review-queue/{item_id}/correction-schema", {
+        params: { path: { workspace_id: this.workspaceId, item_id: itemId } }
+      })
+    );
+  }
+  async getDiff(itemId) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/review-queue/{item_id}/diff", {
+        params: { path: { workspace_id: this.workspaceId, item_id: itemId } }
+      })
+    );
+  }
+};
+
+// src/resources/recordings.ts
+var RecordingsResource = class extends WorkspaceScopedResource {
+  async getUrls(callSid) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/recordings/{call_sid}/urls", {
+        params: { path: { workspace_id: this.workspaceId, call_sid: callSid } }
+      })
+    );
+  }
+  async getMetadata(callSid) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/recordings/{call_sid}/metadata", {
+        params: { path: { workspace_id: this.workspaceId, call_sid: callSid } }
+      })
+    );
+  }
+  async download(callSid, filename) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/recordings/{call_sid}/download/{filename}", {
+        params: { path: { workspace_id: this.workspaceId, call_sid: callSid, filename } }
+      })
+    );
+  }
+};
+
+// src/resources/audit.ts
+var AuditResource = class extends WorkspaceScopedResource {
+  async list(params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/audit", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+  async getSummary(params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/audit/summary", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+  async getPhiAccess(params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/audit/phi-access", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+  async createExport(body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/audit/export", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
+  }
+  async listExports() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/audit/exports", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  async getEntityAccessLog(entityId2, params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/audit/entity/{entity_id}/access-log", {
+        params: { path: { workspace_id: this.workspaceId, entity_id: entityId2 }, query: params }
+      })
+    );
+  }
+};
+
+// src/resources/webhook-destinations.ts
+var WebhookDestinationsResource = class extends WorkspaceScopedResource {
+  async list(params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/webhook-destinations", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+  async create(body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/webhook-destinations", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
+  }
+  async get(destinationId) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/webhook-destinations/{destination_id}", {
+        params: { path: { workspace_id: this.workspaceId, destination_id: destinationId } }
+      })
+    );
+  }
+  async update(destinationId, body) {
+    return extractData(
+      await this.client.PUT("/v1/{workspace_id}/webhook-destinations/{destination_id}", {
+        params: { path: { workspace_id: this.workspaceId, destination_id: destinationId } },
+        body
+      })
+    );
+  }
+  async delete(destinationId) {
+    await this.client.DELETE("/v1/{workspace_id}/webhook-destinations/{destination_id}", {
+      params: { path: { workspace_id: this.workspaceId, destination_id: destinationId } }
+    });
+  }
+  async listDeliveries(destinationId, params) {
+    return extractData(
+      await this.client.GET(
+        "/v1/{workspace_id}/webhook-destinations/{destination_id}/deliveries",
+        {
+          params: {
+            path: { workspace_id: this.workspaceId, destination_id: destinationId },
+            query: params
+          }
+        }
+      )
+    );
+  }
+  async rotateSecret(destinationId) {
+    return extractData(
+      await this.client.POST(
+        "/v1/{workspace_id}/webhook-destinations/{destination_id}/rotate-secret",
+        {
+          params: { path: { workspace_id: this.workspaceId, destination_id: destinationId } }
+        }
+      )
+    );
+  }
+};
+
+// src/resources/safety.ts
+var SafetyResource = class extends WorkspaceScopedResource {
+  async getConfig() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/safety/config", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  async updateConfig(body) {
+    return extractData(
+      await this.client.PUT("/v1/{workspace_id}/safety/config", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
+  }
+  async listTemplates() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/safety/templates", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  async getTemplate(templateId) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/safety/templates/{template_id}", {
+        params: { path: { workspace_id: this.workspaceId, template_id: templateId } }
+      })
+    );
+  }
+  async applyTemplate(templateId, body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/safety/templates/{template_id}/apply", {
+        params: { path: { workspace_id: this.workspaceId, template_id: templateId } },
+        body
+      })
+    );
+  }
+};
+
+// src/resources/compliance.ts
+var ComplianceResource = class extends WorkspaceScopedResource {
+  async getDashboard() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/compliance/dashboard", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  async getHipaa(params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/compliance/hipaa", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+  async getAccessReview() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/compliance/access-review", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+};
+
+// src/resources/functions.ts
+var FunctionsResource = class extends WorkspaceScopedResource {
+  async list() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/functions", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  async create(body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/functions", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
+  }
+  async delete(functionName) {
+    await this.client.DELETE("/v1/{workspace_id}/functions/{function_name}", {
+      params: { path: { workspace_id: this.workspaceId, function_name: functionName } }
+    });
+  }
+  async test(functionName, body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/functions/{function_name}/test", {
+        params: { path: { workspace_id: this.workspaceId, function_name: functionName } },
+        body
+      })
+    );
+  }
+  async getCatalog() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/functions/catalog", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  async query(body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/functions/query", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
+  }
+  async sync() {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/functions/sync", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
   }
 };
 
@@ -852,7 +2094,9 @@ var MemoryResource = class extends WorkspaceScopedResource {
 var workspaceId = (id) => id;
 var apiKeyId = (id) => id;
 var agentId = (id) => id;
+var personaId = (id) => id;
 var skillId = (id) => id;
+var actionId = (id) => id;
 var serviceId = (id) => id;
 var contextGraphId = (id) => id;
 var callId = (id) => id;
@@ -862,56 +2106,80 @@ var entityId = (id) => id;
 var eventId = (id) => id;
 var simulationRunId = (id) => id;
 var simulationSessionId = (id) => id;
+var functionId = (id) => id;
 var dataSourceId = (id) => id;
 
-// src/core/utils.ts
-async function* paginate(fetcher) {
-  let token = void 0;
-  while (true) {
-    const page = await fetcher(token);
-    for (const item of page.items) {
-      yield item;
-    }
-    if (!page.has_more || page.continuation_token === null) break;
-    token = page.continuation_token;
+// src/core/rate-limit.ts
+function parseRateLimitHeaders(headers) {
+  const limit = headers.get("x-ratelimit-limit");
+  const remaining = headers.get("x-ratelimit-remaining");
+  const reset = headers.get("x-ratelimit-reset");
+  const retryAfter = headers.get("retry-after");
+  return {
+    limit: limit ? parseInt(limit, 10) : null,
+    remaining: remaining ? parseInt(remaining, 10) : null,
+    reset: reset ? new Date(parseInt(reset, 10) * 1e3) : null,
+    retryAfter: retryAfter ? parseInt(retryAfter, 10) : null
+  };
+}
+
+// src/core/webhooks.ts
+async function verifyWebhookSignature(payload, signature, secret) {
+  const encoder = new TextEncoder();
+  const key = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const mac = await crypto.subtle.sign(
+    "HMAC",
+    key,
+    typeof payload === "string" ? encoder.encode(payload) : payload
+  );
+  const expected = Array.from(new Uint8Array(mac)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return signature === `sha256=${expected}`;
+}
+async function parseWebhookEvent(payload, signature, secret) {
+  const valid = await verifyWebhookSignature(payload, signature, secret);
+  if (!valid) {
+    throw new Error("Invalid webhook signature");
   }
+  return JSON.parse(payload);
 }
 
 // src/index.ts
 var DEFAULT_BASE_URL = "https://api.platform.amigo.ai";
 var AmigoClient = class {
-  /** Workspace management */
   workspaces;
-  /** API key management */
   apiKeys;
-  /** Agent management — AI agents that handle calls */
   agents;
-  /** Skill management — reusable AI capabilities */
+  /** @deprecated Use `actions` instead */
   skills;
-  /** Service management — external service configurations */
+  actions;
+  operators;
+  triggers;
   services;
-  /** Context graph management — conversation flow structures */
   contextGraphs;
-  /** Data source management — external data connections */
   dataSources;
-  /** World model — entities, events, and timelines */
   world;
-  /** Call records and intelligence */
   calls;
-  /** Phone number provisioning and management */
   phoneNumbers;
-  /** Integration management — EHR, CRM, and other external systems */
   integrations;
-  /** Analytics — aggregate metrics about calls and conversions */
   analytics;
-  /** Simulation runs and interactive testing sessions */
   simulations;
-  /** Workspace-level settings (voice, branding, security, outreach, etc.) */
   settings;
-  /** Billing — usage summaries and invoices */
   billing;
-  /** Agent Memory — structured long-term memory for entities */
   memory;
+  personas;
+  reviewQueue;
+  recordings;
+  audit;
+  webhookDestinations;
+  safety;
+  compliance;
+  functions;
   constructor(config) {
     if (!config.apiKey || typeof config.apiKey !== "string") {
       throw new ConfigurationError("apiKey is required and must be a non-empty string");
@@ -920,27 +2188,40 @@ var AmigoClient = class {
       throw new ConfigurationError("workspaceId is required and must be a non-empty string");
     }
     const baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
-    const rc = {
+    const client = createPlatformClient({
       apiKey: config.apiKey,
       baseUrl,
-      workspaceId: config.workspaceId
-    };
-    this.workspaces = new WorkspacesResource({ apiKey: config.apiKey, baseUrl });
-    this.apiKeys = new ApiKeysResource(rc);
-    this.agents = new AgentsResource(rc);
-    this.skills = new SkillsResource(rc);
-    this.services = new ServicesResource(rc);
-    this.contextGraphs = new ContextGraphsResource(rc);
-    this.dataSources = new DataSourcesResource(rc);
-    this.world = new WorldResource(rc);
-    this.calls = new CallsResource(rc);
-    this.phoneNumbers = new PhoneNumbersResource(rc);
-    this.integrations = new IntegrationsResource(rc);
-    this.analytics = new AnalyticsResource(rc);
-    this.simulations = new SimulationsResource(rc);
-    this.settings = new SettingsResource(rc);
-    this.billing = new BillingResource(rc);
-    this.memory = new MemoryResource(rc);
+      retry: config.retry,
+      fetch: config.fetch
+    });
+    const ws = config.workspaceId;
+    this.workspaces = new WorkspacesResource(client, ws);
+    this.apiKeys = new ApiKeysResource(client, ws);
+    this.agents = new AgentsResource(client, ws);
+    this.skills = new SkillsResource(client, ws);
+    this.actions = new ActionsResource(client, ws);
+    this.operators = new OperatorsResource(client, ws);
+    this.triggers = new TriggersResource(client, ws);
+    this.services = new ServicesResource(client, ws);
+    this.contextGraphs = new ContextGraphsResource(client, ws);
+    this.dataSources = new DataSourcesResource(client, ws);
+    this.world = new WorldResource(client, ws);
+    this.calls = new CallsResource(client, ws);
+    this.phoneNumbers = new PhoneNumbersResource(client, ws);
+    this.integrations = new IntegrationsResource(client, ws);
+    this.analytics = new AnalyticsResource(client, ws);
+    this.simulations = new SimulationsResource(client, ws);
+    this.settings = new SettingsResource(client, ws);
+    this.billing = new BillingResource(client, ws);
+    this.memory = new MemoryResource(client, ws);
+    this.personas = new PersonasResource(client, ws);
+    this.reviewQueue = new ReviewQueueResource(client, ws);
+    this.recordings = new RecordingsResource(client, ws);
+    this.audit = new AuditResource(client, ws);
+    this.webhookDestinations = new WebhookDestinationsResource(client, ws);
+    this.safety = new SafetyResource(client, ws);
+    this.compliance = new ComplianceResource(client, ws);
+    this.functions = new FunctionsResource(client, ws);
   }
 };
 export {
@@ -959,6 +2240,7 @@ export {
   ServerError,
   ServiceUnavailableError,
   ValidationError,
+  actionId,
   agentId,
   apiKeyId,
   callId,
@@ -966,17 +2248,22 @@ export {
   dataSourceId,
   entityId,
   eventId,
+  functionId,
   integrationId,
   isAmigoError,
   isAuthenticationError,
   isNotFoundError,
   isRateLimitError,
   paginate,
+  parseRateLimitHeaders,
+  parseWebhookEvent,
+  personaId,
   phoneNumberId,
   serviceId,
   simulationRunId,
   simulationSessionId,
   skillId,
+  verifyWebhookSignature,
   workspaceId
 };
 //# sourceMappingURL=index.mjs.map