@usestatemachines/sdk 0.7.0 → 0.8.0

package/esm/models/request-detail.js

@@ -14,13 +14,15 @@ export const RequestDetailRespondedBy = {
 export const RequestDetailRespondedBy$inboundSchema = openEnums.inboundSchema(RequestDetailRespondedBy);
 /** @internal */
 export const RequestDetail$inboundSchema = z.object({
-    app: types.string(),
+    appName: types.string(),
     completedAt: types.date(),
     durationMs: types.number(),
     environmentId: types.string(),
     errorCode: types.nullable(types.string()),
     id: types.string(),
+    mcpServer: types.nullable(types.string()),
     method: types.string(),
+    operation: types.nullable(types.string()),
     path: types.string(),
     query: types.string(),
     receivedAt: types.date(),
@@ -28,6 +30,8 @@ export const RequestDetail$inboundSchema = z.object({
     respondedBy: RequestDetailRespondedBy$inboundSchema,
     responseBytes: types.nullable(types.number()),
     responseStatus: types.number(),
+    service: types.nullable(types.string()),
+    tool: types.nullable(types.string()),
     requestBody: BodyPreview$inboundSchema,
     requestHeaders: z.record(z.string(), types.string()),
     responseBody: BodyPreview$inboundSchema,

package/esm/models/request-stats.d.ts

@@ -7,6 +7,10 @@ export type Bucket = {
     serverError: number;
     success: number;
 };
+export type RequestStatsService = {
+    count: number;
+    id: string;
+};
 export type RequestStats = {
     buckets: Array<Bucket>;
     clientErrorCount: number;
@@ -15,6 +19,7 @@ export type RequestStats = {
     p50Ms: number | null;
     p95Ms: number | null;
     serverErrorCount: number;
+    services: Array<RequestStatsService>;
     successCount: number;
     to: Date;
 };
@@ -22,5 +27,8 @@ export type RequestStats = {
 export declare const Bucket$inboundSchema: z.ZodMiniType<Bucket, unknown>;
 export declare function bucketFromJSON(jsonString: string): SafeParseResult<Bucket, SDKValidationError>;
 /** @internal */
+export declare const RequestStatsService$inboundSchema: z.ZodMiniType<RequestStatsService, unknown>;
+export declare function requestStatsServiceFromJSON(jsonString: string): SafeParseResult<RequestStatsService, SDKValidationError>;
+/** @internal */
 export declare const RequestStats$inboundSchema: z.ZodMiniType<RequestStats, unknown>;
 export declare function requestStatsFromJSON(jsonString: string): SafeParseResult<RequestStats, SDKValidationError>;

package/esm/models/request-stats.js

@@ -15,6 +15,14 @@ export function bucketFromJSON(jsonString) {
     return safeParse(jsonString, (x) => Bucket$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Bucket' from JSON`);
 }
 /** @internal */
+export const RequestStatsService$inboundSchema = z.object({
+    count: types.number(),
+    id: types.string(),
+});
+export function requestStatsServiceFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => RequestStatsService$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'RequestStatsService' from JSON`);
+}
+/** @internal */
 export const RequestStats$inboundSchema = z.object({
     buckets: z.array(z.lazy(() => Bucket$inboundSchema)),
     clientErrorCount: types.number(),
@@ -23,6 +31,7 @@ export const RequestStats$inboundSchema = z.object({
     p50Ms: types.nullable(types.number()),
     p95Ms: types.nullable(types.number()),
     serverErrorCount: types.number(),
+    services: z.array(z.lazy(() => RequestStatsService$inboundSchema)),
     successCount: types.number(),
     to: types.date(),
 });

package/esm/models/request.d.ts

@@ -8,13 +8,18 @@ export declare const RequestRespondedBy: {
 };
 export type RequestRespondedBy = OpenEnum<typeof RequestRespondedBy>;
 export type RequestT = {
-    app: string;
+    appName: string;
     completedAt: Date;
     durationMs: number;
     environmentId: string;
     errorCode: string | null;
     id: string;
+    /**
+     * The MCP server that the request called, as the app named it. `null` when the gateway answered, when State Machines refused the request before the app read it, or when the request called no MCP server that the environment serves.
+     */
+    mcpServer: string | null;
     method: string;
+    operation: string | null;
     path: string;
     query: string;
     receivedAt: Date;
@@ -22,6 +27,8 @@ export type RequestT = {
     respondedBy: RequestRespondedBy;
     responseBytes: number | null;
     responseStatus: number;
+    service: string | null;
+    tool: string | null;
 };
 /** @internal */
 export declare const RequestRespondedBy$inboundSchema: z.ZodMiniType<RequestRespondedBy, unknown>;

package/esm/models/request.js

@@ -14,13 +14,15 @@ export const RequestRespondedBy$inboundSchema = openEnums.inboundSchema(RequestR
 /** @internal */
 export const RequestT$inboundSchema = z
     .object({
-    app: types.string(),
+    appName: types.string(),
     completedAt: types.date(),
     durationMs: types.number(),
     environmentId: types.string(),
     errorCode: types.nullable(types.string()),
     id: types.string(),
+    mcpServer: types.nullable(types.string()),
     method: types.string(),
+    operation: types.nullable(types.string()),
     path: types.string(),
     query: types.string(),
     receivedAt: types.date(),
@@ -28,6 +30,8 @@ export const RequestT$inboundSchema = z
     respondedBy: RequestRespondedBy$inboundSchema,
     responseBytes: types.nullable(types.number()),
     responseStatus: types.number(),
+    service: types.nullable(types.string()),
+    tool: types.nullable(types.string()),
 });
 export function requestFromJSON(jsonString) {
     return safeParse(jsonString, (x) => RequestT$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'RequestT' from JSON`);

package/esm/models/service.d.ts

@@ -0,0 +1,25 @@
+import * as z from "zod/v4-mini";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+import { McpServer } from "./mcp-server.js";
+export declare const Visibility: {
+    readonly Public: "public";
+    readonly Preview: "preview";
+};
+export type Visibility = OpenEnum<typeof Visibility>;
+export type Service = {
+    description: string;
+    id: string;
+    limitations: Array<string>;
+    name: string;
+    path: string;
+    prompt: Array<string>;
+    servers?: Array<McpServer> | undefined;
+    visibility: Visibility;
+};
+/** @internal */
+export declare const Visibility$inboundSchema: z.ZodMiniType<Visibility, unknown>;
+/** @internal */
+export declare const Service$inboundSchema: z.ZodMiniType<Service, unknown>;
+export declare function serviceFromJSON(jsonString: string): SafeParseResult<Service, SDKValidationError>;

package/esm/models/service.js

@@ -0,0 +1,28 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+import * as types from "../types/primitives.js";
+import { McpServer$inboundSchema } from "./mcp-server.js";
+export const Visibility = {
+    Public: "public",
+    Preview: "preview",
+};
+/** @internal */
+export const Visibility$inboundSchema = openEnums.inboundSchema(Visibility);
+/** @internal */
+export const Service$inboundSchema = z.object({
+    description: types.string(),
+    id: types.string(),
+    limitations: z.array(types.string()),
+    name: types.string(),
+    path: types.string(),
+    prompt: z.array(types.string()),
+    servers: types.optional(z.array(McpServer$inboundSchema)),
+    visibility: Visibility$inboundSchema,
+});
+export function serviceFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Service$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Service' from JSON`);
+}

package/esm/models/snapshot.d.ts

@@ -7,6 +7,12 @@ import { SnapshotStatus } from "./snapshot-status.js";
 export type SnapshotApp = {
     appId: string;
     name: string;
+    services: {
+        [k: string]: any;
+    };
+    setup: {
+        [k: string]: any;
+    };
     sizeBytes: number | null;
     version: string;
     versionId: string;
@@ -26,6 +32,7 @@ export type Snapshot = {
     createdBy: Principal;
     deletedAt: Date | null;
     environmentId: string;
+    environmentName: string | null;
     failure: Failure | null;
     id: string;
     name: string | null;

package/esm/models/snapshot.js

@@ -16,6 +16,8 @@ export const SnapshotApp$inboundSchema = z
     .object({
     appId: types.string(),
     name: types.string(),
+    services: z.record(z.string(), z.any()),
+    setup: z.record(z.string(), z.any()),
     sizeBytes: types.nullable(types.number()),
     version: types.string(),
     versionId: types.string(),
@@ -41,6 +43,7 @@ export const Snapshot$inboundSchema = z
     createdBy: Principal$inboundSchema,
     deletedAt: types.nullable(types.date()),
     environmentId: types.string(),
+    environmentName: types.nullable(types.string()),
     failure: types.nullable(z.lazy(() => Failure$inboundSchema)),
     id: types.string(),
     name: types.nullable(types.string()),

package/esm/models/version.d.ts

@@ -2,8 +2,8 @@ import * as z from "zod/v4-mini";
 import { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { Actor } from "./actor.js";
-import { Api } from "./api.js";
 import { SDKValidationError } from "./errors/sdk-validation-error.js";
+import { Service } from "./service.js";
 export declare const Status: {
     readonly Published: "published";
     readonly Retired: "retired";
@@ -11,12 +11,12 @@ export declare const Status: {
 export type Status = OpenEnum<typeof Status>;
 export type Version = {
     actors: Array<Actor>;
-    apis: Array<Api>;
     appId: string;
     id: string;
     isDefault: boolean;
     publishedAt: Date;
     retiredAt: Date | null;
+    services: Array<Service>;
     status: Status;
     version: string;
 };

package/esm/models/version.js

@@ -6,7 +6,7 @@ import { safeParse } from "../lib/schemas.js";
 import * as openEnums from "../types/enums.js";
 import * as types from "../types/primitives.js";
 import { Actor$inboundSchema } from "./actor.js";
-import { Api$inboundSchema } from "./api.js";
+import { Service$inboundSchema } from "./service.js";
 export const Status = {
     Published: "published",
     Retired: "retired",
@@ -17,12 +17,12 @@ export const Status$inboundSchema = openEnums
 /** @internal */
 export const Version$inboundSchema = z.object({
     actors: z.array(Actor$inboundSchema),
-    apis: z.array(Api$inboundSchema),
     appId: types.string(),
     id: types.string(),
     isDefault: types.boolean(),
     publishedAt: types.date(),
     retiredAt: types.nullable(types.date()),
+    services: z.array(Service$inboundSchema),
     status: Status$inboundSchema,
     version: types.string(),
 });

package/esm/sdk/environments.d.ts

@@ -4,6 +4,7 @@ import * as operations from "../models/operations/index.js";
 export declare class Environments extends ClientSDK {
     list(request?: operations.ListEnvironmentsRequest | undefined, options?: RequestOptions): Promise<operations.ListEnvironmentsResponse>;
     create(request: operations.CreateEnvironmentRequest, options?: RequestOptions): Promise<models.Environment>;
+    creators(request?: operations.ListEnvironmentCreatorsRequest | undefined, options?: RequestOptions): Promise<operations.ListEnvironmentCreatorsResponse>;
     delete(request: operations.DeleteEnvironmentRequest, options?: RequestOptions): Promise<models.Environment>;
     get(request: operations.GetEnvironmentRequest, options?: RequestOptions): Promise<models.Environment>;
     update(request: operations.UpdateEnvironmentRequest, options?: RequestOptions): Promise<models.Environment>;

package/esm/sdk/environments.js

@@ -3,6 +3,7 @@
  */
 import { environmentsConnect } from "../funcs/environments-connect.js";
 import { environmentsCreate } from "../funcs/environments-create.js";
+import { environmentsCreators } from "../funcs/environments-creators.js";
 import { environmentsDelete } from "../funcs/environments-delete.js";
 import { environmentsGet } from "../funcs/environments-get.js";
 import { environmentsList } from "../funcs/environments-list.js";
@@ -16,6 +17,9 @@ export class Environments extends ClientSDK {
     async create(request, options) {
         return unwrapAsync(environmentsCreate(this, request, options));
     }
+    async creators(request, options) {
+        return unwrapAsync(environmentsCreators(this, request, options));
+    }
     async delete(request, options) {
         return unwrapAsync(environmentsDelete(this, request, options));
     }

package/esm/types/discriminated-union.d.ts

@@ -0,0 +1,24 @@
+import * as z from "zod/v4-mini";
+export type Unknown<Discriminator extends string, UnknownValue = "UNKNOWN"> = {
+    [K in Discriminator]: UnknownValue;
+} & {
+    raw: unknown;
+    isUnknown: true;
+};
+export declare function isUnknown<Discriminator extends string>(value: unknown): value is Unknown<Discriminator>;
+/**
+ * Forward-compatible discriminated union parser.
+ *
+ * If the input does not match one of the predefined options, it will be
+ * captured and available as `{ raw: <original input>, [discriminator]: "UNKNOWN", isUnknown: true }`.
+ *
+ * @param inputPropertyName - The discriminator property name in the input payload
+ * @param options - Map of discriminator values to their corresponding schemas
+ * @param opts - Optional configuration object
+ * @param opts.unknownValue - The value to use for the discriminator when the input is unknown (default: "UNKNOWN")
+ * @param opts.outputPropertyName - Output property name if the sanitized (camelCase) property name differs from inputPropertyName
+ */
+export declare function discriminatedUnion<InputDiscriminator extends string, TOptions extends Readonly<Record<string, z.ZodMiniType>>, UnknownValue extends string = "UNKNOWN", OutputDiscriminator extends string = InputDiscriminator>(inputPropertyName: InputDiscriminator, options: TOptions, opts?: {
+    unknownValue?: UnknownValue;
+    outputPropertyName?: OutputDiscriminator;
+}): z.ZodMiniType<z.output<TOptions[keyof TOptions]> | Unknown<OutputDiscriminator, UnknownValue>, unknown>;

package/esm/types/discriminated-union.js

@@ -0,0 +1,60 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { startCountingDefaultToZeroValue } from "./default-to-zero-value.js";
+import { startCountingUnrecognized } from "./unrecognized.js";
+const UNKNOWN = Symbol("UNKNOWN");
+export function isUnknown(value) {
+    return typeof value === "object" && value !== null && UNKNOWN in value;
+}
+/**
+ * Forward-compatible discriminated union parser.
+ *
+ * If the input does not match one of the predefined options, it will be
+ * captured and available as `{ raw: <original input>, [discriminator]: "UNKNOWN", isUnknown: true }`.
+ *
+ * @param inputPropertyName - The discriminator property name in the input payload
+ * @param options - Map of discriminator values to their corresponding schemas
+ * @param opts - Optional configuration object
+ * @param opts.unknownValue - The value to use for the discriminator when the input is unknown (default: "UNKNOWN")
+ * @param opts.outputPropertyName - Output property name if the sanitized (camelCase) property name differs from inputPropertyName
+ */
+export function discriminatedUnion(inputPropertyName, options, opts = {}) {
+    const { unknownValue = "UNKNOWN", outputPropertyName } = opts;
+    return z.pipe(z.unknown(), z.transform((input) => {
+        const fallback = Object.defineProperties({
+            raw: input,
+            [outputPropertyName ?? inputPropertyName]: unknownValue,
+            isUnknown: true,
+        }, { [UNKNOWN]: { value: true, enumerable: false, configurable: false } });
+        const isObject = typeof input === "object" && input !== null;
+        if (!isObject)
+            return fallback;
+        const discriminator = input[inputPropertyName];
+        if (typeof discriminator !== "string")
+            return fallback;
+        if (!(discriminator in options))
+            return fallback;
+        const schema = options[discriminator];
+        if (!schema)
+            return fallback;
+        // Start counters before parsing to track nested unrecognized/zeroDefault values
+        const unrecognizedCtr = startCountingUnrecognized();
+        const zeroDefaultCtr = startCountingDefaultToZeroValue();
+        const result = z.safeParse(schema, input);
+        if (!result.success) {
+            // Parse failed - don't propagate any counts from the failed attempt
+            unrecognizedCtr.end(0);
+            zeroDefaultCtr.end(0);
+            return fallback;
+        }
+        // Parse succeeded - propagate the actual counts
+        unrecognizedCtr.end();
+        zeroDefaultCtr.end();
+        if (outputPropertyName) {
+            result.data[outputPropertyName] = discriminator;
+        }
+        return result.data;
+    }));
+}

package/esm/types/smart-union.js

@@ -4,6 +4,7 @@
 // Not needed if lax mode
 import * as z from "zod/v4-mini";
 import { startCountingDefaultToZeroValue } from "./default-to-zero-value.js";
+import { isUnknown as isDiscriminatedUnionUnknown } from "./discriminated-union.js";
 import { RFCDate } from "./rfcdate.js";
 import { startCountingUnrecognized } from "./unrecognized.js";
 /**
@@ -87,7 +88,7 @@ function countFieldsRecursive(parsed) {
     let index = 0;
     while (index < queue.length) {
         const value = queue[index++];
-        if (value === undefined) {
+        if (value === undefined || isDiscriminatedUnionUnknown(value)) {
             continue;
         }
         // Check if it's a primitive value