agentstack-sdk 0.5.1-rc2 → 0.5.2-rc2

package/src/client/a2a/protocol/types.ts

@@ -0,0 +1,127 @@
+/**
+ * Copyright 2025 © BeeAI a Series of LF Projects, LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type z from 'zod';
+
+import type {
+  agentCapabilitiesSchema,
+  agentCardSchema,
+  agentCardSignatureSchema,
+  agentExtensionSchema,
+  agentInterfaceSchema,
+  agentProviderSchema,
+  agentSkillSchema,
+  apiKeySecuritySchemeSchema,
+  artifactSchema,
+  authenticatedExtendedCardNotConfiguredErrorSchema,
+  authorizationCodeOAuthFlowSchema,
+  clientCredentialsOAuthFlowSchema,
+  contentTypeNotSupportedErrorSchema,
+  dataPartSchema,
+  filePartSchema,
+  fileWithBytesSchema,
+  fileWithUriSchema,
+  getTaskResponseSchema,
+  getTaskSuccessResponseSchema,
+  httpAuthSecuritySchemeSchema,
+  implicitOAuthFlowSchema,
+  internalErrorSchema,
+  invalidAgentResponseErrorSchema,
+  invalidParamsErrorSchema,
+  invalidRequestErrorSchema,
+  jsonParseErrorSchema,
+  jsonRpcErrorResponseSchema,
+  jsonRpcErrorSchema,
+  messageSchema,
+  methodNotFoundErrorSchema,
+  mutualTlsSecuritySchemeSchema,
+  oauth2SecuritySchemeSchema,
+  oauthFlowsSchema,
+  openIdConnectSecuritySchemeSchema,
+  partSchema,
+  passwordOAuthFlowSchema,
+  pushNotificationNotSupportedErrorSchema,
+  securitySchemeSchema,
+  taskArtifactUpdateEventSchema,
+  taskNotCancelableErrorSchema,
+  taskNotFoundErrorSchema,
+  taskSchema,
+  taskStatusSchema,
+  taskStatusUpdateEventSchema,
+  textPartSchema,
+  unsupportedOperationErrorSchema,
+} from './schemas';
+
+export type AgentInterface = z.infer<typeof agentInterfaceSchema>;
+
+export type AgentExtension = z.infer<typeof agentExtensionSchema>;
+
+export type AgentCapabilities = z.infer<typeof agentCapabilitiesSchema>;
+
+export type AgentProvider = z.infer<typeof agentProviderSchema>;
+
+export type AgentCardSignature = z.infer<typeof agentCardSignatureSchema>;
+
+export type AgentSkill = z.infer<typeof agentSkillSchema>;
+
+export type AuthorizationCodeOAuthFlow = z.infer<typeof authorizationCodeOAuthFlowSchema>;
+export type ClientCredentialsOAuthFlow = z.infer<typeof clientCredentialsOAuthFlowSchema>;
+export type ImplicitOAuthFlow = z.infer<typeof implicitOAuthFlowSchema>;
+export type PasswordOAuthFlow = z.infer<typeof passwordOAuthFlowSchema>;
+
+export type OAuthFlows = z.infer<typeof oauthFlowsSchema>;
+
+export type APIKeySecurityScheme = z.infer<typeof apiKeySecuritySchemeSchema>;
+export type HTTPAuthSecurityScheme = z.infer<typeof httpAuthSecuritySchemeSchema>;
+export type OAuth2SecurityScheme = z.infer<typeof oauth2SecuritySchemeSchema>;
+export type OpenIdConnectSecurityScheme = z.infer<typeof openIdConnectSecuritySchemeSchema>;
+export type MutualTLSSecurityScheme = z.infer<typeof mutualTlsSecuritySchemeSchema>;
+
+export type SecurityScheme = z.infer<typeof securitySchemeSchema>;
+
+export type AgentCard = z.infer<typeof agentCardSchema>;
+
+export type FileWithBytes = z.infer<typeof fileWithBytesSchema>;
+export type FileWithUri = z.infer<typeof fileWithUriSchema>;
+
+export type TextPart = z.infer<typeof textPartSchema>;
+export type FilePart = z.infer<typeof filePartSchema>;
+export type DataPart = z.infer<typeof dataPartSchema>;
+
+export type Part = z.infer<typeof partSchema>;
+
+export type Artifact = z.infer<typeof artifactSchema>;
+
+export type Message = z.infer<typeof messageSchema>;
+
+export type TaskStatus = z.infer<typeof taskStatusSchema>;
+
+export type TaskStatusUpdateEvent = z.infer<typeof taskStatusUpdateEventSchema>;
+
+export type Task = z.infer<typeof taskSchema>;
+
+export type TaskArtifactUpdateEvent = z.infer<typeof taskArtifactUpdateEventSchema>;
+
+export type JSONRPCError = z.infer<typeof jsonRpcErrorSchema>;
+export type JSONParseError = z.infer<typeof jsonParseErrorSchema>;
+export type InvalidRequestError = z.infer<typeof invalidRequestErrorSchema>;
+export type MethodNotFoundError = z.infer<typeof methodNotFoundErrorSchema>;
+export type InvalidParamsError = z.infer<typeof invalidParamsErrorSchema>;
+export type InternalError = z.infer<typeof internalErrorSchema>;
+export type TaskNotFoundError = z.infer<typeof taskNotFoundErrorSchema>;
+export type TaskNotCancelableError = z.infer<typeof taskNotCancelableErrorSchema>;
+export type PushNotificationNotSupportedError = z.infer<typeof pushNotificationNotSupportedErrorSchema>;
+export type UnsupportedOperationError = z.infer<typeof unsupportedOperationErrorSchema>;
+export type ContentTypeNotSupportedError = z.infer<typeof contentTypeNotSupportedErrorSchema>;
+export type InvalidAgentResponseError = z.infer<typeof invalidAgentResponseErrorSchema>;
+export type AuthenticatedExtendedCardNotConfiguredError = z.infer<
+  typeof authenticatedExtendedCardNotConfiguredErrorSchema
+>;
+
+export type JSONRPCErrorResponse = z.infer<typeof jsonRpcErrorResponseSchema>;
+
+export type GetTaskSuccessResponse = z.infer<typeof getTaskSuccessResponseSchema>;
+
+export type GetTaskResponse = z.infer<typeof getTaskResponseSchema>;

package/src/client/a2a/protocol/utils.ts

@@ -0,0 +1,39 @@
+/**
+ * Copyright 2025 © BeeAI a Series of LF Projects, LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import z from 'zod';
+
+export function a2aSchema<T extends z.ZodType>(schema: T) {
+  return z.preprocess((value) => normalizeOptionalNulls(schema, value), schema);
+}
+
+// Only handles ZodOptional and ZodObject here.
+// ZodArray/ZodUnion/ZodRecord aren't traversed and are normalized via their nested a2aSchema types (e.g., z.array(a2aSchema(...)).
+function normalizeOptionalNulls(schema: z.core.$ZodType, data: unknown): unknown {
+  if (schema instanceof z.ZodOptional) {
+    if (data === null) {
+      return undefined;
+    }
+
+    return normalizeOptionalNulls(schema.unwrap(), data);
+  }
+
+  if (schema instanceof z.ZodObject) {
+    if (data === null || typeof data !== 'object' || Array.isArray(data)) {
+      return data;
+    }
+
+    const { shape } = schema;
+    const record = data as Record<string, unknown>;
+
+    return Object.keys(record).reduce<Record<string, unknown>>((acc, key) => {
+      acc[key] = key in shape ? normalizeOptionalNulls(shape[key], record[key]) : record[key];
+
+      return acc;
+    }, {});
+  }
+
+  return data;
+}

package/src/client/api/common/schemas.ts

@@ -0,0 +1,45 @@
+/**
+ * Copyright 2025 © BeeAI a Series of LF Projects, LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import z from 'zod';
+
+import { GitHubVersionType } from './types';
+
+export const gitHubVersionTypeSchema = z.enum(GitHubVersionType);
+
+export const gitHubRegistryLocationSchema = z.string();
+
+export const networkRegistryLocationSchema = z.string();
+
+export const fileSystemRegistryLocationSchema = z.string();
+
+export const dockerImageIdSchema = z.string();
+
+export const dockerImageProviderLocationSchema = dockerImageIdSchema;
+
+export const networkProviderLocationSchema = z.string();
+
+export const resolvedGitHubUrlSchema = z.object({
+  host: z.string(),
+  org: z.string(),
+  repo: z.string(),
+  version: z.string(),
+  version_type: gitHubVersionTypeSchema,
+  commit_hash: z.string(),
+  path: z.string().nullish(),
+});
+
+export const resolvedDockerImageIdSchema = z.object({
+  registry: z.string(),
+  repository: z.string(),
+  tag: z.string(),
+  digest: z.string(),
+  image_id: dockerImageIdSchema,
+});
+
+export const readableStreamSchema = z.custom<ReadableStream<Uint8Array<ArrayBuffer>>>(
+  (value) => value instanceof ReadableStream,
+  { error: 'Expected ReadableStream' },
+);

package/src/client/api/common/types.ts

@@ -0,0 +1,34 @@
+/**
+ * Copyright 2025 © BeeAI a Series of LF Projects, LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type z from 'zod';
+
+import type {
+  dockerImageIdSchema,
+  dockerImageProviderLocationSchema,
+  fileSystemRegistryLocationSchema,
+  gitHubRegistryLocationSchema,
+  networkProviderLocationSchema,
+  networkRegistryLocationSchema,
+  resolvedDockerImageIdSchema,
+  resolvedGitHubUrlSchema,
+} from './schemas';
+
+export enum GitHubVersionType {
+  Head = 'head',
+  Tag = 'tag',
+}
+
+export type GitHubRegistryLocation = z.infer<typeof gitHubRegistryLocationSchema>;
+export type NetworkRegistryLocation = z.infer<typeof networkRegistryLocationSchema>;
+export type FileSystemRegistryLocation = z.infer<typeof fileSystemRegistryLocationSchema>;
+
+export type DockerImageId = z.infer<typeof dockerImageIdSchema>;
+
+export type DockerImageProviderLocation = z.infer<typeof dockerImageProviderLocationSchema>;
+export type NetworkProviderLocation = z.infer<typeof networkProviderLocationSchema>;
+
+export type ResolvedGitHubUrl = z.infer<typeof resolvedGitHubUrlSchema>;
+export type ResolvedDockerImageId = z.infer<typeof resolvedDockerImageIdSchema>;

package/src/client/api/configuration/api.ts

@@ -0,0 +1,31 @@
+/**
+ * Copyright 2025 © BeeAI a Series of LF Projects, LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { CallApi } from '../core/types';
+import { ApiMethod } from '../core/types';
+import { readSystemConfigurationResponseSchema, updateSystemConfigurationResponseSchema } from './schemas';
+import type { UpdateSystemConfigurationRequest } from './types';
+
+export function createConfigurationApi(callApi: CallApi) {
+  const readSystemConfiguration = () =>
+    callApi({
+      method: ApiMethod.Get,
+      path: '/api/v1/configurations/system',
+      schema: readSystemConfigurationResponseSchema,
+    });
+
+  const updateSystemConfiguration = ({ ...body }: UpdateSystemConfigurationRequest) =>
+    callApi({
+      method: ApiMethod.Put,
+      path: '/api/v1/configurations/system',
+      schema: updateSystemConfigurationResponseSchema,
+      body,
+    });
+
+  return {
+    readSystemConfiguration,
+    updateSystemConfiguration,
+  };
+}

package/src/client/api/configuration/schemas.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright 2025 © BeeAI a Series of LF Projects, LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import z from 'zod';
+
+export const systemConfigurationSchema = z.object({
+  id: z.string(),
+  created_by: z.string(),
+  updated_at: z.string(),
+  default_embedding_model: z.string().nullish(),
+  default_llm_model: z.string().nullish(),
+});
+
+export const readSystemConfigurationRequestSchema = z.never();
+
+export const readSystemConfigurationResponseSchema = systemConfigurationSchema;
+
+export const updateSystemConfigurationRequestSchema = z.object({
+  default_embedding_model: z.string().nullish(),
+  default_llm_model: z.string().nullish(),
+});
+
+export const updateSystemConfigurationResponseSchema = systemConfigurationSchema;

package/src/client/api/configuration/types.ts

@@ -0,0 +1,22 @@
+/**
+ * Copyright 2025 © BeeAI a Series of LF Projects, LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type z from 'zod';
+
+import type {
+  readSystemConfigurationRequestSchema,
+  readSystemConfigurationResponseSchema,
+  systemConfigurationSchema,
+  updateSystemConfigurationRequestSchema,
+  updateSystemConfigurationResponseSchema,
+} from './schemas';
+
+export type SystemConfiguration = z.infer<typeof systemConfigurationSchema>;
+
+export type ReadSystemConfigurationRequest = z.infer<typeof readSystemConfigurationRequestSchema>;
+export type ReadSystemConfigurationResponse = z.infer<typeof readSystemConfigurationResponseSchema>;
+
+export type UpdateSystemConfigurationRequest = z.infer<typeof updateSystemConfigurationRequestSchema>;
+export type UpdateSystemConfigurationResponse = z.infer<typeof updateSystemConfigurationResponseSchema>;

package/src/client/api/connectors/api.ts

@@ -0,0 +1,86 @@
+/**
+ * Copyright 2025 © BeeAI a Series of LF Projects, LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { CallApi } from '../core/types';
+import { ApiMethod } from '../core/types';
+import {
+  connectConnectorResponseSchema,
+  createConnectorResponseSchema,
+  deleteConnectorResponseSchema,
+  disconnectConnectorResponseSchema,
+  listConnectorPresetsResponseSchema,
+  listConnectorsResponseSchema,
+  readConnectorResponseSchema,
+} from './schemas';
+import type {
+  ConnectConnectorRequest,
+  CreateConnectorRequest,
+  DeleteConnectorRequest,
+  DisconnectConnectorRequest,
+  ReadConnectorRequest,
+} from './types';
+
+export function createConnectorsApi(callApi: CallApi) {
+  const listConnectors = () =>
+    callApi({
+      method: ApiMethod.Get,
+      path: '/api/v1/connectors',
+      schema: listConnectorsResponseSchema,
+    });
+
+  const createConnector = ({ ...body }: CreateConnectorRequest) =>
+    callApi({
+      method: ApiMethod.Post,
+      path: '/api/v1/connectors',
+      schema: createConnectorResponseSchema,
+      body,
+    });
+
+  const readConnector = ({ connector_id }: ReadConnectorRequest) =>
+    callApi({
+      method: ApiMethod.Get,
+      path: `/api/v1/connectors/${connector_id}`,
+      schema: readConnectorResponseSchema,
+    });
+
+  const deleteConnector = ({ connector_id }: DeleteConnectorRequest) =>
+    callApi({
+      method: ApiMethod.Delete,
+      path: `/api/v1/connectors/${connector_id}`,
+      schema: deleteConnectorResponseSchema,
+    });
+
+  const connectConnector = ({ connector_id, ...body }: ConnectConnectorRequest) =>
+    callApi({
+      method: ApiMethod.Post,
+      path: `/api/v1/connectors/${connector_id}/connect`,
+      schema: connectConnectorResponseSchema,
+      body,
+    });
+
+  const disconnectConnector = ({ connector_id }: DisconnectConnectorRequest) =>
+    callApi({
+      method: ApiMethod.Post,
+      path: `/api/v1/connectors/${connector_id}/disconnect`,
+      schema: disconnectConnectorResponseSchema,
+    });
+
+  const listConnectorPresets = () =>
+    callApi({
+      method: ApiMethod.Get,
+      path: '/api/v1/connectors/presets',
+      schema: listConnectorPresetsResponseSchema,
+    });
+
+  return {
+    listConnectors,
+    createConnector,
+    readConnector,
+    deleteConnector,
+    connectConnector,
+    disconnectConnector,
+    listConnectorPresets,
+  };
+}

package/src/client/api/connectors/schemas.ts

@@ -0,0 +1,77 @@
+/**
+ * Copyright 2025 © BeeAI a Series of LF Projects, LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import z from 'zod';
+
+import { paginatedResponseSchema } from '../core/schemas';
+import { ConnectorState } from './types';
+
+export const connectorStateSchema = z.enum(ConnectorState);
+
+export const connectorSchema = z.object({
+  id: z.string(),
+  url: z.string(),
+  state: connectorStateSchema,
+  auth_request: z
+    .object({
+      type: z.literal('code'),
+      authorization_endpoint: z.string(),
+    })
+    .nullable(),
+  disconnect_reason: z.string().nullable(),
+  metadata: z.record(z.string(), z.string()).nullable(),
+});
+
+export const listConnectorsRequestSchema = z.never();
+
+export const listConnectorsResponseSchema = paginatedResponseSchema.extend({
+  items: z.array(connectorSchema),
+});
+
+export const createConnectorRequestSchema = z.object({
+  match_preset: z.boolean(),
+  url: z.string(),
+  client_id: z.string().nullish(),
+  client_secret: z.string().nullish(),
+  metadata: z.record(z.string(), z.string()).nullish(),
+});
+
+export const createConnectorResponseSchema = connectorSchema;
+
+export const readConnectorRequestSchema = z.object({
+  connector_id: z.string(),
+});
+
+export const readConnectorResponseSchema = connectorSchema;
+
+export const deleteConnectorRequestSchema = z.object({
+  connector_id: z.string(),
+});
+
+export const deleteConnectorResponseSchema = z.null();
+
+export const connectConnectorRequestSchema = z.object({
+  connector_id: z.string(),
+  redirect_url: z.string().nullish(),
+});
+
+export const connectConnectorResponseSchema = connectorSchema;
+
+export const disconnectConnectorRequestSchema = z.object({
+  connector_id: z.string(),
+});
+
+export const disconnectConnectorResponseSchema = connectorSchema;
+
+export const connectorPresetSchema = z.object({
+  url: z.string(),
+  metadata: z.record(z.string(), z.string()).nullable(),
+});
+
+export const listConnectorPresetsRequestSchema = z.never();
+
+export const listConnectorPresetsResponseSchema = paginatedResponseSchema.extend({
+  items: z.array(connectorPresetSchema),
+});

package/src/client/api/connectors/types.ts

@@ -0,0 +1,57 @@
+/**
+ * Copyright 2025 © BeeAI a Series of LF Projects, LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type z from 'zod';
+
+import type {
+  connectConnectorRequestSchema,
+  connectConnectorResponseSchema,
+  connectorPresetSchema,
+  connectorSchema,
+  createConnectorRequestSchema,
+  createConnectorResponseSchema,
+  deleteConnectorRequestSchema,
+  deleteConnectorResponseSchema,
+  disconnectConnectorRequestSchema,
+  disconnectConnectorResponseSchema,
+  listConnectorPresetsRequestSchema,
+  listConnectorPresetsResponseSchema,
+  listConnectorsRequestSchema,
+  listConnectorsResponseSchema,
+  readConnectorRequestSchema,
+  readConnectorResponseSchema,
+} from './schemas';
+
+export enum ConnectorState {
+  Created = 'created',
+  AuthRequired = 'auth_required',
+  Connected = 'connected',
+  Disconnected = 'disconnected',
+}
+
+export type Connector = z.infer<typeof connectorSchema>;
+
+export type ListConnectorsRequest = z.infer<typeof listConnectorsRequestSchema>;
+export type ListConnectorsResponse = z.infer<typeof listConnectorsResponseSchema>;
+
+export type CreateConnectorRequest = z.infer<typeof createConnectorRequestSchema>;
+export type CreateConnectorResponse = z.infer<typeof createConnectorResponseSchema>;
+
+export type ReadConnectorRequest = z.infer<typeof readConnectorRequestSchema>;
+export type ReadConnectorResponse = z.infer<typeof readConnectorResponseSchema>;
+
+export type DeleteConnectorRequest = z.infer<typeof deleteConnectorRequestSchema>;
+export type DeleteConnectorResponse = z.infer<typeof deleteConnectorResponseSchema>;
+
+export type ConnectConnectorRequest = z.infer<typeof connectConnectorRequestSchema>;
+export type ConnectConnectorResponse = z.infer<typeof connectConnectorResponseSchema>;
+
+export type DisconnectConnectorRequest = z.infer<typeof disconnectConnectorRequestSchema>;
+export type DisconnectConnectorResponse = z.infer<typeof disconnectConnectorResponseSchema>;
+
+export type ConnectorPreset = z.infer<typeof connectorPresetSchema>;
+
+export type ListConnectorPresetsRequest = z.infer<typeof listConnectorPresetsRequestSchema>;
+export type ListConnectorPresetsResponse = z.infer<typeof listConnectorPresetsResponseSchema>;

package/src/client/api/contexts/api.ts

@@ -0,0 +1,113 @@
+/**
+ * Copyright 2025 © BeeAI a Series of LF Projects, LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { CallApi } from '../core/types';
+import { ApiMethod } from '../core/types';
+import {
+  createContextHistoryResponseSchema,
+  createContextResponseSchema,
+  createContextTokenResponseSchema,
+  deleteContextResponseSchema,
+  listContextHistoryResponseSchema,
+  listContextsResponseSchema,
+  patchContextMetadataResponseSchema,
+  readContextResponseSchema,
+  updateContextResponseSchema,
+} from './schemas';
+import type {
+  CreateContextHistoryRequest,
+  CreateContextRequest,
+  CreateContextTokenRequest,
+  DeleteContextRequest,
+  ListContextHistoryRequest,
+  ListContextsRequest,
+  PatchContextMetadataRequest,
+  ReadContextRequest,
+  UpdateContextRequest,
+} from './types';
+
+export function createContextsApi(callApi: CallApi) {
+  const listContexts = ({ query }: ListContextsRequest) =>
+    callApi({
+      method: ApiMethod.Get,
+      path: '/api/v1/contexts',
+      schema: listContextsResponseSchema,
+      query,
+    });
+
+  const createContext = ({ ...body }: CreateContextRequest) =>
+    callApi({
+      method: ApiMethod.Post,
+      path: '/api/v1/contexts',
+      schema: createContextResponseSchema,
+      body,
+    });
+
+  const readContext = ({ context_id }: ReadContextRequest) =>
+    callApi({
+      method: ApiMethod.Get,
+      path: `/api/v1/contexts/${context_id}`,
+      schema: readContextResponseSchema,
+    });
+
+  const updateContext = ({ context_id, ...body }: UpdateContextRequest) =>
+    callApi({
+      method: ApiMethod.Put,
+      path: `/api/v1/contexts/${context_id}`,
+      schema: updateContextResponseSchema,
+      body,
+    });
+
+  const deleteContext = ({ context_id }: DeleteContextRequest) =>
+    callApi({
+      method: ApiMethod.Delete,
+      path: `/api/v1/contexts/${context_id}`,
+      schema: deleteContextResponseSchema,
+    });
+
+  const listContextHistory = ({ context_id, query }: ListContextHistoryRequest) =>
+    callApi({
+      method: ApiMethod.Get,
+      path: `/api/v1/contexts/${context_id}/history`,
+      schema: listContextHistoryResponseSchema,
+      query,
+    });
+
+  const createContextHistory = ({ context_id, ...body }: CreateContextHistoryRequest) =>
+    callApi({
+      method: ApiMethod.Post,
+      path: `/api/v1/contexts/${context_id}/history`,
+      schema: createContextHistoryResponseSchema,
+      body,
+    });
+
+  const patchContextMetadata = ({ context_id, ...body }: PatchContextMetadataRequest) =>
+    callApi({
+      method: ApiMethod.Patch,
+      path: `/api/v1/contexts/${context_id}/metadata`,
+      schema: patchContextMetadataResponseSchema,
+      body,
+    });
+
+  const createContextToken = ({ context_id, ...body }: CreateContextTokenRequest) =>
+    callApi({
+      method: ApiMethod.Post,
+      path: `/api/v1/contexts/${context_id}/token`,
+      schema: createContextTokenResponseSchema,
+      body,
+    });
+
+  return {
+    listContexts,
+    createContext,
+    readContext,
+    updateContext,
+    deleteContext,
+    listContextHistory,
+    createContextHistory,
+    patchContextMetadata,
+    createContextToken,
+  };
+}