@useago/sdk 0.3.0 → 0.3.2

package/dist/rolldown-runtime-BqCkTl7Q.cjs

@@ -0,0 +1,50 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+Object.defineProperty(exports, "__commonJSMin", {
+	enumerable: true,
+	get: function() {
+		return __commonJSMin;
+	}
+});
+Object.defineProperty(exports, "__exportAll", {
+	enumerable: true,
+	get: function() {
+		return __exportAll;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});

package/dist/rolldown-runtime-CNZpIYwj.js

@@ -0,0 +1,33 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+export { __exportAll as n, __toESM as r, __commonJSMin as t };

package/dist/state/ClientContextRegistry.d.ts

@@ -0,0 +1,64 @@
+/**
+ * A single piece of context the client wants the LLM to know about.
+ */
+export interface ContextEntry {
+    /** Human-readable label (e.g. "Order detail", "Current user") */
+    name?: string;
+    /** Short description of what this context represents */
+    description?: string;
+    /** Arbitrary structured data the AI should know about */
+    data?: Record<string, unknown>;
+}
+/**
+ * Serialised client context sent with each message.
+ */
+export interface ContextSnapshot {
+    /** All active context entries keyed by their registration key */
+    entries: Record<string, ContextEntry>;
+}
+/**
+ * A function that returns a fresh context entry on demand.
+ * Evaluated every time a message is sent — use it to pull data from stores,
+ * refs, or any source that isn't captured by React state.
+ */
+export type DynamicContextProvider = () => ContextEntry | null | undefined;
+/**
+ * Registry that collects client-side context from across the component tree.
+ *
+ * Components register/unregister context slices via unique keys.
+ * When a message is sent the registry produces a single snapshot.
+ */
+export declare class ClientContextRegistry {
+    private entries;
+    private dynamicProviders;
+    /**
+     * Register or update a static context entry.
+     */
+    set(key: string, entry: ContextEntry): void;
+    /**
+     * Remove a static context entry (typically on component unmount).
+     */
+    remove(key: string): boolean;
+    /**
+     * Register a dynamic context provider. The function is called every time
+     * a message is sent, so it always returns the freshest data.
+     *
+     * Use this for context that lives outside React state — global stores,
+     * refs, or computed values that shouldn't trigger re-renders.
+     */
+    addDynamicProvider(key: string, provider: DynamicContextProvider): void;
+    /**
+     * Remove a dynamic context provider.
+     */
+    removeDynamicProvider(key: string): boolean;
+    /**
+     * Build a snapshot of the current client context.
+     * Evaluates every registered dynamic provider. Returns `null` when there is
+     * nothing to report.
+     */
+    getSnapshot(): ContextSnapshot | null;
+    /**
+     * Remove all entries and dynamic providers.
+     */
+    clear(): void;
+}

package/dist/state/createStore.d.ts

@@ -0,0 +1,30 @@
+/**
+ * A minimal observable store: one value, synchronous subscriptions, and
+ * optional persistence via {@link PersistOptions} (localStorage by default).
+ *
+ * ```ts
+ * const store = createStore({ count: 0 });
+ * store.subscribe((state) => save(state));
+ * store.set({ count: 1 }); // listeners fire synchronously
+ *
+ * const cart = createStore({ items: [] }, { key: "cart" }); // persisted
+ * ```
+ */
+export interface Store<T> {
+    /** Current state. */
+    get(): T;
+    /** Replace the state and notify subscribers synchronously. */
+    set(next: T): void;
+    /** Register a listener; returns a function that removes it. */
+    subscribe(listener: (state: T) => void): () => void;
+}
+/** The slice of the Web Storage API that {@link createStore} relies on. */
+type StorageLike = Pick<Storage, "getItem" | "setItem">;
+export interface PersistOptions {
+    /** Key under which the state is JSON-serialized. */
+    key: string;
+    /** Storage backend; defaults to `globalThis.localStorage`. */
+    storage?: StorageLike;
+}
+export declare function createStore<T>(initial: T, persist?: PersistOptions): Store<T>;
+export {};

package/dist/vue/composables/useAgoStore.d.ts

@@ -0,0 +1,18 @@
+import { type ShallowRef } from "vue";
+import type { Store } from "../../state/createStore";
+/**
+ * Read a framework-agnostic AGO store (`createStore`) as a reactive Vue ref.
+ *
+ * The ref's `.value` updates on every `store.set(...)`. Mutate through the store,
+ * not the ref. A `shallowRef` is used because the store replaces its value
+ * wholesale, so deep reactivity would be wasted work.
+ *
+ * ```ts
+ * const cart = createStore({ items: [] as string[] });
+ *
+ * // in setup():
+ * const state = useAgoStore(cart);
+ * // template: {{ state.items.length }}
+ * ```
+ */
+export declare function useAgoStore<T>(store: Store<T>): ShallowRef<T>;

package/dist/vue/index.d.ts

@@ -6,5 +6,6 @@ export { useMessages } from "./composables/useMessages";
 export { useConversation } from "./composables/useConversation";
 export { useAgoFunction, useAgoNavigation } from "./composables/useAgoFunction";
 export { useAgoEvents } from "./composables/useAgoEvents";
+export { useAgoStore } from "./composables/useAgoStore";
 export { AGO_CLIENT_KEY } from "./symbols";
 export type { AgoConfig, AgoMessage, Conversation, AgoAgent, AgoSource, ToolCallData, } from "../client/types";