@compose-market/sdk 0.4.3 → 0.5.0

package/generated/inference/src/models/chat-message.ts

@@ -0,0 +1,82 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../lib/primitives.js";
+import { ClosedEnum } from "../types/enums.js";
+import { smartUnion } from "../types/smart-union.js";
+
+export const Role = {
+  System: "system",
+  User: "user",
+  Assistant: "assistant",
+  Tool: "tool",
+} as const;
+export type Role = ClosedEnum<typeof Role>;
+
+export type Content = string | Array<{ [k: string]: any }>;
+
+export type ChatMessage = {
+  role: Role;
+  content: string | Array<{ [k: string]: any }> | null;
+  name?: string | undefined;
+  toolCallId?: string | undefined;
+  toolCalls?: Array<{ [k: string]: any }> | undefined;
+  [additionalProperties: string]: unknown;
+};
+
+/** @internal */
+export const Role$outboundSchema: z.ZodMiniEnum<typeof Role> = z.enum(Role);
+
+/** @internal */
+export type Content$Outbound = string | Array<{ [k: string]: any }>;
+
+/** @internal */
+export const Content$outboundSchema: z.ZodMiniType<Content$Outbound, Content> =
+  smartUnion([z.string(), z.array(z.record(z.string(), z.any()))]);
+
+export function contentToJSON(content: Content): string {
+  return JSON.stringify(Content$outboundSchema.parse(content));
+}
+
+/** @internal */
+export type ChatMessage$Outbound = {
+  role: string;
+  content: string | Array<{ [k: string]: any }> | null;
+  name?: string | undefined;
+  tool_call_id?: string | undefined;
+  tool_calls?: Array<{ [k: string]: any }> | undefined;
+  [additionalProperties: string]: unknown;
+};
+
+/** @internal */
+export const ChatMessage$outboundSchema: z.ZodMiniType<
+  ChatMessage$Outbound,
+  ChatMessage
+> = z.pipe(
+  z.catchall(
+    z.object({
+      role: Role$outboundSchema,
+      content: z.nullable(
+        smartUnion([z.string(), z.array(z.record(z.string(), z.any()))]),
+      ),
+      name: z.optional(z.string()),
+      toolCallId: z.optional(z.string()),
+      toolCalls: z.optional(z.array(z.record(z.string(), z.any()))),
+    }),
+    z.any(),
+  ),
+  z.transform((v) => {
+    return {
+      ...remap$(v, {
+        toolCallId: "tool_call_id",
+        toolCalls: "tool_calls",
+      }),
+    };
+  }),
+);
+
+export function chatMessageToJSON(chatMessage: ChatMessage): string {
+  return JSON.stringify(ChatMessage$outboundSchema.parse(chatMessage));
+}

package/generated/inference/src/models/compose-receipt-body.ts

@@ -0,0 +1,75 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import {
+  ComposeReceiptLineItem,
+  ComposeReceiptLineItem$inboundSchema,
+} from "./compose-receipt-line-item.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export type ComposeReceiptBody = {
+  subject?: string | undefined;
+  lineItems?: Array<ComposeReceiptLineItem> | undefined;
+  /**
+   * Non-negative integer amount in USDC atomic units.
+   */
+  providerAmountWei?: string | undefined;
+  /**
+   * Non-negative integer amount in USDC atomic units.
+   */
+  platformFeeWei?: string | undefined;
+  /**
+   * Non-negative integer amount in USDC atomic units.
+   */
+  finalAmountWei?: string | undefined;
+  txHash?: string | undefined;
+  network?: string | undefined;
+  settledAt?: number | undefined;
+  [additionalProperties: string]: unknown;
+};
+
+/** @internal */
+export const ComposeReceiptBody$inboundSchema: z.ZodMiniType<
+  ComposeReceiptBody,
+  unknown
+> = z.pipe(
+  z.catchall(
+    z.object({
+      subject: types.optional(types.string()),
+      line_items: types.optional(z.array(ComposeReceiptLineItem$inboundSchema)),
+      provider_amount_wei: types.optional(types.string()),
+      platform_fee_wei: types.optional(types.string()),
+      final_amount_wei: types.optional(types.string()),
+      tx_hash: types.optional(types.string()),
+      network: types.optional(types.string()),
+      settled_at: types.optional(types.number()),
+    }),
+    z.any(),
+  ),
+  z.transform((v) => {
+    return remap$(v, {
+      "line_items": "lineItems",
+      "provider_amount_wei": "providerAmountWei",
+      "platform_fee_wei": "platformFeeWei",
+      "final_amount_wei": "finalAmountWei",
+      "tx_hash": "txHash",
+      "settled_at": "settledAt",
+    });
+  }),
+);
+
+export function composeReceiptBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<ComposeReceiptBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ComposeReceiptBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ComposeReceiptBody' from JSON`,
+  );
+}

