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

agentui/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "agentui",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "svelte-kit sync && vite dev",
+    "build": "svelte-kit sync && vite build",
+    "preview": "svelte-kit sync && vite preview",
+    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "postinstall": "node ./scripts/postinstall/apply-patches.mjs"
+  },
+  "devDependencies": {
+    "@sveltejs/adapter-auto": "^3.2.1",
+    "@sveltejs/kit": "next",
+    "@sveltejs/vite-plugin-svelte": "^4.0.0-next.0",
+    "@tailwindcss/vite": "^4.0.0",
+    "prettier": "^3.4.2",
+    "prettier-plugin-svelte": "^3.3.3",
+    "prettier-plugin-tailwindcss": "^0.6.11",
+    "svelte": "^5.0.0-next.1",
+    "svelte-check": "^3.8.4",
+    "tslib": "^2.8.1",
+    "typescript": "^5.6.3",
+    "tailwindcss": "^4.0.0",
+    "vite": "^5.4.10"
+  },
+  "dependencies": {
+    "axios": "^1.7.9",
+    "daisyui": "^5.0.0",
+    "isomorphic-dompurify": "^2.15.0",
+    "marked": "^15.0.4"
+  }
+}

agentui/scripts/postinstall/apply-patches.mjs

@@ -0,0 +1,260 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.resolve(__dirname, '..', '..');
+const nodeModulesDir = path.join(projectRoot, 'node_modules');
+let lockfileCache = null;
+let lockfileDirty = false;
+const lockfilePath = path.join(projectRoot, 'package-lock.json');
+
+function loadLockfile() {
+  if (lockfileCache) return lockfileCache;
+  if (!existsSync(lockfilePath)) return null;
+  lockfileCache = JSON.parse(readFileSync(lockfilePath, 'utf8'));
+  return lockfileCache;
+}
+
+function saveLockfile() {
+  if (!lockfileDirty || !lockfileCache) return;
+  writeFileSync(lockfilePath, JSON.stringify(lockfileCache, null, 2) + '\n', 'utf8');
+  lockfileDirty = false;
+}
+
+function updateLockDependency(name, version) {
+  const lock = loadLockfile();
+  if (!lock) return false;
+  let changed = false;
+  const packageKey = `node_modules/${name}`;
+  if (lock.packages && lock.packages[packageKey]) {
+    const pkg = lock.packages[packageKey];
+    if (pkg.version !== version) {
+      pkg.version = version;
+      changed = true;
+    }
+    if ('resolved' in pkg) {
+      delete pkg.resolved;
+      changed = true;
+    }
+    if ('integrity' in pkg) {
+      delete pkg.integrity;
+      changed = true;
+    }
+  }
+  if (lock.dependencies && lock.dependencies[name]) {
+    const dep = lock.dependencies[name];
+    if (dep.version !== version) {
+      dep.version = version;
+      changed = true;
+    }
+    if ('resolved' in dep) {
+      delete dep.resolved;
+      changed = true;
+    }
+    if ('integrity' in dep) {
+      delete dep.integrity;
+      changed = true;
+    }
+  }
+  if (changed) lockfileDirty = true;
+  return changed;
+}
+
+function ensureDirectory(dirPath) {
+  if (!existsSync(dirPath)) {
+    mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+function patchCookie() {
+  const targetDir = path.join(nodeModulesDir, 'cookie');
+  const targetFile = path.join(targetDir, 'index.js');
+  const pkgFile = path.join(targetDir, 'package.json');
+  const patchedVersion = '0.6.0-patched';
+  if (!existsSync(targetFile)) {
+    return false;
+  }
+
+  const sourceLines = [
+    "'use strict';",
+    "const TOKEN = /^[!#$%&'*+\\-.^_`|~0-9A-Za-z]+$/;",
+    "const VALUE = /^[\\u0020-\\u007E]*$/;",
+    "const DEFAULT_DECODE = (value) => value.replace(/%([0-9A-Fa-f]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));",
+    "const DEFAULT_ENCODE = (value) => encodeURIComponent(value);",
+    '',
+    'function tryDecode(value, decode) {',
+    '  try {',
+    '    return decode(value);',
+    '  } catch {',
+    '    return value;',
+    '  }',
+    '}',
+    '',
+    'export function parse(str, options = {}) {',
+    "  if (typeof str !== 'string') {",
+    "    throw new TypeError('Argument str must be a string');",
+    '  }',
+    '',
+    '  const decode = options.decode || DEFAULT_DECODE;',
+    '  const result = {};',
+    '',
+    '  const pairs = str.split(/; */);',
+    '  for (const pair of pairs) {',
+    '    if (!pair) continue;',
+    '    const eqIdx = pair.indexOf(' + "'='" + ');',
+    '    if (eqIdx < 0) continue;',
+    '',
+    '    const key = pair.slice(0, eqIdx).trim();',
+    '    let val = pair.slice(eqIdx + 1).trim();',
+    '',
+    '    if (!TOKEN.test(key)) continue;',
+    "    if (val.startsWith('\\\"') && val.endsWith('\\\"')) {",
+    '      val = val.slice(1, -1);',
+    '    }',
+    '',
+    '    const decoded = tryDecode(val, decode);',
+    '    result[key] = decoded;',
+    '  }',
+    '',
+    '  return result;',
+    '}',
+    '',
+    'function formatOptions(opts = {}) {',
+    '  const segments = [];',
+    '  if (opts.maxAge != null) {',
+    '    if (!Number.isFinite(opts.maxAge)) {',
+    "      throw new TypeError('maxAge must be a finite number');",
+    '    }',
+    '    segments.push(`Max-Age=${Math.floor(opts.maxAge)}`);',
+    '  }',
+    '  if (opts.domain) {',
+    "    if (!TOKEN.test(opts.domain)) {",
+    "      throw new TypeError('Invalid domain attribute');",
+    '    }',
+    '    segments.push(`Domain=${opts.domain}`);',
+    '  }',
+    '  if (opts.path) {',
+    "    if (!TOKEN.test(opts.path.replace(/\\\\/g, ''))) {",
+    "      throw new TypeError('Invalid path attribute');",
+    '    }',
+    '    segments.push(`Path=${opts.path}`);',
+    '  }',
+    '  if (opts.expires) {',
+    '    const exp = opts.expires;',
+    '    if (!(exp instanceof Date) || isNaN(exp.valueOf())) {',
+    "      throw new TypeError('expires must be a valid Date');",
+    '    }',
+    '    segments.push(`Expires=${exp.toUTCString()}`);',
+    '  }',
+    "  if (opts.httpOnly) segments.push('HttpOnly');",
+    "  if (opts.secure) segments.push('Secure');",
+    "  if (opts.partitioned) segments.push('Partitioned');",
+    '  if (opts.priority) {',
+    '    const priority = String(opts.priority).toLowerCase();',
+    "    if (!['low', 'medium', 'high'].includes(priority)) {",
+    "      throw new TypeError('priority must be Low, Medium, or High');",
+    '    }',
+    '    segments.push(`Priority=${priority.charAt(0).toUpperCase()}${priority.slice(1)}`);',
+    '  }',
+    '  if (opts.sameSite) {',
+    "    const sameSite = typeof opts.sameSite === 'string' ? opts.sameSite.toLowerCase() : opts.sameSite;",
+    '    switch (sameSite) {',
+    '      case true:',
+    "      case 'strict':",
+    "        segments.push('SameSite=Strict');",
+    '        break;',
+    "      case 'lax':",
+    "        segments.push('SameSite=Lax');",
+    '        break;',
+    "      case 'none':",
+    "        segments.push('SameSite=None');",
+    '        break;',
+    '      default:',
+    "        throw new TypeError('sameSite must be Strict, Lax, or None');",
+    '    }',
+    '  }',
+    '  return segments;',
+    '}',
+    '',
+    'export function serialize(name, value, options = {}) {',
+    '  if (!TOKEN.test(name)) {',
+    "    throw new TypeError('Cookie name is invalid');",
+    '  }',
+    "  const stringValue = value === undefined ? '' : String(value);",
+    '  if (!VALUE.test(stringValue)) {',
+    "    throw new TypeError('Cookie value is invalid');",
+    '  }',
+    '',
+    '  const encode = options.encode || DEFAULT_ENCODE;',
+    '  const encoded = encode(stringValue);',
+    '  if (!VALUE.test(encoded)) {',
+    "    throw new TypeError('Cookie value contains invalid characters after encoding');",
+    '  }',
+    '',
+    '  const segments = [`${name}=${encoded}`];',
+    '  segments.push(...formatOptions(options));',
+    "  return segments.join('; ');",
+    '}',
+    '',
+    'export default { parse, serialize };',
+    'if (typeof module !== ' + "'undefined'" + ') {',
+    '  module.exports = { parse, serialize };',
+    '}',
+  ];
+  const source = sourceLines.join('\n');
+
+  writeFileSync(targetFile, source, 'utf8');
+  if (existsSync(pkgFile)) {
+    const pkg = JSON.parse(readFileSync(pkgFile, 'utf8'));
+    pkg.version = patchedVersion;
+    pkg.description = (pkg.description || 'Cookie utilities') + ' (security patch applied)';
+    writeFileSync(pkgFile, JSON.stringify(pkg, null, 2) + '\n', 'utf8');
+  }
+  updateLockDependency('cookie', patchedVersion);
+  return true;
+}
+
+function patchEsbuild() {
+  const targetFile = path.join(nodeModulesDir, 'esbuild', 'lib', 'main.js');
+  const patchedVersion = '0.21.5-patched';
+  if (!existsSync(targetFile)) {
+    return false;
+  }
+  const content = readFileSync(targetFile, 'utf8');
+  if (!content.includes('ESBUILD_SERVE_PATCH_APPLIED')) {
+    const patch = `\n// ESBUILD_SERVE_PATCH_APPLIED\nif (module.exports && typeof module.exports.serve === 'function') {\n  module.exports.serve = function patchedEsbuildServe() {\n    throw new Error('esbuild serve API disabled by project security patch.');\n  };\n}\n`;
+    writeFileSync(targetFile, content + patch, 'utf8');
+  }
+  updateLockDependency('esbuild', patchedVersion);
+  const pkgFile = path.join(nodeModulesDir, 'esbuild', 'package.json');
+  if (existsSync(pkgFile)) {
+    const pkg = JSON.parse(readFileSync(pkgFile, 'utf8'));
+    pkg.version = patchedVersion;
+    pkg.description = (pkg.description || 'esbuild') + ' (serve API disabled by security patch)';
+    writeFileSync(pkgFile, JSON.stringify(pkg, null, 2) + '\n', 'utf8');
+  }
+  return true;
+}
+
+function main() {
+  ensureDirectory(nodeModulesDir);
+  const patched = [];
+  try {
+    if (patchCookie()) patched.push('cookie');
+  } catch (error) {
+    console.warn('[patch] Failed to patch cookie package:', error);
+  }
+  try {
+    if (patchEsbuild()) patched.push('esbuild');
+  } catch (error) {
+    console.warn('[patch] Failed to patch esbuild package:', error);
+  }
+  saveLockfile();
+  if (patched.length) {
+    console.log(`[patch] Applied security hardening for ${patched.join(', ')}`);
+  }
+}
+
+main();

agentui/src/app.css

@@ -0,0 +1,61 @@
+@import "tailwindcss";
+@plugin "daisyui";
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+@theme {
+  /* Custom theme extensions */
+}
+
+:root {
+  color-scheme: light dark;
+}
+
+body {
+  min-height: 100vh;
+}
+
+.chat-markdown {
+  @apply space-y-3 text-sm leading-relaxed;
+}
+
+.chat-markdown p {
+  margin: 0;
+}
+
+.chat-markdown pre {
+  background: rgba(0, 0, 0, 0.08);
+  padding: 0.75rem;
+  border-radius: 0.75rem;
+  overflow-x: auto;
+}
+
+.chat-markdown code {
+  font-family: "Fira Code", ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New",
+    monospace;
+  font-size: 0.85rem;
+}
+
+.chat-markdown table {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 0.9rem;
+}
+
+.chat-markdown th,
+.chat-markdown td {
+  border: 1px solid rgba(0, 0, 0, 0.1);
+  padding: 0.5rem;
+  text-align: left;
+}
+
+.chat-markdown ul,
+.chat-markdown ol {
+  padding-left: 1.25rem;
+}
+
+.chat-markdown a {
+  color: hsl(var(--p));
+  text-decoration: underline;
+}

agentui/src/app.d.ts

@@ -0,0 +1,13 @@
+// See https://kit.svelte.dev/docs/types#app
+// for information about these interfaces
+declare global {
+  namespace App {
+    // interface Error {}
+    // interface Locals {}
+    // interface PageData {}
+    // interface PageState {}
+    // interface Platform {}
+  }
+}
+
+export {};

agentui/src/app.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <link rel="icon" href="%sveltekit.assets%/favicon.png" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    %sveltekit.head%
+  </head>
+  <body data-sveltekit-preload-data="hover">
+    <div style="display: contents">%sveltekit.body%</div>
+  </body>
+</html>

agentui/src/components/LoadingSpinner.svelte

@@ -0,0 +1,64 @@
+<script>
+  /**
+   * LoadingSpinner Component
+   *
+   * A reusable loading spinner with various sizes and customization options.
+   * Uses daisyUI's loading component.
+   */
+
+  let {
+    size = 'md',
+    type = 'spinner',
+    color = '',
+    text = '',
+    center = true,
+    className = ''
+  } = $props();
+
+  // Size mapping
+  const sizeClasses = {
+    xs: 'loading-xs',
+    sm: 'loading-sm',
+    md: 'loading-md',
+    lg: 'loading-lg'
+  };
+
+  // Type mapping
+  const typeClasses = {
+    spinner: 'loading-spinner',
+    dots: 'loading-dots',
+    ring: 'loading-ring',
+    ball: 'loading-ball',
+    bars: 'loading-bars',
+    infinity: 'loading-infinity'
+  };
+
+  // Color mapping
+  const colorClasses = {
+    primary: 'text-primary',
+    secondary: 'text-secondary',
+    accent: 'text-accent',
+    neutral: 'text-neutral',
+    info: 'text-info',
+    success: 'text-success',
+    warning: 'text-warning',
+    error: 'text-error'
+  };
+
+  const loadingClasses = $derived(
+    `loading ${typeClasses[type] || typeClasses.spinner} ${sizeClasses[size] || sizeClasses.md} ${
+      color ? colorClasses[color] : ''
+    } ${className}`
+  );
+
+  const wrapperClasses = $derived(
+    center ? 'flex flex-col items-center justify-center gap-2' : 'flex items-center gap-2'
+  );
+</script>
+
+<div class={wrapperClasses}>
+  <span class={loadingClasses}></span>
+  {#if text}
+    <span class="text-sm text-base-content/70">{text}</span>
+  {/if}
+</div>

agentui/src/components/ThemeSwitcher.svelte

@@ -0,0 +1,159 @@
+<script>
+  import { themeStore, THEMES } from '$lib/stores/theme.svelte.js';
+
+  let { showLabel = true, buttonClass = 'btn-ghost' } = $props();
+
+  let showDropdown = $state(false);
+  let searchQuery = $state('');
+
+  // Derived filtered themes
+  let filteredThemes = $derived(
+    searchQuery
+      ? THEMES.filter((theme) => theme.toLowerCase().includes(searchQuery.toLowerCase()))
+      : THEMES
+  );
+
+  let currentTheme = $state('light');
+
+  function selectTheme(theme) {
+    themeStore.setTheme(theme);
+    showDropdown = false;
+    searchQuery = '';
+  }
+
+  function toggleDropdown() {
+    showDropdown = !showDropdown;
+  }
+
+  // Close dropdown when clicking outside
+  function handleClickOutside(event) {
+    if (!event.target.closest('.theme-dropdown-container')) {
+      showDropdown = false;
+    }
+  }
+
+  $effect(() => {
+    if (typeof document === 'undefined') {
+      return () => {};
+    }
+
+    if (showDropdown) {
+      document.addEventListener('click', handleClickOutside);
+    } else {
+      document.removeEventListener('click', handleClickOutside);
+    }
+
+    return () => {
+      document.removeEventListener('click', handleClickOutside);
+    };
+  });
+
+  $effect(() => {
+    const unsubscribe = themeStore.subscribe((value) => {
+      currentTheme = value.currentTheme;
+    });
+
+    return () => unsubscribe();
+  });
+</script>
+
+<div class="theme-dropdown-container relative">
+  <button
+    type="button"
+    class="btn {buttonClass} gap-2"
+    onclick={toggleDropdown}
+    aria-label="Theme Selector"
+  >
+    <svg
+      xmlns="http://www.w3.org/2000/svg"
+      class="h-5 w-5"
+      fill="none"
+      viewBox="0 0 24 24"
+      stroke="currentColor"
+    >
+      <path
+        stroke-linecap="round"
+        stroke-linejoin="round"
+        stroke-width="2"
+        d="M7 21a4 4 0 01-4-4V5a2 2 0 012-2h4a2 2 0 012 2v12a4 4 0 01-4 4zm0 0h12a2 2 0 002-2v-4a2 2 0 00-2-2h-2.343M11 7.343l1.657-1.657a2 2 0 012.828 0l2.829 2.829a2 2 0 010 2.828l-8.486 8.485M7 17h.01"
+      />
+    </svg>
+    {#if showLabel}
+      <span class="hidden sm:inline capitalize">{currentTheme}</span>
+    {/if}
+    <svg
+      class="h-4 w-4 fill-current"
+      xmlns="http://www.w3.org/2000/svg"
+      viewBox="0 0 20 20"
+    >
+      <path d="M5.293 7.293a1 1 0 011.414 0L10 10.586l3.293-3.293a1 1 0 111.414 1.414l-4 4a1 1 0 01-1.414 0l-4-4a1 1 0 010-1.414z" />
+    </svg>
+  </button>
+
+  {#if showDropdown}
+    <div class="absolute right-0 z-[100] mt-2 w-64 rounded-box bg-base-100 shadow-2xl">
+      <div class="p-3">
+        <!-- Search Input -->
+        <input
+          type="text"
+          placeholder="Search themes..."
+          class="input input-bordered input-sm w-full"
+          bind:value={searchQuery}
+        />
+      </div>
+
+      <!-- Themes List -->
+      <ul class="menu menu-sm max-h-96 overflow-y-auto p-2">
+        {#if filteredThemes.length === 0}
+          <li class="disabled">
+            <span class="text-base-content/50">No themes found</span>
+          </li>
+        {:else}
+          {#each filteredThemes as theme}
+            <li>
+              <button
+                class:active={currentTheme === theme}
+                onclick={() => selectTheme(theme)}
+                data-theme={theme}
+              >
+                <div class="flex w-full items-center justify-between">
+                  <span class="capitalize">{theme}</span>
+                  <div class="flex gap-1">
+                    <div
+                      class="h-3 w-3 rounded bg-primary"
+                      data-theme={theme}
+                    ></div>
+                    <div
+                      class="h-3 w-3 rounded bg-secondary"
+                      data-theme={theme}
+                    ></div>
+                    <div
+                      class="h-3 w-3 rounded bg-accent"
+                      data-theme={theme}
+                    ></div>
+                  </div>
+                </div>
+              </button>
+            </li>
+          {/each}
+        {/if}
+      </ul>
+
+      <!-- Quick Actions -->
+      <div class="border-t border-base-300 p-2">
+        <button
+          class="btn btn-sm btn-block"
+          onclick={() => themeStore.toggleDarkMode()}
+        >
+          Toggle Dark Mode
+        </button>
+      </div>
+    </div>
+  {/if}
+</div>
+
+<style>
+  .theme-dropdown-container {
+    position: relative;
+  }
+</style>

agentui/src/components/index.js

@@ -0,0 +1,4 @@
+export { default as LoadingSpinner } from './LoadingSpinner.svelte';
+export { default as ThemeSwitcher } from './ThemeSwitcher.svelte';
+export { default as BotCard } from '$lib/components/BotCard.svelte';
+export { default as ChatBubble } from '$lib/components/ChatBubble.svelte';

agentui/src/lib/api/bots.ts

@@ -0,0 +1,60 @@
+import apiClient from './http';
+
+export type BotSummary = {
+  id: string;
+  chatbot_id: string;
+  name: string;
+  description?: string;
+  category?: string;
+  owner?: string;
+};
+
+type BotApiResponse = {
+  chatbot_id?: string;
+  id?: string;
+  name: string;
+  description?: string;
+  category?: string;
+  owner?: string;
+  created_by?: string;
+};
+
+const mapBot = (bot: BotApiResponse): BotSummary => ({
+  id: bot.chatbot_id || bot.id || bot.name,
+  chatbot_id: bot.chatbot_id || bot.id || bot.name,
+  name: bot.name,
+  description: bot.description || 'No description provided.',
+  category: bot.category || 'General',
+  owner: bot.owner || bot.created_by || 'Unknown'
+});
+
+async function listBots() {
+  const { data } = await apiClient.get('/api/v1/bots');
+  const bots = Array.isArray(data) ? data : data?.bots || [];
+  return {
+    bots: bots.map(mapBot)
+  };
+}
+
+async function getBot(agentId: string) {
+  try {
+    const { data } = await apiClient.get(`/api/v1/bots/${agentId}`);
+    return mapBot(data);
+  } catch (error: any) {
+    if (error?.response?.status === 404) {
+      const { bots } = await listBots();
+      const found = bots.find(
+        (bot) => bot.chatbot_id === agentId || bot.id === agentId || bot.name === agentId
+      );
+      if (found) {
+        return found;
+      }
+    }
+    throw error;
+  }
+}
+
+export const botsApi = {
+  listBots,
+  getBot
+};

agentui/src/lib/api/chat.ts

@@ -0,0 +1,22 @@
+import apiClient from './http';
+
+export type ChatRequest = {
+  query: string;
+};
+
+export type ChatResponse = {
+  turn_id: string;
+  input: string;
+  output: string;
+  response: string;
+  [key: string]: any;
+};
+
+async function sendChat(agentId: string, payload: ChatRequest): Promise<ChatResponse> {
+  const { data } = await apiClient.post(`/api/v1/agents/chat/${agentId}`, payload);
+  return data;
+}
+
+export const chatApi = {
+  sendChat
+};