@hookdeck/outpost-sdk 0.1.1 → 0.3.0

package/src/lib/matchers.ts

@@ -3,11 +3,10 @@
  */
 
 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"
@@ -176,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;
@@ -205,21 +206,22 @@ 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;
@@ -231,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;
@@ -250,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];
     }
 
@@ -266,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 = {
@@ -284,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,
       ];
@@ -318,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

@@ -64,6 +64,7 @@ type RequestConfig = {
   headers?: HeadersInit;
   security?: SecurityState | null;
   uaHeader?: string;
+  userAgent?: string | undefined;
   timeoutMs?: number;
 };
 
@@ -95,19 +96,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;
   }
 
   public _createRequest(
@@ -180,7 +183,10 @@ 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,
+      );
     }
 
     const fetchOptions: Omit<RequestInit, "method" | "body"> = {

package/src/lib/security.ts

@@ -6,8 +6,8 @@ import * as components from "../models/components/index.js";
 
 type OAuth2PasswordFlow = {
   username: string;
-  password?: string | undefined;
-  clientID: string;
+  password: string;
+  clientID?: string | undefined;
   clientSecret?: string | undefined;
   tokenURL: string;
 };

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

@@ -6,7 +6,6 @@ import { buildCommand } from "@stricli/core";
 import { numberParser } from "@stricli/core";
 import * as z from "zod";
 import { consoleLoggerLevels } from "../../console-logger.js";
-import { mcpScopes } from "../../scopes.js";
 
 export const startCommand = buildCommand({
   loader: async () => {
@@ -37,18 +36,6 @@ export const startCommand = buildCommand({
           return z.string().parse(value);
         },
       },
-      ...(mcpScopes.length
-        ? {
-          scope: {
-            kind: "enum",
-            brief:
-              "Mount tools/resources that match given scope (repeatable flag)",
-            values: mcpScopes,
-            variadic: true,
-            optional: true,
-          },
-        }
-        : {}),
       "admin-api-key": {
         kind: "parsed",
         brief: "Sets the adminApiKey auth field for the API",

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

@@ -11,14 +11,12 @@ import {
   ConsoleLoggerLevel,
   createConsoleLogger,
 } from "../../console-logger.js";
-import { MCPScope } from "../../scopes.js";
 import { createMCPServer } from "../../server.js";
 
 interface StartCommandFlags {
   readonly transport: "stdio" | "sse";
   readonly port: number;
   readonly tool?: string[];
-  readonly scope?: MCPScope[];
   readonly "admin-api-key"?: string | undefined;
   readonly "tenant-jwt"?: string | undefined;
   readonly "tenant-id"?: SDKOptions["tenantId"] | undefined;
@@ -51,10 +49,9 @@ async function startStdio(flags: StartCommandFlags) {
   const server = createMCPServer({
     logger,
     allowedTools: flags.tool,
-    scopes: flags.scope,
     security: {
-      adminApiKey: flags["admin-api-key"],
-      tenantJwt: flags["tenant-jwt"],
+      adminApiKey: flags["admin-api-key"] ?? "",
+      tenantJwt: flags["tenant-jwt"] ?? "",
     },
     tenantId: flags["tenant-id"],
     serverURL: flags["server-url"],
@@ -76,10 +73,9 @@ async function startSSE(flags: StartCommandFlags) {
   const mcpServer = createMCPServer({
     logger,
     allowedTools: flags.tool,
-    scopes: flags.scope,
     security: {
-      adminApiKey: flags["admin-api-key"],
-      tenantJwt: flags["tenant-jwt"],
+      adminApiKey: flags["admin-api-key"] ?? "",
+      tenantJwt: flags["tenant-jwt"] ?? "",
     },
     tenantId: flags["tenant-id"],
     serverURL: flags["server-url"],

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

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

package/src/mcp-server/server.ts

@@ -51,7 +51,7 @@ export function createMCPServer(deps: {
 }) {
   const server = new McpServer({
     name: "Outpost",
-    version: "0.1.1",
+    version: "0.3.0",
   });
 
   const client = new OutpostCore({

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

@@ -30,6 +30,8 @@ Publishes an event to the specified topic, potentially routed to a specific dest
       };
     }
 
-    return formatResult(void 0, apiCall);
+    const value = result.value;
+
+    return formatResult(value, apiCall);
   },
 };

package/src/models/components/azureservicebusconfig.ts

@@ -0,0 +1,69 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type AzureServiceBusConfig = {
+  /**
+   * The name of the Azure Service Bus queue or topic to publish messages to.
+   */
+  name: string;
+};
+
+/** @internal */
+export const AzureServiceBusConfig$inboundSchema: z.ZodType<
+  AzureServiceBusConfig,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string(),
+});
+
+/** @internal */
+export type AzureServiceBusConfig$Outbound = {
+  name: string;
+};
+
+/** @internal */
+export const AzureServiceBusConfig$outboundSchema: z.ZodType<
+  AzureServiceBusConfig$Outbound,
+  z.ZodTypeDef,
+  AzureServiceBusConfig
+> = z.object({
+  name: z.string(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AzureServiceBusConfig$ {
+  /** @deprecated use `AzureServiceBusConfig$inboundSchema` instead. */
+  export const inboundSchema = AzureServiceBusConfig$inboundSchema;
+  /** @deprecated use `AzureServiceBusConfig$outboundSchema` instead. */
+  export const outboundSchema = AzureServiceBusConfig$outboundSchema;
+  /** @deprecated use `AzureServiceBusConfig$Outbound` instead. */
+  export type Outbound = AzureServiceBusConfig$Outbound;
+}
+
+export function azureServiceBusConfigToJSON(
+  azureServiceBusConfig: AzureServiceBusConfig,
+): string {
+  return JSON.stringify(
+    AzureServiceBusConfig$outboundSchema.parse(azureServiceBusConfig),
+  );
+}
+
+export function azureServiceBusConfigFromJSON(
+  jsonString: string,
+): SafeParseResult<AzureServiceBusConfig, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AzureServiceBusConfig$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AzureServiceBusConfig' from JSON`,
+  );
+}

package/src/models/components/azureservicebuscredentials.ts

@@ -0,0 +1,78 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type AzureServiceBusCredentials = {
+  /**
+   * The connection string for the Azure Service Bus namespace.
+   */
+  connectionString: string;
+};
+
+/** @internal */
+export const AzureServiceBusCredentials$inboundSchema: z.ZodType<
+  AzureServiceBusCredentials,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  connection_string: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "connection_string": "connectionString",
+  });
+});
+
+/** @internal */
+export type AzureServiceBusCredentials$Outbound = {
+  connection_string: string;
+};
+
+/** @internal */
+export const AzureServiceBusCredentials$outboundSchema: z.ZodType<
+  AzureServiceBusCredentials$Outbound,
+  z.ZodTypeDef,
+  AzureServiceBusCredentials
+> = z.object({
+  connectionString: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    connectionString: "connection_string",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AzureServiceBusCredentials$ {
+  /** @deprecated use `AzureServiceBusCredentials$inboundSchema` instead. */
+  export const inboundSchema = AzureServiceBusCredentials$inboundSchema;
+  /** @deprecated use `AzureServiceBusCredentials$outboundSchema` instead. */
+  export const outboundSchema = AzureServiceBusCredentials$outboundSchema;
+  /** @deprecated use `AzureServiceBusCredentials$Outbound` instead. */
+  export type Outbound = AzureServiceBusCredentials$Outbound;
+}
+
+export function azureServiceBusCredentialsToJSON(
+  azureServiceBusCredentials: AzureServiceBusCredentials,
+): string {
+  return JSON.stringify(
+    AzureServiceBusCredentials$outboundSchema.parse(azureServiceBusCredentials),
+  );
+}
+
+export function azureServiceBusCredentialsFromJSON(
+  jsonString: string,
+): SafeParseResult<AzureServiceBusCredentials, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AzureServiceBusCredentials$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AzureServiceBusCredentials' from JSON`,
+  );
+}

package/src/models/components/destination.ts

@@ -18,6 +18,12 @@ import {
   DestinationAWSSQS$Outbound,
   DestinationAWSSQS$outboundSchema,
 } from "./destinationawssqs.js";
+import {
+  DestinationAzureServiceBus,
+  DestinationAzureServiceBus$inboundSchema,
+  DestinationAzureServiceBus$Outbound,
+  DestinationAzureServiceBus$outboundSchema,
+} from "./destinationazureservicebus.js";
 import {
   DestinationHookdeck,
   DestinationHookdeck$inboundSchema,
@@ -41,8 +47,9 @@ export type Destination =
   | (DestinationWebhook & { type: "webhook" })
   | (DestinationAWSSQS & { type: "aws_sqs" })
   | (DestinationRabbitMQ & { type: "rabbitmq" })
-  | (DestinationHookdeck & { type: "hookdeck" })
-  | (DestinationAWSKinesis & { type: "aws_kinesis" });
+  | (DestinationAWSKinesis & { type: "aws_kinesis" })
+  | (DestinationAzureServiceBus & { type: "azure_servicebus" })
+  | (DestinationHookdeck & { type: "hookdeck" });
 
 /** @internal */
 export const Destination$inboundSchema: z.ZodType<
@@ -65,13 +72,18 @@ export const Destination$inboundSchema: z.ZodType<
       type: v.type,
     })),
   ),
-  DestinationHookdeck$inboundSchema.and(
-    z.object({ type: z.literal("hookdeck") }).transform((v) => ({
+  DestinationAWSKinesis$inboundSchema.and(
+    z.object({ type: z.literal("aws_kinesis") }).transform((v) => ({
       type: v.type,
     })),
   ),
-  DestinationAWSKinesis$inboundSchema.and(
-    z.object({ type: z.literal("aws_kinesis") }).transform((v) => ({
+  DestinationAzureServiceBus$inboundSchema.and(
+    z.object({ type: z.literal("azure_servicebus") }).transform((v) => ({
+      type: v.type,
+    })),
+  ),
+  DestinationHookdeck$inboundSchema.and(
+    z.object({ type: z.literal("hookdeck") }).transform((v) => ({
       type: v.type,
     })),
   ),
@@ -82,8 +94,9 @@ export type Destination$Outbound =
   | (DestinationWebhook$Outbound & { type: "webhook" })
   | (DestinationAWSSQS$Outbound & { type: "aws_sqs" })
   | (DestinationRabbitMQ$Outbound & { type: "rabbitmq" })
-  | (DestinationHookdeck$Outbound & { type: "hookdeck" })
-  | (DestinationAWSKinesis$Outbound & { type: "aws_kinesis" });
+  | (DestinationAWSKinesis$Outbound & { type: "aws_kinesis" })
+  | (DestinationAzureServiceBus$Outbound & { type: "azure_servicebus" })
+  | (DestinationHookdeck$Outbound & { type: "hookdeck" });
 
 /** @internal */
 export const Destination$outboundSchema: z.ZodType<
@@ -106,13 +119,18 @@ export const Destination$outboundSchema: z.ZodType<
       type: v.type,
     })),
   ),
-  DestinationHookdeck$outboundSchema.and(
-    z.object({ type: z.literal("hookdeck") }).transform((v) => ({
+  DestinationAWSKinesis$outboundSchema.and(
+    z.object({ type: z.literal("aws_kinesis") }).transform((v) => ({
       type: v.type,
     })),
   ),
-  DestinationAWSKinesis$outboundSchema.and(
-    z.object({ type: z.literal("aws_kinesis") }).transform((v) => ({
+  DestinationAzureServiceBus$outboundSchema.and(
+    z.object({ type: z.literal("azure_servicebus") }).transform((v) => ({
+      type: v.type,
+    })),
+  ),
+  DestinationHookdeck$outboundSchema.and(
+    z.object({ type: z.literal("hookdeck") }).transform((v) => ({
       type: v.type,
     })),
   ),