retell-sdk 1.15.21 → 2.2.2

package/src/lib/http.ts

@@ -0,0 +1,203 @@
+/*
+ * Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+ */
+
+export type Fetcher = (
+  input: RequestInfo | URL,
+  init?: RequestInit,
+) => Promise<Response>;
+
+const DEFAULT_FETCHER: Fetcher = (input, init) => fetch(input, init);
+
+export interface HTTPClientOptions {
+  fetcher?: Fetcher;
+}
+
+type BeforeRequestHook = (req: Request) => Request | void;
+type RequestErrorHook = (err: unknown, req: Request) => void;
+type ResponseHook = (res: Response, req: Request) => void;
+
+export class HTTPClient {
+  private fetcher: Fetcher;
+  private requestHooks: BeforeRequestHook[] = [];
+  private requestErrorHooks: RequestErrorHook[] = [];
+  private responseHooks: ResponseHook[] = [];
+
+  constructor(private options: HTTPClientOptions = {}) {
+    this.fetcher = options.fetcher || DEFAULT_FETCHER;
+  }
+
+  async request(request: Request): Promise<Response> {
+    const req = this.requestHooks.reduce((currentReq, fn) => {
+      const nextRequest = fn(currentReq);
+      return nextRequest || currentReq;
+    }, request);
+
+    try {
+      const res = await this.fetcher(req);
+      this.responseHooks.forEach((fn) => fn(res, req));
+      return res;
+    } catch (err) {
+      this.requestErrorHooks.forEach((fn) => fn(err, req));
+      throw err;
+    }
+  }
+
+  /**
+   * Registers a hook that is called before a request is made. The hook function
+   * can mutate the request or return a new request. This may be useful to add
+   * additional information to request such as request IDs and tracing headers.
+   */
+  addHook(hook: "beforeRequest", fn: BeforeRequestHook): this;
+  /**
+   * Registers a hook that is called when a request cannot be made due to a
+   * network error.
+   */
+  addHook(hook: "requestError", fn: RequestErrorHook): this;
+  /**
+   * Registers a hook that is called when a response has been received from the
+   * server.
+   */
+  addHook(hook: "response", fn: ResponseHook): this;
+  addHook(
+    ...args:
+      | [hook: "beforeRequest", fn: BeforeRequestHook]
+      | [hook: "requestError", fn: RequestErrorHook]
+      | [hook: "response", fn: ResponseHook]
+  ) {
+    if (args[0] === "beforeRequest") {
+      this.requestHooks.push(args[1]);
+    } else if (args[0] === "requestError") {
+      this.requestErrorHooks.push(args[1]);
+    } else if (args[0] === "response") {
+      this.responseHooks.push(args[1]);
+    } else {
+      throw new Error(`Invalid hook type: ${args[0]}`);
+    }
+    return this;
+  }
+
+  /** Removes a hook that was previously registered with `addHook`. */
+  removeHook(hook: "beforeRequest", fn: BeforeRequestHook): this;
+  /** Removes a hook that was previously registered with `addHook`. */
+  removeHook(hook: "requestError", fn: RequestErrorHook): this;
+  /** Removes a hook that was previously registered with `addHook`. */
+  removeHook(hook: "response", fn: ResponseHook): this;
+  removeHook(
+    ...args:
+      | [hook: "beforeRequest", fn: BeforeRequestHook]
+      | [hook: "requestError", fn: RequestErrorHook]
+      | [hook: "response", fn: ResponseHook]
+  ) {
+    let target: unknown[];
+    if (args[0] === "beforeRequest") {
+      target = this.requestHooks;
+    } else if (args[0] === "requestError") {
+      target = this.requestErrorHooks;
+    } else if (args[0] === "response") {
+      target = this.responseHooks;
+    } else {
+      throw new Error(`Invalid hook type: ${args[0]}`);
+    }
+
+    const index = target.findIndex((v) => v === args[1]);
+    if (index >= 0) {
+      target.splice(index, 1);
+    }
+
+    return this;
+  }
+
+  clone() {
+    const child = new HTTPClient(this.options);
+    child.requestHooks = this.requestHooks.slice();
+    child.requestErrorHooks = this.requestErrorHooks.slice();
+    child.responseHooks = this.responseHooks.slice();
+
+    return child;
+  }
+}
+
+export function matchContentType(response: Response, pattern: string): boolean {
+  if (pattern === "*" || pattern === "*/*") {
+    return true;
+  }
+
+  const contentType =
+    response.headers.get("content-type") ?? "application/octet-stream";
+
+  const idx = contentType.split(";").findIndex((raw) => {
+    const ctype = raw.trim();
+    if (ctype === pattern) {
+      return true;
+    }
+
+    const parts = ctype.split("/");
+    if (parts.length !== 2) {
+      return false;
+    }
+
+    return `${parts[0]}/*` === pattern || `*/${parts[1]}` === pattern;
+  });
+
+  return idx >= 0;
+}
+
+const codeRangeRE = new RegExp("^[0-9]xx$", "i");
+
+export function matchStatusCode(
+  response: Response,
+  codes: number | string | (number | string)[],
+) {
+  const actual = `${response.status}`;
+  const expectedCodes = Array.isArray(codes) ? codes : [codes];
+  if (!expectedCodes.length) {
+    return false;
+  }
+
+  return expectedCodes.some((ec) => {
+    const code = `${ec}`;
+
+    if (code === "default") {
+      return true;
+    }
+
+    if (!codeRangeRE.test(`${code}`)) {
+      return code === actual;
+    }
+
+    const expectFamily = code.charAt(0);
+    if (!expectFamily) {
+      throw new Error("Invalid status code range");
+    }
+
+    const actualFamily = actual.charAt(0);
+    if (!actualFamily) {
+      throw new Error(`Invalid response status code: ${actual}`);
+    }
+
+    return actualFamily === expectFamily;
+  });
+}
+
+export function matchResponse(
+  response: Response,
+  code: number | string | (number | string)[],
+  contentTypePattern: string,
+): boolean {
+  return (
+    matchStatusCode(response, code) &&
+    matchContentType(response, contentTypePattern)
+  );
+}
+
+const headerValRE = /, */;
+export function unpackHeaders(headers: Headers): Record<string, string[]> {
+  const out: Record<string, string[]> = {};
+
+  for (const [k, v] of headers.entries()) {
+    out[k] = v.split(headerValRE);
+  }
+
+  return out;
+}

