@usestatemachines/sdk 0.7.1 → 0.8.0

package/esm/extensions/client.js

@@ -2,7 +2,7 @@ import { SDK_METADATA } from '../lib/config.js';
 import { HTTPClient } from '../lib/http.js';
 import { StateMachines as Generated } from '../sdk/sdk.js';
 import { bindCredentials } from './credentials.js';
-import { CallerAbortedError, StateMachinesError, toStateMachinesError, } from './errors.js';
+import { CallerAbortedError, toStateMachinesError } from './errors.js';
 import { linkSignal } from './signal.js';
 import { environmentAt, poll, snapshotAt, } from './wait.js';
 export class StateMachines {
@@ -10,10 +10,9 @@ export class StateMachines {
     #fetch;
     #workspaceId;
     #callSignals = new Map();
-    #apis = new Map();
     #lastCall = 0;
     constructor(options = {}) {
-        const apiKey = options.apiKey ?? environmentApiKey();
+        const apiKey = options.apiKey ?? environmentVariable('STATEMACHINES_API_KEY');
         if (!apiKey) {
             throw new TypeError('Pass apiKey or set STATEMACHINES_API_KEY.');
         }
@@ -25,6 +24,7 @@ export class StateMachines {
         if (!(attemptTimeoutMs > 0 && Number.isFinite(attemptTimeoutMs))) {
             throw new RangeError('attemptTimeoutMs must be a positive, finite number.');
         }
+        const baseUrl = baseUrlOrigin(options.baseUrl ?? environmentVariable('STATEMACHINES_BASE_URL'));
         const fetcher = options.fetch;
         // The arrow keeps `this` unbound; runtimes such as workerd reject fetch called on another object.
         const httpClient = new HTTPClient(fetcher ? { fetcher: (input) => fetcher(input) } : {});
@@ -35,10 +35,10 @@ export class StateMachines {
             apiKey,
             userAgent: `statemachines-sdk-ts/${SDK_METADATA.sdkVersion}`,
             httpClient,
-            ...(options.baseUrl ? { serverURL: options.baseUrl } : {}),
+            ...(baseUrl === undefined ? {} : { serverURL: baseUrl }),
         });
     }
-    /** The caller: its principal, organization, workspace, permissions and limits. */
+    /** The caller: its credential, principal, organization, workspace, permissions and limits. */
     me() {
         return this.#call(undefined, (call) => this.#sdk.me(call));
     }
@@ -80,7 +80,7 @@ export class StateMachines {
          */
         wait: async (environmentId, options) => this.#bind(await poll(environmentId, (signal) => this.#read(signal, (call) => this.#sdk.environments.get({ environmentId }, call)), environmentAt(options.status), options)),
         /** Credentials for one app of the environment. */
-        connect: (environmentId, app, options = {}) => this.#connect(environmentId, null, app, options),
+        connect: (environmentId, appName, options = {}) => this.#connect(environmentId, appName, options),
     };
     snapshots = {
         /** Creates a snapshot of a running environment and, unless `wait` is false, waits until it is `ready`. */
@@ -129,51 +129,18 @@ export class StateMachines {
             ? { ...input, workspaceId: this.#workspaceId }
             : input;
     }
-    async #connect(environmentId, known, app, options) {
-        const body = options.actorId === undefined ? {} : { actorId: options.actorId };
-        const [credentials, apis] = await Promise.all([
-            this.#call(undefined, (call) => this.#sdk.environments.connect({ environmentId, appName: app, body }, call)),
-            (async () => {
-                const environment = known ?? (await this.environments.get(environmentId));
-                const entry = environment.apps.find(({ name }) => name === app);
-                return entry ? this.#versionApis(entry.appId, entry.versionId) : [];
-            })(),
-        ]);
-        return bindCredentials(credentials, apis, this.#fetch);
-    }
-    /** A version's APIs never change, so each is read once per client. */
-    #versionApis(appId, versionId) {
-        let apis = this.#apis.get(versionId);
-        if (!apis) {
-            apis = this.#findVersion(appId, versionId);
-            apis.catch(() => this.#apis.delete(versionId));
-            this.#apis.set(versionId, apis);
-        }
-        return apis;
-    }
-    async #findVersion(appId, versionId) {
-        let cursor;
-        do {
-            const page = await this.apps.versions(appId, cursor ? { cursor } : {});
-            const version = page.data.find(({ id }) => id === versionId);
-            if (version) {
-                return version.apis;
-            }
-            cursor = page.nextCursor ?? undefined;
-        } while (cursor);
-        throw new StateMachinesError({
-            message: `Version ${versionId} of ${appId} was not found.`,
-            status: null,
-            code: 'not_found',
-            requestId: null,
-            fields: null,
-            retryAfterMs: null,
-        });
+    async #connect(environmentId, appName, options) {
+        const body = {
+            ...(options.actorId === undefined ? {} : { actorId: options.actorId }),
+            ...(options.services === undefined ? {} : { services: options.services }),
+        };
+        const credentials = await this.#call(undefined, (call) => this.#sdk.environments.connect({ environmentId, appName, body }, call));
+        return bindCredentials(credentials, this.#fetch);
     }
     #bind(data) {
         const { id } = data;
         const helpers = {
-            connect: (app, options = {}) => this.#connect(id, data, app, options),
+            connect: (appName, options = {}) => this.#connect(id, appName, options),
             delete: (options) => this.environments.delete(id, options),
             refresh: () => this.environments.get(id),
             snapshots: {
@@ -257,7 +224,23 @@ function waitOptions(options) {
         ...(options.signal ? { signal: options.signal } : {}),
     };
 }
-function environmentApiKey() {
+function baseUrlOrigin(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const origin = value.endsWith('/') ? value.slice(0, -1) : value;
+    const url = URL.canParse(origin) ? new URL(origin) : undefined;
+    if (!url ||
+        /[{}]/.test(origin) ||
+        origin !== url.origin ||
+        !(url.protocol === 'https:' ||
+            (url.protocol === 'http:' &&
+                (url.hostname === 'localhost' || url.hostname === '127.0.0.1')))) {
+        throw new TypeError('baseUrl or STATEMACHINES_BASE_URL must be an HTTPS origin, or HTTP with localhost or 127.0.0.1.');
+    }
+    return origin;
+}
+function environmentVariable(name) {
     const runtime = globalThis;
-    return runtime.process?.env?.STATEMACHINES_API_KEY;
+    return runtime.process?.env?.[name];
 }

package/esm/extensions/credentials.d.ts

@@ -1,13 +1,30 @@
-import type { Api } from '../models/api.js';
-import type { Credentials as CredentialsData } from '../models/credentials.js';
-/** The API's `Credentials`, plus `fetch` to call the app with them. */
+import type { Credentials as CredentialsData, CredentialsService as CredentialsServiceData } from '../models/credentials.js';
+/** What a client needs to reach one MCP server of a service: send `headers` with every request to `url`. */
+export interface McpServerCredentials {
+    url: string;
+    headers: Record<string, string>;
+}
+/** One service from the credentials, plus `server` to hand one of its MCP servers to a client. */
+export type ServiceCredentials = CredentialsServiceData & {
+    /**
+     * The URL of one MCP server the service serves, with the service's headers.
+     * Throws a `TypeError` naming the served MCP servers when it serves no MCP server
+     * named `name`.
+     */
+    server(name: string): McpServerCredentials;
+};
+/** The API's `Credentials`, plus `fetch` to call the app and `service` to find one service. */
 export type Credentials = CredentialsData & {
     /**
-     * Sends one request to the app: `path` is joined to `url`, `headers` are added, and
-     * `token` goes in the header of the API whose path matches (`Authorization: Bearer`
-     * for Salesforce REST and Bulk 2.0). Never retries, never follows redirects, never
-     * sends the State Machines API key. The SOAP session header is the caller's job.
+     * Sends one request to the `api` service: `path` is joined to its `url`.
+     * Its `headers` are defaults, so a header the caller sets, such as another
+     * session's `Authorization`, is sent instead. The environment token header
+     * is always the service's. Never retries, never follows redirects, never
+     * sends the State Machines API key. Throws a `TypeError` when the
+     * credentials list no `api` service.
      */
     fetch(path: string, init?: RequestInit): Promise<Response>;
+    /** The service with this ID. Throws a `TypeError` naming the listed services when there is none. */
+    service(id: string): ServiceCredentials;
 };
-export declare function bindCredentials(data: CredentialsData, apis: readonly Api[], fetcher: typeof fetch | undefined): Credentials;
+export declare function bindCredentials(data: CredentialsData, fetcher: typeof fetch | undefined): Credentials;

package/esm/extensions/credentials.js

@@ -1,56 +1,91 @@
-const HTTP_TOKEN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+/** The gateway admits a request by this header, so a caller cannot replace it. */
+const ENVIRONMENT_TOKEN_HEADER = 'StateMachines-Environment-Token';
 // Checked on the path part only. Covers protocol-relative starts, backslashes, control
 // characters and encoded dots, slashes and backslashes, including double encoding.
 const UNSAFE_PATH = /^\/\/|\\|%(?:25)*(?:2e|2f|5c)|\p{Cc}/iu;
-const OUTSIDE = 'Credentials.fetch only reaches paths under the app url.';
-export function bindCredentials(data, apis, fetcher) {
-    const base = URL.canParse(data.url) ? new URL(data.url) : null;
-    if (!base || !/^https?:$/.test(base.protocol) || base.search || base.hash) {
-        throw new TypeError('The credentials url is not a plain http(s) URL.');
-    }
-    if (!base.pathname.endsWith('/')) {
-        base.pathname += '/';
+const OUTSIDE = 'Credentials.fetch only reaches paths under the api service url.';
+export function bindCredentials(data, fetcher) {
+    return new BoundCredentials(data, fetcher);
+}
+// Methods live on the prototype, so neither JSON nor a spread copies them.
+class BoundCredentials {
+    actorId;
+    appName;
+    environmentId;
+    expiresAt;
+    login;
+    services;
+    token;
+    #api;
+    #fetcher;
+    constructor(data, fetcher) {
+        this.actorId = data.actorId;
+        this.appName = data.appName;
+        this.environmentId = data.environmentId;
+        this.expiresAt = data.expiresAt;
+        this.login = data.login;
+        this.services = data.services;
+        this.token = data.token;
+        this.#fetcher = fetcher;
+        const api = data.services.find((candidate) => candidate.id === 'api');
+        this.#api = api
+            ? { base: baseUrl(api.url), headers: { ...api.headers } }
+            : null;
     }
-    const send = async (path, init = {}) => {
+    async fetch(path, init = {}) {
+        const { base, headers: apiHeaders } = this.#api ?? this.#unlisted('api');
         const url = resolve(base, path);
         const headers = new Headers(init.headers);
-        const actor = actorHeader(apis, `/${url.pathname.slice(base.pathname.length)}`, data.token);
-        // Ours go last so a caller header of the same name cannot replace them.
-        for (const [name, value] of Object.entries(data.headers)) {
-            headers.set(name, value);
-        }
-        if (actor) {
-            headers.set(actor.name, actor.value);
+        for (const [name, value] of Object.entries(apiHeaders)) {
+            if (!headers.has(name) ||
+                name.toLowerCase() === ENVIRONMENT_TOKEN_HEADER.toLowerCase()) {
+                headers.set(name, value);
+            }
         }
         const request = new Request(url, { ...init, headers, redirect: 'manual' });
         // Called on `globalThis` at use time: a stored unbound `fetch` throws "Illegal invocation" in Workers.
-        return fetcher ? fetcher(request) : globalThis.fetch(request);
-    };
-    return Object.defineProperty({ ...data }, 'fetch', {
-        value: send,
-        enumerable: false,
-    });
+        return this.#fetcher ? this.#fetcher(request) : globalThis.fetch(request);
+    }
+    service(id) {
+        const entry = this.services.find((candidate) => candidate.id === id);
+        return entry ? new BoundService(entry) : this.#unlisted(id);
+    }
+    #unlisted(id) {
+        const listed = this.services.map((each) => each.id).join(', ') || 'none';
+        throw new TypeError(`These credentials list no service named ${JSON.stringify(id)}. They list ${listed}.`);
+    }
 }
-/** The longest `pathTemplate` that prefixes the path names the API; `{...}` matches one segment. */
-function actorHeader(apis, path, token) {
-    let match = null;
-    for (const api of apis) {
-        const pattern = api.pathTemplate
-            .replace(/\/+$/, '')
-            .split(/\{[^}]*\}/)
-            .map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
-            .join('[^/]+');
-        if (new RegExp(`^${pattern}(?:/|$)`).test(path) &&
-            api.pathTemplate.length > (match?.pathTemplate.length ?? -1)) {
-            match = api;
+class BoundService {
+    headers;
+    id;
+    url;
+    constructor(entry) {
+        this.headers = entry.headers;
+        this.id = entry.id;
+        this.url = entry.url;
+        // Set only when present, so a spread or JSON of a service without servers has no `servers` key.
+        if (entry.servers) {
+            this.servers = entry.servers;
+        }
+    }
+    server(name) {
+        const found = this.servers?.find((candidate) => candidate.name === name);
+        if (!found) {
+            const served = this.servers?.map((each) => each.name).join(', ') || 'none';
+            throw new TypeError(`The ${this.id} service serves no MCP server named ${JSON.stringify(name)}. It serves ${served}.`);
         }
+        return { url: found.url, headers: { ...this.headers } };
+    }
+}
+function baseUrl(url) {
+    const base = URL.canParse(url) ? new URL(url) : null;
+    if (!base || !/^https?:$/.test(base.protocol) || base.search || base.hash) {
+        throw new TypeError('The api service url is not a plain http(s) URL.');
     }
-    if (!match || !HTTP_TOKEN.test(match.actorHeader)) {
-        return null;
+    if (!base.pathname.endsWith('/')) {
+        base.pathname += '/';
     }
-    return match.actorHeader.toLowerCase() === 'authorization'
-        ? { name: 'Authorization', value: `Bearer ${token}` }
-        : { name: match.actorHeader, value: token };
+    return base;
 }
 function resolve(base, path) {
     const pathPart = path.split(/[?#]/, 1)[0] ?? '';

package/esm/extensions/environment.d.ts

@@ -9,7 +9,7 @@ import type { Credentials } from './credentials.js';
 export type Environment = EnvironmentData & EnvironmentHelpers;
 export interface EnvironmentHelpers {
     /** Credentials for one app; `actorId` defaults to the app's default actor. */
-    connect(app: string, options?: ConnectOptions): Promise<Credentials>;
+    connect(appName: string, options?: ConnectOptions): Promise<Credentials>;
     delete(options?: SignalOptions): Promise<Environment>;
     /** Reads the environment again. */
     refresh(): Promise<Environment>;

package/esm/extensions/errors.js

@@ -48,7 +48,7 @@ export class EnvironmentFailedError extends StateMachinesError {
         super({
             ...noResponse,
             message: failure
-                ? `Environment ${environment.id} failed: ${failure.message} (${failure.code}, app ${failure.app}).`
+                ? `Environment ${environment.id} failed: ${failure.message} (${failure.code}, app ${failure.appName}).`
                 : `Environment ${environment.id} failed.`,
         });
         this.environment = environment;

package/esm/extensions/index.d.ts

@@ -1,7 +1,7 @@
-export type { Actor, Api, App, AuditEvent, BodyPreview, CreateEnvironment, CreateEnvironmentApp, EnvironmentApp, EnvironmentFailure, EnvironmentFailureCode, EnvironmentStatus, ErrorCode, Me, Permission, Principal, RequestDetail, RequestStats, RequestT as Request, Snapshot, SnapshotStatus, Version, Workspace, } from '../models/index.js';
+export type { Actor, App, AppEntry, AuditEvent, BodyPreview, CreateEnvironment, CreateEnvironmentApp, EnvironmentApp, EnvironmentFailure, EnvironmentFailureCode, EnvironmentStatus, ErrorCode, Me, Permission, Principal, RequestDetail, RequestStats, RequestT as Request, Snapshot, SnapshotStatus, Version, Workspace, } from '../models/index.js';
 export type { ConnectOptions, CreateEnvironmentOptions, CreateSnapshotOptions, ListAuditEventsQuery, ListEnvironmentsQuery, ListRequestsQuery, ListSnapshotsQuery, ListWorkspacesQuery, Page, PageQuery, RequestStatsQuery, SignalOptions, StateMachinesOptions, } from './client.js';
 export { StateMachines } from './client.js';
-export type { Credentials } from './credentials.js';
+export type { Credentials, McpServerCredentials, ServiceCredentials, } from './credentials.js';
 export type { Environment, EnvironmentHelpers } from './environment.js';
 export { EnvironmentFailedError, SnapshotFailedError, StateMachinesError, UnexpectedStatusError, WaitTimeoutError, } from './errors.js';
 export type { WaitOptions } from './wait.js';

package/esm/extensions/yaml.js

@@ -1,6 +1,6 @@
 import { isAlias, isScalar, parseDocument, visit } from 'yaml';
 import { invalidInput } from './errors.js';
-const APP_FIELDS = new Set(['app', 'name', 'settings']);
+const APP_FIELDS = new Set(['appId', 'name', 'setup', 'services']);
 /**
  * Parses a YAML document with the fields of `CreateEnvironment`. The SDK checks the shape;
  * the API checks the values. Anchors, aliases, tags and duplicate keys are refused.
@@ -97,8 +97,8 @@ export function parseEnvironmentYaml(text) {
                 add(key, 'Unknown field.');
         }
     }
-    if ('apps' in value === 'snapshotId' in value) {
-        add('$', 'Pass exactly one of apps and snapshotId.');
+    if (!('apps' in value) && !('snapshotId' in value)) {
+        add('$', 'Send apps, snapshotId or both.');
     }
     if (Object.keys(fields).length > 0) {
         throw bad(fields);
@@ -110,22 +110,24 @@ function checkApp(app, path, add) {
         return;
     }
     if (!isRecord(app)) {
-        add(path, 'Expected an app ID or a mapping with app.');
+        add(path, 'Expected an app ID or a mapping with appId.');
         return;
     }
-    const { app: id, name, settings } = app;
-    if (typeof id !== 'string') {
-        add(`${path}.app`, 'Expected a string.');
+    const { appId, name } = app;
+    if (typeof appId !== 'string') {
+        add(`${path}.appId`, 'Expected a string.');
     }
     if ('name' in app && typeof name !== 'string') {
         add(`${path}.name`, 'Expected a string.');
     }
-    if ('settings' in app && !isRecord(settings)) {
-        add(`${path}.settings`, 'Expected a mapping.');
+    for (const field of ['setup', 'services']) {
+        if (field in app && !isRecord(app[field])) {
+            add(`${path}.${field}`, 'Expected a mapping.');
+        }
     }
-    for (const key of Object.keys(app)) {
-        if (!APP_FIELDS.has(key)) {
-            add(`${path}.${key}`, 'Unknown field.');
+    for (const field of Object.keys(app)) {
+        if (!APP_FIELDS.has(field)) {
+            add(`${path}.${field}`, 'Unknown field.');
         }
     }
 }

package/esm/funcs/environments-creators.d.ts

@@ -0,0 +1,11 @@
+import { StateMachinesCore } from "../core.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { ConnectionError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, UnexpectedClientError } from "../models/errors/http-client-errors.js";
+import * as errors from "../models/errors/index.js";
+import { ResponseValidationError } from "../models/errors/response-validation-error.js";
+import { SDKValidationError } from "../models/errors/sdk-validation-error.js";
+import { StateMachinesHTTPError } from "../models/errors/state-machines-http-error.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+export declare function environmentsCreators(client: StateMachinesCore, request?: operations.ListEnvironmentCreatorsRequest | undefined, options?: RequestOptions): APIPromise<Result<operations.ListEnvironmentCreatorsResponse, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/environments-creators.js

@@ -0,0 +1,90 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { encodeFormQuery } from "../lib/encodings.js";
+import { matchStatusCode } from "../lib/http.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.js";
+import * as errors from "../models/errors/index.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+export function environmentsCreators(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => z.parse(z.optional(operations.ListEnvironmentCreatorsRequest$outboundSchema), value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = null;
+    const path = pathToFunc("/v1/environments/creators")();
+    const query = encodeFormQuery({
+        "workspaceId": payload?.workspaceId,
+    });
+    const headers = new Headers(compactMap({
+        Accept: "application/json",
+    }));
+    const secConfig = await extractSecurity(client._options.apiKey);
+    const securityInput = secConfig == null ? {} : { apiKey: secConfig };
+    const requestSecurity = resolveGlobalSecurity(securityInput);
+    const context = {
+        options: client._options,
+        baseURL: options?.serverURL ?? client._baseURL ?? "",
+        operationID: "listEnvironmentCreators",
+        oAuth2Scopes: null,
+        resolvedSecurity: requestSecurity,
+        securitySource: client._options.apiKey,
+        retryConfig: options?.retries
+            || client._options.retryConfig
+            || {
+                strategy: "backoff",
+                backoff: {
+                    initialInterval: 1000,
+                    maxInterval: 5000,
+                    exponent: 1.5,
+                    maxElapsedTime: 600000,
+                },
+                retryConnectionErrors: true,
+            }
+            || { strategy: "none" },
+        retryCodes: options?.retryCodes || ["502", "503", "504"],
+    };
+    const requestRes = client._createRequest(context, {
+        security: requestSecurity,
+        method: "GET",
+        baseURL: options?.serverURL,
+        path: path,
+        headers: headers,
+        query: query,
+        body: body,
+        userAgent: client._options.userAgent,
+        timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+    }, options);
+    if (!requestRes.ok) {
+        return [requestRes, { status: "invalid" }];
+    }
+    const req = requestRes.value;
+    const doResult = await client._do(req, {
+        context,
+        isErrorStatusCode: (statusCode) => matchStatusCode({ status: statusCode }, ["4XX", "5XX"]),
+        retryConfig: context.retryConfig,
+        retryCodes: context.retryCodes,
+    });
+    if (!doResult.ok) {
+        return [doResult, { status: "request-error", request: req }];
+    }
+    const response = doResult.value;
+    const responseFields = {
+        HttpMeta: { Response: response, Request: req },
+    };
+    const [result] = await M.match(M.json(200, operations.ListEnvironmentCreatorsResponse$inboundSchema), M.jsonErr([400, 401, 403, 404, 409, 413, 422, 429], errors.ErrorT$inboundSchema), M.jsonErr([500, 503], errors.ErrorT$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    if (!result.ok) {
+        return [result, { status: "complete", request: req, response }];
+    }
+    return [result, { status: "complete", request: req, response }];
+}

package/esm/funcs/environments-list.js

@@ -24,6 +24,8 @@ async function $do(client, request, options) {
     const body = null;
     const path = pathToFunc("/v1/environments")();
     const query = encodeFormQuery({
+        "appId": payload?.appId,
+        "createdBy": payload?.createdBy,
         "cursor": payload?.cursor,
         "label": payload?.label,
         "limit": payload?.limit,

package/esm/funcs/requests-list.js

@@ -24,16 +24,20 @@ async function $do(client, request, options) {
     const body = null;
     const path = pathToFunc("/v1/requests")();
     const query = encodeFormQuery({
-        "app": payload.app,
+        "appName": payload.appName,
         "cursor": payload.cursor,
         "environmentId": payload.environmentId,
         "from": payload.from,
         "limit": payload.limit,
+        "mcpServer": payload.mcpServer,
         "method": payload.method,
+        "operation": payload.operation,
         "responseStatus": payload.responseStatus,
         "search": payload.search,
+        "service": payload.service,
         "statusClass": payload.statusClass,
         "to": payload.to,
+        "tool": payload.tool,
         "writesOnly": payload.writesOnly,
     });
     const headers = new Headers(compactMap({

package/esm/funcs/requests-stats.js

@@ -25,14 +25,18 @@ async function $do(client, request, options) {
     const body = null;
     const path = pathToFunc("/v1/requests/stats")();
     const query = encodeFormQuery({
-        "app": payload.app,
+        "appName": payload.appName,
         "environmentId": payload.environmentId,
         "from": payload.from,
+        "mcpServer": payload.mcpServer,
         "method": payload.method,
+        "operation": payload.operation,
         "responseStatus": payload.responseStatus,
         "search": payload.search,
+        "service": payload.service,
         "statusClass": payload.statusClass,
         "to": payload.to,
+        "tool": payload.tool,
         "writesOnly": payload.writesOnly,
     });
     const headers = new Headers(compactMap({

package/esm/lib/config.d.ts

@@ -31,7 +31,7 @@ export declare function serverURLFromOptions(options: SDKOptions): URL | null;
 export declare const SDK_METADATA: {
     readonly language: "typescript";
     readonly openapiDocVersion: "1.0.0";
-    readonly sdkVersion: "0.7.1";
+    readonly sdkVersion: "0.8.0";
     readonly genVersion: "2.941.0";
-    readonly userAgent: "speakeasy-sdk/typescript 0.7.1 2.941.0 1.0.0 @usestatemachines/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 0.8.0 2.941.0 1.0.0 @usestatemachines/sdk";
 };

package/esm/lib/config.js

@@ -24,7 +24,7 @@ export function serverURLFromOptions(options) {
 export const SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0.0",
-    sdkVersion: "0.7.1",
+    sdkVersion: "0.8.0",
     genVersion: "2.941.0",
-    userAgent: "speakeasy-sdk/typescript 0.7.1 2.941.0 1.0.0 @usestatemachines/sdk",
+    userAgent: "speakeasy-sdk/typescript 0.8.0 2.941.0 1.0.0 @usestatemachines/sdk",
 };

package/esm/models/app-entry.d.ts

@@ -0,0 +1,8 @@
+import * as z from "zod/v4-mini";
+import { CreateEnvironmentApp, CreateEnvironmentApp$Outbound } from "./create-environment-app.js";
+export type AppEntry = CreateEnvironmentApp | string;
+/** @internal */
+export type AppEntry$Outbound = CreateEnvironmentApp$Outbound | string;
+/** @internal */
+export declare const AppEntry$outboundSchema: z.ZodMiniType<AppEntry$Outbound, AppEntry>;
+export declare function appEntryToJSON(appEntry: AppEntry): string;

package/esm/models/app-entry.js

@@ -0,0 +1,11 @@
+/*
+ * 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 { CreateEnvironmentApp$outboundSchema, } from "./create-environment-app.js";
+/** @internal */
+export const AppEntry$outboundSchema = smartUnion([CreateEnvironmentApp$outboundSchema, z.string()]);
+export function appEntryToJSON(appEntry) {
+    return JSON.stringify(AppEntry$outboundSchema.parse(appEntry));
+}

package/esm/models/create-environment-app.d.ts

@@ -0,0 +1,25 @@
+import * as z from "zod/v4-mini";
+export type CreateEnvironmentApp = {
+    appId: string;
+    name?: string | undefined;
+    services?: {
+        [k: string]: any;
+    } | undefined;
+    setup?: {
+        [k: string]: any;
+    } | undefined;
+};
+/** @internal */
+export type CreateEnvironmentApp$Outbound = {
+    appId: string;
+    name?: string | undefined;
+    services?: {
+        [k: string]: any;
+    } | undefined;
+    setup?: {
+        [k: string]: any;
+    } | undefined;
+};
+/** @internal */
+export declare const CreateEnvironmentApp$outboundSchema: z.ZodMiniType<CreateEnvironmentApp$Outbound, CreateEnvironmentApp>;
+export declare function createEnvironmentAppToJSON(createEnvironmentApp: CreateEnvironmentApp): string;

package/esm/models/create-environment-app.js

@@ -0,0 +1,14 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+/** @internal */
+export const CreateEnvironmentApp$outboundSchema = z.object({
+    appId: z.string(),
+    name: z.optional(z.string()),
+    services: z.optional(z.record(z.string(), z.any())),
+    setup: z.optional(z.record(z.string(), z.any())),
+});
+export function createEnvironmentAppToJSON(createEnvironmentApp) {
+    return JSON.stringify(CreateEnvironmentApp$outboundSchema.parse(createEnvironmentApp));
+}