@greatapps/greatagents-ui 0.1.0

package/src/client/index.ts

@@ -0,0 +1,254 @@
+import type {
+  ApiResponse,
+  Agent,
+  AgentTool,
+  AvailabilityResult,
+  CalendarStatus,
+  ContactUser,
+  Conversation,
+  GagentsContact,
+  Objective,
+  PromptVersion,
+  Tool,
+  ToolCredential,
+} from "../types";
+
+export interface GagentsClientConfig {
+  baseUrl: string;
+  token: string;
+  language?: string;
+  idWl?: number;
+}
+
+export function createGagentsClient(config: GagentsClientConfig) {
+  const { baseUrl, token, language = "pt-br", idWl = 1 } = config;
+
+  function buildUrl(idAccount: number, path: string): string {
+    return `${baseUrl}/v1/${language}/${idWl}/accounts/${idAccount}/${path}`;
+  }
+
+  async function request<T>(
+    method: string,
+    idAccount: number,
+    path: string,
+    body?: unknown,
+    params?: Record<string, string>,
+  ): Promise<ApiResponse<T>> {
+    const url = new URL(buildUrl(idAccount, path));
+    if (params) {
+      Object.entries(params).forEach(([k, v]) => url.searchParams.set(k, v));
+    }
+
+    const res = await fetch(url.toString(), {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`,
+      },
+      body: body ? JSON.stringify(body) : undefined,
+    });
+
+    if (!res.ok) {
+      let message = `HTTP ${res.status}: ${res.statusText}`;
+      try {
+        const errorBody = await res.json();
+        message = errorBody.message || message;
+      } catch {
+        /* ignore parse errors */
+      }
+      throw new Error(message);
+    }
+
+    const json: ApiResponse<T> = await res.json();
+
+    // For mutations, treat API-level failures as errors so TanStack Query
+    // fires onError instead of onSuccess (API returns HTTP 200 even on failure)
+    if (method !== "GET" && json.status === 0) {
+      throw new Error(json.message || "Operação falhou");
+    }
+
+    return json;
+  }
+
+  return {
+    // --- Agents ---
+    listAgents: (idAccount: number, params?: Record<string, string>) =>
+      request<Agent[]>("GET", idAccount, "agents", undefined, params),
+
+    getAgent: (idAccount: number, id: number) =>
+      request<Agent>("GET", idAccount, `agents/${id}`),
+
+    createAgent: (
+      idAccount: number,
+      body: Pick<Agent, "title"> &
+        Partial<Pick<Agent, "prompt" | "photo" | "delay_typing" | "waiting_time">>,
+    ) => request<Agent>("POST", idAccount, "agents", body),
+
+    updateAgent: (
+      idAccount: number,
+      id: number,
+      body: Partial<
+        Pick<Agent, "title" | "prompt" | "photo" | "delay_typing" | "waiting_time" | "active">
+      >,
+    ) => request<Agent>("PUT", idAccount, `agents/${id}`, body),
+
+    deleteAgent: (idAccount: number, id: number) =>
+      request<void>("DELETE", idAccount, `agents/${id}`),
+
+    // --- Tools ---
+    listTools: (idAccount: number, params?: Record<string, string>) =>
+      request<Tool[]>("GET", idAccount, "tools", undefined, params),
+
+    getTool: (idAccount: number, id: number) =>
+      request<Tool>("GET", idAccount, `tools/${id}`),
+
+    createTool: (
+      idAccount: number,
+      body: Pick<Tool, "name" | "type"> &
+        Partial<Pick<Tool, "slug" | "description" | "auth_config" | "function_definitions">>,
+    ) => request<Tool>("POST", idAccount, "tools", body),
+
+    updateTool: (
+      idAccount: number,
+      id: number,
+      body: Partial<
+        Pick<Tool, "name" | "slug" | "type" | "description" | "auth_config" | "function_definitions">
+      >,
+    ) => request<Tool>("PUT", idAccount, `tools/${id}`, body),
+
+    deleteTool: (idAccount: number, id: number) =>
+      request<void>("DELETE", idAccount, `tools/${id}`),
+
+    // --- Agent Tools ---
+    listAgentTools: (idAccount: number, idAgent: number, params?: Record<string, string>) =>
+      request<AgentTool[]>("GET", idAccount, `agents/${idAgent}/tools`, undefined, params),
+
+    addAgentTool: (
+      idAccount: number,
+      idAgent: number,
+      body: Pick<AgentTool, "id_tool"> &
+        Partial<Pick<AgentTool, "enabled" | "custom_instructions" | "parameter_mappings" | "id_tool_credential">>,
+    ) => request<AgentTool>("POST", idAccount, `agents/${idAgent}/tools`, body),
+
+    updateAgentTool: (
+      idAccount: number,
+      idAgent: number,
+      id: number,
+      body: Partial<
+        Pick<AgentTool, "enabled" | "custom_instructions" | "parameter_mappings" | "id_tool_credential">
+      >,
+    ) => request<AgentTool>("PUT", idAccount, `agents/${idAgent}/tools/${id}`, body),
+
+    removeAgentTool: (idAccount: number, idAgent: number, id: number) =>
+      request<void>("DELETE", idAccount, `agents/${idAgent}/tools/${id}`),
+
+    // --- Objectives ---
+    listObjectives: (idAccount: number, idAgent: number, params?: Record<string, string>) =>
+      request<Objective[]>("GET", idAccount, `agents/${idAgent}/objectives`, undefined, params),
+
+    getObjective: (idAccount: number, idAgent: number, id: number) =>
+      request<Objective>("GET", idAccount, `agents/${idAgent}/objectives/${id}`),
+
+    createObjective: (
+      idAccount: number,
+      idAgent: number,
+      body: Pick<Objective, "title"> &
+        Partial<Pick<Objective, "slug" | "prompt" | "order" | "active">>,
+    ) => request<Objective>("POST", idAccount, `agents/${idAgent}/objectives`, body),
+
+    updateObjective: (
+      idAccount: number,
+      idAgent: number,
+      id: number,
+      body: Partial<Pick<Objective, "title" | "slug" | "prompt" | "order" | "active">>,
+    ) => request<Objective>("PUT", idAccount, `agents/${idAgent}/objectives/${id}`, body),
+
+    deleteObjective: (idAccount: number, idAgent: number, id: number) =>
+      request<void>("DELETE", idAccount, `agents/${idAgent}/objectives/${id}`),
+
+    // --- Conversations ---
+    listConversations: (idAccount: number, params?: Record<string, string>) =>
+      request<Conversation[]>("GET", idAccount, "conversations", undefined, params),
+
+    listAgentConversations: (idAccount: number, idAgent: number, params?: Record<string, string>) =>
+      request<Conversation[]>("GET", idAccount, `agents/${idAgent}/conversations`, undefined, params),
+
+    getConversation: (idAccount: number, id: number) =>
+      request<Conversation>("GET", idAccount, `conversations/${id}`),
+
+    // --- Prompt Versions ---
+    listPromptVersions: (idAccount: number, idAgent: number, params?: Record<string, string>) =>
+      request<PromptVersion[]>("GET", idAccount, `agents/${idAgent}/prompt-versions`, undefined, params),
+
+    // --- Tool Credentials ---
+    listToolCredentials: (idAccount: number, params?: Record<string, string>) =>
+      request<ToolCredential[]>("GET", idAccount, "tool-credentials", undefined, params),
+
+    createToolCredential: (
+      idAccount: number,
+      body: Pick<ToolCredential, "id_tool" | "label" | "credentials_encrypted"> &
+        Partial<Pick<ToolCredential, "expires_at">>,
+    ) => request<ToolCredential>("POST", idAccount, "tool-credentials", body),
+
+    updateToolCredential: (
+      idAccount: number,
+      id: number,
+      body: Partial<
+        Pick<ToolCredential, "id_tool" | "label" | "credentials_encrypted" | "expires_at" | "status">
+      >,
+    ) => request<ToolCredential>("PUT", idAccount, `tool-credentials/${id}`, body),
+
+    deleteToolCredential: (idAccount: number, id: number) =>
+      request<void>("DELETE", idAccount, `tool-credentials/${id}`),
+
+    // --- Contact Users ---
+    listContactUsers: (idAccount: number, params?: Record<string, string>) =>
+      request<ContactUser[]>("GET", idAccount, "contact-users", undefined, params),
+
+    getContactUser: (idAccount: number, id: number) =>
+      request<ContactUser>("GET", idAccount, `contact-users/${id}`),
+
+    // --- Contacts ---
+    listGagentsContacts: (idAccount: number, params?: Record<string, string>) =>
+      request<GagentsContact[]>("GET", idAccount, "contacts", undefined, params),
+
+    // --- Calendar Integration ---
+    initiateCalendarConnect: (
+      idAccount: number,
+      body: { external_reference: string; provider?: string },
+    ) => request<{ auth_url: string }>("POST", idAccount, "calendar/connect", body),
+
+    getCalendarStatus: (
+      idAccount: number,
+      externalReference: string,
+      provider = "google-calendar",
+    ) =>
+      request<CalendarStatus>(
+        "GET",
+        idAccount,
+        `calendar/status/${encodeURIComponent(externalReference)}`,
+        undefined,
+        { provider },
+      ),
+
+    checkCalendarAvailability: (
+      idAccount: number,
+      body: { id_professional: number; start_time: string; end_time: string },
+    ) => request<AvailabilityResult>("POST", idAccount, "calendar/availability", body),
+
+    disconnectCalendar: (
+      idAccount: number,
+      externalReference: string,
+      provider = "google-calendar",
+    ) =>
+      request<void>(
+        "DELETE",
+        idAccount,
+        `calendar/disconnect/${encodeURIComponent(externalReference)}`,
+        undefined,
+        { provider },
+      ),
+  };
+}
+
+export type GagentsClient = ReturnType<typeof createGagentsClient>;

package/src/hooks/index.ts

@@ -0,0 +1,30 @@
+// Config & Client
+export { type GagentsHookConfig, useGagentsClient } from "./types";
+
+// Agents
+export { useAgents, useAgent, useCreateAgent, useUpdateAgent, useDeleteAgent } from "./use-agents";
+
+// Tools
+export { useTools, useTool, useCreateTool, useUpdateTool, useDeleteTool } from "./use-tools";
+
+// Objectives
+export { useObjectives, useCreateObjective, useUpdateObjective, useDeleteObjective } from "./use-objectives";
+
+// Agent Tools
+export { useAgentTools, useAddAgentTool, useRemoveAgentTool, useUpdateAgentTool } from "./use-agent-tools";
+
+// Conversations
+export { useConversations, useAgentConversations, useConversation } from "./use-conversations";
+
+// Settings (Prompt Versions, Tool Credentials, Contact Users)
+export {
+  usePromptVersions,
+  useToolCredentials,
+  useCreateToolCredential,
+  useUpdateToolCredential,
+  useDeleteToolCredential,
+  useContactUsers,
+} from "./use-settings";
+
+// Contacts
+export { useGagentsContacts } from "./use-contacts";

package/src/hooks/types.ts

@@ -0,0 +1,31 @@
+import { useMemo } from "react";
+import { createGagentsClient } from "../client";
+
+// ---------------------------------------------------------------------------
+// Hook Configuration
+// ---------------------------------------------------------------------------
+
+export interface GagentsHookConfig {
+  accountId: number;
+  token: string;
+  baseUrl: string;
+  language?: string;
+  idWl?: number;
+}
+
+// ---------------------------------------------------------------------------
+// Internal helper — memoized client from config
+// ---------------------------------------------------------------------------
+
+export function useGagentsClient(config: GagentsHookConfig) {
+  return useMemo(
+    () =>
+      createGagentsClient({
+        baseUrl: config.baseUrl,
+        token: config.token,
+        language: config.language,
+        idWl: config.idWl,
+      }),
+    [config.baseUrl, config.token, config.language, config.idWl],
+  );
+}

package/src/hooks/use-agent-tools.ts

@@ -0,0 +1,72 @@
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import type { GagentsHookConfig } from "./types";
+import { useGagentsClient } from "./types";
+
+export function useAgentTools(config: GagentsHookConfig, idAgent: number) {
+  const client = useGagentsClient(config);
+
+  return useQuery({
+    queryKey: ["greatagents", "agent-tools", config.accountId, idAgent],
+    queryFn: () => client.listAgentTools(config.accountId, idAgent),
+    enabled: !!config.token && !!config.accountId && !!idAgent,
+    select: (res) => ({ data: res.data || [], total: res.total || 0 }),
+  });
+}
+
+export function useAddAgentTool(config: GagentsHookConfig) {
+  const client = useGagentsClient(config);
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: ({
+      idAgent,
+      body,
+    }: {
+      idAgent: number;
+      body: { id_tool: number; enabled?: boolean };
+    }) => client.addAgentTool(config.accountId, idAgent, body),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["greatagents", "agent-tools"] });
+    },
+  });
+}
+
+export function useRemoveAgentTool(config: GagentsHookConfig) {
+  const client = useGagentsClient(config);
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: ({ idAgent, id }: { idAgent: number; id: number }) =>
+      client.removeAgentTool(config.accountId, idAgent, id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["greatagents", "agent-tools"] });
+    },
+  });
+}
+
+export function useUpdateAgentTool(config: GagentsHookConfig) {
+  const client = useGagentsClient(config);
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: ({
+      idAgent,
+      id,
+      body,
+    }: {
+      idAgent: number;
+      id: number;
+      body: Partial<{
+        enabled: boolean;
+        custom_instructions: string | null;
+        parameter_mappings: string | null;
+        id_tool_credential: number | null;
+      }>;
+    }) => client.updateAgentTool(config.accountId, idAgent, id, body),
+    onSuccess: (_data, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: ["greatagents", "agent-tools", config.accountId, variables.idAgent],
+      });
+    },
+  });
+}

package/src/hooks/use-agents.ts

@@ -0,0 +1,89 @@
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import type { GagentsHookConfig } from "./types";
+import { useGagentsClient } from "./types";
+
+export function useAgents(config: GagentsHookConfig, params?: Record<string, string>) {
+  const client = useGagentsClient(config);
+
+  return useQuery({
+    queryKey: ["greatagents", "agents", config.accountId, params],
+    queryFn: () => client.listAgents(config.accountId, params),
+    enabled: !!config.token && !!config.accountId,
+    select: (res) => ({ data: res.data || [], total: res.total || 0 }),
+  });
+}
+
+export function useAgent(config: GagentsHookConfig, id: number | null) {
+  const client = useGagentsClient(config);
+
+  return useQuery({
+    queryKey: ["greatagents", "agent", config.accountId, id],
+    queryFn: () => client.getAgent(config.accountId, id!),
+    enabled: !!config.token && !!config.accountId && !!id,
+    select: (res) => {
+      const d = res.data;
+      return Array.isArray(d) ? d[0] : d;
+    },
+  });
+}
+
+export function useCreateAgent(config: GagentsHookConfig) {
+  const client = useGagentsClient(config);
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (body: {
+      title: string;
+      prompt?: string;
+      photo?: string;
+      delay_typing?: number;
+      waiting_time?: number;
+    }) => client.createAgent(config.accountId, body),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["greatagents", "agents"] });
+    },
+  });
+}
+
+export function useUpdateAgent(config: GagentsHookConfig) {
+  const client = useGagentsClient(config);
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: ({
+      id,
+      body,
+    }: {
+      id: number;
+      body: {
+        title?: string;
+        prompt?: string;
+        photo?: string;
+        delay_typing?: number;
+        waiting_time?: number;
+        active?: boolean;
+      };
+    }) => client.updateAgent(config.accountId, id, body),
+    onSuccess: (_data, variables) => {
+      queryClient.invalidateQueries({ queryKey: ["greatagents", "agents"] });
+      queryClient.invalidateQueries({
+        queryKey: ["greatagents", "agent", config.accountId, variables.id],
+      });
+      queryClient.invalidateQueries({
+        queryKey: ["greatagents", "prompt-versions", config.accountId, variables.id],
+      });
+    },
+  });
+}
+
+export function useDeleteAgent(config: GagentsHookConfig) {
+  const client = useGagentsClient(config);
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (id: number) => client.deleteAgent(config.accountId, id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["greatagents", "agents"] });
+    },
+  });
+}

package/src/hooks/use-contacts.ts

@@ -0,0 +1,14 @@
+import { useQuery } from "@tanstack/react-query";
+import type { GagentsHookConfig } from "./types";
+import { useGagentsClient } from "./types";
+
+export function useGagentsContacts(config: GagentsHookConfig, params?: Record<string, string>) {
+  const client = useGagentsClient(config);
+
+  return useQuery({
+    queryKey: ["greatagents", "contacts", config.accountId, params],
+    queryFn: () => client.listGagentsContacts(config.accountId, params),
+    enabled: !!config.token && !!config.accountId,
+    select: (res) => ({ data: res.data || [], total: res.total || 0 }),
+  });
+}

package/src/hooks/use-conversations.ts

@@ -0,0 +1,39 @@
+import { useQuery } from "@tanstack/react-query";
+import type { GagentsHookConfig } from "./types";
+import { useGagentsClient } from "./types";
+
+export function useConversations(config: GagentsHookConfig) {
+  const client = useGagentsClient(config);
+
+  return useQuery({
+    queryKey: ["greatagents", "conversations", config.accountId],
+    queryFn: () => client.listConversations(config.accountId),
+    enabled: !!config.token && !!config.accountId,
+    select: (res) => ({ data: res.data || [], total: res.total || 0 }),
+  });
+}
+
+export function useAgentConversations(config: GagentsHookConfig, idAgent: number) {
+  const client = useGagentsClient(config);
+
+  return useQuery({
+    queryKey: ["greatagents", "conversations", config.accountId, "agent", idAgent],
+    queryFn: () => client.listAgentConversations(config.accountId, idAgent),
+    enabled: !!config.token && !!config.accountId && !!idAgent,
+    select: (res) => ({ data: res.data || [], total: res.total || 0 }),
+  });
+}
+
+export function useConversation(config: GagentsHookConfig, id: number) {
+  const client = useGagentsClient(config);
+
+  return useQuery({
+    queryKey: ["greatagents", "conversations", config.accountId, id],
+    queryFn: () => client.getConversation(config.accountId, id),
+    enabled: !!config.token && !!config.accountId && !!id,
+    select: (res) => {
+      const d = res.data;
+      return Array.isArray(d) ? d[0] : d;
+    },
+  });
+}

package/src/hooks/use-objectives.ts

@@ -0,0 +1,77 @@
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import type { GagentsHookConfig } from "./types";
+import { useGagentsClient } from "./types";
+
+export function useObjectives(config: GagentsHookConfig, idAgent: number) {
+  const client = useGagentsClient(config);
+
+  return useQuery({
+    queryKey: ["greatagents", "objectives", config.accountId, idAgent],
+    queryFn: () => client.listObjectives(config.accountId, idAgent),
+    enabled: !!config.token && !!config.accountId && !!idAgent,
+    select: (res) => ({ data: res.data || [], total: res.total || 0 }),
+  });
+}
+
+export function useCreateObjective(config: GagentsHookConfig) {
+  const client = useGagentsClient(config);
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: ({
+      idAgent,
+      body,
+    }: {
+      idAgent: number;
+      body: {
+        title: string;
+        slug?: string;
+        prompt?: string | null;
+        order?: number;
+        active?: boolean;
+      };
+    }) => client.createObjective(config.accountId, idAgent, body),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["greatagents", "objectives"] });
+    },
+  });
+}
+
+export function useUpdateObjective(config: GagentsHookConfig) {
+  const client = useGagentsClient(config);
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: ({
+      idAgent,
+      id,
+      body,
+    }: {
+      idAgent: number;
+      id: number;
+      body: Partial<{
+        title: string;
+        slug: string;
+        prompt: string | null;
+        order: number;
+        active: boolean;
+      }>;
+    }) => client.updateObjective(config.accountId, idAgent, id, body),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["greatagents", "objectives"] });
+    },
+  });
+}
+
+export function useDeleteObjective(config: GagentsHookConfig) {
+  const client = useGagentsClient(config);
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: ({ idAgent, id }: { idAgent: number; id: number }) =>
+      client.deleteObjective(config.accountId, idAgent, id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["greatagents", "objectives"] });
+    },
+  });
+}