@absolutejs/absolute 0.19.0-beta.364 → 0.19.0-beta.365

package/dist/ai-client/angular/ai/index.js

@@ -665,10 +665,112 @@ class AIStreamService {
 AIStreamService = __legacyDecorateClassTS([
   Injectable({ providedIn: "root" })
 ], AIStreamService);
+// src/angular/ai/rag-client.service.ts
+import { Injectable as Injectable2 } from "@angular/core";
+
+// src/ai/client/ragClient.ts
+var jsonHeaders = {
+  "Content-Type": "application/json"
+};
+var normalizeBasePath = (path) => path.endsWith("/") ? path.slice(0, -1) : path;
+var parseJson = async (response) => {
+  const payload = await response.json();
+  return payload;
+};
+var toErrorMessage = async (response) => {
+  try {
+    const payload = await response.json();
+    if (typeof payload.error === "string" && payload.error) {
+      return payload.error;
+    }
+  } catch {}
+  return `Request failed with status ${response.status}`;
+};
+var createRAGClient = (options) => {
+  const basePath = normalizeBasePath(options.path);
+  const fetchImpl = options.fetch ?? fetch;
+  return {
+    async ingest(chunks) {
+      const response = await fetchImpl(`${basePath}/ingest`, {
+        body: JSON.stringify({ chunks }),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        return {
+          ok: false,
+          error: await toErrorMessage(response)
+        };
+      }
+      return parseJson(response);
+    },
+    async search(input) {
+      const response = await fetchImpl(`${basePath}/search`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok) {
+        throw new Error(payload.error ?? "RAG search failed");
+      }
+      return payload.results ?? [];
+    },
+    async status() {
+      const response = await fetchImpl(`${basePath}/status`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      return parseJson(response);
+    },
+    async clearIndex() {
+      const response = await fetchImpl(`${basePath}/index`, {
+        method: "DELETE"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      return parseJson(response);
+    }
+  };
+};
+
+// src/angular/ai/rag-client.service.ts
+class RAGClientService {
+  clients = new Map;
+  client(path) {
+    const existing = this.clients.get(path);
+    if (existing) {
+      return existing;
+    }
+    const created = createRAGClient({ path });
+    this.clients.set(path, created);
+    return created;
+  }
+  ingest(path, chunks) {
+    return this.client(path).ingest(chunks);
+  }
+  search(path, input) {
+    return this.client(path).search(input);
+  }
+  status(path) {
+    return this.client(path).status();
+  }
+  clearIndex(path) {
+    return this.client(path).clearIndex();
+  }
+}
+RAGClientService = __legacyDecorateClassTS([
+  Injectable2({ providedIn: "root" })
+], RAGClientService);
 // src/angular/ai/ai-rag-stream.service.ts
 class RAGStreamService extends AIStreamService {
 }
 export {
   RAGStreamService,
+  RAGClientService,
   AIStreamService
 };

package/dist/ai-client/react/ai/index.js

@@ -629,10 +629,186 @@ var useAIStream = (path, conversationId) => {
     send
   };
 };
+// src/react/ai/useRAGIngest.ts
+import { useCallback as useCallback2, useMemo, useState } from "react";
+
+// src/ai/client/ragClient.ts
+var jsonHeaders = {
+  "Content-Type": "application/json"
+};
+var normalizeBasePath = (path) => path.endsWith("/") ? path.slice(0, -1) : path;
+var parseJson = async (response) => {
+  const payload = await response.json();
+  return payload;
+};
+var toErrorMessage = async (response) => {
+  try {
+    const payload = await response.json();
+    if (typeof payload.error === "string" && payload.error) {
+      return payload.error;
+    }
+  } catch {}
+  return `Request failed with status ${response.status}`;
+};
+var createRAGClient = (options) => {
+  const basePath = normalizeBasePath(options.path);
+  const fetchImpl = options.fetch ?? fetch;
+  return {
+    async ingest(chunks) {
+      const response = await fetchImpl(`${basePath}/ingest`, {
+        body: JSON.stringify({ chunks }),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        return {
+          ok: false,
+          error: await toErrorMessage(response)
+        };
+      }
+      return parseJson(response);
+    },
+    async search(input) {
+      const response = await fetchImpl(`${basePath}/search`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok) {
+        throw new Error(payload.error ?? "RAG search failed");
+      }
+      return payload.results ?? [];
+    },
+    async status() {
+      const response = await fetchImpl(`${basePath}/status`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      return parseJson(response);
+    },
+    async clearIndex() {
+      const response = await fetchImpl(`${basePath}/index`, {
+        method: "DELETE"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      return parseJson(response);
+    }
+  };
+};
+
+// src/react/ai/useRAGIngest.ts
+var useRAGIngest = (path) => {
+  const client = useMemo(() => createRAGClient({ path }), [path]);
+  const [error, setError] = useState(null);
+  const [isIngesting, setIsIngesting] = useState(false);
+  const [lastIngestCount, setLastIngestCount] = useState(null);
+  const ingest = useCallback2(async (chunks) => {
+    setIsIngesting(true);
+    setError(null);
+    try {
+      const response = await client.ingest(chunks);
+      if (!response.ok) {
+        throw new Error(response.error ?? "RAG ingest failed");
+      }
+      setLastIngestCount(response.count ?? chunks.length);
+      return response;
+    } catch (caught) {
+      const message = caught instanceof Error ? caught.message : String(caught);
+      setError(message);
+      throw caught;
+    } finally {
+      setIsIngesting(false);
+    }
+  }, [client]);
+  return {
+    error,
+    ingest,
+    isIngesting,
+    lastIngestCount
+  };
+};
+// src/react/ai/useRAGSearch.ts
+import { useCallback as useCallback3, useMemo as useMemo2, useState as useState2 } from "react";
+var useRAGSearch = (path) => {
+  const client = useMemo2(() => createRAGClient({ path }), [path]);
+  const [results, setResults] = useState2([]);
+  const [error, setError] = useState2(null);
+  const [isSearching, setIsSearching] = useState2(false);
+  const search = useCallback3(async (input) => {
+    setIsSearching(true);
+    setError(null);
+    try {
+      const nextResults = await client.search(input);
+      setResults(nextResults);
+      return nextResults;
+    } catch (caught) {
+      const message = caught instanceof Error ? caught.message : String(caught);
+      setError(message);
+      throw caught;
+    } finally {
+      setIsSearching(false);
+    }
+  }, [client]);
+  return {
+    error,
+    isSearching,
+    results,
+    search,
+    setResults
+  };
+};
+// src/react/ai/useRAGStatus.ts
+import { useCallback as useCallback4, useEffect as useEffect3, useMemo as useMemo3, useState as useState3 } from "react";
+var useRAGStatus = (path, autoLoad = true) => {
+  const client = useMemo3(() => createRAGClient({ path }), [path]);
+  const [status, setStatus] = useState3();
+  const [capabilities, setCapabilities] = useState3();
+  const [error, setError] = useState3(null);
+  const [isLoading, setIsLoading] = useState3(autoLoad);
+  const refresh = useCallback4(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await client.status();
+      setStatus(response.status);
+      setCapabilities(response.capabilities);
+      return response;
+    } catch (caught) {
+      const message = caught instanceof Error ? caught.message : String(caught);
+      setError(message);
+      throw caught;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  useEffect3(() => {
+    if (!autoLoad) {
+      setIsLoading(false);
+      return;
+    }
+    refresh();
+  }, [autoLoad, refresh]);
+  return {
+    capabilities,
+    error,
+    isLoading,
+    refresh,
+    status
+  };
+};
 // src/react/ai/useRAGStream.ts
 var useRAGStream = useAIStream;
 export {
   useRAGStream,
+  useRAGStatus,
+  useRAGSearch,
+  useRAGIngest,
   useAIStream,
   AIStreamProvider
 };

package/dist/ai-client/vue/ai/index.js

@@ -590,10 +590,182 @@ var useAIStream = (path, conversationId) => {
     send
   };
 };
+// src/vue/ai/useRAGIngest.ts
+import { ref as ref2 } from "vue";
+
+// src/ai/client/ragClient.ts
+var jsonHeaders = {
+  "Content-Type": "application/json"
+};
+var normalizeBasePath = (path) => path.endsWith("/") ? path.slice(0, -1) : path;
+var parseJson = async (response) => {
+  const payload = await response.json();
+  return payload;
+};
+var toErrorMessage = async (response) => {
+  try {
+    const payload = await response.json();
+    if (typeof payload.error === "string" && payload.error) {
+      return payload.error;
+    }
+  } catch {}
+  return `Request failed with status ${response.status}`;
+};
+var createRAGClient = (options) => {
+  const basePath = normalizeBasePath(options.path);
+  const fetchImpl = options.fetch ?? fetch;
+  return {
+    async ingest(chunks) {
+      const response = await fetchImpl(`${basePath}/ingest`, {
+        body: JSON.stringify({ chunks }),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        return {
+          ok: false,
+          error: await toErrorMessage(response)
+        };
+      }
+      return parseJson(response);
+    },
+    async search(input) {
+      const response = await fetchImpl(`${basePath}/search`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok) {
+        throw new Error(payload.error ?? "RAG search failed");
+      }
+      return payload.results ?? [];
+    },
+    async status() {
+      const response = await fetchImpl(`${basePath}/status`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      return parseJson(response);
+    },
+    async clearIndex() {
+      const response = await fetchImpl(`${basePath}/index`, {
+        method: "DELETE"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      return parseJson(response);
+    }
+  };
+};
+
+// src/vue/ai/useRAGIngest.ts
+var useRAGIngest = (path) => {
+  const client = createRAGClient({ path });
+  const error = ref2(null);
+  const isIngesting = ref2(false);
+  const lastIngestCount = ref2(null);
+  const ingest = async (chunks) => {
+    isIngesting.value = true;
+    error.value = null;
+    try {
+      const response = await client.ingest(chunks);
+      if (!response.ok) {
+        throw new Error(response.error ?? "RAG ingest failed");
+      }
+      lastIngestCount.value = response.count ?? chunks.length;
+      return response;
+    } catch (caught) {
+      error.value = caught instanceof Error ? caught.message : String(caught);
+      throw caught;
+    } finally {
+      isIngesting.value = false;
+    }
+  };
+  return {
+    error,
+    ingest,
+    isIngesting,
+    lastIngestCount
+  };
+};
+// src/vue/ai/useRAGSearch.ts
+import { ref as ref3 } from "vue";
+var useRAGSearch = (path) => {
+  const client = createRAGClient({ path });
+  const results = ref3([]);
+  const error = ref3(null);
+  const isSearching = ref3(false);
+  const search = async (input) => {
+    isSearching.value = true;
+    error.value = null;
+    try {
+      const nextResults = await client.search(input);
+      results.value = nextResults;
+      return nextResults;
+    } catch (caught) {
+      error.value = caught instanceof Error ? caught.message : String(caught);
+      throw caught;
+    } finally {
+      isSearching.value = false;
+    }
+  };
+  return {
+    error,
+    isSearching,
+    results,
+    search
+  };
+};
+// src/vue/ai/useRAGStatus.ts
+import { onMounted, ref as ref4 } from "vue";
+var useRAGStatus = (path, autoLoad = true) => {
+  const client = createRAGClient({ path });
+  const status = ref4();
+  const capabilities = ref4();
+  const error = ref4(null);
+  const isLoading = ref4(autoLoad);
+  const refresh = async () => {
+    isLoading.value = true;
+    error.value = null;
+    try {
+      const response = await client.status();
+      status.value = response.status;
+      capabilities.value = response.capabilities;
+      return response;
+    } catch (caught) {
+      error.value = caught instanceof Error ? caught.message : String(caught);
+      throw caught;
+    } finally {
+      isLoading.value = false;
+    }
+  };
+  onMounted(() => {
+    if (!autoLoad) {
+      isLoading.value = false;
+      return;
+    }
+    refresh();
+  });
+  return {
+    capabilities,
+    error,
+    isLoading,
+    refresh,
+    status
+  };
+};
 // src/vue/ai/useRAGStream.ts
 var useRAGStream = useAIStream;
 export {
   useRAGStream,
+  useRAGStatus,
+  useRAGSearch,
+  useRAGIngest,
   useAIStream,
   AIStreamKey
 };

package/dist/angular/ai/index.js

@@ -802,13 +802,115 @@ class AIStreamService {
 AIStreamService = __legacyDecorateClassTS([
   Injectable({ providedIn: "root" })
 ], AIStreamService);
+// src/angular/ai/rag-client.service.ts
+import { Injectable as Injectable2 } from "@angular/core";
+
+// src/ai/client/ragClient.ts
+var jsonHeaders = {
+  "Content-Type": "application/json"
+};
+var normalizeBasePath = (path) => path.endsWith("/") ? path.slice(0, -1) : path;
+var parseJson = async (response) => {
+  const payload = await response.json();
+  return payload;
+};
+var toErrorMessage = async (response) => {
+  try {
+    const payload = await response.json();
+    if (typeof payload.error === "string" && payload.error) {
+      return payload.error;
+    }
+  } catch {}
+  return `Request failed with status ${response.status}`;
+};
+var createRAGClient = (options) => {
+  const basePath = normalizeBasePath(options.path);
+  const fetchImpl = options.fetch ?? fetch;
+  return {
+    async ingest(chunks) {
+      const response = await fetchImpl(`${basePath}/ingest`, {
+        body: JSON.stringify({ chunks }),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        return {
+          ok: false,
+          error: await toErrorMessage(response)
+        };
+      }
+      return parseJson(response);
+    },
+    async search(input) {
+      const response = await fetchImpl(`${basePath}/search`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok) {
+        throw new Error(payload.error ?? "RAG search failed");
+      }
+      return payload.results ?? [];
+    },
+    async status() {
+      const response = await fetchImpl(`${basePath}/status`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      return parseJson(response);
+    },
+    async clearIndex() {
+      const response = await fetchImpl(`${basePath}/index`, {
+        method: "DELETE"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      return parseJson(response);
+    }
+  };
+};
+
+// src/angular/ai/rag-client.service.ts
+class RAGClientService {
+  clients = new Map;
+  client(path) {
+    const existing = this.clients.get(path);
+    if (existing) {
+      return existing;
+    }
+    const created = createRAGClient({ path });
+    this.clients.set(path, created);
+    return created;
+  }
+  ingest(path, chunks) {
+    return this.client(path).ingest(chunks);
+  }
+  search(path, input) {
+    return this.client(path).search(input);
+  }
+  status(path) {
+    return this.client(path).status();
+  }
+  clearIndex(path) {
+    return this.client(path).clearIndex();
+  }
+}
+RAGClientService = __legacyDecorateClassTS([
+  Injectable2({ providedIn: "root" })
+], RAGClientService);
 // src/angular/ai/ai-rag-stream.service.ts
 class RAGStreamService extends AIStreamService {
 }
 export {
   RAGStreamService,
+  RAGClientService,
   AIStreamService
 };
 
-//# debugId=495F18A29C25C48164756E2164756E21
+//# debugId=B9F2B1CC9F729DCA64756E2164756E21
 //# sourceMappingURL=index.js.map