package/src/lib/retries.ts

@@ -0,0 +1,207 @@
+/*
+ * Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+ */
+
+export type BackoffStrategy = {
+  initialInterval: number;
+  maxInterval: number;
+  exponent: number;
+  maxElapsedTime: number;
+};
+
+const defaultBackoff: BackoffStrategy = {
+  initialInterval: 500,
+  maxInterval: 60000,
+  exponent: 1.5,
+  maxElapsedTime: 3600000,
+};
+
+export type RetryConfig =
+  | { strategy: "none" }
+  | {
+      strategy: "backoff";
+      backoff?: BackoffStrategy;
+      retryConnectionErrors?: boolean;
+    };
+
+class PermanentError extends Error {
+  inner: unknown;
+
+  constructor(inner: unknown) {
+    super("Permanent error");
+    this.inner = inner;
+
+    Object.setPrototypeOf(this, PermanentError.prototype);
+  }
+}
+
+class TemporaryError extends Error {
+  res: Response;
+
+  constructor(res: Response) {
+    super("Temporary error");
+    this.res = res;
+
+    Object.setPrototypeOf(this, TemporaryError.prototype);
+  }
+}
+
+export async function retry(
+  fetchFn: () => Promise<Response>,
+  options: {
+    config: RetryConfig;
+    statusCodes: string[];
+  },
+): Promise<Response> {
+  switch (options.config.strategy) {
+    case "backoff":
+      return retryBackoff(
+        wrapFetcher(fetchFn, {
+          statusCodes: options.statusCodes,
+          retryConnectionErrors: !!options.config.retryConnectionErrors,
+        }),
+        options.config.backoff ?? defaultBackoff,
+      );
+    default:
+      return await fetchFn();
+  }
+}
+
+function wrapFetcher(
+  fn: () => Promise<Response>,
+  options: {
+    statusCodes: string[];
+    retryConnectionErrors: boolean;
+  },
+): () => Promise<Response> {
+  return async () => {
+    try {
+      const res = await fn();
+      if (isRetryableResponse(res, options.statusCodes)) {
+        throw new TemporaryError(res);
+      }
+
+      return res;
+    } catch (err) {
+      if (err instanceof TemporaryError) {
+        throw err;
+      }
+
+      if (
+        options.retryConnectionErrors &&
+        (isTimeoutError(err) || isConnectionError(err))
+      ) {
+        throw err;
+      }
+
+      throw new PermanentError(err);
+    }
+  };
+}
+
+function isConnectionError(err: unknown) {
+  if (typeof err !== "object" || err == null) {
+    return false;
+  }
+
+  // Covers fetch in Deno as well
+  const isBrowserErr =
+    err instanceof TypeError &&
+    err.message.toLowerCase().startsWith("failed to fetch");
+
+  const isNodeErr =
+    err instanceof TypeError &&
+    err.message.toLowerCase().startsWith("fetch failed");
+
+  const isBunErr = "name" in err && err.name === "ConnectionError";
+
+  const isGenericErr =
+    "code" in err &&
+    typeof err.code === "string" &&
+    err.code.toLowerCase() === "econnreset";
+
+  return isBrowserErr || isNodeErr || isGenericErr || isBunErr;
+}
+
+function isTimeoutError(err: unknown) {
+  if (typeof err !== "object" || err == null) {
+    return false;
+  }
+
+  // Fetch in browser, Node.js, Bun, Deno
+  const isNative = "name" in err && err.name === "TimeoutError";
+
+  // Node.js HTTP client and Axios
+  const isGenericErr =
+    "code" in err &&
+    typeof err.code === "string" &&
+    err.code.toLowerCase() === "econnaborted";
+
+  return isNative || isGenericErr;
+}
+
+const codeRangeRE = new RegExp("^[0-9]xx$", "i");
+
+function isRetryableResponse(res: Response, statusCodes: string[]): boolean {
+  const actual = `${res.status}`;
+
+  return statusCodes.some((code) => {
+    if (!codeRangeRE.test(code)) {
+      return code === actual;
+    }
+
+    const expectFamily = code.charAt(0);
+    if (!expectFamily) {
+      throw new Error("Invalid status code range");
+    }
+
+    const actualFamily = actual.charAt(0);
+    if (!actualFamily) {
+      throw new Error(`Invalid response status code: ${actual}`);
+    }
+
+    return actualFamily === expectFamily;
+  });
+}
+
+async function retryBackoff(
+  fn: () => Promise<Response>,
+  strategy: BackoffStrategy,
+): Promise<Response> {
+  const { maxElapsedTime, initialInterval, exponent, maxInterval } = strategy;
+
+  const start = Date.now();
+  let x = 0;
+
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    try {
+      const res = await fn();
+      return res;
+    } catch (err) {
+      if (err instanceof PermanentError) {
+        throw err.inner;
+      }
+      const elapsed = Date.now() - start;
+      if (elapsed > maxElapsedTime) {
+        if (err instanceof TemporaryError) {
+          return err.res;
+        }
+
+        throw err;
+      }
+
+      const d = Math.min(
+        initialInterval * Math.pow(x, exponent) + Math.random() * 1000,
+        maxInterval,
+      );
+
+      await delay(d);
+      x++;
+    }
+  }
+}
+
+async function delay(delay: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, delay));
+}

