@reactive-agents/svelte 0.9.0 → 0.10.0

package/dist/index.d.ts

@@ -0,0 +1,94 @@
+import * as svelte_store from 'svelte/store';
+
+/** Mirrors the AgentStreamEvent union from @reactive-agents/runtime. */
+type AgentStreamEvent = {
+    readonly _tag: "TextDelta";
+    readonly text: string;
+} | {
+    readonly _tag: "StreamCompleted";
+    readonly output: string;
+    readonly metadata: Record<string, unknown>;
+    readonly taskId?: string;
+    readonly agentId?: string;
+} | {
+    readonly _tag: "StreamError";
+    readonly cause: string;
+} | {
+    readonly _tag: "IterationProgress";
+    readonly iteration: number;
+    readonly maxIterations: number;
+    readonly status: string;
+} | {
+    readonly _tag: "StreamCancelled";
+    readonly reason: string;
+    readonly iterationsCompleted: number;
+} | {
+    readonly _tag: string;
+    readonly [key: string]: unknown;
+};
+type AgentHookState = "idle" | "streaming" | "completed" | "error";
+interface UseAgentStreamReturn {
+    /** Accumulated text output so far (grows as TextDelta events arrive). */
+    text: string;
+    /** All raw events received since the last run(). */
+    events: AgentStreamEvent[];
+    /** Current execution status. */
+    status: AgentHookState;
+    /** Error message if status === "error". */
+    error: string | null;
+    /** Full output when status === "completed". */
+    output: string | null;
+    /** Trigger a new run. Cancels any in-progress stream. */
+    run: (prompt: string, body?: Record<string, unknown>) => void;
+    /** Cancel the active stream. */
+    cancel: () => void;
+}
+interface UseAgentReturn {
+    /** Final output when status === "completed". */
+    output: string | null;
+    /** Whether the agent is currently running. */
+    loading: boolean;
+    /** Error message if the run failed. */
+    error: string | null;
+    /** Trigger a run. Resolves on completion. */
+    run: (prompt: string, body?: Record<string, unknown>) => Promise<string>;
+}
+
+interface AgentStreamState {
+    text: string;
+    events: AgentStreamEvent[];
+    status: "idle" | "streaming" | "completed" | "error";
+    error: string | null;
+    output: string | null;
+}
+/**
+ * Create a reactive Svelte store that streams agent output token-by-token.
+ * Returns a store + run() and cancel() functions.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { createAgentStream } from "@reactive-agents/svelte";
+ *   const agent = createAgentStream("/api/agent");
+ * </script>
+ * <button on:click={() => agent.run("Hello!")}>Run</button>
+ * <p>{$agent.text}</p>
+ * ```
+ */
+declare function createAgentStream(endpoint: string, requestInit?: Omit<RequestInit, "method" | "body" | "signal">): {
+    subscribe: (this: void, run: svelte_store.Subscriber<AgentStreamState>, invalidate?: () => void) => svelte_store.Unsubscriber;
+    run: (prompt: string, body?: Record<string, unknown>) => Promise<void>;
+    cancel: () => void;
+};
+
+interface AgentState {
+    output: string | null;
+    loading: boolean;
+    error: string | null;
+}
+declare function createAgent(endpoint: string, requestInit?: Omit<RequestInit, "method" | "body">): {
+    subscribe: (this: void, run: svelte_store.Subscriber<AgentState>, invalidate?: () => void) => svelte_store.Unsubscriber;
+    run: (prompt: string, body?: Record<string, unknown>) => Promise<string>;
+};
+
+export { type AgentHookState, type AgentState, type AgentStreamEvent, type AgentStreamState, type UseAgentReturn, type UseAgentStreamReturn, createAgent, createAgentStream };

package/dist/index.js

@@ -0,0 +1,105 @@
+// src/agent-stream.ts
+import { writable } from "svelte/store";
+function createAgentStream(endpoint, requestInit) {
+  const store = writable({
+    text: "",
+    events: [],
+    status: "idle",
+    error: null,
+    output: null
+  });
+  let abortController = null;
+  function cancel() {
+    abortController?.abort();
+    store.update((s) => ({ ...s, status: "idle" }));
+  }
+  async function run(prompt, body) {
+    abortController?.abort();
+    abortController = new AbortController();
+    store.set({ text: "", events: [], status: "streaming", error: null, output: null });
+    try {
+      const res = await fetch(endpoint, {
+        ...requestInit,
+        method: "POST",
+        signal: abortController.signal,
+        headers: { "Content-Type": "application/json", ...requestInit?.headers },
+        body: JSON.stringify({ prompt, ...body })
+      });
+      if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+      if (!res.body) throw new Error("No response body");
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) continue;
+          const raw = line.slice(6).trim();
+          if (!raw) continue;
+          try {
+            const event = JSON.parse(raw);
+            store.update((s) => {
+              const next = { ...s, events: [...s.events, event] };
+              if (event._tag === "TextDelta" && "text" in event) {
+                next.text = s.text + event.text;
+              } else if (event._tag === "StreamCompleted" && "output" in event) {
+                next.output = event.output;
+                next.status = "completed";
+              } else if (event._tag === "StreamError" && "cause" in event) {
+                next.error = event.cause;
+                next.status = "error";
+              } else if (event._tag === "StreamCancelled") {
+                next.status = "idle";
+              }
+              return next;
+            });
+          } catch {
+          }
+        }
+      }
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") return;
+      store.update((s) => ({
+        ...s,
+        error: err instanceof Error ? err.message : String(err),
+        status: "error"
+      }));
+    }
+  }
+  return { subscribe: store.subscribe, run, cancel };
+}
+
+// src/agent.ts
+import { writable as writable2 } from "svelte/store";
+function createAgent(endpoint, requestInit) {
+  const store = writable2({ output: null, loading: false, error: null });
+  async function run(prompt, body) {
+    store.update((s) => ({ ...s, loading: true, error: null, output: null }));
+    try {
+      const res = await fetch(endpoint, {
+        ...requestInit,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...requestInit?.headers },
+        body: JSON.stringify({ prompt, ...body })
+      });
+      if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+      const data = await res.json();
+      const result = data.output ?? data.result ?? "";
+      store.update((s) => ({ ...s, output: result, loading: false }));
+      return result;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      store.update((s) => ({ ...s, error: msg, loading: false }));
+      throw err;
+    }
+  }
+  return { subscribe: store.subscribe, run };
+}
+export {
+  createAgent,
+  createAgentStream
+};

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@reactive-agents/svelte",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Svelte stores for Reactive Agents — agentStream, agentRun",
   "type": "module",
   "exports": {
     ".": {
+      "bun": "./src/index.ts",
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "default": "./dist/index.js"