@meetkai/mka1 0.54.85 → 0.54.88

package/src/react-query/sandboxNetworkPoliciesGet.ts

@@ -0,0 +1,154 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import {
+  InvalidateQueryFilters,
+  QueryClient,
+  useQuery,
+  UseQueryResult,
+  useSuspenseQuery,
+  UseSuspenseQueryResult,
+} from "@tanstack/react-query";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../models/errors/httpclienterrors.js";
+import * as errors from "../models/errors/index.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { SDKError } from "../models/errors/sdkerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as operations from "../models/operations/index.js";
+import { useSDKContext } from "./_context.js";
+import {
+  QueryHookOptions,
+  SuspenseQueryHookOptions,
+  TupleToPrefixes,
+} from "./_types.js";
+import {
+  buildSandboxNetworkPoliciesGetQuery,
+  prefetchSandboxNetworkPoliciesGet,
+  queryKeySandboxNetworkPoliciesGet,
+  SandboxNetworkPoliciesGetQueryData,
+} from "./sandboxNetworkPoliciesGet.core.js";
+export {
+  buildSandboxNetworkPoliciesGetQuery,
+  prefetchSandboxNetworkPoliciesGet,
+  queryKeySandboxNetworkPoliciesGet,
+  type SandboxNetworkPoliciesGetQueryData,
+};
+
+export type SandboxNetworkPoliciesGetQueryError =
+  | errors.HTTPValidationError
+  | SDKError
+  | ResponseValidationError
+  | ConnectionError
+  | RequestAbortedError
+  | RequestTimeoutError
+  | InvalidRequestError
+  | UnexpectedClientError
+  | SDKValidationError;
+
+/**
+ * Get Tenant Network Policy
+ *
+ * @remarks
+ * Read the authenticated tenant policy; optional expected IDs reject workspace changes, never select tenancy.
+ */
+export function useSandboxNetworkPoliciesGet(
+  request: operations.GetTenantNetworkPolicyRequest,
+  options?: QueryHookOptions<
+    SandboxNetworkPoliciesGetQueryData,
+    SandboxNetworkPoliciesGetQueryError
+  >,
+): UseQueryResult<
+  SandboxNetworkPoliciesGetQueryData,
+  SandboxNetworkPoliciesGetQueryError
+> {
+  const client = useSDKContext();
+  return useQuery({
+    ...buildSandboxNetworkPoliciesGetQuery(
+      client,
+      request,
+      options,
+    ),
+    ...options,
+  });
+}
+
+/**
+ * Get Tenant Network Policy
+ *
+ * @remarks
+ * Read the authenticated tenant policy; optional expected IDs reject workspace changes, never select tenancy.
+ */
+export function useSandboxNetworkPoliciesGetSuspense(
+  request: operations.GetTenantNetworkPolicyRequest,
+  options?: SuspenseQueryHookOptions<
+    SandboxNetworkPoliciesGetQueryData,
+    SandboxNetworkPoliciesGetQueryError
+  >,
+): UseSuspenseQueryResult<
+  SandboxNetworkPoliciesGetQueryData,
+  SandboxNetworkPoliciesGetQueryError
+> {
+  const client = useSDKContext();
+  return useSuspenseQuery({
+    ...buildSandboxNetworkPoliciesGetQuery(
+      client,
+      request,
+      options,
+    ),
+    ...options,
+  });
+}
+
+export function setSandboxNetworkPoliciesGetData(
+  client: QueryClient,
+  queryKeyBase: [
+    scope: operations.Scope,
+    parameters: {
+      expectedOrganizationId?: string | null | undefined;
+      expectedTeamId?: string | null | undefined;
+      xOnBehalfOf?: string | undefined;
+    },
+  ],
+  data: SandboxNetworkPoliciesGetQueryData,
+): SandboxNetworkPoliciesGetQueryData | undefined {
+  const key = queryKeySandboxNetworkPoliciesGet(...queryKeyBase);
+
+  return client.setQueryData<SandboxNetworkPoliciesGetQueryData>(key, data);
+}
+
+export function invalidateSandboxNetworkPoliciesGet(
+  client: QueryClient,
+  queryKeyBase: TupleToPrefixes<
+    [
+      scope: operations.Scope,
+      parameters: {
+        expectedOrganizationId?: string | null | undefined;
+        expectedTeamId?: string | null | undefined;
+        xOnBehalfOf?: string | undefined;
+      },
+    ]
+  >,
+  filters?: Omit<InvalidateQueryFilters, "queryKey" | "predicate" | "exact">,
+): Promise<void> {
+  return client.invalidateQueries({
+    ...filters,
+    queryKey: ["@meetkai/mka1", "networkPolicies", "get", ...queryKeyBase],
+  });
+}
+
+export function invalidateAllSandboxNetworkPoliciesGet(
+  client: QueryClient,
+  filters?: Omit<InvalidateQueryFilters, "queryKey" | "predicate" | "exact">,
+): Promise<void> {
+  return client.invalidateQueries({
+    ...filters,
+    queryKey: ["@meetkai/mka1", "networkPolicies", "get"],
+  });
+}

