@polpo-ai/react 0.2.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OpenPolpo Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,556 @@
+# @polpo-ai/react
+
+Type-safe React hooks for OpenPolpo with real-time Server-Sent Events (SSE) updates.
+
+## Features
+
+- 🎣 **Modern React Hooks**: Built with `useSyncExternalStore` for optimal performance
+- 📡 **Real-time Updates**: Push-based SSE, not polling
+- 🔄 **Auto-reconnect**: Exponential backoff with event ID resumption
+- 📦 **Zero Runtime Dependencies**: Only peer dependency is React
+- 🎯 **Type-safe**: Full TypeScript support with inferred types
+- ⚡ **Optimized**: Memoized selectors with WeakMap caching
+- 🔌 **Request Deduplication**: Automatic concurrent request coalescing
+
+## Installation
+
+```bash
+npm install @polpo-ai/react
+```
+
+**Peer Dependencies**:
+- `react`: ^18.0.0 || ^19.0.0
+
+## Quick Start
+
+```tsx
+import { PolpoProvider, useTasks, useAgents, useStats } from '@polpo-ai/react';
+
+function App() {
+  return (
+    <PolpoProvider
+      baseUrl="http://localhost:3890"
+      apiKey="optional-api-key"
+    >
+      <Dashboard />
+    </PolpoProvider>
+  );
+}
+
+function Dashboard() {
+  const { tasks } = useTasks();
+  const agents = useAgents();
+  const stats = useStats();
+
+  return (
+    <div>
+      <h1>Polpo Dashboard</h1>
+      <p>Tasks: {tasks.length}</p>
+      <p>Pending: {stats?.pending ?? 0}</p>
+      <ul>
+        {tasks.map(task => (
+          <li key={task.id}>
+            {task.title} - {task.status}
+          </li>
+        ))}
+      </ul>
+    </div>
+  );
+}
+```
+
+## API Reference
+
+### PolpoProvider
+
+Root provider component that manages connection and state.
+
+```tsx
+<PolpoProvider
+  baseUrl="http://localhost:3890"
+  apiKey="optional-key"
+  autoConnect={true}
+>
+  {children}
+</PolpoProvider>
+```
+
+**Props**:
+- `baseUrl`: OpenPolpo server URL
+- `apiKey?`: Optional API key for authentication
+- `autoConnect?`: Auto-connect on mount (default: true)
+- `eventFilter?`: Array of SSE event type patterns to subscribe to
+
+### Hooks
+
+#### usePolpo()
+
+Access full Polpo state and methods.
+
+```tsx
+const { client, connectionStatus } = usePolpo();
+
+// connectionStatus: 'connecting' | 'connected' | 'reconnecting' | 'disconnected' | 'error'
+
+// Use the client to call API methods:
+await client.createTask({ title: '...', description: '...', assignTo: 'backend-dev' });
+await client.createMission({ data: '...', name: 'my-mission' });
+```
+
+#### useTasks(filter?)
+
+Get all tasks with optional filtering.
+
+```tsx
+// All tasks
+const { tasks } = useTasks();
+
+// Filtered tasks
+const { tasks: pendingTasks } = useTasks({ status: 'pending' });
+const { tasks: agentTasks } = useTasks({ assignTo: 'backend-dev' });
+```
+
+**Returns**: `UseTasksReturn` (includes `tasks: Task[]`, `isLoading`, `error`, `createTask`, `deleteTask`, `retryTask`, `refetch`)
+
+```typescript
+interface Task {
+  id: string;
+  title: string;
+  description: string;
+  assignTo: string;
+  status: 'draft' | 'pending' | 'awaiting_approval' | 'assigned' | 'in_progress' | 'review' | 'done' | 'failed';
+  dependsOn: string[];
+  group?: string;
+  result?: TaskResult;
+  createdAt: string;
+  updatedAt: string;
+  expectations: TaskExpectation[];
+  retries: number;
+  maxRetries: number;
+  missionGroup?: string;
+}
+```
+
+#### useTask(taskId)
+
+Get a single task by ID.
+
+```tsx
+const task = useTask('task-123');
+
+if (!task) {
+  return <div>Task not found</div>;
+}
+
+return <div>{task.title}: {task.status}</div>;
+```
+
+**Returns**: `Task | undefined`
+
+#### useMissions()
+
+Get all missions with CRUD and execution methods.
+
+```tsx
+const {
+  missions,
+  isLoading,
+  error,
+  createMission,
+  updateMission,
+  deleteMission,
+  executeMission,
+  resumeMission,
+  abortMission,
+  refetch,
+} = useMissions();
+```
+
+**Returns**: `UseMissionsReturn`
+
+```typescript
+interface Mission {
+  id: string;
+  name: string;
+  data: string;
+  prompt?: string;
+  status: 'draft' | 'active' | 'paused' | 'completed' | 'failed' | 'cancelled';
+  deadline?: string;
+  schedule?: string;
+  recurring?: boolean;
+  qualityThreshold?: number;
+  createdAt: string;
+  updatedAt: string;
+}
+```
+
+#### useMission(missionId)
+
+Get a single mission by ID.
+
+```tsx
+const { mission, report, isLoading, executeMission, abortMission } = useMission('mission-123');
+```
+
+**Returns**: `UseMissionReturn` (includes `mission`, `report: MissionReport | undefined`, and action methods)
+
+#### useAgents(filter?)
+
+Get all agents.
+
+```tsx
+const agents = useAgents();
+const availableAgents = useAgents({ available: true });
+```
+
+**Returns**: `AgentConfig[]`
+
+```typescript
+interface AgentConfig {
+  name: string;
+  role?: string;
+  model?: string;
+  allowedTools?: string[];
+  systemPrompt?: string;
+  skills?: string[];
+  maxTurns?: number;
+  maxConcurrency?: number;
+  volatile?: boolean;
+  missionGroup?: string;
+}
+```
+
+#### useProcesses()
+
+Get running agent processes.
+
+```tsx
+const processes = useProcesses();
+
+return (
+  <ul>
+    {processes.map(proc => (
+      <li key={proc.agentName}>
+        {proc.agentName} - PID: {proc.pid} - {proc.alive ? 'Running' : 'Dead'}
+      </li>
+    ))}
+  </ul>
+);
+```
+
+**Returns**: `AgentProcess[]`
+
+```typescript
+interface AgentProcess {
+  agentName: string;
+  pid: number;
+  taskId: string;
+  startedAt: string;
+  alive: boolean;
+  activity: AgentActivity;
+}
+
+interface AgentActivity {
+  lastTool?: string;
+  lastFile?: string;
+  filesCreated: string[];
+  filesEdited: string[];
+  toolCalls: number;
+  totalTokens: number;
+  lastUpdate: string;
+  summary?: string;
+  sessionId?: string;
+}
+```
+
+#### useEvents(limit?)
+
+Get recent events from the event stream.
+
+```tsx
+const events = useEvents(50); // Last 50 events
+
+return (
+  <ul>
+    {events.map(event => (
+      <li key={event.id}>
+        {event.event}: {event.timestamp}
+      </li>
+    ))}
+  </ul>
+);
+```
+
+**Returns**: `SSEEvent[]`
+
+#### useStats()
+
+Get aggregate statistics.
+
+```tsx
+const stats = useStats();
+
+if (!stats) return null;
+
+return (
+  <div>
+    <p>Pending: {stats.pending}</p>
+    <p>Running: {stats.running}</p>
+    <p>Queued: {stats.queued}</p>
+    <p>Done: {stats.done}</p>
+    <p>Failed: {stats.failed}</p>
+  </div>
+);
+```
+
+**Returns**: `PolpoStats | null`
+
+```typescript
+interface PolpoStats {
+  pending: number;
+  running: number;
+  done: number;
+  failed: number;
+  queued: number;
+}
+```
+
+#### useMemory()
+
+Get Polpo memory entries.
+
+```tsx
+const memory = useMemory();
+```
+
+**Returns**: `MemoryEntry[]`
+
+#### useLogs(limit?)
+
+Get recent log entries.
+
+```tsx
+const logs = useLogs(100);
+```
+
+**Returns**: `LogEntry[]`
+
+### Methods
+
+#### createTask(task)
+
+Create a new task via the `useTasks` hook or directly via the client.
+
+```tsx
+const { createTask } = useTasks();
+
+await createTask({
+  title: 'Implement feature X',
+  description: 'Add authentication to the API',
+  assignTo: 'backend-dev',
+});
+```
+
+#### retryTask(taskId)
+
+Retry a failed task.
+
+```tsx
+const { retryTask } = useTasks();
+
+await retryTask('task-123');
+```
+
+#### createMission(req)
+
+Create a new mission.
+
+```tsx
+const { createMission } = useMissions();
+
+await createMission({
+  data: 'tasks:\n  - title: Task 1\n    assignTo: backend-dev\n    description: Do something',
+  name: 'new-feature',
+});
+```
+
+#### executeMission(missionId)
+
+Execute a mission (create tasks and start agents).
+
+```tsx
+const { executeMission } = useMissions();
+
+await executeMission('mission-123');
+```
+
+## Real-time Updates
+
+The SDK uses Server-Sent Events (SSE) for push-based real-time updates. All hooks automatically update when the server emits events.
+
+**Event Types**:
+- `task:created`, `task:transition`, `task:updated`, `task:removed`, `task:retry`, `task:fix`, `task:timeout`
+- `mission:saved`, `mission:executed`, `mission:completed`, `mission:resumed`, `mission:deleted`
+- `agent:spawned`, `agent:finished`, `agent:activity`, `agent:stale`
+- `assessment:started`, `assessment:progress`, `assessment:complete`, `assessment:corrected`
+- `orchestrator:started`, `orchestrator:tick`, `orchestrator:shutdown`
+
+**Auto-reconnect**:
+- Exponential backoff (`reconnectDelay` → `maxReconnectDelay`, defaults 1s → 30s)
+- Resumes from last event ID
+
+## Authentication
+
+The SDK supports two authentication methods:
+
+**Header-based** (preferred):
+```tsx
+<PolpoProvider
+  baseUrl="http://localhost:3890"
+  apiKey="your-api-key"
+>
+```
+
+**Query parameter** (for EventSource):
+The SDK automatically appends `?apiKey=` to SSE requests when an API key is provided, since EventSource doesn't support custom headers.
+
+## TypeScript
+
+Full TypeScript support with exported types:
+
+```typescript
+import type {
+  Task,
+  Mission,
+  MissionReport,
+  AgentConfig,
+  AgentProcess,
+  SSEEvent,
+  PolpoStats,
+  CreateTaskRequest,
+  UpdateTaskRequest,
+  CreateMissionRequest,
+  UpdateMissionRequest,
+} from '@polpo-ai/react';
+```
+
+## Examples
+
+### Task List with Retry
+
+```tsx
+import { useTasks } from '@polpo-ai/react';
+
+function TaskList() {
+  const { tasks, retryTask } = useTasks();
+
+  return (
+    <ul>
+      {tasks.map(task => (
+        <li key={task.id}>
+          <span>{task.title} - {task.status}</span>
+          {task.status === 'failed' && (
+            <button onClick={() => retryTask(task.id)}>
+              Retry
+            </button>
+          )}
+        </li>
+      ))}
+    </ul>
+  );
+}
+```
+
+### Live Agent Activity
+
+```tsx
+import { useProcesses } from '@polpo-ai/react';
+
+function AgentActivity() {
+  const processes = useProcesses();
+
+  return (
+    <div>
+      {processes.filter(p => p.alive).map(proc => (
+        <div key={proc.agentName}>
+          <h3>{proc.agentName}</h3>
+          <p>Task: {proc.taskId}</p>
+          {proc.activity && (
+            <>
+              <p>Tool: {proc.activity.lastTool}</p>
+              <p>File: {proc.activity.lastFile}</p>
+            </>
+          )}
+        </div>
+      ))}
+    </div>
+  );
+}
+```
+
+### Mission Progress
+
+```tsx
+import { useMission, useTasks } from '@polpo-ai/react';
+
+function MissionProgress({ missionId }: { missionId: string }) {
+  const { mission, report } = useMission(missionId);
+  const { tasks } = useTasks({ group: missionId });
+
+  if (!mission) return null;
+
+  const completed = tasks.filter(t => t.status === 'done').length;
+  const total = tasks.length;
+  const progress = total > 0 ? (completed / total) * 100 : 0;
+
+  return (
+    <div>
+      <h2>{mission.name} ({mission.status})</h2>
+      <progress value={completed} max={total} />
+      <p>{progress.toFixed(0)}% complete ({completed}/{total})</p>
+      {report && <p>Score: {report.avgScore?.toFixed(1) ?? 'N/A'}</p>}
+    </div>
+  );
+}
+```
+
+### Event Stream
+
+```tsx
+import { useEvents } from '@polpo-ai/react';
+
+function EventFeed() {
+  const events = useEvents(20);
+
+  return (
+    <ul>
+      {events.map(event => (
+        <li key={event.id}>
+          <strong>{event.event}</strong>
+          {' - '}
+          {new Date(event.timestamp).toLocaleTimeString()}
+        </li>
+      ))}
+    </ul>
+  );
+}
+```
+
+## Performance
+
+The SDK is optimized for performance:
+
+- **Memoized Selectors**: WeakMap caching prevents unnecessary re-renders
+- **Batched Updates**: `queueMicrotask` batching for event processing
+- **Request Deduplication**: Concurrent identical requests are coalesced
+- **Efficient Filtering**: Hooks support filtering without re-computation
+
+## Bundle Size
+
+- **Zero runtime dependencies** (only React peer)
+- Tree-shakeable ESM exports
+- `sideEffects: false` for optimal bundling
+
+## License
+
+MIT

