@meistrari/chat-nuxt 3.17.0-rc.3 → 3.17.0-rc.5

package/dist/module.d.mts

@@ -34,6 +34,13 @@ interface ChatNuxtModuleOptions {
      * `NUXT_CHAT_NUXT_SECRETLESS_EXECUTION`.
      */
     secretlessExecution?: boolean;
+    /**
+     * Opt this deployment into the experimental agent-api v5 snapshot path: the
+     * server proxy adds `"agent-api-v5": true` to the `x-chat-config` header, so
+     * wake and execute prefer the published snapshot (with v4 fallback). Defaults
+     * to `false`; also settable via `NUXT_CHAT_NUXT_AGENT_API_V5`.
+     */
+    agentApiV5?: boolean;
 }
 declare const _default: any;
 

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@meistrari/chat-nuxt",
   "configKey": "chatNuxt",
-  "version": "3.17.0-rc.3",
+  "version": "3.17.0-rc.5",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "unknown"

package/dist/module.mjs

@@ -451,7 +451,8 @@ const module$1 = defineNuxtModule({
       authTokenCookie: hostAuthComposablePath ? options.authTokenCookie || existingChatNuxtRuntimeConfig?.authTokenCookie : void 0,
       // Explicit boolean default keeps the key in runtime config so the
       // NUXT_CHAT_NUXT_SECRETLESS_EXECUTION env override can apply.
-      secretlessExecution: options.secretlessExecution ?? existingChatNuxtRuntimeConfig?.secretlessExecution ?? false
+      secretlessExecution: options.secretlessExecution ?? existingChatNuxtRuntimeConfig?.secretlessExecution ?? false,
+      agentApiV5: options.agentApiV5 ?? existingChatNuxtRuntimeConfig?.agentApiV5 ?? false
     };
     if (hostAuthComposablePath && !rc.chatNuxt.authTokenCookie) {
       console.warn(

package/dist/runtime/citations/components/chat-url-citation.vue

@@ -1,9 +1,24 @@
 <script setup>
+import { loadCitationSiteName } from "../site-name";
 const props = defineProps({
   citation: { type: Object, required: true }
 });
 const faviconFailed = ref(false);
-const accessibleLabel = computed(() => `${props.citation.sourceLabel}: ${props.citation.title}`);
+const siteName = ref(null);
+const sourceLabel = computed(() => siteName.value || props.citation.sourceLabel);
+onMounted(() => {
+  watch(() => props.citation.href, async (href, _previous, onCleanup) => {
+    let active = true;
+    onCleanup(() => {
+      active = false;
+    });
+    siteName.value = null;
+    const name = await loadCitationSiteName(href);
+    if (active)
+      siteName.value = name;
+  }, { immediate: true });
+});
+const accessibleLabel = computed(() => `${sourceLabel.value}: ${props.citation.title}`);
 </script>
 
 <template>
@@ -32,7 +47,7 @@ const accessibleLabel = computed(() => `${props.citation.sourceLabel}: ${props.c
                 @error="faviconFailed = true"
             >
             <span v-else i-ph-globe-simple class="url-citation-fallback" aria-hidden="true" />
-            <span>{{ citation.sourceLabel }}</span>
+            <span>{{ sourceLabel }}</span>
         </a>
 
         <template #content>
@@ -48,7 +63,7 @@ const accessibleLabel = computed(() => `${props.citation.sourceLabel}: ${props.c
                     >
                     <span v-else i-ph-globe-simple class="url-citation-card__fallback" aria-hidden="true" />
                     <span body-12-medium text-secondary truncate>
-                        {{ citation.sourceLabel }}
+                        {{ sourceLabel }}
                     </span>
                 </div>
 

package/dist/runtime/citations/site-name.d.ts

@@ -0,0 +1,5 @@
+export declare function createCitationSiteNameLoader(fetchMetadata: (url: string) => Promise<{
+    siteName?: string | null;
+    retryable?: boolean;
+}>, now?: () => number): (href: string) => Promise<string | null>;
+export declare const loadCitationSiteName: (href: string) => Promise<string | null>;

package/dist/runtime/citations/site-name.js

@@ -0,0 +1,36 @@
+export function createCitationSiteNameLoader(fetchMetadata, now = Date.now) {
+  const cache = /* @__PURE__ */ new Map();
+  return (href) => {
+    let key;
+    try {
+      const url = new URL(href);
+      url.hash = "";
+      key = url.href;
+    } catch {
+      return Promise.resolve(null);
+    }
+    const cached = cache.get(key);
+    if (cached && cached.expires > now())
+      return cached.result;
+    const result = Promise.resolve().then(() => fetchMetadata(key)).then((value) => {
+      if (value.retryable)
+        throw new Error("Citation metadata temporarily unavailable");
+      return typeof value.siteName === "string" && value.siteName.trim() ? value.siteName.trim() : null;
+    }).catch(() => {
+      if (cache.get(key)?.result === result)
+        cache.delete(key);
+      return null;
+    });
+    cache.delete(key);
+    if (cache.size >= 512)
+      cache.delete(cache.keys().next().value);
+    cache.set(key, { expires: now() + 60 * 60 * 1e3, result });
+    return result;
+  };
+}
+export const loadCitationSiteName = createCitationSiteNameLoader(async (url) => {
+  const response = await fetch(`/api/citation-metadata?${new URLSearchParams({ url })}`);
+  if (!response.ok)
+    throw new Error("Citation metadata unavailable");
+  return response.json();
+});

package/dist/runtime/server/api/citation-metadata.get.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    siteName: string | null;
+    retryable?: undefined;
+} | {
+    siteName: null;
+    retryable: boolean;
+}>>;
+export default _default;

package/dist/runtime/server/api/citation-metadata.get.js

@@ -0,0 +1,12 @@
+import { defineEventHandler, getQuery, setResponseHeaders } from "h3";
+import { createSiteNameCache } from "../utils/citation-metadata.js";
+const getSiteName = createSiteNameCache();
+export default defineEventHandler(async (event) => {
+  setResponseHeaders(event, { "cache-control": "private, no-store" });
+  const url = getQuery(event).url;
+  try {
+    return { siteName: typeof url === "string" ? await getSiteName(url) : null };
+  } catch {
+    return { siteName: null, retryable: true };
+  }
+});

package/dist/runtime/server/utils/chat-api-proxy.js

@@ -1,4 +1,4 @@
-import { PREPARED_AGENT_RUNTIME_CONFIG_KEY, SECRETLESS_EXECUTION_CONFIG_KEY } from "../../types/schemas/chat/chat-config.js";
+import { AGENT_API_V5_CONFIG_KEY, PREPARED_AGENT_RUNTIME_CONFIG_KEY, SECRETLESS_EXECUTION_CONFIG_KEY } from "../../types/schemas/chat/chat-config.js";
 import { createError, defineEventHandler, getHeader, getRequestURL, getRouterParam, proxyRequest } from "h3";
 import { useRuntimeConfig } from "nitropack/runtime";
 import { resolveAuthToken } from "./auth-token.js";
@@ -64,6 +64,9 @@ function buildProxyHeaders(event) {
   if (config.chatNuxt?.secretlessExecution) {
     chatConfig[SECRETLESS_EXECUTION_CONFIG_KEY] = true;
   }
+  if (config.chatNuxt?.agentApiV5) {
+    chatConfig[AGENT_API_V5_CONFIG_KEY] = true;
+  }
   const headers = {
     "authorization": `Bearer ${token}`,
     "x-chat-client": "chat-nuxt",

package/dist/runtime/server/utils/citation-metadata.d.ts

@@ -0,0 +1,16 @@
+export declare const MAX_HTML_BYTES: number;
+export declare function publicCitationUrl(value: unknown): URL;
+export declare function isPublicAddress(address: string): boolean;
+export declare function parseCitationSiteName(html: string): string | null;
+interface Address {
+    address: string;
+    family: number;
+}
+export declare function resolvePublicAddress(hostname: string, resolve: (host: string) => Promise<Address[]>): Promise<Address>;
+declare function requestPage(url: URL, signal: AbortSignal): Promise<{
+    redirect?: string;
+    html?: string;
+}>;
+export declare function fetchCitationSiteName(input: string, request?: typeof requestPage): Promise<string | null>;
+export declare function createSiteNameCache(load?: typeof fetchCitationSiteName, now?: () => number): (input: string) => Promise<string | null>;
+export {};

package/dist/runtime/server/utils/citation-metadata.js

@@ -0,0 +1,187 @@
+import { Parser } from "htmlparser2";
+import ipaddr from "ipaddr.js";
+export const MAX_HTML_BYTES = 256 * 1024;
+const TIMEOUT_MS = 5e3;
+const MAX_REDIRECTS = 3;
+class PermanentMetadataError extends Error {
+}
+export function publicCitationUrl(value) {
+  if (typeof value !== "string" || value.length > 2048)
+    throw new PermanentMetadataError("Invalid citation URL");
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new PermanentMetadataError("Invalid citation URL");
+  }
+  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.port)
+    throw new PermanentMetadataError("Invalid citation URL");
+  url.hash = "";
+  return url;
+}
+export function isPublicAddress(address) {
+  try {
+    return ipaddr.process(address.replace(/^\[|\]$/g, "")).range() === "unicast";
+  } catch {
+    return false;
+  }
+}
+export function parseCitationSiteName(html) {
+  let siteName = null;
+  const parser = new Parser({
+    onopentag(name, attributes) {
+      if (name !== "meta" || siteName || (attributes.property || attributes.name || "").toLowerCase() !== "og:site_name")
+        return;
+      const value = (attributes.content || "").replace(/[\p{Cc}\p{Cf}]/gu, " ").replace(/\s+/g, " ").trim();
+      if (value && value.length <= 100)
+        siteName = value;
+    }
+  }, { decodeEntities: true });
+  parser.end(html);
+  return siteName;
+}
+export async function resolvePublicAddress(hostname, resolve) {
+  const host = hostname.replace(/^\[|\]$/g, "");
+  const addresses = ipaddr.isValid(host) ? [{ address: host, family: ipaddr.parse(host).kind() === "ipv4" ? 4 : 6 }] : await resolve(host);
+  if (!addresses.length || addresses.some((record) => !isPublicAddress(record.address)))
+    throw new PermanentMetadataError("Non-public citation address");
+  return addresses[0];
+}
+async function requestPage(url, signal) {
+  const [{ lookup }, http, https, { Buffer }] = await Promise.all([
+    import("node:dns/promises"),
+    import("node:http"),
+    import("node:https"),
+    import("node:buffer")
+  ]);
+  const address = await resolvePublicAddress(url.hostname, (host) => lookup(host, { all: true }));
+  signal.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const request = (url.protocol === "https:" ? https.request : http.request)(url, {
+      agent: false,
+      family: address.family,
+      signal,
+      // Preserve the original Host header and TLS server name. Only the
+      // socket destination is pinned; no cookies or auth are forwarded.
+      lookup: (_hostname, _options, callback) => callback(null, address.address, address.family),
+      headers: { "accept": "text/html,application/xhtml+xml", "accept-encoding": "identity" }
+    }, (response) => {
+      const status = response.statusCode || 0;
+      if ([301, 302, 303, 307, 308].includes(status)) {
+        response.destroy();
+        resolve({ redirect: response.headers.location });
+        return;
+      }
+      if (status < 200 || status >= 300) {
+        response.destroy();
+        const retryable = status >= 500 || [408, 425, 429].includes(status);
+        reject(retryable ? new Error("Citation page unavailable") : new PermanentMetadataError("Citation page unavailable"));
+        return;
+      }
+      if (!/^(?:text\/html|application\/xhtml\+xml)(?:;|$)/i.test(response.headers["content-type"] || "") || response.headers["content-encoding"] && response.headers["content-encoding"] !== "identity") {
+        response.destroy();
+        reject(new PermanentMetadataError("Unsupported citation content"));
+        return;
+      }
+      const chunks = [];
+      let size = 0;
+      response.on("data", (chunk) => {
+        size += chunk.length;
+        if (size > MAX_HTML_BYTES) {
+          const remaining = MAX_HTML_BYTES - (size - chunk.length);
+          chunks.push(chunk.subarray(0, remaining));
+          resolve({ html: Buffer.concat(chunks).toString("utf8") });
+          response.destroy();
+          return;
+        }
+        chunks.push(chunk);
+      });
+      response.on("end", () => resolve({ html: Buffer.concat(chunks).toString("utf8") }));
+      response.on("error", reject);
+    });
+    request.on("error", reject);
+    request.end();
+  });
+}
+export async function fetchCitationSiteName(input, request = requestPage) {
+  const controller = new AbortController();
+  let timer;
+  const timeout = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => {
+      controller.abort();
+      reject(new Error("Citation metadata timed out"));
+    }, TIMEOUT_MS);
+  });
+  try {
+    return await Promise.race([timeout, (async () => {
+      let url = publicCitationUrl(input);
+      for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
+        const response = await request(url, controller.signal);
+        if (!response.redirect)
+          return response.html ? parseCitationSiteName(response.html) : null;
+        let target;
+        try {
+          target = new URL(response.redirect, url);
+        } catch {
+          throw new PermanentMetadataError("Invalid citation redirect");
+        }
+        url = publicCitationUrl(target.href);
+      }
+      throw new PermanentMetadataError("Too many citation redirects");
+    })()]);
+  } catch (error) {
+    if (error instanceof PermanentMetadataError)
+      return null;
+    throw error;
+  } finally {
+    clearTimeout(timer);
+    controller.abort();
+  }
+}
+export function createSiteNameCache(load = fetchCitationSiteName, now = Date.now) {
+  const cache = /* @__PURE__ */ new Map();
+  const queue = [];
+  let active = 0;
+  return (input) => {
+    let key;
+    try {
+      key = publicCitationUrl(input).href;
+    } catch {
+      return Promise.resolve(null);
+    }
+    const cached = cache.get(key);
+    if (cached && cached.expires > now())
+      return cached.result;
+    if (active >= 8 && queue.length >= 64)
+      return Promise.reject(new Error("Citation metadata queue full"));
+    const entry = { expires: Number.POSITIVE_INFINITY, result: Promise.resolve(null) };
+    entry.result = new Promise((resolve, reject) => {
+      const start = () => {
+        active++;
+        void Promise.resolve().then(() => load(key)).then((name) => {
+          entry.expires = now() + 60 * 60 * 1e3;
+          resolve(name);
+        }, (error) => {
+          if (cache.get(key) === entry)
+            cache.delete(key);
+          reject(error);
+        }).finally(() => {
+          active--;
+          queue.shift()?.();
+        });
+      };
+      if (active < 8)
+        start();
+      else
+        queue.push(start);
+    });
+    cache.delete(key);
+    if (cache.size >= 512) {
+      const oldestCompleted = [...cache].find(([, value]) => Number.isFinite(value.expires));
+      if (oldestCompleted)
+        cache.delete(oldestCompleted[0]);
+    }
+    cache.set(key, entry);
+    return entry.result;
+  };
+}