package/src/lib/sdks.ts

@@ -0,0 +1,107 @@
+/*
+ * Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+ */
+
+import { HTTPClient, matchResponse, matchStatusCode, unpackHeaders } from "./http";
+import { SecurityState, resolveSecurity, resolveGlobalSecurity } from "./security";
+import { pathToFunc } from "./url";
+import { encodeForm } from "./encodings";
+import { stringToBase64 } from "./base64";
+
+export type RequestOptions = {
+    fetchOptions?: Omit<RequestInit, "method" | "body">;
+};
+
+type RequestConfig = {
+    method: string;
+    path: string;
+    baseURL?: string | URL;
+    query?: string;
+    body?: RequestInit["body"];
+    headers?: HeadersInit;
+    security?: SecurityState | null;
+};
+
+export class ClientSDK {
+    readonly #client: HTTPClient;
+    protected readonly baseURL: URL;
+
+    constructor(init: { client: HTTPClient; baseURL: URL }) {
+        const url = init.baseURL;
+        url.pathname = url.pathname.replace(/\/+$/, "") + "/";
+
+        this.#client = init.client;
+        this.baseURL = url;
+    }
+
+    protected async fetch$(conf: RequestConfig, options?: RequestOptions) {
+        const { method, path, query, headers: opHeaders, security } = conf;
+
+        const reqURL = new URL(conf.baseURL ?? this.baseURL);
+        const inputURL = new URL(path, reqURL);
+
+        if (path) {
+            reqURL.pathname += inputURL.pathname.replace(/^\/+/, "");
+        }
+
+        let finalQuery = query || "";
+
+        const secQuery: string[] = [];
+        for (const [k, v] of Object.entries(security?.queryParams || {})) {
+            secQuery.push(encodeForm(k, v, { charEncoding: "percent" }));
+        }
+        if (secQuery.length) {
+            finalQuery += `&${secQuery.join("&")}`;
+        }
+
+        if (finalQuery) {
+            const q = finalQuery.startsWith("&") ? finalQuery.slice(1) : finalQuery;
+            reqURL.search = `?${q}`;
+        }
+
+        const headers = new Headers(opHeaders);
+
+        const username = security?.basic.username || "";
+        const password = security?.basic.password || "";
+        if (username) {
+            const encoded = stringToBase64([username, password].join(":"));
+            headers.set("Authorization", `Basic ${encoded}`);
+        }
+
+        const securityHeaders = new Headers(security?.headers || {});
+        for (const [k, v] of securityHeaders) {
+            headers.set(k, v);
+        }
+
+        let cookie = headers.get("cookie") || "";
+        for (const [k, v] of Object.entries(security?.cookies || {})) {
+            cookie += `; ${k}=${v}`;
+        }
+        cookie = cookie.startsWith("; ") ? cookie.slice(2) : cookie;
+        headers.set("cookie", cookie);
+
+        const userHeaders = new Headers(options?.fetchOptions?.headers);
+        for (const [k, v] of userHeaders) {
+            headers.set(k, v);
+        }
+
+        const req = new Request(reqURL, {
+            ...options?.fetchOptions,
+            body: conf.body ?? null,
+            headers,
+            method,
+        });
+
+        return this.#client.request(req);
+    }
+
+    protected unpackHeaders = unpackHeaders;
+
+    protected matchStatusCode = matchStatusCode;
+    protected matchResponse = matchResponse;
+
+    protected templateURLComponent = pathToFunc;
+
+    protected resolveSecurity = resolveSecurity;
+    protected resolveGlobalSecurity = resolveGlobalSecurity;
+}