package/dist/hooks/use-active-delays.d.ts

@@ -0,0 +1,19 @@
+import type { ActiveDelay } from "@polpo-ai/client";
+export interface UseActiveDelaysReturn {
+    /** Active delays from SSE events (live, updated by delay:started/delay:expired). */
+    activeDelays: ActiveDelay[];
+    /** Active delays fetched from the server (initial load). */
+    fetchedDelays: ActiveDelay[];
+    /** Refetch from server. */
+    refetch: () => void;
+    loading: boolean;
+}
+/**
+ * Hook for accessing active delay timers.
+ *
+ * Combines two sources:
+ * 1. SSE events (delay:started / delay:expired) → store.activeDelays (real-time)
+ * 2. Initial fetch from GET /missions/delays (catches delays that started before SSE connected)
+ */
+export declare function useActiveDelays(): UseActiveDelaysReturn;
+//# sourceMappingURL=use-active-delays.d.ts.map

package/dist/hooks/use-active-delays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-active-delays.d.ts","sourceRoot":"","sources":["../../src/hooks/use-active-delays.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,MAAM,WAAW,qBAAqB;IACpC,oFAAoF;IACpF,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,4DAA4D;IAC5D,aAAa,EAAE,WAAW,EAAE,CAAC;IAC7B,2BAA2B;IAC3B,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,IAAI,qBAAqB,CAkCvD"}

