syllable-sdk 0.1.0-alpha → 0.1.0-alpha.2

package/src/funcs/{organizationsList.ts → v1Create.ts}

@@ -2,9 +2,10 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
-import * as z from "zod";
 import { SyllableSDKCore } from "../core.js";
+import { encodeJSON } from "../lib/encodings.js";
 import * as M from "../lib/matchers.js";
+import { safeParse } from "../lib/schemas.js";
 import { RequestOptions } from "../lib/sdks.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
@@ -16,22 +17,25 @@ import {
   RequestTimeoutError,
   UnexpectedClientError,
 } from "../models/errors/httpclienterrors.js";
+import * as errors from "../models/errors/index.js";
 import { SDKError } from "../models/errors/sdkerror.js";
 import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
 import { Result } from "../types/fp.js";
 
 /**
- * Organizations List
+ * Create Label
  *
  * @remarks
- * List all organizations
+ * Create a new label
  */
-export async function organizationsList(
+export async function v1Create(
   client: SyllableSDKCore,
+  request: components.SessionLabelCreate,
   options?: RequestOptions,
 ): Promise<
   Result<
-    Array<components.Organization>,
+    components.SessionLabel,
+    | errors.HTTPValidationError
     | SDKError
     | SDKValidationError
     | UnexpectedClientError
@@ -41,26 +45,47 @@ export async function organizationsList(
     | ConnectionError
   >
 > {
-  const path = pathToFunc("/api/v1/organizations/")();
+  const parsed = safeParse(
+    request,
+    (value) => components.SessionLabelCreate$outboundSchema.parse(value),
+    "Input validation failed",
+  );
+  if (!parsed.ok) {
+    return parsed;
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload, { explode: true });
+
+  const path = pathToFunc("/api/v1/session_labels/")();
 
   const headers = new Headers({
+    "Content-Type": "application/json",
     Accept: "application/json",
   });
 
   const secConfig = await extractSecurity(client._options.apiKeyHeader);
   const securityInput = secConfig == null ? {} : { apiKeyHeader: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
   const context = {
-    operationID: "organizations_list",
+    operationID: "session_label_create",
     oAuth2Scopes: [],
+
+    resolvedSecurity: requestSecurity,
+
     securitySource: client._options.apiKeyHeader,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
   };
-  const requestSecurity = resolveGlobalSecurity(securityInput);
 
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "GET",
+    method: "POST",
     path: path,
     headers: headers,
+    body: body,
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
   }, options);
   if (!requestRes.ok) {
@@ -70,18 +95,22 @@ export async function organizationsList(
 
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["4XX", "5XX"],
-    retryConfig: options?.retries
-      || client._options.retryConfig,
-    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+    errorCodes: ["422", "4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
   });
   if (!doResult.ok) {
     return doResult;
   }
   const response = doResult.value;
 
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req },
+  };
+
   const [result] = await M.match<
-    Array<components.Organization>,
+    components.SessionLabel,
+    | errors.HTTPValidationError
     | SDKError
     | SDKValidationError
     | UnexpectedClientError
@@ -90,9 +119,10 @@ export async function organizationsList(
     | RequestTimeoutError
     | ConnectionError
   >(
-    M.json(200, z.array(components.Organization$inboundSchema)),
+    M.json(200, components.SessionLabel$inboundSchema),
+    M.jsonErr(422, errors.HTTPValidationError$inboundSchema),
     M.fail(["4XX", "5XX"]),
-  )(response);
+  )(response, { extraFields: responseFields });
   if (!result.ok) {
     return result;
   }

package/src/funcs/{conversationsGetById.ts → v1GetById.ts}

@@ -24,15 +24,15 @@ import * as operations from "../models/operations/index.js";
 import { Result } from "../types/fp.js";
 
 /**
- * Get Conversation By Id
+ * Get Label By Id
  */
-export async function conversationsGetById(
+export async function v1GetById(
   client: SyllableSDKCore,
-  request: operations.ConversationGetByIdRequest,
+  request: operations.SessionLabelGetByIdRequest,
   options?: RequestOptions,
 ): Promise<
   Result<
-    components.ConversationTranscriptionResponse,
+    components.SessionLabel,
     | errors.HTTPValidationError
     | SDKError
     | SDKValidationError
@@ -46,7 +46,7 @@ export async function conversationsGetById(
   const parsed = safeParse(
     request,
     (value) =>
-      operations.ConversationGetByIdRequest$outboundSchema.parse(value),
+      operations.SessionLabelGetByIdRequest$outboundSchema.parse(value),
     "Input validation failed",
   );
   if (!parsed.ok) {
@@ -56,13 +56,14 @@ export async function conversationsGetById(
   const body = null;
 
   const pathParams = {
-    conversation_id: encodeSimple("conversation_id", payload.conversation_id, {
-      explode: false,
-      charEncoding: "percent",
-    }),
+    session_label_id: encodeSimple(
+      "session_label_id",
+      payload.session_label_id,
+      { explode: false, charEncoding: "percent" },
+    ),
   };
 
-  const path = pathToFunc("/api/v1/conversations/{conversation_id}")(
+  const path = pathToFunc("/api/v1/session_labels/{session_label_id}")(
     pathParams,
   );
 
@@ -72,12 +73,20 @@ export async function conversationsGetById(
 
   const secConfig = await extractSecurity(client._options.apiKeyHeader);
   const securityInput = secConfig == null ? {} : { apiKeyHeader: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
   const context = {
-    operationID: "conversation_get_by_id",
+    operationID: "session_label_get_by_id",
     oAuth2Scopes: [],
+
+    resolvedSecurity: requestSecurity,
+
     securitySource: client._options.apiKeyHeader,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
   };
-  const requestSecurity = resolveGlobalSecurity(securityInput);
 
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
@@ -95,9 +104,8 @@ export async function conversationsGetById(
   const doResult = await client._do(req, {
     context,
     errorCodes: ["422", "4XX", "5XX"],
-    retryConfig: options?.retries
-      || client._options.retryConfig,
-    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
   });
   if (!doResult.ok) {
     return doResult;
@@ -109,7 +117,7 @@ export async function conversationsGetById(
   };
 
   const [result] = await M.match<
-    components.ConversationTranscriptionResponse,
+    components.SessionLabel,
     | errors.HTTPValidationError
     | SDKError
     | SDKValidationError
@@ -119,7 +127,7 @@ export async function conversationsGetById(
     | RequestTimeoutError
     | ConnectionError
   >(
-    M.json(200, components.ConversationTranscriptionResponse$inboundSchema),
+    M.json(200, components.SessionLabel$inboundSchema),
     M.jsonErr(422, errors.HTTPValidationError$inboundSchema),
     M.fail(["4XX", "5XX"]),
   )(response, { extraFields: responseFields });

package/src/funcs/v1List.ts

@@ -0,0 +1,141 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { SyllableSDKCore } from "../core.js";
+import { encodeFormQuery } from "../lib/encodings.js";
+import * as M from "../lib/matchers.js";
+import { safeParse } from "../lib/schemas.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.js";
+import * as components from "../models/components/index.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../models/errors/httpclienterrors.js";
+import * as errors from "../models/errors/index.js";
+import { SDKError } from "../models/errors/sdkerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as operations from "../models/operations/index.js";
+import { Result } from "../types/fp.js";
+
+/**
+ * Session Labels List
+ */
+export async function v1List(
+  client: SyllableSDKCore,
+  request: operations.SessionLabelsListRequest,
+  options?: RequestOptions,
+): Promise<
+  Result<
+    components.ListResponseSessionLabel,
+    | errors.HTTPValidationError
+    | SDKError
+    | SDKValidationError
+    | UnexpectedClientError
+    | InvalidRequestError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | ConnectionError
+  >
+> {
+  const parsed = safeParse(
+    request,
+    (value) => operations.SessionLabelsListRequest$outboundSchema.parse(value),
+    "Input validation failed",
+  );
+  if (!parsed.ok) {
+    return parsed;
+  }
+  const payload = parsed.value;
+  const body = null;
+
+  const path = pathToFunc("/api/v1/session_labels/")();
+
+  const query = encodeFormQuery({
+    "end_datetime": payload.end_datetime,
+    "fields": payload.fields,
+    "limit": payload.limit,
+    "order_by": payload.order_by,
+    "order_by_direction": payload.order_by_direction,
+    "page": payload.page,
+    "search_field_values": payload.search_field_values,
+    "search_fields": payload.search_fields,
+    "start_datetime": payload.start_datetime,
+  });
+
+  const headers = new Headers({
+    Accept: "application/json",
+  });
+
+  const secConfig = await extractSecurity(client._options.apiKeyHeader);
+  const securityInput = secConfig == null ? {} : { apiKeyHeader: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
+  const context = {
+    operationID: "session_labels_list",
+    oAuth2Scopes: [],
+
+    resolvedSecurity: requestSecurity,
+
+    securitySource: client._options.apiKeyHeader,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+  };
+
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    path: path,
+    headers: headers,
+    query: query,
+    body: body,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+  }, options);
+  if (!requestRes.ok) {
+    return requestRes;
+  }
+  const req = requestRes.value;
+
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["422", "4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
+  });
+  if (!doResult.ok) {
+    return doResult;
+  }
+  const response = doResult.value;
+
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req },
+  };
+
+  const [result] = await M.match<
+    components.ListResponseSessionLabel,
+    | errors.HTTPValidationError
+    | SDKError
+    | SDKValidationError
+    | UnexpectedClientError
+    | InvalidRequestError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | ConnectionError
+  >(
+    M.json(200, components.ListResponseSessionLabel$inboundSchema),
+    M.jsonErr(422, errors.HTTPValidationError$inboundSchema),
+    M.fail(["4XX", "5XX"]),
+  )(response, { extraFields: responseFields });
+  if (!result.ok) {
+    return result;
+  }
+
+  return result;
+}

package/src/hooks/hooks.ts

@@ -17,8 +17,6 @@ import {
   SDKInitOptions,
 } from "./types.js";
 
-import { initHooks } from "./registration.js";
-
 export class SDKHooks implements Hooks {
   sdkInitHooks: SDKInitHook[] = [];
   beforeCreateRequestHooks: BeforeCreateRequestHook[] = [];
@@ -27,7 +25,6 @@ export class SDKHooks implements Hooks {
   afterErrorHooks: AfterErrorHook[] = [];
 
   constructor() {
-    initHooks(this);
   }
 
   registerSDKInitHook(hook: SDKInitHook) {

package/src/hooks/types.ts

@@ -3,11 +3,15 @@
  */
 
 import { HTTPClient, RequestInput } from "../lib/http.js";
+import { RetryConfig } from "../lib/retries.js";
+import { SecurityState } from "../lib/security.js";
 
 export type HookContext = {
   operationID: string;
   oAuth2Scopes?: string[];
   securitySource?: any | (() => Promise<any>);
+  retryConfig: RetryConfig;
+  resolvedSecurity: SecurityState | null;
 };
 
 export type Awaitable<T> = T | Promise<T>;

package/src/lib/config.ts

@@ -11,7 +11,14 @@ import { Params, pathToFunc } from "./url.js";
  * Contains the list of servers available to the SDK
  */
 export const ServerList = [
-  "http://127.0.0.1:8001",
+  /**
+   * dev server
+   */
+  "http://localhost:8001",
+  /**
+   * dev / port-forwarding server
+   */
+  "http://localhost:8001",
 ] as const;
 
 export type SDKOptions = {
@@ -54,7 +61,8 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "0.0.2",
-  sdkVersion: "0.1.0-alpha",
-  genVersion: "2.438.15",
-  userAgent: "speakeasy-sdk/typescript 0.1.0-alpha 2.438.15 0.0.2 syllable-sdk",
+  sdkVersion: "0.1.0-alpha.2",
+  genVersion: "2.457.2",
+  userAgent:
+    "speakeasy-sdk/typescript 0.1.0-alpha.2 2.457.2 0.0.2 syllable-sdk",
 } as const;

package/src/lib/env.ts

@@ -13,11 +13,10 @@ export interface Env {
 }
 
 export const envSchema: z.ZodType<Env, z.ZodTypeDef, unknown> = z.object({
-  SYLLABLESDK_API_KEY_HEADER: z.string(),
+  SYLLABLESDK_API_KEY_HEADER: z.string().optional(),
 
-  SYLLABLESDK_DEBUG: z.coerce.boolean(),
-})
-  .partial();
+  SYLLABLESDK_DEBUG: z.coerce.boolean().optional(),
+});
 
 let envMemo: Env | undefined = undefined;
 /**

package/src/lib/primitives.ts

@@ -2,6 +2,26 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
+class InvariantError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "InvariantError";
+  }
+}
+
+export function invariant(
+  condition: unknown,
+  message: string,
+): asserts condition {
+  if (!condition) {
+    throw new InvariantError(message);
+  }
+}
+
+export type ExactPartial<T> = {
+  [P in keyof T]?: T[P] | undefined;
+};
+
 export type Remap<Inp, Mapping extends { [k in keyof Inp]?: string | null }> = {
   [k in keyof Inp as Mapping[k] extends string /* if we have a string mapping for this key then use it */
     ? Mapping[k]

package/src/lib/retries.ts

@@ -26,23 +26,44 @@ export type RetryConfig =
       retryConnectionErrors?: boolean;
     };
 
-class PermanentError extends Error {
-  inner: unknown;
+/**
+ * PermanentError is an error that is not recoverable. Throwing this error will
+ * cause a retry loop to terminate.
+ */
+export class PermanentError extends Error {
+  /** The underlying cause of the error. */
+  override readonly cause: unknown;
+
+  constructor(message: string, options?: { cause?: unknown }) {
+    let msg = message;
+    if (options?.cause) {
+      msg += `: ${options.cause}`;
+    }
 
-  constructor(inner: unknown) {
-    super("Permanent error");
-    this.inner = inner;
+    super(msg, options);
+    this.name = "PermanentError";
+    // In older runtimes, the cause field would not have been assigned through
+    // the super() call.
+    if (typeof this.cause === "undefined") {
+      this.cause = options?.cause;
+    }
 
     Object.setPrototypeOf(this, PermanentError.prototype);
   }
 }
 
-class TemporaryError extends Error {
-  res: Response;
+/**
+ * TemporaryError is an error is used to signal that an HTTP request can be
+ * retried as part of a retry loop. If retry attempts are exhausted and this
+ * error is thrown, the response will be returned to the caller.
+ */
+export class TemporaryError extends Error {
+  response: Response;
 
-  constructor(res: Response) {
-    super("Temporary error");
-    this.res = res;
+  constructor(message: string, response: Response) {
+    super(message);
+    this.response = response;
+    this.name = "TemporaryError";
 
     Object.setPrototypeOf(this, TemporaryError.prototype);
   }
@@ -80,11 +101,14 @@ function wrapFetcher(
     try {
       const res = await fn();
       if (isRetryableResponse(res, options.statusCodes)) {
-        throw new TemporaryError(res);
+        throw new TemporaryError(
+          "Response failed with retryable status code",
+          res,
+        );
       }
 
       return res;
-    } catch (err) {
+    } catch (err: unknown) {
       if (err instanceof TemporaryError) {
         throw err;
       }
@@ -96,7 +120,7 @@ function wrapFetcher(
         throw err;
       }
 
-      throw new PermanentError(err);
+      throw new PermanentError("Permanent error", { cause: err });
     }
   };
 }
@@ -139,37 +163,25 @@ async function retryBackoff(
     try {
       const res = await fn();
       return res;
-    } catch (err) {
+    } catch (err: unknown) {
       if (err instanceof PermanentError) {
-        throw err.inner;
+        throw err.cause;
       }
       const elapsed = Date.now() - start;
       if (elapsed > maxElapsedTime) {
         if (err instanceof TemporaryError) {
-          return err.res;
+          return err.response;
         }
 
         throw err;
       }
 
       let retryInterval = 0;
-      if (err instanceof TemporaryError && err.res && err.res.headers) {
-        const retryVal = err.res.headers.get("retry-after") || "";
-        if (retryVal != "") {
-          const parsedNumber = Number(retryVal);
-          if (!isNaN(parsedNumber) && Number.isInteger(parsedNumber)) {
-            retryInterval = parsedNumber * 1000;
-          } else {
-            const parsedDate = Date.parse(retryVal);
-            if (!isNaN(parsedDate)) {
-              const deltaMS = parsedDate - Date.now();
-              retryInterval = deltaMS > 0 ? Math.ceil(deltaMS) : 0;
-            }
-          }
-        }
+      if (err instanceof TemporaryError) {
+        retryInterval = retryIntervalFromResponse(err.response);
       }
 
-      if (retryInterval == 0) {
+      if (retryInterval <= 0) {
         retryInterval =
           initialInterval * Math.pow(x, exponent) + Math.random() * 1000;
       }
@@ -182,6 +194,26 @@ async function retryBackoff(
   }
 }
 
+function retryIntervalFromResponse(res: Response): number {
+  const retryVal = res.headers.get("retry-after") || "";
+  if (!retryVal) {
+    return 0;
+  }
+
+  const parsedNumber = Number(retryVal);
+  if (Number.isInteger(parsedNumber)) {
+    return parsedNumber * 1000;
+  }
+
+  const parsedDate = Date.parse(retryVal);
+  if (Number.isInteger(parsedDate)) {
+    const deltaMS = parsedDate - Date.now();
+    return deltaMS > 0 ? Math.ceil(deltaMS) : 0;
+  }
+
+  return 0;
+}
+
 async function delay(delay: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, delay));
 }

package/src/lib/sdks.ts

@@ -224,8 +224,8 @@ export class ClientSDK {
     options: {
       context: HookContext;
       errorCodes: number | string | (number | string)[];
-      retryConfig?: RetryConfig | undefined;
-      retryCodes?: string[] | undefined;
+      retryConfig: RetryConfig;
+      retryCodes: string[];
     },
   ): Promise<
     Result<
@@ -237,8 +237,6 @@ export class ClientSDK {
     >
   > {
     const { context, errorCodes } = options;
-    const retryConfig = options.retryConfig || { strategy: "none" };
-    const retryCodes = options.retryCodes || [];
 
     return retry(
       async () => {
@@ -249,22 +247,28 @@ export class ClientSDK {
 
         let response = await this.#httpClient.request(req);
 
-        if (matchStatusCode(response, errorCodes)) {
-          const result = await this.#hooks.afterError(context, response, null);
-          if (result.error) {
-            throw result.error;
+        try {
+          if (matchStatusCode(response, errorCodes)) {
+            const result = await this.#hooks.afterError(
+              context,
+              response,
+              null,
+            );
+            if (result.error) {
+              throw result.error;
+            }
+            response = result.response || response;
+          } else {
+            response = await this.#hooks.afterSuccess(context, response);
           }
-          response = result.response || response;
-        } else {
-          response = await this.#hooks.afterSuccess(context, response);
+        } finally {
+          await logResponse(this.#logger, response, req)
+            .catch(e => this.#logger?.log("Failed to log response:", e));
         }
 
-        await logResponse(this.#logger, response, req)
-          .catch(e => this.#logger?.log("Failed to log response:", e));
-
         return response;
       },
-      { config: retryConfig, statusCodes: retryCodes },
+      { config: options.retryConfig, statusCodes: options.retryCodes },
     ).then(
       (r) => OK(r),
       (err) => {