package/generated/inference/src/models/compose-receipt-line-item.ts

@@ -0,0 +1,55 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export type ComposeReceiptLineItem = {
+  key: string;
+  unit: string;
+  quantity: number;
+  unitPriceUsd?: number | undefined;
+  /**
+   * Non-negative integer amount in USDC atomic units.
+   */
+  amountWei: string;
+  [additionalProperties: string]: unknown;
+};
+
+/** @internal */
+export const ComposeReceiptLineItem$inboundSchema: z.ZodMiniType<
+  ComposeReceiptLineItem,
+  unknown
+> = z.pipe(
+  z.catchall(
+    z.object({
+      key: types.string(),
+      unit: types.string(),
+      quantity: types.number(),
+      unit_price_usd: types.optional(types.number()),
+      amount_wei: types.string(),
+    }),
+    z.any(),
+  ),
+  z.transform((v) => {
+    return remap$(v, {
+      "unit_price_usd": "unitPriceUsd",
+      "amount_wei": "amountWei",
+    });
+  }),
+);
+
+export function composeReceiptLineItemFromJSON(
+  jsonString: string,
+): SafeParseResult<ComposeReceiptLineItem, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ComposeReceiptLineItem$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ComposeReceiptLineItem' from JSON`,
+  );
+}

package/generated/inference/src/models/embeddings-create-request.ts

@@ -0,0 +1,62 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { smartUnion } from "../types/smart-union.js";
+import {
+  ModelProvider,
+  ModelProvider$outboundSchema,
+} from "./model-provider.js";
+
+export type Input = string | Array<string>;
+
+export type EmbeddingsCreateRequest = {
+  model: string;
+  input: string | Array<string>;
+  provider?: ModelProvider | undefined;
+  dimensions?: number | undefined;
+  [additionalProperties: string]: unknown;
+};
+
+/** @internal */
+export type Input$Outbound = string | Array<string>;
+
+/** @internal */
+export const Input$outboundSchema: z.ZodMiniType<Input$Outbound, Input> =
+  smartUnion([z.string(), z.array(z.string())]);
+
+export function inputToJSON(input: Input): string {
+  return JSON.stringify(Input$outboundSchema.parse(input));
+}
+
+/** @internal */
+export type EmbeddingsCreateRequest$Outbound = {
+  model: string;
+  input: string | Array<string>;
+  provider?: string | undefined;
+  dimensions?: number | undefined;
+  [additionalProperties: string]: unknown;
+};
+
+/** @internal */
+export const EmbeddingsCreateRequest$outboundSchema: z.ZodMiniType<
+  EmbeddingsCreateRequest$Outbound,
+  EmbeddingsCreateRequest
+> = z.catchall(
+  z.object({
+    model: z.string(),
+    input: smartUnion([z.string(), z.array(z.string())]),
+    provider: z.optional(ModelProvider$outboundSchema),
+    dimensions: z.optional(z.int()),
+  }),
+  z.any(),
+);
+
+export function embeddingsCreateRequestToJSON(
+  embeddingsCreateRequest: EmbeddingsCreateRequest,
+): string {
+  return JSON.stringify(
+    EmbeddingsCreateRequest$outboundSchema.parse(embeddingsCreateRequest),
+  );
+}

package/generated/inference/src/models/embeddings-response.ts