package/dist/runtime/types/schemas/chat/chat-config.d.ts

@@ -1,2 +1,3 @@
 export declare const PREPARED_AGENT_RUNTIME_CONFIG_KEY = "prepared-agent-runtime";
 export declare const SECRETLESS_EXECUTION_CONFIG_KEY = "secretless-execution";
+export declare const AGENT_API_V5_CONFIG_KEY = "agent-api-v5";

package/dist/runtime/types/schemas/chat/chat-config.js

@@ -1,2 +1,3 @@
 export const PREPARED_AGENT_RUNTIME_CONFIG_KEY = 'prepared-agent-runtime';
 export const SECRETLESS_EXECUTION_CONFIG_KEY = 'secretless-execution';
+export const AGENT_API_V5_CONFIG_KEY = 'agent-api-v5';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meistrari/chat-nuxt",
-  "version": "3.17.0-rc.3",
+  "version": "3.17.0-rc.5",
   "type": "module",
   "exports": {
     ".": {
@@ -51,6 +51,8 @@
     "@vueuse/components": "^12.8.0",
     "@vueuse/core": "^12.8.0",
     "h3": "^1.15.0",
+    "htmlparser2": "12.0.0",
+    "ipaddr.js": "2.5.0",
     "markstream-vue": "2.0.7",
     "mermaid": "^11.13.0",
     "motion": "^11.13.0",