ai-parrot 0.17.2__cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

crew-builder/src/lib/components/index.ts

@@ -0,0 +1,10 @@
+export { default as AgentNode } from './AgentNode.svelte';
+export { default as ConfigPanel } from './ConfigPanel.svelte';
+export { default as JsonTreeNode } from './JsonTreeNode.svelte';
+export { default as JsonViewer } from './JsonViewer.svelte';
+export { default as MarkdownEditor } from './MarkdownEditor.svelte';
+export { default as ThemeToggle } from './ThemeToggle.svelte';
+export { default as Toast } from './Toast.svelte';
+export { default as Toolbar } from './Toolbar.svelte';
+export { default as LoadingSpinner } from '../../components/LoadingSpinner.svelte';
+export { default as ThemeSwitcher } from '../../components/ThemeSwitcher.svelte';

crew-builder/src/lib/config.ts

@@ -0,0 +1,8 @@
+const DEFAULT_ENV_LABEL = import.meta.env?.VITE_CREW_BUILDER_ENV || 'local';
+const environmentLabel = DEFAULT_ENV_LABEL.trim() || 'local';
+const storageNamespace = `crew-builder.${environmentLabel}`;
+
+export const config = {
+  environmentLabel,
+  conversationStoragePrefix: `${storageNamespace}.conversation`
+};

crew-builder/src/lib/stores/auth.svelte.ts