package/src/react-query/sandboxNetworkPoliciesSet.ts

@@ -0,0 +1,112 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import {
+  MutationKey,
+  useMutation,
+  UseMutationResult,
+} from "@tanstack/react-query";
+import { SDKCore } from "../core.js";
+import { sandboxNetworkPoliciesSet } from "../funcs/sandboxNetworkPoliciesSet.js";
+import { combineSignals } from "../lib/primitives.js";
+import { RequestOptions } from "../lib/sdks.js";
+import * as components from "../models/components/index.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../models/errors/httpclienterrors.js";
+import * as errors from "../models/errors/index.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { SDKError } from "../models/errors/sdkerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+import { useSDKContext } from "./_context.js";
+import { MutationHookOptions } from "./_types.js";
+
+export type SandboxNetworkPoliciesSetMutationVariables = {
+  request: operations.SetTenantNetworkPolicyRequest;
+  options?: RequestOptions;
+};
+
+export type SandboxNetworkPoliciesSetMutationData =
+  components.TenantNetworkPolicy;
+
+export type SandboxNetworkPoliciesSetMutationError =
+  | errors.HTTPValidationError
+  | SDKError
+  | ResponseValidationError
+  | ConnectionError
+  | RequestAbortedError
+  | RequestTimeoutError
+  | InvalidRequestError
+  | UnexpectedClientError
+  | SDKValidationError;
+
+/**
+ * Set Tenant Network Policy
+ *
+ * @remarks
+ * Administrator-only update with optimistic revision checking. An enabled empty list denies all outbound hosts.
+ */
+export function useSandboxNetworkPoliciesSetMutation(
+  options?: MutationHookOptions<
+    SandboxNetworkPoliciesSetMutationData,
+    SandboxNetworkPoliciesSetMutationError,
+    SandboxNetworkPoliciesSetMutationVariables
+  >,
+): UseMutationResult<
+  SandboxNetworkPoliciesSetMutationData,
+  SandboxNetworkPoliciesSetMutationError,
+  SandboxNetworkPoliciesSetMutationVariables
+> {
+  const client = useSDKContext();
+  return useMutation({
+    ...buildSandboxNetworkPoliciesSetMutation(client, options),
+    ...options,
+  });
+}
+
+export function mutationKeySandboxNetworkPoliciesSet(): MutationKey {
+  return ["@meetkai/mka1", "networkPolicies", "set"];
+}
+
+export function buildSandboxNetworkPoliciesSetMutation(
+  client$: SDKCore,
+  hookOptions?: RequestOptions,
+): {
+  mutationKey: MutationKey;
+  mutationFn: (
+    variables: SandboxNetworkPoliciesSetMutationVariables,
+  ) => Promise<SandboxNetworkPoliciesSetMutationData>;
+} {
+  return {
+    mutationKey: mutationKeySandboxNetworkPoliciesSet(),
+    mutationFn: function sandboxNetworkPoliciesSetMutationFn({
+      request,
+      options,
+    }): Promise<SandboxNetworkPoliciesSetMutationData> {
+      const mergedOptions = {
+        ...hookOptions,
+        ...options,
+        fetchOptions: {
+          ...hookOptions?.fetchOptions,
+          ...options?.fetchOptions,
+          signal: combineSignals(
+            hookOptions?.fetchOptions?.signal,
+            options?.fetchOptions?.signal,
+          ),
+        },
+      };
+      return unwrapAsync(sandboxNetworkPoliciesSet(
+        client$,
+        request,
+        mergedOptions,
+      ));
+    },
+  };
+}