package/dist/hooks/use-active-delays.js

@@ -0,0 +1,35 @@
+import { useSyncExternalStore, useState, useEffect, useCallback } from "react";
+import { usePolpoContext } from "../provider/polpo-context.js";
+/**
+ * Hook for accessing active delay timers.
+ *
+ * Combines two sources:
+ * 1. SSE events (delay:started / delay:expired) → store.activeDelays (real-time)
+ * 2. Initial fetch from GET /missions/delays (catches delays that started before SSE connected)
+ */
+export function useActiveDelays() {
+    const { client, store } = usePolpoContext();
+    // Real-time from store (fed by SSE events via event-reducer)
+    const storeDelays = useSyncExternalStore(store.subscribe, () => store.getSnapshot().activeDelays, () => store.getServerSnapshot().activeDelays);
+    const [fetchedDelays, setFetchedDelays] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [fetchCount, setFetchCount] = useState(0);
+    const refetch = useCallback(() => setFetchCount(c => c + 1), []);
+    useEffect(() => {
+        setLoading(true);
+        client.listDelays()
+            .then((delays) => {
+            setFetchedDelays(delays);
+            // Also seed the store so SSE events can update from here
+            for (const d of delays) {
+                store.getSnapshot().activeDelays.set(`${d.group}:${d.delayName}`, d);
+            }
+        })
+            .catch(() => { })
+            .finally(() => setLoading(false));
+    }, [client, store, fetchCount]);
+    // Merge: store has real-time data, fetched fills in pre-existing delays
+    const activeDelays = Array.from(storeDelays.values());
+    return { activeDelays, fetchedDelays, refetch, loading };
+}
+//# sourceMappingURL=use-active-delays.js.map