@@ -0,0 +1,228 @@
+import { browser } from '$app/environment';
+import { goto } from '$app/navigation';
+import type { Subscriber } from 'svelte/store';
+import type { LoginResponse, SessionData } from '$lib/auth/auth';
+import { login as loginRequest } from '$lib/auth/auth';
+
+interface AuthState {
+  user: LoginResponse | null;
+  session: SessionData | null;
+  token: string | null;
+  loading: boolean;
+  isAuthenticated: boolean;
+}
+
+class AuthStore {
+  private state: AuthState = {
+    user: null,
+    session: null,
+    token: null,
+    loading: true,
+    isAuthenticated: false
+  };
+
+  private subscribers = new Set<Subscriber<AuthState>>();
+
+  get user() {
+    return this.state.user;
+  }
+
+  set user(value: LoginResponse | null) {
+    this.setState({ user: value });
+  }
+
+  get session() {
+    return this.state.session;
+  }
+
+  set session(value: SessionData | null) {
+    this.setState({ session: value });
+  }
+
+  get token() {
+    return this.state.token;
+  }
+
+  set token(value: string | null) {
+    this.setState({ token: value });
+  }
+
+  get loading() {
+    return this.state.loading;
+  }
+
+  set loading(value: boolean) {
+    this.setState({ loading: value });
+  }
+
+  get isAuthenticated() {
+    return this.state.isAuthenticated;
+  }
+
+  get currentUser() {
+    if (!this.state.user) return null;
+
+    return {
+      id: this.state.user.id,
+      user_id: this.state.user.user_id,
+      username: this.state.user.username,
+      email: this.state.user.email,
+      name: this.state.user.name
+    };
+  }
+
+  subscribe(run: Subscriber<AuthState>) {
+    run(this.state);
+    this.subscribers.add(run);
+
+    return () => {
+      this.subscribers.delete(run);
+    };
+  }
+
+  private notify() {
+    for (const subscriber of this.subscribers) {
+      subscriber(this.state);
+    }
+  }
+
+  private setState(partial: Partial<AuthState>) {
+    this.state = {
+      ...this.state,
+      ...partial
+    };
+    this.state.isAuthenticated = Boolean(this.state.token);
+    this.notify();
+  }
+
+  init() {
+    if (!browser) {
+      this.loading = false;
+      return;
+    }
+
+    const storedToken = localStorage.getItem('token');
+    const storedUser = localStorage.getItem('user');
+    const storedSession = localStorage.getItem('session');
+
+    if (storedToken && storedUser) {
+      try {
+        const parsedUser = JSON.parse(storedUser) as LoginResponse;
+        this.user = parsedUser;
+        this.token = storedToken;
+
+        if (storedSession) {
+          this.session = JSON.parse(storedSession) as SessionData;
+        }
+      } catch (error) {
+        console.error('Failed to parse stored auth data', error);
+        this.clearStorage();
+      }
+    } else {
+      this.user = null;
+      this.session = null;
+      this.token = null;
+    }
+
+    this.loading = false;
+  }
+
+  private clearStorage() {
+    if (!browser) return;
+
+    localStorage.removeItem('token');
+    localStorage.removeItem('user');
+    localStorage.removeItem('session');
+    localStorage.removeItem('user_id');
+    localStorage.removeItem('id');
+    localStorage.removeItem('username');
+    localStorage.removeItem('email');
+
+    this.user = null;
+    this.session = null;
+    this.token = null;
+  }
+
+  private saveToStorage(data: LoginResponse) {
+    if (!browser) return;
+
+    localStorage.setItem('token', data.token);
+    localStorage.setItem('user', JSON.stringify(data));
+
+    if (data.session) {
+      localStorage.setItem('session', JSON.stringify(data.session));
+    }
+
+    localStorage.setItem('user_id', data.user_id.toString());
+    localStorage.setItem('id', data.id);
+    localStorage.setItem('username', data.username);
+    localStorage.setItem('email', data.email);
+  }
+
+  async login(username: string, password: string) {
+    this.loading = true;
+
+    try {
+      const response = await loginRequest({ username, password });
+      const data = response.data;
+
+      if (!data?.token) {
+        throw new Error('Authentication token missing from response');
+      }
+
+      this.user = data;
+      this.session = data.session;
+      this.token = data.token;
+      this.loading = false;
+
+      this.saveToStorage(data);
+
+      await goto('/');
+
+      return { success: true };
+    } catch (error: any) {
+      this.loading = false;
+
+      let message = 'Invalid credentials';
+
+      if (error.response) {
+        const status = error.response.status;
+        const responseData = error.response.data;
+
+        if (status === 403) {
+          message = responseData?.message || 'Access forbidden. Please check your credentials.';
+        } else if (status === 401) {
+          message = responseData?.message || 'Invalid username or password.';
+        } else if (status === 400) {
+          message = responseData?.message || 'Invalid request. Please check your input.';
+        } else if (status >= 400 && status < 500) {
+          message = responseData?.message || `Authentication failed (${status}).`;
+        } else if (status >= 500) {
+          message = responseData?.message || 'Server error. Please try again later.';
+        }
+      } else if (error.message) {
+        message = error.message;
+      }
+
+      return {
+        success: false,
+        error: message,
+        status: error.response?.status
+      };
+    }
+  }
+
+  async logout() {
+    this.clearStorage();
+    this.loading = false;
+
+    await goto('/login');
+  }
+
+  checkAuth() {
+    if (!browser) return false;
+    return Boolean(localStorage.getItem('token'));
+  }
+}
+
+export const authStore = new AuthStore();

crew-builder/src/lib/stores/crewStore.ts