package/src/sdk/auth.ts

@@ -11,16 +11,16 @@ import { ServiceAccounts } from "./serviceaccounts.js";
 import { Teams } from "./teams.js";
 
 export class Auth extends ClientSDK {
-  private _apiKeys?: ApiKeys;
-  get apiKeys(): ApiKeys {
-    return (this._apiKeys ??= new ApiKeys(this._options));
-  }
-
   private _teams?: Teams;
   get teams(): Teams {
     return (this._teams ??= new Teams(this._options));
   }
 
+  private _apiKeys?: ApiKeys;
+  get apiKeys(): ApiKeys {
+    return (this._apiKeys ??= new ApiKeys(this._options));
+  }
+
   private _serviceAccounts?: ServiceAccounts;
   get serviceAccounts(): ServiceAccounts {
     return (this._serviceAccounts ??= new ServiceAccounts(this._options));

package/src/sdk/connectors.ts

@@ -0,0 +1,136 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { sandboxConnectorsConnect } from "../funcs/sandboxConnectorsConnect.js";
+import { sandboxConnectorsCreateAuthorizationIntent } from "../funcs/sandboxConnectorsCreateAuthorizationIntent.js";
+import { sandboxConnectorsDisconnect } from "../funcs/sandboxConnectorsDisconnect.js";
+import { sandboxConnectorsList } from "../funcs/sandboxConnectorsList.js";
+import { sandboxConnectorsListTools } from "../funcs/sandboxConnectorsListTools.js";
+import { sandboxConnectorsSetApiKey } from "../funcs/sandboxConnectorsSetApiKey.js";
+import { sandboxConnectorsSetTools } from "../funcs/sandboxConnectorsSetTools.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as components from "../models/components/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Connectors extends ClientSDK {
+  /**
+   * List Connectors
+   *
+   * @remarks
+   * List the connectors you can connect and your connection to each, or `null` when you have none. `status` is `needs_login` when the connector must be reconnected. `tool_allowlist` set to `null` means sessions may call every tool the connector lists, read or write. Only an environment with `network_access` set to `full` can list connectors, at most `max_per_environment` of them.
+   */
+  async list(
+    request: operations.ListSandboxConnectorsRequest,
+    options?: RequestOptions,
+  ): Promise<components.ConnectorCatalogModel> {
+    return unwrapAsync(sandboxConnectorsList(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Start Connector Sign-In
+   *
+   * @remarks
+   * Start connecting an OAuth connector to your account. Send the user to the returned `authorize_url`. The connector redirects back to the platform callback page with a `code` and the same `state`, which it passes to `POST /connectors/oauth/connections` before `expires_in_seconds` elapses. Each `state` works once, and only for the account that started the sign-in.
+   */
+  async createAuthorizationIntent(
+    request: operations.CreateSandboxConnectorAuthorizationIntentRequest,
+    options?: RequestOptions,
+  ): Promise<components.ConnectorAuthorizeIntentModel> {
+    return unwrapAsync(sandboxConnectorsCreateAuthorizationIntent(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Finish Connector Sign-In
+   *
+   * @remarks
+   * Exchange the `code` and `state` from the connector's redirect for a stored connection. Call it as the same signed-in user who started the sign-in. The sandbox service keeps the token encrypted and never returns it.
+   */
+  async connect(
+    request: operations.ConnectSandboxConnectorRequest,
+    options?: RequestOptions,
+  ): Promise<components.ConnectorModel> {
+    return unwrapAsync(sandboxConnectorsConnect(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Set Connector API Key
+   *
+   * @remarks
+   * Connect an API-key connector. The key is checked against the connector before it is stored (422 when the connector refuses it) and is never returned.
+   */
+  async setApiKey(
+    request: operations.SetSandboxConnectorApiKeyRequest,
+    options?: RequestOptions,
+  ): Promise<components.ConnectorModel> {
+    return unwrapAsync(sandboxConnectorsSetApiKey(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Disconnect Connector
+   *
+   * @remarks
+   * Delete your connection to a connector and revoke its token at the connector when it supports revocation. The connection is deleted even if the connector does not confirm the revocation.
+   */
+  async disconnect(
+    request: operations.DisconnectSandboxConnectorRequest,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(sandboxConnectorsDisconnect(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * List Connector Tools
+   *
+   * @remarks
+   * List the connector's tools now, with whether each is read-only, your tool allowlist, and `allowed`: the tools a session could call. 409 when the connector must be reconnected.
+   */
+  async listTools(
+    request: operations.ListSandboxConnectorToolsRequest,
+    options?: RequestOptions,
+  ): Promise<components.ConnectorToolsModel> {
+    return unwrapAsync(sandboxConnectorsListTools(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Set Connector Tool Allowlist
+   *
+   * @remarks
+   * Choose which of the connector's tools sessions may call. Send a list of tool names, or `null` to allow every tool the connector lists, read or write.
+   */
+  async setTools(
+    request: operations.SetSandboxConnectorToolsRequest,
+    options?: RequestOptions,
+  ): Promise<components.ConnectorModel> {
+    return unwrapAsync(sandboxConnectorsSetTools(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/networkpolicies.ts

@@ -0,0 +1,64 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { sandboxNetworkPoliciesEffective } from "../funcs/sandboxNetworkPoliciesEffective.js";
+import { sandboxNetworkPoliciesGet } from "../funcs/sandboxNetworkPoliciesGet.js";
+import { sandboxNetworkPoliciesSet } from "../funcs/sandboxNetworkPoliciesSet.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as components from "../models/components/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class NetworkPolicies extends ClientSDK {
+  /**
+   * Get Effective Network Policy
+   *
+   * @remarks
+   * Intersect the authenticated tenant's organization and team hostname allowlists.
+   */
+  async effective(
+    request: operations.GetEffectiveNetworkPolicyRequest,
+    options?: RequestOptions,
+  ): Promise<components.EffectiveNetworkPolicy> {
+    return unwrapAsync(sandboxNetworkPoliciesEffective(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get Tenant Network Policy
+   *
+   * @remarks
+   * Read the authenticated tenant policy; optional expected IDs reject workspace changes, never select tenancy.
+   */
+  async get(
+    request: operations.GetTenantNetworkPolicyRequest,
+    options?: RequestOptions,
+  ): Promise<components.TenantNetworkPolicy> {
+    return unwrapAsync(sandboxNetworkPoliciesGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Set Tenant Network Policy
+   *
+   * @remarks
+   * Administrator-only update with optimistic revision checking. An enabled empty list denies all outbound hosts.
+   */
+  async set(
+    request: operations.SetTenantNetworkPolicyRequest,
+    options?: RequestOptions,
+  ): Promise<components.TenantNetworkPolicy> {
+    return unwrapAsync(sandboxNetworkPoliciesSet(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/sandbox.ts

@@ -22,8 +22,10 @@ import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as components from "../models/components/index.js";
 import * as operations from "../models/operations/index.js";
 import { unwrapAsync } from "../types/fp.js";
+import { Connectors } from "./connectors.js";
 import { Environments } from "./environments.js";
 import { Github } from "./github.js";
+import { NetworkPolicies } from "./networkpolicies.js";
 
 export class Sandbox extends ClientSDK {
   private _github?: Github;
@@ -31,16 +33,26 @@ export class Sandbox extends ClientSDK {
     return (this._github ??= new Github(this._options));
   }
 
+  private _networkPolicies?: NetworkPolicies;
+  get networkPolicies(): NetworkPolicies {
+    return (this._networkPolicies ??= new NetworkPolicies(this._options));
+  }
+
   private _environments?: Environments;
   get environments(): Environments {
     return (this._environments ??= new Environments(this._options));
   }
 
+  private _connectors?: Connectors;
+  get connectors(): Connectors {
+    return (this._connectors ??= new Connectors(this._options));
+  }
+
   /**
    * Create Session
    *
    * @remarks
-   * Create a sandbox session and return its public session metadata, session token, and provider. Set `session_kind` to `browser` to start a browser-backed session instead of a standard command/code sandbox. Set `queue_if_full` to `true` to queue the request instead of failing when runner capacity is temporarily unavailable. It does not queue requests for session kinds the deployment does not support. Browser sessions require a Firecracker-backed deployment; standard-only deployments reject them immediately with `browser_sessions_not_enabled`.
+   * Create a sandbox session and return its public session metadata, session token, and provider. Set `session_kind` to `browser` to start a browser-backed session instead of a standard command/code sandbox. Set `queue_if_full` to `true` to queue the request instead of failing when runner capacity is temporarily unavailable. It does not queue requests for session kinds the deployment does not support. Browser sessions require a Firecracker-backed deployment; standard-only deployments reject them immediately with `browser_sessions_not_enabled`. An optional caller `network_policy` restricts outbound hostnames and is intersected with the organization, team and operator policies. An empty allowlist denies outbound access.
    */
   async create(
     request: operations.CreateSessionRequest,

package/src/sdk/teams.ts

@@ -6,15 +6,36 @@ import { authTeamsAddMember } from "../funcs/authTeamsAddMember.js";
 import { authTeamsCreate } from "../funcs/authTeamsCreate.js";
 import { authTeamsDelete } from "../funcs/authTeamsDelete.js";
 import { authTeamsGet } from "../funcs/authTeamsGet.js";
+import { authTeamsGetNetworkPolicyAccess } from "../funcs/authTeamsGetNetworkPolicyAccess.js";
 import { authTeamsList } from "../funcs/authTeamsList.js";
 import { authTeamsListMembers } from "../funcs/authTeamsListMembers.js";
 import { authTeamsRemoveMember } from "../funcs/authTeamsRemoveMember.js";
 import { authTeamsUpdate } from "../funcs/authTeamsUpdate.js";
+import { authTeamsUpdateMember } from "../funcs/authTeamsUpdateMember.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as operations from "../models/operations/index.js";
 import { unwrapAsync } from "../types/fp.js";
 
 export class Teams extends ClientSDK {
+  /**
+   * Read current network policy management access
+   *
+   * @remarks
+   * Current human membership and administrator permissions, verified with cookie caching disabled. A signed-in session is required; API keys cannot administer network policy. Expected IDs must match the active workspace.
+   */
+  async getNetworkPolicyAccess(
+    security: operations.GetNetworkPolicyAccessSecurity,
+    request: operations.GetNetworkPolicyAccessRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetNetworkPolicyAccessResponseBody> {
+    return unwrapAsync(authTeamsGetNetworkPolicyAccess(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+
   /**
    * Create a team
    */
@@ -116,6 +137,23 @@ export class Teams extends ClientSDK {
     ));
   }
 
+  /**
+   * Set a team member role
+   *
+   * @remarks
+   * Organization owner/admin only. Team admins may manage their own team network policy; other team administration remains org-admin-only.
+   */
+  async updateMember(
+    request: operations.UpdateTeamMemberRequest,
+    options?: RequestOptions,
+  ): Promise<operations.UpdateTeamMemberResponseBody> {
+    return unwrapAsync(authTeamsUpdateMember(
+      this,
+      request,
+      options,
+    ));
+  }
+
   /**
    * Remove a team member
    */