@@ -0,0 +1,55 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import {
+  ComposeReceiptBody,
+  ComposeReceiptBody$inboundSchema,
+} from "./compose-receipt-body.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export type EmbeddingsResponse = {
+  object: "list";
+  data: Array<{ [k: string]: any }>;
+  model: string;
+  usage: { [k: string]: any };
+  composeReceipt?: ComposeReceiptBody | undefined;
+  [additionalProperties: string]: unknown;
+};
+
+/** @internal */
+export const EmbeddingsResponse$inboundSchema: z.ZodMiniType<
+  EmbeddingsResponse,
+  unknown
+> = z.pipe(
+  z.catchall(
+    z.object({
+      object: types.literal("list"),
+      data: z.array(z.record(z.string(), z.any())),
+      model: types.string(),
+      usage: z.record(z.string(), z.any()),
+      compose_receipt: types.optional(ComposeReceiptBody$inboundSchema),
+    }),
+    z.any(),
+  ),
+  z.transform((v) => {
+    return remap$(v, {
+      "compose_receipt": "composeReceipt",
+    });
+  }),
+);
+
+export function embeddingsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<EmbeddingsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EmbeddingsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EmbeddingsResponse' from JSON`,
+  );
+}

package/generated/inference/src/models/error-envelope.ts

@@ -0,0 +1,32 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export type ErrorT = {
+  code: string;
+  message: string;
+  details?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const ErrorT$inboundSchema: z.ZodMiniType<ErrorT, unknown> = z.object({
+  code: types.string(),
+  message: types.string(),
+  details: types.optional(z.record(z.string(), z.any())),
+});
+
+export function errorFromJSON(
+  jsonString: string,
+): SafeParseResult<ErrorT, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ErrorT$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ErrorT' from JSON`,
+  );
+}

package/generated/inference/src/models/errors/compose-market-default-error.ts

@@ -0,0 +1,40 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { ComposeMarketError } from "./compose-market-error.js";
+
+/** The fallback error class if no more specific error class is matched */
+export class ComposeMarketDefaultError extends ComposeMarketError {
+  constructor(
+    message: string,
+    httpMeta: {
+      response: Response;
+      request: Request;
+      body: string;
+    },
+  ) {
+    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" : ". ";
+    let bodyDisplay = body;
+    if (body.length > 10000) {
+      const truncated = body.substring(0, 10000);
+      const remaining = body.length - 10000;
+      bodyDisplay = `${truncated}...and ${remaining} more chars`;
+    }
+    message += `Body: ${bodyDisplay}`;
+    message = message.trim();
+    super(message, httpMeta);
+    this.name = "ComposeMarketDefaultError";
+  }
+}

package/generated/inference/src/models/errors/compose-market-error.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 ComposeMarketError 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 = "ComposeMarketError";
+  }
+}

package/generated/inference/src/models/errors/error-envelope.ts

@@ -0,0 +1,62 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as types from "../../types/primitives.js";
+import * as models from "../index.js";
+import { ComposeMarketError } from "./compose-market-error.js";
+
+export type ErrorEnvelopeData = {
+  error: models.ErrorT;
+  /**
+   * Raw HTTP response; suitable for custom response parsing
+   */
+  rawResponse?: Response | undefined;
+};
+
+export class ErrorEnvelope extends ComposeMarketError {
+  error: models.ErrorT;
+
+  /** The original data that was passed to this error instance. */
+  data$: ErrorEnvelopeData;
+
+  constructor(
+    err: ErrorEnvelopeData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.error?.message
+      || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    this.error = err.error;
+
+    this.name = "ErrorEnvelope";
+  }
+}
+
+/** @internal */
+export const ErrorEnvelope$inboundSchema: z.ZodMiniType<
+  ErrorEnvelope,
+  unknown
+> = z.pipe(
+  z.object({
+    error: z.lazy(() => models.ErrorT$inboundSchema),
+    RawResponse: types.optional(z.custom<Response>(x => x instanceof Response)),
+    request$: z.custom<Request>(x => x instanceof Request),
+    response$: z.custom<Response>(x => x instanceof Response),
+    body$: z.string(),
+  }),
+  z.transform((v) => {
+    const remapped = remap$(v, {
+      "RawResponse": "rawResponse",
+    });
+
+    return new ErrorEnvelope(remapped, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  }),
+);

package/generated/inference/src/models/errors/error-response.ts

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { smartUnion } from "../../types/smart-union.js";
+import {
+  ErrorEnvelope,
+  ErrorEnvelope$inboundSchema,
+} from "./error-envelope.js";
+import { LegacyError, LegacyError$inboundSchema } from "./legacy-error.js";
+import { SDKValidationError } from "./sdk-validation-error.js";
+
+/**
+ * Compose error response.
+ */
+export type ErrorResponse = ErrorEnvelope | LegacyError;
+
+/** @internal */
+export const ErrorResponse$inboundSchema: z.ZodMiniType<
+  ErrorResponse,
+  unknown
+> = smartUnion([ErrorEnvelope$inboundSchema, LegacyError$inboundSchema]);
+
+export function errorResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ErrorResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ErrorResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ErrorResponse' from JSON`,
+  );
+}

