agentstack-sdk 0.5.1-rc2 → 0.5.2-rc2

package/src/client/api/providers/api.ts

@@ -0,0 +1,122 @@
+/**
+ * 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 {
+  createProviderResponseSchema,
+  deleteProviderResponseSchema,
+  listProvidersResponseSchema,
+  listProviderVariablesResponseSchema,
+  patchProviderResponseSchema,
+  previewProviderResponseSchema,
+  readProviderByLocationResponseSchema,
+  readProviderLogsResponseSchema,
+  readProviderResponseSchema,
+  updateProviderVariablesResponseSchema,
+} from './schemas';
+import type {
+  CreateProviderRequest,
+  DeleteProviderRequest,
+  ListProvidersRequest,
+  ListProviderVariablesRequest,
+  PatchProviderRequest,
+  PreviewProviderRequest,
+  ReadProviderByLocationRequest,
+  ReadProviderLogsRequest,
+  ReadProviderRequest,
+  UpdateProviderVariablesRequest,
+} from './types';
+
+export function createProvidersApi(callApi: CallApi) {
+  const listProviders = ({ query }: ListProvidersRequest) =>
+    callApi({
+      method: ApiMethod.Get,
+      path: '/api/v1/providers',
+      schema: listProvidersResponseSchema,
+      query,
+    });
+
+  const createProvider = ({ ...body }: CreateProviderRequest) =>
+    callApi({
+      method: ApiMethod.Post,
+      path: '/api/v1/providers',
+      schema: createProviderResponseSchema,
+      body,
+    });
+
+  const readProvider = ({ id }: ReadProviderRequest) =>
+    callApi({
+      method: ApiMethod.Get,
+      path: `/api/v1/providers/${id}`,
+      schema: readProviderResponseSchema,
+    });
+
+  const deleteProvider = ({ id }: DeleteProviderRequest) =>
+    callApi({
+      method: ApiMethod.Delete,
+      path: `/api/v1/providers/${id}`,
+      schema: deleteProviderResponseSchema,
+    });
+
+  const patchProvider = ({ id, ...body }: PatchProviderRequest) =>
+    callApi({
+      method: ApiMethod.Patch,
+      path: `/api/v1/providers/${id}`,
+      schema: patchProviderResponseSchema,
+      body,
+    });
+
+  const readProviderLogs = ({ id }: ReadProviderLogsRequest) =>
+    callApi({
+      method: ApiMethod.Get,
+      path: `/api/v1/providers/${id}/logs`,
+      schema: readProviderLogsResponseSchema,
+      parseAsStream: true,
+    });
+
+  const listProviderVariables = ({ id }: ListProviderVariablesRequest) =>
+    callApi({
+      method: ApiMethod.Get,
+      path: `/api/v1/providers/${id}/variables`,
+      schema: listProviderVariablesResponseSchema,
+    });
+
+  const updateProviderVariables = ({ id, ...body }: UpdateProviderVariablesRequest) =>
+    callApi({
+      method: ApiMethod.Put,
+      path: `/api/v1/providers/${id}/variables`,
+      schema: updateProviderVariablesResponseSchema,
+      body,
+    });
+
+  const readProviderByLocation = ({ location }: ReadProviderByLocationRequest) =>
+    callApi({
+      method: ApiMethod.Get,
+      path: `/api/v1/providers/by-location/${location}`,
+      schema: readProviderByLocationResponseSchema,
+    });
+
+  const previewProvider = ({ ...body }: PreviewProviderRequest) =>
+    callApi({
+      method: ApiMethod.Post,
+      path: '/api/v1/providers/preview',
+      schema: previewProviderResponseSchema,
+      body,
+    });
+
+  return {
+    listProviders,
+    createProvider,
+    readProvider,
+    deleteProvider,
+    patchProvider,
+    readProviderLogs,
+    listProviderVariables,
+    updateProviderVariables,
+    readProviderByLocation,
+    previewProvider,
+  };
+}

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

@@ -0,0 +1,140 @@
+/**
+ * Copyright 2025 © BeeAI a Series of LF Projects, LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import z from 'zod';
+
+import { agentCardSchema } from '../../a2a/protocol/schemas';
+import {
+  dockerImageProviderLocationSchema,
+  fileSystemRegistryLocationSchema,
+  gitHubRegistryLocationSchema,
+  networkProviderLocationSchema,
+  networkRegistryLocationSchema,
+  readableStreamSchema,
+  resolvedDockerImageIdSchema,
+  resolvedGitHubUrlSchema,
+} from '../common/schemas';
+import { paginatedResponseSchema } from '../core/schemas';
+import { ProviderStatus, ProviderType, ProviderUnmanagedStatus } from './types';
+
+export const providerTypeSchema = z.enum(ProviderType);
+
+export const providerStatusSchema = z.enum(ProviderStatus);
+
+export const providerUnmanagedStatusSchema = z.enum(ProviderUnmanagedStatus);
+
+export const providerErrorSchema = z.object({
+  message: z.string(),
+});
+
+export const providerEnvVarSchema = z.object({
+  name: z.string(),
+  required: z.boolean(),
+  description: z.string().nullish(),
+});
+
+export const providerVersionInfoSchema = z.object({
+  docker: resolvedDockerImageIdSchema.nullish(),
+  github: resolvedGitHubUrlSchema.nullish(),
+});
+
+export const providerSchema = z.object({
+  id: z.string(),
+  source: z.union([dockerImageProviderLocationSchema, networkProviderLocationSchema]),
+  agent_card: agentCardSchema,
+  state: z.union([providerStatusSchema, providerUnmanagedStatusSchema]),
+  origin: z.string(),
+  created_at: z.string(),
+  created_by: z.string(),
+  updated_at: z.string(),
+  last_active_at: z.string(),
+  auto_stop_timeout: z.string(),
+  managed: z.boolean(),
+  type: providerTypeSchema,
+  env: z.array(providerEnvVarSchema),
+  registry: z
+    .union([gitHubRegistryLocationSchema, networkRegistryLocationSchema, fileSystemRegistryLocationSchema])
+    .nullish(),
+  last_error: providerErrorSchema.nullish(),
+  missing_configuration: z.array(providerEnvVarSchema).optional(),
+  version_info: providerVersionInfoSchema.optional(),
+});
+
+export const listProvidersRequestSchema = z.object({
+  query: z
+    .object({
+      origin: z.string().nullish(),
+      user_owned: z.boolean().nullish(),
+    })
+    .optional(),
+});
+
+export const listProvidersResponseSchema = paginatedResponseSchema.extend({
+  items: z.array(providerSchema),
+});
+
+export const createProviderRequestSchema = z.object({
+  location: z.union([dockerImageProviderLocationSchema, networkProviderLocationSchema]),
+  agent_card: agentCardSchema.nullish(),
+  auto_stop_timeout_sec: z.number().nullish(),
+  origin: z.string().nullish(),
+  variables: z.record(z.string(), z.string()).nullish(),
+});
+
+export const createProviderResponseSchema = providerSchema;
+
+export const readProviderRequestSchema = z.object({
+  id: z.string(),
+});
+
+export const readProviderResponseSchema = providerSchema;
+
+export const deleteProviderRequestSchema = z.object({
+  id: z.string(),
+});
+
+export const deleteProviderResponseSchema = z.null();
+
+export const patchProviderRequestSchema = z.object({
+  id: z.string(),
+  location: z.union([dockerImageProviderLocationSchema, networkProviderLocationSchema]).nullish(),
+  agent_card: agentCardSchema.nullish(),
+  auto_stop_timeout_sec: z.number().nullish(),
+  origin: z.string().nullish(),
+  variables: z.record(z.string(), z.string()).nullish(),
+});
+
+export const patchProviderResponseSchema = providerSchema;
+
+export const readProviderLogsRequestSchema = z.object({
+  id: z.string(),
+});
+
+export const readProviderLogsResponseSchema = readableStreamSchema;
+
+export const listProviderVariablesRequestSchema = z.object({
+  id: z.string(),
+});
+
+export const listProviderVariablesResponseSchema = z.object({
+  variables: z.record(z.string(), z.string()),
+});
+
+export const updateProviderVariablesRequestSchema = z.object({
+  id: z.string(),
+  variables: z.record(z.string(), z.union([z.string(), z.null()])),
+});
+
+export const updateProviderVariablesResponseSchema = z.null();
+
+export const readProviderByLocationRequestSchema = z.object({
+  location: z.string(),
+});
+
+export const readProviderByLocationResponseSchema = providerSchema;
+
+export const previewProviderRequestSchema = createProviderRequestSchema;
+
+export const previewProviderResponseSchema = providerSchema;

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

@@ -0,0 +1,87 @@
+/**
+ * Copyright 2025 © BeeAI a Series of LF Projects, LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type z from 'zod';
+
+import type {
+  createProviderRequestSchema,
+  createProviderResponseSchema,
+  deleteProviderRequestSchema,
+  deleteProviderResponseSchema,
+  listProvidersRequestSchema,
+  listProvidersResponseSchema,
+  listProviderVariablesRequestSchema,
+  listProviderVariablesResponseSchema,
+  patchProviderRequestSchema,
+  patchProviderResponseSchema,
+  previewProviderRequestSchema,
+  previewProviderResponseSchema,
+  providerEnvVarSchema,
+  providerErrorSchema,
+  providerSchema,
+  providerVersionInfoSchema,
+  readProviderByLocationRequestSchema,
+  readProviderByLocationResponseSchema,
+  readProviderLogsRequestSchema,
+  readProviderLogsResponseSchema,
+  readProviderRequestSchema,
+  readProviderResponseSchema,
+  updateProviderVariablesRequestSchema,
+  updateProviderVariablesResponseSchema,
+} from './schemas';
+
+export enum ProviderType {
+  Managed = 'managed',
+  Unmanaged = 'unmanaged',
+}
+
+export enum ProviderStatus {
+  Missing = 'missing',
+  Starting = 'starting',
+  Ready = 'ready',
+  Running = 'running',
+  Error = 'error',
+}
+
+export enum ProviderUnmanagedStatus {
+  Online = 'online',
+  Offline = 'offline',
+}
+
+export type ProviderError = z.infer<typeof providerErrorSchema>;
+export type ProviderEnvVar = z.infer<typeof providerEnvVarSchema>;
+export type ProviderVersionInfo = z.infer<typeof providerVersionInfoSchema>;
+
+export type Provider = z.infer<typeof providerSchema>;
+
+export type ListProvidersRequest = z.infer<typeof listProvidersRequestSchema>;
+export type ListProvidersResponse = z.infer<typeof listProvidersResponseSchema>;
+
+export type CreateProviderRequest = z.infer<typeof createProviderRequestSchema>;
+export type CreateProviderResponse = z.infer<typeof createProviderResponseSchema>;
+
+export type ReadProviderRequest = z.infer<typeof readProviderRequestSchema>;
+export type ReadProviderResponse = z.infer<typeof readProviderResponseSchema>;
+
+export type DeleteProviderRequest = z.infer<typeof deleteProviderRequestSchema>;
+export type DeleteProviderResponse = z.infer<typeof deleteProviderResponseSchema>;
+
+export type PatchProviderRequest = z.infer<typeof patchProviderRequestSchema>;
+export type PatchProviderResponse = z.infer<typeof patchProviderResponseSchema>;
+
+export type ReadProviderLogsRequest = z.infer<typeof readProviderLogsRequestSchema>;
+export type ReadProviderLogsResponse = z.infer<typeof readProviderLogsResponseSchema>;
+
+export type ListProviderVariablesRequest = z.infer<typeof listProviderVariablesRequestSchema>;
+export type ListProviderVariablesResponse = z.infer<typeof listProviderVariablesResponseSchema>;
+
+export type UpdateProviderVariablesRequest = z.infer<typeof updateProviderVariablesRequestSchema>;
+export type UpdateProviderVariablesResponse = z.infer<typeof updateProviderVariablesResponseSchema>;
+
+export type ReadProviderByLocationRequest = z.infer<typeof readProviderByLocationRequestSchema>;
+export type ReadProviderByLocationResponse = z.infer<typeof readProviderByLocationResponseSchema>;
+
+export type PreviewProviderRequest = z.infer<typeof previewProviderRequestSchema>;
+export type PreviewProviderResponse = z.infer<typeof previewProviderResponseSchema>;

package/src/client/api/schemas.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2025 © BeeAI a Series of LF Projects, LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export * from './common/schemas';
+export * from './configuration/schemas';
+export * from './connectors/schemas';
+export * from './contexts/schemas';
+export * from './files/schemas';
+export * from './model-providers/schemas';
+export * from './provider-builds/schemas';
+export * from './providers/schemas';
+export * from './user-feedback/schemas';
+export * from './users/schemas';
+export * from './variables/schemas';

package/src/client/api/types.ts

@@ -3,133 +3,14 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import z from 'zod';
-
-export const contextSchema = z.object({
-  id: z.string(),
-  created_at: z.string(),
-  updated_at: z.string(),
-  last_active_at: z.string(),
-  created_by: z.string(),
-  provider_id: z.string().nullable(),
-  metadata: z.record(z.string(), z.unknown()).nullable(),
-});
-export type CreateContextResponse = z.infer<typeof contextSchema>;
-
-export const contextTokenSchema = z.object({
-  token: z.string(),
-  expires_at: z.string().nullable(),
-});
-export type ContextToken = z.infer<typeof contextTokenSchema>;
-
-export enum ModelCapability {
-  Llm = 'llm',
-  Embedding = 'embedding',
-}
-
-const paginatedResultSchema = z.object({
-  items: z.array(z.unknown()),
-  total_count: z.number(),
-  has_more: z.boolean(),
-  next_page_token: z.string().nullable(),
-});
-
-export const modelProviderMatchSchema = paginatedResultSchema.extend({
-  items: z.array(
-    z.object({
-      model_id: z.string(),
-      score: z.number(),
-    }),
-  ),
-});
-export type ModelProviderMatch = z.infer<typeof modelProviderMatchSchema>;
-
-export const resourceIdPermissionSchema = z.object({
-  id: z.string(),
-});
-
-export type ResourceIdPermission = z.infer<typeof resourceIdPermissionSchema>;
-
-export const contextPermissionsGrantSchema = z.object({
-  files: z.array(z.literal(['read', 'write', 'extract', '*'])).optional(),
-  vector_stores: z.array(z.literal(['read', 'write', '*'])).optional(),
-  context_data: z.array(z.literal(['read', 'write', '*'])).optional(),
-});
-
-export type ContextPermissionsGrant = z.infer<typeof contextPermissionsGrantSchema>;
-
-export const globalPermissionsGrantSchema = contextPermissionsGrantSchema
-  .extend({
-    feedback: z.array(z.literal('write')).optional(),
-
-    llm: z.array(z.union([z.literal('*'), resourceIdPermissionSchema])).optional(),
-    embeddings: z.array(z.union([z.literal('*'), resourceIdPermissionSchema])).optional(),
-    model_providers: z.array(z.literal(['read', 'write', '*'])).optional(),
-
-    a2a_proxy: z.array(z.union([z.literal('*'), z.string()])).optional(),
-
-    providers: z.array(z.literal(['read', 'write', '*'])).optional(),
-    provider_variables: z.array(z.literal(['read', 'write', '*'])).optional(),
-
-    contexts: z.array(z.literal(['read', 'write', '*'])).optional(),
-
-    mcp_providers: z.array(z.literal(['read', 'write', '*'])).optional(),
-    mcp_tools: z.array(z.literal(['read', '*'])).optional(),
-    mcp_proxy: z.array(z.literal('*')).optional(),
-
-    connectors: z.array(z.literal(['read', 'write', 'proxy', '*'])).optional(),
-  })
-  .superRefine((val, ctx) => {
-    if (!val.a2a_proxy) return;
-
-    if (val.a2a_proxy.length === 0) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: 'a2a_proxy cannot be empty array',
-        path: ['a2a_proxy'],
-      });
-      return;
-    }
-
-    const hasWildcard = val.a2a_proxy.includes('*');
-    const hasOthers = val.a2a_proxy.some((v) => v !== '*');
-
-    if (hasWildcard && hasOthers) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: "a2a_proxy cannot mix '*' with specific providers",
-        path: ['a2a_proxy'],
-      });
-    }
-  });
-
-export type GlobalPermissionsGrant = z.infer<typeof globalPermissionsGrantSchema>;
-
-export enum ConnectorState {
-  Created = 'created',
-  AuthRequired = 'auth_required',
-  Connected = 'connected',
-  Disconnected = 'disconnected',
-}
-
-export const connectorSchema = z.object({
-  id: z.string(),
-  url: z.string(),
-  state: z.enum(ConnectorState),
-  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 type Connector = z.infer<typeof connectorSchema>;
-
-export const listConnectorsResponseSchema = paginatedResultSchema.extend({
-  items: z.array(connectorSchema),
-});
-
-export type ListConnectorsResponse = z.infer<typeof listConnectorsResponseSchema>;
+export * from './common/types';
+export * from './configuration/types';
+export * from './connectors/types';
+export * from './contexts/types';
+export * from './files/types';
+export * from './model-providers/types';
+export * from './provider-builds/types';
+export * from './providers/types';
+export * from './user-feedback/types';
+export * from './users/types';
+export * from './variables/types';

package/src/client/api/user-feedback/api.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 { createUserFeedbackResponseSchema } from './schemas';
+import type { CreateUserFeedbackRequest } from './types';
+
+export function createUserFeedbackApi(callApi: CallApi) {
+  const createUserFeedback = ({ ...body }: CreateUserFeedbackRequest) =>
+    callApi({
+      method: ApiMethod.Post,
+      path: '/api/v1/user_feedback',
+      schema: createUserFeedbackResponseSchema,
+      body,
+    });
+
+  return {
+    createUserFeedback,
+  };
+}

package/src/client/api/user-feedback/schemas.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright 2025 © BeeAI a Series of LF Projects, LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import z from 'zod';
+
+export const createUserFeedbackRequestSchema = z.object({
+  provider_id: z.string(),
+  context_id: z.string(),
+  task_id: z.string(),
+  message: z.string(),
+  rating: z.union([z.literal(1), z.literal(-1)]),
+  comment: z.string().nullish(),
+  comment_tags: z.array(z.string()).nullish(),
+});
+
+export const createUserFeedbackResponseSchema = z.null();

package/src/client/api/user-feedback/types.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright 2025 © BeeAI a Series of LF Projects, LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type z from 'zod';
+
+import type { createUserFeedbackRequestSchema, createUserFeedbackResponseSchema } from './schemas';
+
+export type CreateUserFeedbackRequest = z.infer<typeof createUserFeedbackRequestSchema>;
+export type CreateUserFeedbackResponse = z.infer<typeof createUserFeedbackResponseSchema>;

package/src/client/api/users/api.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 { readUserResponseSchema } from './schemas';
+
+export function createUsersApi(callApi: CallApi) {
+  const readUser = () =>
+    callApi({
+      method: ApiMethod.Get,
+      path: '/api/v1/user',
+      schema: readUserResponseSchema,
+    });
+
+  return {
+    readUser,
+  };
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Copyright 2025 © BeeAI a Series of LF Projects, LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import z from 'zod';
+
+import { UserRole } from './types';
+
+export const userRoleSchema = z.enum(UserRole);
+
+export const userSchema = z.object({
+  id: z.string(),
+  role: userRoleSchema,
+  email: z.string(),
+  created_at: z.string(),
+});
+
+export const readUserRequestSchema = z.never();
+
+export const readUserResponseSchema = userSchema;

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

@@ -0,0 +1,19 @@
+/**
+ * Copyright 2025 © BeeAI a Series of LF Projects, LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type z from 'zod';
+
+import type { readUserRequestSchema, readUserResponseSchema, userSchema } from './schemas';
+
+export enum UserRole {
+  Admin = 'admin',
+  Developer = 'developer',
+  User = 'user',
+}
+
+export type User = z.infer<typeof userSchema>;
+
+export type ReadUserRequest = z.infer<typeof readUserRequestSchema>;
+export type ReadUserResponse = z.infer<typeof readUserResponseSchema>;

package/src/client/api/variables/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 { listVariablesResponseSchema, updateVariablesResponseSchema } from './schemas';
+import type { UpdateVariablesRequest } from './types';
+
+export function createVariablesApi(callApi: CallApi) {
+  const listVariables = () =>
+    callApi({
+      method: ApiMethod.Get,
+      path: '/api/v1/variables',
+      schema: listVariablesResponseSchema,
+    });
+
+  const updateVariables = ({ ...body }: UpdateVariablesRequest) =>
+    callApi({
+      method: ApiMethod.Put,
+      path: '/api/v1/variables',
+      schema: updateVariablesResponseSchema,
+      body,
+    });
+
+  return {
+    listVariables,
+    updateVariables,
+  };
+}

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

@@ -0,0 +1,18 @@
+/**
+ * Copyright 2025 © BeeAI a Series of LF Projects, LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import z from 'zod';
+
+export const listVariablesRequestSchema = z.never();
+
+export const listVariablesResponseSchema = z.object({
+  variables: z.record(z.string(), z.string()),
+});
+
+export const updateVariablesRequestSchema = z.object({
+  variables: z.record(z.string(), z.union([z.string(), z.null()])),
+});
+
+export const updateVariablesResponseSchema = z.null();