package/dist/hooks/use-active-delays.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-active-delays.js","sourceRoot":"","sources":["../../src/hooks/use-active-delays.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,QAAQ,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AAC/E,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAa/D;;;;;;GAMG;AACH,MAAM,UAAU,eAAe;IAC7B,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,eAAe,EAAE,CAAC;IAE5C,6DAA6D;IAC7D,MAAM,WAAW,GAAG,oBAAoB,CACtC,KAAK,CAAC,SAAS,EACf,GAAG,EAAE,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,YAAY,EACtC,GAAG,EAAE,CAAC,KAAK,CAAC,iBAAiB,EAAE,CAAC,YAAY,CAC7C,CAAC;IAEF,MAAM,CAAC,aAAa,EAAE,gBAAgB,CAAC,GAAG,QAAQ,CAAgB,EAAE,CAAC,CAAC;IACtE,MAAM,CAAC,OAAO,EAAE,UAAU,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC7C,MAAM,CAAC,UAAU,EAAE,aAAa,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;IAEhD,MAAM,OAAO,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IAEjE,SAAS,CAAC,GAAG,EAAE;QACb,UAAU,CAAC,IAAI,CAAC,CAAC;QACjB,MAAM,CAAC,UAAU,EAAE;aAChB,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;YACf,gBAAgB,CAAC,MAAM,CAAC,CAAC;YACzB,yDAAyD;YACzD,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;gBACvB,KAAK,CAAC,WAAW,EAAE,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,CAAC;YACvE,CAAC;QACH,CAAC,CAAC;aACD,KAAK,CAAC,GAAG,EAAE,GAAqB,CAAC,CAAC;aAClC,OAAO,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC;IACtC,CAAC,EAAE,CAAC,MAAM,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC;IAEhC,wEAAwE;IACxE,MAAM,YAAY,GAAG,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,CAAC,CAAC;IAEtD,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC;AAC3D,CAAC"}

