@documenso/sdk-typescript 0.2.0 → 0.3.0

package/src/lib/matchers.ts

@@ -3,13 +3,13 @@
  */
 
 import { APIError } from "../models/errors/apierror.js";
-import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
-import { Result } from "../types/fp.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { ERR, OK, Result } from "../types/fp.js";
 import { matchResponse, matchStatusCode, StatusCodePredicate } from "./http.js";
 import { isPlainObject } from "./is-plain-object.js";
-import { safeParse } from "./schemas.js";
 
 export type Encoding =
+  | "jsonl"
   | "json"
   | "text"
   | "bytes"
@@ -19,6 +19,7 @@ export type Encoding =
   | "fail";
 
 const DEFAULT_CONTENT_TYPES: Record<Encoding, string> = {
+  jsonl: "application/jsonl",
   json: "application/json",
   text: "text/plain",
   bytes: "application/octet-stream",
@@ -72,6 +73,21 @@ export function json<T>(
   return { ...options, enc: "json", codes, schema };
 }
 
+export function jsonl<T>(
+  codes: StatusCodePredicate,
+  schema: Schema<T>,
+  options?: MatchOptions,
+): ValueMatcher<T> {
+  return { ...options, enc: "jsonl", codes, schema };
+}
+
+export function jsonlErr<E>(
+  codes: StatusCodePredicate,
+  schema: Schema<E>,
+  options?: MatchOptions,
+): ErrorMatcher<E> {
+  return { ...options, err: true, enc: "jsonl", codes, schema };
+}
 export function textErr<E>(
   codes: StatusCodePredicate,
   schema: Schema<E>,
@@ -159,17 +175,19 @@ export type MatchedError<Matchers> = Matchers extends Matcher<any, infer E>[]
   : never;
 export type MatchFunc<T, E> = (
   response: Response,
+  request: Request,
   options?: { resultKey?: string; extraFields?: Record<string, unknown> },
 ) => Promise<[result: Result<T, E>, raw: unknown]>;
 
 export function match<T, E>(
   ...matchers: Array<Matcher<T, E>>
-): MatchFunc<T, E | APIError | SDKValidationError> {
+): MatchFunc<T, E | APIError | ResponseValidationError> {
   return async function matchFunc(
     response: Response,
+    request: Request,
     options?: { resultKey?: string; extraFields?: Record<string, unknown> },
   ): Promise<
-    [result: Result<T, E | APIError | SDKValidationError>, raw: unknown]
+    [result: Result<T, E | APIError | ResponseValidationError>, raw: unknown]
   > {
     let raw: unknown;
     let matcher: Matcher<T, E> | undefined;
@@ -188,21 +206,25 @@ export function match<T, E>(
     }
 
     if (!matcher) {
-      const responseBody = await response.text();
       return [{
         ok: false,
-        error: new APIError(
-          "Unexpected API response status or content-type",
+        error: new APIError("Unexpected Status or Content-Type", {
           response,
-          responseBody,
-        ),
-      }, responseBody];
+          request,
+          body: await response.text().catch(() => ""),
+        }),
+      }, raw];
     }
 
     const encoding = matcher.enc;
+    let body = "";
     switch (encoding) {
       case "json":
-        raw = await response.json();
+        body = await response.text();
+        raw = JSON.parse(body);
+        break;
+      case "jsonl":
+        raw = response.body;
         break;
       case "bytes":
         raw = new Uint8Array(await response.arrayBuffer());
@@ -211,16 +233,19 @@ export function match<T, E>(
         raw = response.body;
         break;
       case "text":
-        raw = await response.text();
+        body = await response.text();
+        raw = body;
         break;
       case "sse":
         raw = response.body;
         break;
       case "nil":
-        raw = await discardResponseBody(response);
+        body = await response.text();
+        raw = undefined;
         break;
       case "fail":
-        raw = await response.text();
+        body = await response.text();
+        raw = body;
         break;
       default:
         encoding satisfies never;
@@ -230,11 +255,7 @@ export function match<T, E>(
     if (matcher.enc === "fail") {
       return [{
         ok: false,
-        error: new APIError(
-          "API error occurred",
-          response,
-          typeof raw === "string" ? raw : "",
-        ),
+        error: new APIError("API error occurred", { request, response, body }),
       }, raw];
     }
 
@@ -246,6 +267,9 @@ export function match<T, E>(
         ...options?.extraFields,
         ...(matcher.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
         ...(isPlainObject(raw) ? raw : null),
+        request$: request,
+        response$: response,
+        body$: body,
       };
     } else if (resultKey) {
       data = {
@@ -264,18 +288,20 @@ export function match<T, E>(
     }
 
     if ("err" in matcher) {
-      const result = safeParse(
+      const result = safeParseResponse(
         data,
         (v: unknown) => matcher.schema.parse(v),
         "Response validation failed",
+        { request, response, body },
       );
       return [result.ok ? { ok: false, error: result.value } : result, raw];
     } else {
       return [
-        safeParse(
+        safeParseResponse(
           data,
           (v: unknown) => matcher.schema.parse(v),
           "Response validation failed",
+          { request, response, body },
         ),
         raw,
       ];
@@ -298,25 +324,22 @@ export function unpackHeaders(headers: Headers): Record<string, string[]> {
   return out;
 }
 
-/**
- * Discards the response body to free up resources.
- *
- * To learn why this is need, see the undici docs:
- * https://undici.nodejs.org/#/?id=garbage-collection
- */
-export async function discardResponseBody(res: Response) {
-  const reader = res.body?.getReader();
-  if (reader == null) {
-    return;
-  }
-
+function safeParseResponse<Inp, Out>(
+  rawValue: Inp,
+  fn: (value: Inp) => Out,
+  errorMessage: string,
+  httpMeta: { response: Response; request: Request; body: string },
+): Result<Out, ResponseValidationError> {
   try {
-    let done = false;
-    while (!done) {
-      const res = await reader.read();
-      done = res.done;
-    }
-  } finally {
-    reader.releaseLock();
+    return OK(fn(rawValue));
+  } catch (err) {
+    return ERR(
+      new ResponseValidationError(errorMessage, {
+        cause: err,
+        rawValue,
+        rawMessage: errorMessage,
+        ...httpMeta,
+      }),
+    );
   }
 }

package/src/lib/sdks.ts

@@ -47,12 +47,14 @@ export type RequestOptions = {
    */
   serverURL?: string | URL;
   /**
+   * @deprecated `fetchOptions` has been flattened into `RequestOptions`.
+   *
    * Sets various request options on the `fetch` call made by an SDK method.
    *
    * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#options|Request}
    */
   fetchOptions?: Omit<RequestInit, "method" | "body">;
-};
+} & Omit<RequestInit, "method" | "body">;
 
 type RequestConfig = {
   method: string;
@@ -63,6 +65,7 @@ type RequestConfig = {
   headers?: HeadersInit;
   security?: SecurityState | null;
   uaHeader?: string;
+  userAgent?: string | undefined;
   timeoutMs?: number;
 };
 
@@ -94,19 +97,21 @@ export class ClientSDK {
     } else {
       this.#hooks = new SDKHooks();
     }
-    this._options = { ...options, hooks: this.#hooks };
-
     const url = serverURLFromOptions(options);
     if (url) {
       url.pathname = url.pathname.replace(/\/+$/, "") + "/";
     }
+
     const { baseURL, client } = this.#hooks.sdkInit({
       baseURL: url,
       client: options.httpClient || new HTTPClient(),
     });
     this._baseURL = baseURL;
     this.#httpClient = client;
-    this.#logger = options.debugLogger;
+
+    this._options = { ...options, hooks: this.#hooks };
+
+    this.#logger = this._options.debugLogger;
     if (!this.#logger && env().DOCUMENSO_DEBUG) {
       this.#logger = console;
     }
@@ -172,7 +177,9 @@ export class ClientSDK {
     cookie = cookie.startsWith("; ") ? cookie.slice(2) : cookie;
     headers.set("cookie", cookie);
 
-    const userHeaders = new Headers(options?.fetchOptions?.headers);
+    const userHeaders = new Headers(
+      options?.headers ?? options?.fetchOptions?.headers,
+    );
     for (const [k, v] of userHeaders) {
       headers.set(k, v);
     }
@@ -180,23 +187,22 @@ export class ClientSDK {
     // Only set user agent header in non-browser-like environments since CORS
     // policy disallows setting it in browsers e.g. Chrome throws an error.
     if (!isBrowserLike) {
-      headers.set(conf.uaHeader ?? "user-agent", SDK_METADATA.userAgent);
+      headers.set(
+        conf.uaHeader ?? "user-agent",
+        conf.userAgent ?? SDK_METADATA.userAgent,
+      );
     }
 
-    let fetchOptions = options?.fetchOptions;
+    const fetchOptions: Omit<RequestInit, "method" | "body"> = {
+      ...options?.fetchOptions,
+      ...options,
+    };
     if (!fetchOptions?.signal && conf.timeoutMs && conf.timeoutMs > 0) {
       const timeoutSignal = AbortSignal.timeout(conf.timeoutMs);
-      if (!fetchOptions) {
-        fetchOptions = { signal: timeoutSignal };
-      } else {
-        fetchOptions.signal = timeoutSignal;
-      }
+      fetchOptions.signal = timeoutSignal;
     }
 
     if (conf.body instanceof ReadableStream) {
-      if (!fetchOptions) {
-        fetchOptions = {};
-      }
       Object.assign(fetchOptions, { duplex: "half" });
     }
 
@@ -302,7 +308,9 @@ export class ClientSDK {
   }
 }
 
-const jsonLikeContentTypeRE = /^application\/(?:.{0,100}\+)?json/;
+const jsonLikeContentTypeRE = /(application|text)\/.*?\+*json.*/;
+const jsonlLikeContentTypeRE =
+  /(application|text)\/(.*?\+*\bjsonl\b.*|.*?\+*\bx-ndjson\b.*)/;
 async function logRequest(logger: Logger | undefined, req: Request) {
   if (!logger) {
     return;
@@ -368,9 +376,13 @@ async function logResponse(
   logger.group("Body:");
   switch (true) {
     case matchContentType(res, "application/json")
-      || jsonLikeContentTypeRE.test(ct):
+      || jsonLikeContentTypeRE.test(ct) && !jsonlLikeContentTypeRE.test(ct):
       logger.log(await res.clone().json());
       break;
+    case matchContentType(res, "application/jsonl")
+      || jsonlLikeContentTypeRE.test(ct):
+      logger.log(await res.clone().text());
+      break;
     case matchContentType(res, "text/event-stream"):
       logger.log(`<${contentType}>`);
       break;

package/src/mcp-server/cli/start/impl.ts

@@ -50,7 +50,7 @@ async function startStdio(flags: StartCommandFlags) {
     logger,
     allowedTools: flags.tool,
     scopes: flags.scope,
-    ...{ apiKey: flags["api-key"] },
+    ...{ apiKey: flags["api-key"] ?? "" },
     serverURL: flags["server-url"],
     serverIdx: flags["server-index"],
   });
@@ -71,7 +71,7 @@ async function startSSE(flags: StartCommandFlags) {
     logger,
     allowedTools: flags.tool,
     scopes: flags.scope,
-    ...{ apiKey: flags["api-key"] },
+    ...{ apiKey: flags["api-key"] ?? "" },
     serverURL: flags["server-url"],
     serverIdx: flags["server-index"],
   });

package/src/mcp-server/mcp-server.ts

@@ -19,7 +19,7 @@ const routes = buildRouteMap({
 export const app = buildApplication(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.2.0",
+    currentVersion: "0.3.0",
   },
 });
 

package/src/mcp-server/server.ts

@@ -34,6 +34,8 @@ import { tool$documentsRecipientsUpdate } from "./tools/documentsRecipientsUpdat
 import { tool$documentsRecipientsUpdateMany } from "./tools/documentsRecipientsUpdateMany.js";
 import { tool$documentsRedistribute } from "./tools/documentsRedistribute.js";
 import { tool$documentsUpdate } from "./tools/documentsUpdate.js";
+import { tool$embeddingEmbeddingPresignCreateEmbeddingPresignToken } from "./tools/embeddingEmbeddingPresignCreateEmbeddingPresignToken.js";
+import { tool$embeddingEmbeddingPresignVerifyEmbeddingPresignToken } from "./tools/embeddingEmbeddingPresignVerifyEmbeddingPresignToken.js";
 import { tool$templatesDelete } from "./tools/templatesDelete.js";
 import { tool$templatesDirectLinkCreate } from "./tools/templatesDirectLinkCreate.js";
 import { tool$templatesDirectLinkDelete } from "./tools/templatesDirectLinkDelete.js";
@@ -67,7 +69,7 @@ export function createMCPServer(deps: {
 }) {
   const server = new McpServer({
     name: "Documenso",
-    version: "0.2.0",
+    version: "0.3.0",
   });
 
   const client = new DocumensoCore({
@@ -113,6 +115,8 @@ export function createMCPServer(deps: {
   tool(tool$templatesDelete);
   tool(tool$templatesUse);
   tool(tool$templatesMoveToTeam);
+  tool(tool$embeddingEmbeddingPresignCreateEmbeddingPresignToken);
+  tool(tool$embeddingEmbeddingPresignVerifyEmbeddingPresignToken);
   tool(tool$documentsFieldsGet);
   tool(tool$documentsFieldsCreate);
   tool(tool$documentsFieldsCreateMany);

package/src/mcp-server/tools/embeddingEmbeddingPresignCreateEmbeddingPresignToken.ts

@@ -0,0 +1,40 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { embeddingEmbeddingPresignCreateEmbeddingPresignToken } from "../../funcs/embeddingEmbeddingPresignCreateEmbeddingPresignToken.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request:
+    operations.EmbeddingPresignCreateEmbeddingPresignTokenRequest$inboundSchema,
+};
+
+export const tool$embeddingEmbeddingPresignCreateEmbeddingPresignToken:
+  ToolDefinition<typeof args> = {
+    name: "embedding-embedding-presign-create-embedding-presign-token",
+    description: `Create embedding presign token
+
+Creates a presign token for embedding operations with configurable expiration time`,
+    args,
+    tool: async (client, args, ctx) => {
+      const [result, apiCall] =
+        await embeddingEmbeddingPresignCreateEmbeddingPresignToken(
+          client,
+          args.request,
+          { fetchOptions: { signal: ctx.signal } },
+        ).$inspect();
+
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true,
+        };
+      }
+
+      const value = result.value;
+
+      return formatResult(value, apiCall);
+    },
+  };

package/src/mcp-server/tools/embeddingEmbeddingPresignVerifyEmbeddingPresignToken.ts

@@ -0,0 +1,40 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { embeddingEmbeddingPresignVerifyEmbeddingPresignToken } from "../../funcs/embeddingEmbeddingPresignVerifyEmbeddingPresignToken.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request:
+    operations.EmbeddingPresignVerifyEmbeddingPresignTokenRequest$inboundSchema,
+};
+
+export const tool$embeddingEmbeddingPresignVerifyEmbeddingPresignToken:
+  ToolDefinition<typeof args> = {
+    name: "embedding-embedding-presign-verify-embedding-presign-token",
+    description: `Verify embedding presign token
+
+Verifies a presign token for embedding operations and returns the associated API token`,
+    args,
+    tool: async (client, args, ctx) => {
+      const [result, apiCall] =
+        await embeddingEmbeddingPresignVerifyEmbeddingPresignToken(
+          client,
+          args.request,
+          { fetchOptions: { signal: ctx.signal } },
+        ).$inspect();
+
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true,
+        };
+      }
+
+      const value = result.value;
+
+      return formatResult(value, apiCall);
+    },
+  };

package/src/models/errors/apierror.ts

@@ -2,26 +2,33 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
-export class APIError extends Error {
-  public readonly statusCode: number;
-  public readonly contentType: string;
+import { DocumensoError } from "./documensoerror.js";
 
+/** The fallback error class if no more specific error class is matched */
+export class APIError extends DocumensoError {
   constructor(
     message: string,
-    public readonly rawResponse: Response,
-    public readonly body: string = "",
+    httpMeta: {
+      response: Response;
+      request: Request;
+      body: string;
+    },
   ) {
-    const statusCode = rawResponse.status;
-    const contentType = rawResponse.headers.get("content-type") || "";
-    const bodyString = body.length > 0 ? `\n${body}` : "";
-
-    super(
-      `${message}: Status ${statusCode} Content-Type ${contentType} Body ${bodyString}`,
-    );
-
-    this.statusCode = statusCode;
-    this.contentType = contentType;
-
+    if (message) {
+      message += `: `;
+    }
+    message += `Status ${httpMeta.response.status}`;
+    const contentType = httpMeta.response.headers.get("content-type") || `""`;
+    if (contentType !== "application/json") {
+      message += ` Content-Type ${
+        contentType.includes(" ") ? `"${contentType}"` : contentType
+      }`;
+    }
+    const body = httpMeta.body || `""`;
+    message += body.length > 100 ? "\n" : " ";
+    message += `Body ${body}`;
+    message = message.trim();
+    super(message, httpMeta);
     this.name = "APIError";
   }
 }

package/src/models/errors/documensoerror.ts

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+/** The base class for all HTTP error responses */
+export class DocumensoError extends Error {
+  /** HTTP status code */
+  public readonly statusCode: number;
+  /** HTTP body */
+  public readonly body: string;
+  /** HTTP headers */
+  public readonly headers: Headers;
+  /** HTTP content type */
+  public readonly contentType: string;
+  /** Raw response */
+  public readonly rawResponse: Response;
+
+  constructor(
+    message: string,
+    httpMeta: {
+      response: Response;
+      request: Request;
+      body: string;
+    },
+  ) {
+    super(message);
+    this.statusCode = httpMeta.response.status;
+    this.body = httpMeta.body;
+    this.headers = httpMeta.response.headers;
+    this.contentType = httpMeta.response.headers.get("content-type") || "";
+    this.rawResponse = httpMeta.response;
+
+    this.name = "DocumensoError";
+  }
+}

package/src/models/errors/documentcreatedocumenttemporary.ts

@@ -5,6 +5,7 @@
 import * as z from "zod";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import { DocumensoError } from "./documensoerror.js";
 import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type DocumentCreateDocumentTemporaryInternalServerErrorIssue = {
@@ -25,7 +26,9 @@ export type DocumentCreateDocumentTemporaryInternalServerErrorData = {
 /**
  * Internal server error
  */
-export class DocumentCreateDocumentTemporaryInternalServerError extends Error {
+export class DocumentCreateDocumentTemporaryInternalServerError
+  extends DocumensoError
+{
   code: string;
   issues?:
     | Array<DocumentCreateDocumentTemporaryInternalServerErrorIssue>
@@ -34,13 +37,15 @@ export class DocumentCreateDocumentTemporaryInternalServerError extends Error {
   /** The original data that was passed to this error instance. */
   data$: DocumentCreateDocumentTemporaryInternalServerErrorData;
 
-  constructor(err: DocumentCreateDocumentTemporaryInternalServerErrorData) {
+  constructor(
+    err: DocumentCreateDocumentTemporaryInternalServerErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
     const message = "message" in err && typeof err.message === "string"
       ? err.message
       : `API error occurred: ${JSON.stringify(err)}`;
-    super(message);
+    super(message, httpMeta);
     this.data$ = err;
-
     this.code = err.code;
     if (err.issues != null) this.issues = err.issues;
 
@@ -64,20 +69,24 @@ export type DocumentCreateDocumentTemporaryBadRequestErrorData = {
 /**
  * Invalid input data
  */
-export class DocumentCreateDocumentTemporaryBadRequestError extends Error {
+export class DocumentCreateDocumentTemporaryBadRequestError
+  extends DocumensoError
+{
   code: string;
   issues?: Array<DocumentCreateDocumentTemporaryBadRequestIssue> | undefined;
 
   /** The original data that was passed to this error instance. */
   data$: DocumentCreateDocumentTemporaryBadRequestErrorData;
 
-  constructor(err: DocumentCreateDocumentTemporaryBadRequestErrorData) {
+  constructor(
+    err: DocumentCreateDocumentTemporaryBadRequestErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
     const message = "message" in err && typeof err.message === "string"
       ? err.message
       : `API error occurred: ${JSON.stringify(err)}`;
-    super(message);
+    super(message, httpMeta);
     this.data$ = err;
-
     this.code = err.code;
     if (err.issues != null) this.issues = err.issues;
 
@@ -165,9 +174,16 @@ export const DocumentCreateDocumentTemporaryInternalServerError$inboundSchema:
         DocumentCreateDocumentTemporaryInternalServerErrorIssue$inboundSchema
       ),
     ).optional(),
+    request$: z.instanceof(Request),
+    response$: z.instanceof(Response),
+    body$: z.string(),
   })
     .transform((v) => {
-      return new DocumentCreateDocumentTemporaryInternalServerError(v);
+      return new DocumentCreateDocumentTemporaryInternalServerError(v, {
+        request: v.request$,
+        response: v.response$,
+        body: v.body$,
+      });
     });
 
 /** @internal */
@@ -295,9 +311,16 @@ export const DocumentCreateDocumentTemporaryBadRequestError$inboundSchema:
         DocumentCreateDocumentTemporaryBadRequestIssue$inboundSchema
       ),
     ).optional(),
+    request$: z.instanceof(Request),
+    response$: z.instanceof(Response),
+    body$: z.string(),
   })
     .transform((v) => {
-      return new DocumentCreateDocumentTemporaryBadRequestError(v);
+      return new DocumentCreateDocumentTemporaryBadRequestError(v, {
+        request: v.request$,
+        response: v.response$,
+        body: v.body$,
+      });
     });
 
 /** @internal */