@inkeep/agents-manage-ui 0.34.1 → 0.35.1

package/src/features/agent/state/json-schema.ts

@@ -1,11 +1,15 @@
 import type { JSONSchema7 } from 'json-schema';
 import { nanoid } from 'nanoid';
-import { create } from 'zustand';
+import { create, type StateCreator } from 'zustand';
 import { devtools } from 'zustand/middleware';
 import { useShallow } from 'zustand/react/shallow';
 
 const ROOT_ID = '__root__';
 
+export interface JSONSchemaWithPreview extends JSONSchema7 {
+  inPreview?: boolean;
+}
+
 type TypeValues = keyof typeof Types;
 
 interface NameAndDescription {
@@ -19,9 +23,11 @@ interface NameAndDescription {
   isRequired?: boolean;
   /** JSON Schema title field */
   title?: string;
+  /** @see https://docs.inkeep.com/visual-builder/structured-outputs/artifact-components#preview-fields */
+  isPreview?: boolean;
 }
 
-type EditableField =
+export type EditableField =
   | FieldString
   | FieldNumber
   | FieldBoolean
@@ -57,38 +63,42 @@ interface FieldObject extends NameAndDescription {
 }
 
 type FieldPatch = Partial<
-  Pick<NameAndDescription, 'name' | 'description' | 'isRequired' | 'title'>
+  Pick<NameAndDescription, 'name' | 'description' | 'isRequired' | 'title' | 'isPreview'>
 >;
 
-const applyCommonMetadata = (schema: JSONSchema7, field: NameAndDescription) => {
+const applyCommonMetadata = (schema: JSONSchemaWithPreview, field: NameAndDescription) => {
+  const { hasInPreview } = jsonSchemaStore.getState();
+
   if (field.description) {
     schema.description = field.description;
   }
   if (field.title) {
     schema.title = field.title;
   }
+  if (hasInPreview && field.isPreview) {
+    schema.inPreview = true;
+  }
   return schema;
 };
 
-const fieldsToJsonSchema = (field: EditableField | undefined): JSONSchema7 => {
+const fieldsToJsonSchema = (field: EditableField | undefined): JSONSchemaWithPreview => {
   if (!field) {
     return { type: 'string' };
   }
-
   switch (field.type) {
     case 'object': {
       const properties: Record<string, JSONSchema7> = {};
       const required: string[] = [];
 
       for (const property of field.properties ?? []) {
-        if (!property || !property.name) continue;
+        if (!property.name) continue;
         properties[property.name] = fieldsToJsonSchema(property);
         if (property.isRequired) {
           required.push(property.name);
         }
       }
 
-      const schema: JSONSchema7 = {
+      const schema: JSONSchemaWithPreview = {
         type: 'object',
         properties,
         additionalProperties: false,
@@ -101,7 +111,7 @@ const fieldsToJsonSchema = (field: EditableField | undefined): JSONSchema7 => {
     }
     case 'array': {
       const items = fieldsToJsonSchema(field.items);
-      const schema: JSONSchema7 = {
+      const schema: JSONSchemaWithPreview = {
         type: 'array',
         items,
       };
@@ -109,7 +119,7 @@ const fieldsToJsonSchema = (field: EditableField | undefined): JSONSchema7 => {
       return schema;
     }
     case 'enum': {
-      const schema: JSONSchema7 = {
+      const schema: JSONSchemaWithPreview = {
         type: 'string',
         enum: field.values,
       };
@@ -117,24 +127,18 @@ const fieldsToJsonSchema = (field: EditableField | undefined): JSONSchema7 => {
       return schema;
     }
     case 'number': {
-      const schema: JSONSchema7 = {
-        type: 'number',
-      };
+      const schema: JSONSchemaWithPreview = { type: 'number' };
       applyCommonMetadata(schema, field);
       return schema;
     }
     case 'boolean': {
-      const schema: JSONSchema7 = {
-        type: 'boolean',
-      };
+      const schema: JSONSchemaWithPreview = { type: 'boolean' };
       applyCommonMetadata(schema, field);
       return schema;
     }
     case 'string':
     default: {
-      const schema: JSONSchema7 = {
-        type: 'string',
-      };
+      const schema: JSONSchemaWithPreview = { type: 'string' };
       applyCommonMetadata(schema, field);
       return schema;
     }
@@ -147,17 +151,19 @@ function convertJsonSchemaToFields({
   isRequired,
   id = ROOT_ID,
 }: {
-  schema: JSONSchema7;
+  schema: JSONSchemaWithPreview;
   name?: string;
   isRequired?: boolean;
   id?: string;
 }): EditableField | undefined {
+  const { hasInPreview } = jsonSchemaStore.getState();
   const base: NameAndDescription = {
     id,
     ...(name && { name }),
     ...(schema.description && { description: schema.description }),
     ...(schema.title && { title: schema.title }),
     ...(isRequired && { isRequired: true }),
+    ...(hasInPreview && schema.inPreview && { isPreview: true }),
   };
 
   if (schema.type === 'object') {
@@ -411,7 +417,7 @@ const parseFieldsFromJson = (value: string): EditableField[] => {
   }
 
   try {
-    const parsed = JSON.parse(value) as JSONSchema7;
+    const parsed = JSON.parse(value) as JSONSchemaWithPreview;
     const result = convertJsonSchemaToFields({ schema: parsed });
     if (!result) {
       return [];
@@ -535,10 +541,11 @@ const changeEditableFieldType = (field: EditableField, type: TypeValues): Editab
 
 interface JsonSchemaStateData {
   fields: EditableField[];
+  hasInPreview: boolean;
 }
 
 interface JsonSchemaActions {
-  setFields: (fields: EditableField[]) => void;
+  setFields: (schemaJson: string, hasInPreview?: boolean) => void;
   updateField: (id: string, patch: FieldPatch) => void;
   changeType: (id: string, type: TypeValues) => void;
   addChild: (parentId?: string) => void;
@@ -550,64 +557,68 @@ interface JsonSchemaState extends JsonSchemaStateData {
   actions: JsonSchemaActions;
 }
 
-const jsonSchemaStore = create<JsonSchemaState>()(
-  devtools((set) => ({
-    fields: [],
-    actions: {
-      setFields(fields) {
-        set({ fields });
-      },
-      updateField(id, patch) {
-        set((state) => {
-          const [fields, changed] = updateEditableFields(state.fields, id, (candidate) => ({
-            ...candidate,
-            ...patch,
-          }));
-          return changed ? { fields } : state;
-        });
-      },
-      changeType(id, type) {
-        set((state) => {
-          const [fields, changed] = updateEditableFields(state.fields, id, (candidate) =>
-            changeEditableFieldType(candidate, type)
-          );
-          return changed ? { fields } : state;
-        });
-      },
-      addChild(parentId = ROOT_ID) {
-        set((state) => {
-          const child = createEditableField({
-            type: 'string',
-            id: `${parentId}.${nanoid()}`,
-          });
-          if (parentId === ROOT_ID) {
-            return { fields: [...state.fields, child] };
-          }
-          const [fields, changed] = addChildToEditableTree(state.fields, parentId, child);
-          return changed ? { fields } : state;
-        });
-      },
-      removeField(id) {
-        set((state) => {
-          const filtered = state.fields.filter((field) => field.id !== id);
-          if (filtered.length !== state.fields.length) {
-            return { fields: filtered };
-          }
-          const [fields, changed] = removeEditableFieldFromTree(state.fields, id);
-          return changed ? { fields } : state;
-        });
-      },
-      updateEnumValues(id, values) {
-        set((state) => {
-          const [fields, changed] = updateEditableFields(state.fields, id, (candidate) =>
-            candidate.type === 'enum' ? { ...candidate, values } : candidate
-          );
-          return changed ? { fields } : state;
+const jsonSchemaState: StateCreator<JsonSchemaState> = (set) => ({
+  fields: [],
+  hasInPreview: false,
+  actions: {
+    setFields(schemaJson, hasInPreview) {
+      // Update preview mode before parsing the schema
+      set({ hasInPreview });
+      // Parse fields from the JSON schema using the updated `hasInPreview` state
+      set({ fields: parseFieldsFromJson(schemaJson) });
+    },
+    updateField(id, patch) {
+      set((state) => {
+        const [fields, changed] = updateEditableFields(state.fields, id, (candidate) => ({
+          ...candidate,
+          ...patch,
+        }));
+        return changed ? { fields } : state;
+      });
+    },
+    changeType(id, type) {
+      set((state) => {
+        const [fields, changed] = updateEditableFields(state.fields, id, (candidate) =>
+          changeEditableFieldType(candidate, type)
+        );
+        return changed ? { fields } : state;
+      });
+    },
+    addChild(parentId = ROOT_ID) {
+      set((state) => {
+        const child = createEditableField({
+          type: 'string',
+          id: `${parentId}.${nanoid()}`,
         });
-      },
+        if (parentId === ROOT_ID) {
+          return { fields: [...state.fields, child] };
+        }
+        const [fields, changed] = addChildToEditableTree(state.fields, parentId, child);
+        return changed ? { fields } : state;
+      });
+    },
+    removeField(id) {
+      set((state) => {
+        const filtered = state.fields.filter((field) => field.id !== id);
+        if (filtered.length !== state.fields.length) {
+          return { fields: filtered };
+        }
+        const [fields, changed] = removeEditableFieldFromTree(state.fields, id);
+        return changed ? { fields } : state;
+      });
     },
-  }))
-);
+    updateEnumValues(id, values) {
+      set((state) => {
+        const [fields, changed] = updateEditableFields(state.fields, id, (candidate) =>
+          candidate.type === 'enum' ? { ...candidate, values } : candidate
+        );
+        return changed ? { fields } : state;
+      });
+    },
+  },
+});
+
+const jsonSchemaStore = create<JsonSchemaState>()(devtools(jsonSchemaState));
 
 /**
  * Actions are functions that update values in your store.
@@ -632,7 +643,6 @@ export {
   Types,
   jsonSchemaStore,
   findFieldById,
-  parseFieldsFromJson,
   convertJsonSchemaToFields,
   fieldsToJsonSchema,
   useJsonSchemaStore,

package/src/hooks/use-auth.ts

@@ -0,0 +1,15 @@
+import { useAuthClient } from '@/lib/auth-client';
+
+export function useAuthSession() {
+  const client = useAuthClient();
+
+  const { data: session, isPending, error } = client.useSession();
+
+  return {
+    user: session?.user ?? null,
+    session: session?.session ?? null,
+    isLoading: isPending,
+    isAuthenticated: !!session,
+    error,
+  };
+}

package/src/lib/actions/invitations.ts

@@ -0,0 +1,26 @@
+'use server';
+
+import { makeManagementApiRequest } from "../api/api-config";
+
+export interface PendingInvitation {
+  id: string;
+  email: string;
+  organizationId: string;
+  organizationName: string | null;
+  organizationSlug: string | null;
+  role: string | null;
+  status: string;
+  expiresAt: number;
+  inviterId: string;
+}
+
+export async function getPendingInvitations(email: string): Promise<PendingInvitation[]> {
+  try {
+    return await makeManagementApiRequest<PendingInvitation[]>(
+      `api/invitations/pending?email=${encodeURIComponent(email)}`
+    );
+  } catch {
+    return [];
+  }
+}
+

package/src/lib/actions/user-organizations.ts

@@ -0,0 +1,28 @@
+'use server';
+
+import type { AddUserToOrganizationResponse, UserOrganizationsResponse } from '@inkeep/agents-core/auth/validation';
+import { makeManagementApiRequest } from '../api/api-config';
+
+export interface CreateUserOrganizationParams {
+  userId: string;
+  organizationId: string;
+  role: string;
+}
+
+export async function addUserToOrganization(params: CreateUserOrganizationParams) {
+  const { userId, organizationId, role } = params;
+
+  return await makeManagementApiRequest<AddUserToOrganizationResponse>(
+    `api/users/${userId}/organizations`,
+    {
+      method: 'POST',
+      body: JSON.stringify({ organizationId, role }),
+    }
+  );
+}
+
+export async function getUserOrganizations(userId: string) {
+  return await makeManagementApiRequest<UserOrganizationsResponse>(
+    `api/users/${userId}/organizations`
+  );
+}

package/src/lib/api/api-config.ts

@@ -11,7 +11,7 @@ import { ApiError } from '../types/errors';
 let INKEEP_AGENTS_MANAGE_API_URL: string | null = null;
 let hasWarnedManageApi = false;
 
-function getManageApiUrl(): string {
+export function getManageApiUrl(): string {
   if (INKEEP_AGENTS_MANAGE_API_URL === null) {
     INKEEP_AGENTS_MANAGE_API_URL =
       process.env.INKEEP_AGENTS_MANAGE_API_URL || DEFAULT_INKEEP_AGENTS_MANAGE_API_URL;
@@ -32,9 +32,25 @@ async function makeApiRequestInternal<T>(
   options: RequestInit = {}
 ): Promise<T> {
   const url = `${baseUrl}/${endpoint}`;
-  const defaultHeaders = {
+
+  let cookieHeader: string | undefined;
+  if (typeof window === 'undefined') {
+    try {
+      const { cookies } = await import('next/headers');
+      const cookieStore = await cookies();
+      const allCookies = cookieStore.getAll();
+      // Only forward Better Auth cookies for security
+      const authCookies = allCookies.filter((c) => c.name.startsWith('better-auth.'));
+      cookieHeader = authCookies.map((c) => `${c.name}=${c.value}`).join('; ');
+    } catch {
+      // Not in a server component context, skip cookie forwarding
+    }
+  }
+
+  const defaultHeaders: HeadersInit = {
     'Content-Type': 'application/json',
     ...options.headers,
+    ...(cookieHeader && { Cookie: cookieHeader }),
     ...(process.env.INKEEP_AGENTS_MANAGE_API_BYPASS_SECRET && {
       Authorization: `Bearer ${process.env.INKEEP_AGENTS_MANAGE_API_BYPASS_SECRET}`,
     }),
@@ -48,7 +64,8 @@ async function makeApiRequestInternal<T>(
 
     if (!response.ok) {
       const errorData = await response.json().catch(() => ({
-        error: { code: 'unknown', message: 'Unknown error occurred' },
+        code: 'unknown',
+        message: 'Unknown error occurred',
       }));
 
       throw new ApiError(

package/src/lib/auth-client.ts

@@ -0,0 +1,34 @@
+import { ssoClient } from '@better-auth/sso/client';
+import { ac, adminRole, memberRole, ownerRole } from '@inkeep/agents-core/auth/permissions';
+import { organizationClient } from 'better-auth/client/plugins';
+import { createAuthClient } from 'better-auth/react';
+import { useMemo } from 'react';
+import { useRuntimeConfig } from '@/contexts/runtime-config-context';
+
+export function useAuthClient() {
+  const { PUBLIC_INKEEP_AGENTS_MANAGE_API_URL } = useRuntimeConfig();
+
+  return useMemo(
+    () =>
+      createAuthClient({
+        baseURL: PUBLIC_INKEEP_AGENTS_MANAGE_API_URL,
+        fetchOptions: {
+          credentials: 'include',
+        },
+        plugins: [
+          ssoClient(),
+          organizationClient({
+            ac,
+            roles: {
+              member: memberRole,
+              admin: adminRole,
+              owner: ownerRole,
+            },
+          }),
+        ],
+      }),
+    [PUBLIC_INKEEP_AGENTS_MANAGE_API_URL]
+  );
+}
+
+export type AuthClient = ReturnType<typeof useAuthClient>;

package/src/lib/json-schema-validation.ts

@@ -115,7 +115,7 @@ function validateJsonSchema(schema: any): ValidationError[] {
       });
     }
 
-    if (!schema.required || !Array.isArray(schema.required)) {
+    if (schema.required && !Array.isArray(schema.required)) {
       errors.push({
         path: 'required',
         message: 'Schema must have a "required" array (can be empty)',

package/src/lib/mcp-tools/nango.ts

@@ -131,7 +131,7 @@ export async function fetchNangoIntegration(
 /**
  * Create a new Nango integration
  */
-export async function createNangoIntegration(params: {
+async function createNangoIntegration(params: {
   provider: string;
   uniqueKey: string;
   displayName?: string;

package/tsconfig.json

@@ -30,5 +30,5 @@
     ".next/types/**/*.ts",
     ".next/dev/types/**/*.ts"
   ],
-  "exclude": ["node_modules", ".next", "cypress", "cypress.config.ts"]
+  "exclude": ["node_modules", ".next", "cypress"]
 }