package/dist/hooks/use-agent.d.ts

@@ -0,0 +1,12 @@
+import type { AgentConfig } from "@polpo-ai/client";
+export interface UseAgentReturn {
+    agent: AgentConfig | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+/**
+ * Fetch a single agent by name from the `/agents/:name` endpoint.
+ */
+export declare function useAgent(name: string): UseAgentReturn;
+//# sourceMappingURL=use-agent.d.ts.map

package/dist/hooks/use-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-agent.d.ts","sourceRoot":"","sources":["../../src/hooks/use-agent.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC;IAC1B,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAuBrD"}

package/dist/hooks/use-agent.js

@@ -0,0 +1,28 @@
+import { useCallback, useEffect, useState } from "react";
+import { usePolpoContext } from "../provider/polpo-context.js";
+/**
+ * Fetch a single agent by name from the `/agents/:name` endpoint.
+ */
+export function useAgent(name) {
+    const { client } = usePolpoContext();
+    const [agent, setAgent] = useState(null);
+    const [isLoading, setIsLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const fetchAgent = useCallback(async () => {
+        try {
+            setError(null);
+            const data = await client.getAgent(name);
+            setAgent(data);
+        }
+        catch (err) {
+            setError(err);
+            setAgent(null);
+        }
+    }, [client, name]);
+    useEffect(() => {
+        setIsLoading(true);
+        fetchAgent().finally(() => setIsLoading(false));
+    }, [fetchAgent]);
+    return { agent, isLoading, error, refetch: fetchAgent };
+}
+//# sourceMappingURL=use-agent.js.map

package/dist/hooks/use-agent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-agent.js","sourceRoot":"","sources":["../../src/hooks/use-agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAU/D;;GAEG;AACH,MAAM,UAAU,QAAQ,CAAC,IAAY;IACnC,MAAM,EAAE,MAAM,EAAE,GAAG,eAAe,EAAE,CAAC;IACrC,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,QAAQ,CAAqB,IAAI,CAAC,CAAC;IAC7D,MAAM,CAAC,SAAS,EAAE,YAAY,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;IACjD,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,QAAQ,CAAe,IAAI,CAAC,CAAC;IAEvD,MAAM,UAAU,GAAG,WAAW,CAAC,KAAK,IAAI,EAAE;QACxC,IAAI,CAAC;YACH,QAAQ,CAAC,IAAI,CAAC,CAAC;YACf,MAAM,IAAI,GAAG,MAAM,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YACzC,QAAQ,CAAC,IAAI,CAAC,CAAC;QACjB,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,QAAQ,CAAC,GAAY,CAAC,CAAC;YACvB,QAAQ,CAAC,IAAI,CAAC,CAAC;QACjB,CAAC;IACH,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;IAEnB,SAAS,CAAC,GAAG,EAAE;QACb,YAAY,CAAC,IAAI,CAAC,CAAC;QACnB,UAAU,EAAE,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;IAClD,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC;IAEjB,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC;AAC1D,CAAC"}

package/dist/hooks/use-agents.d.ts

@@ -0,0 +1,16 @@
+import type { AgentConfig, Team, AddAgentRequest, UpdateAgentRequest, AddTeamRequest } from "@polpo-ai/client";
+export interface UseAgentsReturn {
+    agents: AgentConfig[];
+    teams: Team[];
+    isLoading: boolean;
+    error: Error | null;
+    addAgent: (req: AddAgentRequest, teamName?: string) => Promise<void>;
+    updateAgent: (name: string, req: UpdateAgentRequest) => Promise<AgentConfig>;
+    removeAgent: (name: string) => Promise<void>;
+    addTeam: (req: AddTeamRequest) => Promise<void>;
+    removeTeam: (name: string) => Promise<void>;
+    renameTeam: (oldName: string, newName: string) => Promise<Team>;
+    refetch: () => Promise<void>;
+}
+export declare function useAgents(): UseAgentsReturn;
+//# sourceMappingURL=use-agents.d.ts.map