package/generated/inference/src/models/errors/http-client-errors.ts

@@ -0,0 +1,62 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+/**
+ * Base class for all HTTP errors.
+ */
+export class HTTPClientError extends Error {
+  /** The underlying cause of the error. */
+  override readonly cause: unknown;
+  override name = "HTTPClientError";
+  constructor(message: string, opts?: { cause?: unknown }) {
+    let msg = message;
+    if (opts?.cause) {
+      msg += `: ${opts.cause}`;
+    }
+
+    super(msg, opts);
+    // In older runtimes, the cause field would not have been assigned through
+    // the super() call.
+    if (typeof this.cause === "undefined") {
+      this.cause = opts?.cause;
+    }
+  }
+}
+
+/**
+ * An error to capture unrecognised or unexpected errors when making HTTP calls.
+ */
+export class UnexpectedClientError extends HTTPClientError {
+  override name = "UnexpectedClientError";
+}
+
+/**
+ * An error that is raised when any inputs used to create a request are invalid.
+ */
+export class InvalidRequestError extends HTTPClientError {
+  override name = "InvalidRequestError";
+}
+
+/**
+ * An error that is raised when a HTTP request was aborted by the client error.
+ */
+export class RequestAbortedError extends HTTPClientError {
+  override readonly name = "RequestAbortedError";
+}
+
+/**
+ * An error that is raised when a HTTP request timed out due to an AbortSignal
+ * signal timeout.
+ */
+export class RequestTimeoutError extends HTTPClientError {
+  override readonly name = "RequestTimeoutError";
+}
+
+/**
+ * An error that is raised when a HTTP client is unable to make a request to
+ * a server.
+ */
+export class ConnectionError extends HTTPClientError {
+  override readonly name = "ConnectionError";
+}

package/generated/inference/src/models/errors/index.ts

@@ -0,0 +1,14 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+export * from "./compose-market-default-error.js";
+export * from "./compose-market-error.js";
+export * from "./error-envelope.js";
+export * from "./error-response.js";
+export * from "./http-client-errors.js";
+export * from "./legacy-error.js";
+export * from "./payment-required-error.js";
+export * from "./payment-required-response.js";
+export * from "./response-validation-error.js";
+export * from "./sdk-validation-error.js";

package/generated/inference/src/models/errors/legacy-error.ts

@@ -0,0 +1,68 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as types from "../../types/primitives.js";
+import { ComposeMarketError } from "./compose-market-error.js";
+
+export type LegacyErrorData = {
+  error?: string | undefined;
+  code?: string | undefined;
+  message?: string | undefined;
+  /**
+   * Raw HTTP response; suitable for custom response parsing
+   */
+  rawResponse?: Response | undefined;
+
+  [additionalProperties: string]: unknown;
+};
+
+export class LegacyError extends ComposeMarketError {
+  error?: string | undefined;
+  code?: string | undefined;
+
+  /** The original data that was passed to this error instance. */
+  data$: LegacyErrorData;
+
+  constructor(
+    err: LegacyErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.message || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    if (err.error != null) this.error = err.error;
+    if (err.code != null) this.code = err.code;
+
+    this.name = "LegacyError";
+  }
+}
+
+/** @internal */
+export const LegacyError$inboundSchema: z.ZodMiniType<LegacyError, unknown> = z
+  .pipe(
+    z.object({
+      error: types.optional(types.string()),
+      code: types.optional(types.string()),
+      message: types.optional(types.string()),
+      RawResponse: types.optional(
+        z.custom<Response>(x => x instanceof Response),
+      ),
+      request$: z.custom<Request>(x => x instanceof Request),
+      response$: z.custom<Response>(x => x instanceof Response),
+      body$: z.string(),
+    }),
+    z.transform((v) => {
+      const remapped = remap$(v, {
+        "RawResponse": "rawResponse",
+      });
+
+      return new LegacyError(remapped, {
+        request: v.request$,
+        response: v.response$,
+        body: v.body$,
+      });
+    }),
+  );