@@ -0,0 +1,369 @@
+import { MarkerType, type Connection, type Edge, type Node } from '@xyflow/svelte';
+import { derived, get, writable, type Readable } from 'svelte/store';
+
+export type CrewExecutionMode = 'sequential' | 'parallel' | 'hierarchical' | 'flow';
+
+export interface AgentConfig {
+  model: string;
+  temperature: number;
+  [key: string]: unknown;
+}
+
+export interface AgentNodeData extends Record<string, unknown> {
+  agent_id: string;
+  name: string;
+  agent_class: string;
+  config: AgentConfig;
+  tools: string[];
+  system_prompt: string;
+}
+
+export interface CrewMetadata {
+  name: string;
+  description: string;
+  execution_mode: CrewExecutionMode;
+}
+
+export interface CrewState {
+  metadata: CrewMetadata;
+  nodes: Node<AgentNodeData>[];
+  edges: Edge[];
+  nextNodeId: number;
+}
+
+interface CrewApiAgent {
+  agent_id: string;
+  agent_class?: string;
+  name?: string;
+  config?: Partial<AgentConfig> & Record<string, unknown>;
+  tools?: string[];
+  system_prompt?: string | null;
+}
+
+interface CrewApiFlowRelation {
+  source?: string | string[];
+  target?: string | string[];
+}
+
+interface CrewApiResponse {
+  crew_id?: string;
+  name?: string | null;
+  description?: string | null;
+  execution_mode?: CrewExecutionMode;
+  agents?: CrewApiAgent[];
+  flow_relations?: CrewApiFlowRelation[];
+}
+
+const EDGE_MARKER = {
+  type: MarkerType.ArrowClosed,
+  width: 20,
+  height: 20
+} as const;
+
+const createInitialState = (): CrewState => ({
+  metadata: {
+    name: 'research_pipeline',
+    description: 'Sequential pipeline for research and writing',
+    execution_mode: 'sequential'
+  },
+  nodes: [],
+  edges: [],
+  nextNodeId: 1
+});
+
+function createCrewStore() {
+  const initialState = createInitialState();
+
+  const metadataStore = writable(initialState.metadata);
+  const nodesStore = writable<Node<AgentNodeData>[]>(initialState.nodes);
+  const edgesStore = writable<Edge[]>(initialState.edges);
+  const nextNodeIdStore = writable(initialState.nextNodeId);
+
+  const combined: Readable<CrewState> = derived(
+    [metadataStore, nodesStore, edgesStore, nextNodeIdStore],
+    ([$metadata, $nodes, $edges, $nextNodeId]) => ({
+      metadata: $metadata,
+      nodes: $nodes,
+      edges: $edges,
+      nextNodeId: $nextNodeId
+    })
+  );
+
+  function makeAgentNode(id: number, existingNodes: Node<AgentNodeData>[]): Node<AgentNodeData> {
+    const nodeId = `agent-${id}`;
+    return {
+      id: nodeId,
+      type: 'agentNode',
+      position: {
+        x: 100 + existingNodes.length * 50,
+        y: 100 + existingNodes.length * 50
+      },
+      data: {
+        agent_id: `agent_${id}`,
+        name: `Agent ${id}`,
+        agent_class: 'Agent',
+        config: {
+          model: 'gemini-2.5-pro',
+          temperature: 0.7
+        },
+        tools: [],
+        system_prompt: 'You are an expert AI agent.'
+      }
+    };
+  }
+
+  return {
+    subscribe: combined.subscribe,
+    nodes: nodesStore,
+    edges: edgesStore,
+    addAgent: () => {
+      const nextId = get(nextNodeIdStore);
+      nodesStore.update((current) => [...current, makeAgentNode(nextId, current)]);
+      nextNodeIdStore.set(nextId + 1);
+    },
+    updateAgent: (nodeId: string, updatedData: Partial<AgentNodeData>) => {
+      nodesStore.update((current) =>
+        current.map((node) =>
+          node.id === nodeId
+            ? {
+                ...node,
+                data: {
+                  ...node.data,
+                  ...updatedData,
+                  config: {
+                    ...node.data.config,
+                    ...(updatedData.config ?? {})
+                  },
+                  tools: updatedData.tools ?? node.data.tools
+                }
+              }
+            : node
+        )
+      );
+    },
+    deleteAgent: (nodeId: string) => {
+      nodesStore.update((current) => current.filter((node) => node.id !== nodeId));
+      edgesStore.update((current) =>
+        current.filter((edge) => edge.source !== nodeId && edge.target !== nodeId)
+      );
+    },
+    addEdge: (connection: Connection) => {
+      const newEdge: Edge = {
+        id: `${connection.source}-${connection.target}`,
+        source: connection.source,
+        target: connection.target,
+        type: 'smoothstep',
+        animated: true,
+        markerEnd: {
+          type: MarkerType.ArrowClosed,
+          width: 20,
+          height: 20
+        }
+      };
+
+      edgesStore.update((current) => [...current, newEdge]);
+    },
+    updateMetadata: (metadata: Partial<CrewMetadata>) => {
+      metadataStore.update((current) => ({ ...current, ...metadata }));
+    },
+    exportToJSON: () => {
+      const currentMetadata = get(metadataStore);
+      const currentNodes = get(nodesStore);
+      const currentEdges = get(edgesStore);
+      const executionOrder = buildExecutionOrder(currentNodes, currentEdges);
+
+      const agents = executionOrder.map((node) => ({
+        agent_id: node.data.agent_id,
+        name: node.data.name,
+        agent_class: node.data.agent_class,
+        config: node.data.config,
+        ...(node.data.tools && node.data.tools.length > 0 && { tools: node.data.tools }),
+        system_prompt: node.data.system_prompt
+      }));
+
+      return {
+        name: currentMetadata.name,
+        description: currentMetadata.description,
+        execution_mode: currentMetadata.execution_mode,
+        agents
+      };
+    },
+    reset: () => {
+      const resetState = createInitialState();
+      metadataStore.set(resetState.metadata);
+      nodesStore.set(resetState.nodes);
+      edgesStore.set(resetState.edges);
+      nextNodeIdStore.set(resetState.nextNodeId);
+    },
+    importCrew: (crew: CrewApiResponse) => {
+      const agents = Array.isArray(crew.agents) ? crew.agents : [];
+
+      const importedNodes = agents.map((agent, index) => {
+        const nodeId = agent.agent_id || `agent-${index + 1}`;
+        const rawConfig =
+          (agent.config && typeof agent.config === 'object' ? agent.config : {}) as Record<string, unknown>;
+        const model = typeof rawConfig.model === 'string' ? (rawConfig.model as string) : 'gemini-2.5-pro';
+        const temperature =
+          typeof rawConfig.temperature === 'number' ? (rawConfig.temperature as number) : 0.7;
+        const normalizedConfig: AgentConfig = {
+          ...rawConfig,
+          model,
+          temperature
+        };
+        return {
+          id: nodeId,
+          type: 'agentNode' as const,
+          position: {
+            x: 200 + (index % 3) * 260,
+            y: 120 + Math.floor(index / 3) * 220
+          },
+          data: {
+            agent_id: agent.agent_id ?? `agent_${index + 1}`,
+            name: agent.name ?? `Agent ${index + 1}`,
+            agent_class: agent.agent_class ?? 'Agent',
+            config: normalizedConfig,
+            tools: Array.isArray(agent.tools) ? agent.tools : [],
+            system_prompt: agent.system_prompt ?? ''
+          }
+        } satisfies Node<AgentNodeData>;
+      });
+
+      const agentIdToNodeId = new Map<string, string>();
+      importedNodes.forEach((node) => {
+        agentIdToNodeId.set(node.data.agent_id, node.id);
+        agentIdToNodeId.set(node.id, node.id);
+      });
+
+      const edges: Edge[] = [];
+      const edgeIds = new Set<string>();
+      const pushEdge = (source: string, target: string) => {
+        if (!source || !target || source === target) {
+          return;
+        }
+        let baseId = `${source}-${target}`;
+        let uniqueId = baseId;
+        let attempt = 1;
+        while (edgeIds.has(uniqueId)) {
+          uniqueId = `${baseId}-${attempt}`;
+          attempt += 1;
+        }
+        edgeIds.add(uniqueId);
+        edges.push({
+          id: uniqueId,
+          source,
+          target,
+          type: 'smoothstep',
+          animated: true,
+          markerEnd: { ...EDGE_MARKER }
+        });
+      };
+
+      const normalize = (value?: string | string[]) => {
+        if (Array.isArray(value)) {
+          return value.filter((entry): entry is string => typeof entry === 'string' && entry.length > 0);
+        }
+        return typeof value === 'string' && value.length > 0 ? [value] : [];
+      };
+
+      const flowRelations = Array.isArray(crew.flow_relations) ? crew.flow_relations : [];
+
+      if (flowRelations.length > 0) {
+        flowRelations.forEach((relation) => {
+          const sources = normalize(relation.source).map((agentId) => agentIdToNodeId.get(agentId)).filter((value): value is string => Boolean(value));
+          const targets = normalize(relation.target).map((agentId) => agentIdToNodeId.get(agentId)).filter((value): value is string => Boolean(value));
+
+          sources.forEach((sourceId) => {
+            targets.forEach((targetId) => {
+              pushEdge(sourceId, targetId);
+            });
+          });
+        });
+      } else if ((crew.execution_mode ?? 'sequential') === 'sequential' && importedNodes.length > 1) {
+        for (let index = 0; index < importedNodes.length - 1; index += 1) {
+          const sourceId = importedNodes[index]?.id;
+          const targetId = importedNodes[index + 1]?.id;
+          if (sourceId && targetId) {
+            pushEdge(sourceId, targetId);
+          }
+        }
+      }
+
+      const nextId = (() => {
+        const numericIds = importedNodes
+          .map((node) => {
+            const match = /^agent-(\d+)$/.exec(node.id);
+            return match ? Number.parseInt(match[1], 10) : null;
+          })
+          .filter((value): value is number => value !== null);
+        const maxNumericId = numericIds.length > 0 ? Math.max(...numericIds) : 0;
+        return Math.max(importedNodes.length + 1, maxNumericId + 1);
+      })();
+
+      metadataStore.set({
+        name: crew.name ?? 'untitled_crew',
+        description: crew.description ?? '',
+        execution_mode: crew.execution_mode ?? 'sequential'
+      });
+      nodesStore.set(importedNodes);
+      edgesStore.set(edges);
+      nextNodeIdStore.set(nextId);
+    }
+  };
+}
+
+function buildExecutionOrder(nodes: Node<AgentNodeData>[], edges: Edge[]) {
+  if (nodes.length === 0) {
+    return [];
+  }
+
+  const graph = new Map<string, string[]>();
+  const inDegree = new Map<string, number>();
+
+  for (const node of nodes) {
+    graph.set(node.id, []);
+    inDegree.set(node.id, 0);
+  }
+
+  for (const edge of edges) {
+    graph.get(edge.source)?.push(edge.target);
+    inDegree.set(edge.target, (inDegree.get(edge.target) ?? 0) + 1);
+  }
+
+  const queue: Node<AgentNodeData>[] = [];
+  for (const node of nodes) {
+    if ((inDegree.get(node.id) ?? 0) === 0) {
+      queue.push(node);
+    }
+  }
+
+  const sorted: Node<AgentNodeData>[] = [];
+  const nodeMap = new Map(nodes.map((node) => [node.id, node]));
+
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current) continue;
+    sorted.push(current);
+
+    const neighbors = graph.get(current.id) ?? [];
+    for (const neighborId of neighbors) {
+      const nextDegree = (inDegree.get(neighborId) ?? 0) - 1;
+      inDegree.set(neighborId, nextDegree);
+      if (nextDegree === 0) {
+        const neighbor = nodeMap.get(neighborId);
+        if (neighbor) {
+          queue.push(neighbor);
+        }
+      }
+    }
+  }
+
+  for (const node of nodes) {
+    if (!sorted.find((entry) => entry.id === node.id)) {
+      sorted.push(node);
+    }
+  }
+
+  return sorted;
+}
+
+export const crewStore = createCrewStore();