package/src/lib/security.ts

@@ -0,0 +1,164 @@
+/*
+ * Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+ */
+
+import * as components from "../models/components";
+
+export enum SecurityErrorCode {
+    Incomplete = "incomplete",
+    UnrecognisedSecurityType = "unrecognized_security_type",
+}
+
+export class SecurityError extends Error {
+    constructor(public code: SecurityErrorCode, message: string, options?: ErrorOptions) {
+        super(message, options);
+        this.name = "SecurityError";
+    }
+
+    static incomplete(): SecurityError {
+        return new SecurityError(
+            SecurityErrorCode.Incomplete,
+            "Security requirements not met in order to perform the operation"
+        );
+    }
+    static unrecognizedType(type: string): SecurityError {
+        return new SecurityError(
+            SecurityErrorCode.UnrecognisedSecurityType,
+            `Unrecognised security type: ${type}`
+        );
+    }
+}
+
+export type SecurityState = {
+    basic: { username: string; password?: string };
+    headers: Record<string, string>;
+    queryParams: Record<string, string>;
+    cookies: Record<string, string>;
+};
+
+type SecurityInputBasicPacked = {
+    type: "http:basic";
+    value: { username: string; password?: string } | null | undefined;
+};
+
+type SecurityInputBasic = {
+    type: "http:basic";
+    value: string | null | undefined;
+    fieldName: "username" | "password";
+};
+
+type SecurityInputBearer = {
+    type: "http:bearer";
+    value: string | null | undefined;
+    fieldName: string;
+};
+
+type SecurityInputAPIKey = {
+    type: "apiKey:header" | "apiKey:query" | "apiKey:cookie";
+    value: string | null | undefined;
+    fieldName: string;
+};
+
+type SecurityInputOIDC = {
+    type: "openIdConnect";
+    value: string | null | undefined;
+    fieldName: string;
+};
+
+type SecurityInputOAuth2 = {
+    type: "oauth2";
+    value: string | null | undefined;
+    fieldName: string;
+};
+
+export type SecurityInput =
+    | SecurityInputBasic
+    | SecurityInputBasicPacked
+    | SecurityInputBearer
+    | SecurityInputAPIKey
+    | SecurityInputOAuth2
+    | SecurityInputOIDC;
+
+export function resolveSecurity(...options: SecurityInput[][]): SecurityState | null {
+    const state: SecurityState = {
+        basic: { username: "", password: "" },
+        headers: {},
+        queryParams: {},
+        cookies: {},
+    };
+
+    const option = options.find((opts) => opts.every((o) => Boolean(o.value)));
+    if (option == null) {
+        return null;
+    }
+
+    option.forEach((spec) => {
+        if (spec.value == null) {
+            return;
+        }
+
+        const { type } = spec;
+
+        switch (type) {
+            case "apiKey:header":
+                state.headers[spec.fieldName] = spec.value;
+                break;
+            case "apiKey:query":
+                state.queryParams[spec.fieldName] = spec.value;
+                break;
+            case "apiKey:cookie":
+                state.cookies[spec.fieldName] = spec.value;
+                break;
+            case "http:basic":
+                applyBasic(state, spec);
+                break;
+            case "http:bearer":
+                applyBearer(state, spec);
+                break;
+            case "oauth2":
+                applyBearer(state, spec);
+                break;
+            case "openIdConnect":
+                applyBearer(state, spec);
+                break;
+            default:
+                spec satisfies never;
+                throw SecurityError.unrecognizedType(type);
+        }
+    });
+
+    return state;
+}
+
+function applyBasic(state: SecurityState, spec: SecurityInputBasic | SecurityInputBasicPacked) {
+    if (spec.value == null) {
+        return;
+    }
+
+    if ("fieldName" in spec) {
+        state.basic[spec.fieldName] = spec.value;
+    } else {
+        state.basic = spec.value;
+    }
+}
+
+function applyBearer(
+    state: SecurityState,
+    spec: SecurityInputBearer | SecurityInputOAuth2 | SecurityInputOIDC
+) {
+    if (spec.value == null) {
+        return;
+    }
+
+    let value = spec.value;
+    if (value.slice(0, 7).toLowerCase() !== "bearer ") {
+        value = `Bearer ${value}`;
+    }
+
+    state.headers[spec.fieldName] = value;
+}
+export function resolveGlobalSecurity(security: Partial<components.Security> | null | undefined) {
+    return resolveSecurity([
+        { value: security?.apiKey, fieldName: "Authorization", type: "http:bearer" },
+    ]);
+}

package/src/lib/url.ts

@@ -0,0 +1,31 @@
+/*
+ * Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+ */
+
+const hasOwn = Object.prototype.hasOwnProperty;
+
+export function pathToFunc(
+  pathPattern: string,
+  options?: { charEncoding?: "percent" | "none" },
+): (params?: Record<string, string | number>) => string {
+  const paramRE = /\{([a-zA-Z0-9_]+?)\}/g;
+
+  return function buildURLPath(params: Record<string, unknown> = {}): string {
+    return pathPattern.replace(paramRE, function (_, placeholder) {
+      if (!hasOwn.call(params, placeholder)) {
+        throw new Error(`Parameter '${placeholder}' is required`);
+      }
+
+      const value = params[placeholder];
+      if (typeof value !== "string" && typeof value !== "number") {
+        throw new Error(
+          `Parameter '${placeholder}' must be a string or number`,
+        );
+      }
+
+      return options?.charEncoding === "percent"
+        ? encodeURIComponent(`${value}`)
+        : `${value}`;
+    });
+  };
+}