weifuwu 0.24.1 → 0.24.2

package/dist/live.d.ts

@@ -1,8 +1,7 @@
-import { Router } from './router.ts';
-import type { WebSocketHandler } from './router.ts';
+import { Router, type WebSocketHandler } from './router.ts';
 export declare function broadcastReload(): void;
 export declare function liveWs(): WebSocketHandler;
-export declare function liveRouter(dir: string): Router;
+export declare function liveRouter(_dir: string): Router;
 export declare function liveWatcher(dir: string): {
     close: () => void;
 };

package/dist/logdb/rest.d.ts

@@ -1,4 +1,4 @@
-import type { BoundTable } from '../postgres/schema/index.ts';
+import { type BoundTable } from '../postgres/schema/index.ts';
 import type { Context } from '../types.ts';
 export declare function createHandler(entries: BoundTable<any>): (req: Request, ctx: Context) => Promise<Response>;
 export declare function listHandler(entries: BoundTable<any>): (req: Request) => Promise<Response>;

package/dist/mailer.d.ts

@@ -1,4 +1,4 @@
-import type { Transporter } from 'nodemailer';
+import { type Transporter } from 'nodemailer';
 import type { Closeable } from './types.ts';
 /** Options for sending an email. */
 export interface MailOptions {

package/dist/messager/agent.d.ts

@@ -1,4 +1,4 @@
-import type { Sql } from '../vendor.ts';
+import type { SqlClient } from '../vendor.ts';
 import type { AgentModule } from '../agent/types.ts';
 import type { Hub } from '../hub.ts';
 /**
@@ -6,6 +6,6 @@ import type { Hub } from '../hub.ts';
  * - Streaming: broadcasts SSE text tokens in real-time
  * - Multi-round: passes recent channel history as conversation context
  */
-export declare function runAgentRouting(sql: Sql<{}>, messages: {
+export declare function runAgentRouting(sql: SqlClient, messages: {
     insert: (data: any) => Promise<any>;
 }, agents: AgentModule | undefined, hub: Hub, channelId: number, content: string, stream?: boolean, contextMessages?: number): Promise<void>;

package/dist/messager/rest.d.ts

@@ -1,10 +1,10 @@
-import type { Sql } from '../vendor.ts';
+import type { SqlClient } from '../vendor.ts';
 import { Router } from '../router.ts';
 import type { AgentModule } from '../agent/types.ts';
 import type { Hub } from '../hub.ts';
-import type { BoundTable } from '../postgres/schema/index.ts';
+import { type BoundTable } from '../postgres/schema/index.ts';
 interface RestDeps {
-    sql: Sql<{}>;
+    sql: SqlClient;
     channels: BoundTable<any>;
     members: BoundTable<any>;
     messages: BoundTable<any>;

package/dist/messager/ws.d.ts

@@ -1,8 +1,8 @@
-import type { Sql } from '../vendor.ts';
+import type { SqlClient } from '../vendor.ts';
 import type { AgentModule } from '../agent/types.ts';
-import type { Hub } from '../hub.ts';
+import { type Hub } from '../hub.ts';
 interface WSDeps {
-    sql: Sql<{}>;
+    sql: SqlClient;
     agents?: AgentModule;
     redis?: import('../vendor.ts').Redis;
 }

package/dist/opencode/index.d.ts

@@ -1,2 +1,2 @@
 export { opencode } from './client.ts';
-export type { OpencodeOptions, OpencodeModule, SkillDef, SkillRegistry, OpencodePermissions, Session } from './types.ts';
+export type { OpencodeOptions, OpencodeModule, SkillDef, SkillRegistry, OpencodePermissions, Session, } from './types.ts';

package/dist/opencode/permissions.d.ts

@@ -1,5 +1,5 @@
 import type { OpencodePermissions } from './types.ts';
 export declare function isCommandAllowed(command: string): boolean;
-export declare function isPathAllowed(resolvedPath: string, workspace: string, perms?: OpencodePermissions): boolean;
+export declare function isPathAllowed(resolvedPath: string, workspace: string, _perms?: OpencodePermissions): boolean;
 export declare function isToolEnabled(name: string, perms?: OpencodePermissions): boolean;
 export declare function isSkillAllowed(name: string, perms?: OpencodePermissions): boolean;

package/dist/opencode/run.d.ts

@@ -1,5 +1,5 @@
 import { type LanguageModel, type Tool } from 'ai';
-import type { SessionMessage } from './session.ts';
+import { type SessionMessage } from './session.ts';
 export interface ExecuteOptions {
     sessionId: string;
     input: string;

package/dist/opencode/session.d.ts

@@ -1,15 +1,15 @@
-import type { Sql } from '../vendor.ts';
+import type { SqlClient } from '../vendor.ts';
 import type { Session, Message } from './types.ts';
-export declare function createSession(sql: Sql<{}>, opts: {
+export declare function createSession(sql: SqlClient, opts: {
     userId?: number;
     title?: string;
     model?: string;
     systemPrompt?: string;
 }, cwd: string, mountPath: string): Promise<Session>;
-export declare function getSession(sql: Sql<{}>, id: string): Promise<Session | null>;
-export declare function listSessions(sql: Sql<{}>, userId?: number): Promise<Session[]>;
-export declare function deleteSession(sql: Sql<{}>, id: string): Promise<void>;
-export declare function getHistory(sql: Sql<{}>, sessionId: string, limit?: number): Promise<SessionMessage[]>;
+export declare function getSession(sql: SqlClient, id: string): Promise<Session | null>;
+export declare function listSessions(sql: SqlClient, userId?: number): Promise<Session[]>;
+export declare function deleteSession(sql: SqlClient, id: string): Promise<void>;
+export declare function getHistory(sql: SqlClient, sessionId: string, limit?: number): Promise<SessionMessage[]>;
 export interface SessionMessage {
     id: number;
     session_id: string;
@@ -21,6 +21,6 @@ export interface SessionMessage {
     tokens_out: number;
     created_at: string;
 }
-export declare function addTextMessage(sql: Sql<{}>, sessionId: string, role: 'user' | 'assistant', content: string, tokensIn?: number, tokensOut?: number): Promise<Message>;
-export declare function addToolMessages(sql: Sql<{}>, sessionId: string, toolCalls: unknown[], toolResults: unknown[]): Promise<Message>;
-export declare function updateSessionTitle(sql: Sql<{}>, id: string, title: string): Promise<void>;
+export declare function addTextMessage(sql: SqlClient, sessionId: string, role: 'user' | 'assistant', content: string, tokensIn?: number, tokensOut?: number): Promise<Message>;
+export declare function addToolMessages(sql: SqlClient, sessionId: string, toolCalls: unknown[], toolResults: unknown[]): Promise<Message>;
+export declare function updateSessionTitle(sql: SqlClient, id: string, title: string): Promise<void>;

package/dist/opencode/tools/web.d.ts

@@ -1,5 +1,5 @@
 import type { ToolContext } from './index.ts';
-export declare function createWebTool(ctx: ToolContext): import("ai").Tool<{
+export declare function createWebTool(_ctx: ToolContext): import("ai").Tool<{
     url: string;
 }, {
     content: string;

package/dist/opencode/ws.d.ts

@@ -1,8 +1,7 @@
 import type { WebSocket } from '../vendor.ts';
 import type { LanguageModel } from 'ai';
 import type { Context } from '../types.ts';
-import type { PendingQuestion, SkillDef, SkillRegistry } from './types.ts';
-import type { OpencodePermissions } from './types.ts';
+import type { PendingQuestion, SkillDef, SkillRegistry, OpencodePermissions } from './types.ts';
 interface WsDeps {
     sql: any;
     model: LanguageModel;

package/dist/permissions.d.ts

@@ -1,4 +1,4 @@
-import type { Sql } from './vendor.ts';
+import type { SqlClient } from './vendor.ts';
 import type { Middleware, Context, Handler } from './types.ts';
 declare module './types.ts' {
     interface Context {
@@ -11,7 +11,7 @@ declare module './types.ts' {
 export interface PermissionsOptions {
     /** PostgreSQL client. */
     pg: {
-        sql: Sql<{}>;
+        sql: SqlClient;
     };
     /** Table prefix (default: '' → _roles, _user_roles, _role_permissions). */
     prefix?: string;

package/dist/postgres/module.d.ts

@@ -1,15 +1,15 @@
 import type { PostgresClient } from './types.ts';
-import type { Sql } from '../vendor.ts';
+import type { SqlClient } from '../vendor.ts';
 import type { ColumnBuilder, BoundTable, Table } from './schema/index.ts';
 import type { Closeable } from '../types.ts';
 export declare class PgModule implements Closeable {
-    protected sql: Sql<{}>;
+    protected sql: SqlClient;
     protected pg: PostgresClient;
     constructor(pg: PostgresClient);
     table<R extends Record<string, unknown>>(tableOrSchema: string | Table<R>, builders?: {
         [K in keyof R]: ColumnBuilder<R[K]>;
     }): BoundTable<R>;
-    transaction<T>(fn: (sql: Sql<{}>) => Promise<T>, retryOpts?: {
+    transaction<T>(fn: (sql: SqlClient) => Promise<T>, retryOpts?: {
         maxRetries?: number;
     }): Promise<T>;
     migrate(): Promise<void>;

package/dist/postgres/schema/index.d.ts

@@ -3,4 +3,4 @@ export { ColumnBuilder, serial, uuid, text, integer, boolean as boolean, boolean
 export type { PartitionByDef } from './columns.ts';
 export { pgTable, Table, BoundTable } from './table.ts';
 export type { IndexOptions, FindOptions, CreateOptions } from './table.ts';
-export { eq, ne, gt, gte, lt, lte, isNull, isNotNull, like, contains, in_, and, or, not } from './where.ts';
+export { eq, ne, gt, gte, lt, lte, isNull, isNotNull, like, contains, in_, and, or, not, } from './where.ts';

package/dist/postgres/schema/table.d.ts

@@ -1,4 +1,4 @@
-import type { Sql } from '../../vendor.ts';
+import type { SqlClient } from '../../vendor.ts';
 import { ColumnBuilder, type PartitionByDef } from './columns.ts';
 import { SQL } from './sql.ts';
 /** Options for table index creation. */
@@ -64,39 +64,41 @@ export declare class Table<R extends Record<string, unknown>> {
      * Bind this table schema to a SQL connection, returning a `BoundTable`
      * that can run queries without passing `sql` to every call.
      */
-    bind(sql: Sql<{}>): BoundTable<R>;
+    bind(sql: SqlClient): BoundTable<R>;
     /** Returns the primary key column name (DB name), or 'id' as fallback. */
     private get pkColumn();
     /** Adds `deleted_at IS NULL` condition if the table has soft delete and not explicitly excluded. */
     private _softDeleteFilter;
-    create(sql: Sql<{}>, opts?: CreateOptions): Promise<void>;
-    drop(sql: Sql<{}>, opts?: {
+    create(sql: SqlClient, opts?: CreateOptions): Promise<void>;
+    drop(sql: SqlClient, opts?: {
         cascade?: boolean;
     }): Promise<void>;
-    createIndex(sql: Sql<{}>, columns: string | string[], opts?: IndexOptions): Promise<void>;
-    createUniqueIndex(sql: Sql<{}>, columns: string | string[]): Promise<void>;
+    createIndex(sql: SqlClient, columns: string | string[], opts?: IndexOptions): Promise<void>;
+    createUniqueIndex(sql: SqlClient, columns: string | string[]): Promise<void>;
     private _buildConditions;
     private _buildSET;
-    insert(sql: Sql<{}>, data: Partial<R>): Promise<R>;
-    insertMany(sql: Sql<{}>, data: Partial<R>[]): Promise<R[]>;
-    read(sql: Sql<{}>, id: string | number, opts?: Pick<FindOptions, 'select' | 'withDeleted'>): Promise<R | undefined>;
-    readMany(sql: Sql<{}>, where?: Partial<R> | SQL | SQL[], opts?: FindOptions): Promise<{
+    insert(sql: SqlClient, data: Partial<R>): Promise<R>;
+    insertMany(sql: SqlClient, data: Partial<R>[]): Promise<R[]>;
+    read(sql: SqlClient, id: string | number, opts?: Pick<FindOptions, 'select' | 'withDeleted'>): Promise<R | undefined>;
+    readMany(sql: SqlClient, where?: Partial<R> | SQL | SQL[], opts?: FindOptions): Promise<{
         count: number;
         data: R[];
     }>;
-    update(sql: Sql<{}>, id: string | number, data: Partial<R>): Promise<R | undefined>;
-    updateMany(sql: Sql<{}>, where: Partial<R> | SQL | SQL[], data: Partial<R>): Promise<number>;
-    delete(sql: Sql<{}>, id: string | number): Promise<R | undefined>;
-    hardDelete(sql: Sql<{}>, id: string | number): Promise<R | undefined>;
-    deleteMany(sql: Sql<{}>, where: Partial<R> | SQL | SQL[]): Promise<number>;
-    hardDeleteMany(sql: Sql<{}>, where: Partial<R> | SQL | SQL[]): Promise<number>;
-    upsert(sql: Sql<{}>, data: Partial<R>, conflict: string | string[]): Promise<R>;
-    count(sql: Sql<{}>, where?: Partial<R> | SQL | SQL[]): Promise<number>;
+    update(sql: SqlClient, id: string | number, data: Partial<R>): Promise<R | undefined>;
+    updateMany(sql: SqlClient, where: Partial<R> | SQL | SQL[], data: Partial<R>): Promise<number>;
+    delete(sql: SqlClient, id: string | number): Promise<R | undefined>;
+    hardDelete(sql: SqlClient, id: string | number): Promise<R | undefined>;
+    deleteMany(sql: SqlClient, where: Partial<R> | SQL | SQL[]): Promise<number>;
+    hardDeleteMany(sql: SqlClient, where: Partial<R> | SQL | SQL[]): Promise<number>;
+    upsert(sql: SqlClient, data: Partial<R>, conflict: string | string[]): Promise<R>;
+    count(sql: SqlClient, where?: Partial<R> | SQL | SQL[]): Promise<number>;
 }
 export declare class BoundTable<R extends Record<string, unknown>> {
     private inner;
     private sql;
-    constructor(sql: Sql<{}>, tableName: string, builders: Record<string, ColumnBuilder<unknown>>);
+    /** The underlying table name. */
+    get tableName(): string;
+    constructor(sql: SqlClient, tableName: string, builders: Record<string, ColumnBuilder<unknown>>);
     create(opts?: CreateOptions): Promise<void>;
     drop(opts?: {
         cascade?: boolean;
@@ -118,7 +120,7 @@ export declare class BoundTable<R extends Record<string, unknown>> {
     hardDeleteMany(where: Partial<R> | SQL | SQL[]): Promise<number>;
     upsert(data: Partial<R>, conflict: string | string[]): Promise<R>;
     count(where?: Partial<R> | SQL | SQL[]): Promise<number>;
-    withSql(sql: Sql<{}>): BoundTable<R>;
+    withSql(sql: SqlClient): BoundTable<R>;
 }
 /**
  * Define a type-safe table schema.

package/dist/postgres/types.d.ts

@@ -1,13 +1,13 @@
-import type { Sql } from '../vendor.ts';
+import type { SqlClient } from '../vendor.ts';
 import type { Context, Middleware, Closeable } from '../types.ts';
 import type { ColumnBuilder, BoundTable, Table } from './schema/index.ts';
 declare module '../types.ts' {
     interface Context {
-        sql: Sql<{}>;
+        sql: SqlClient;
     }
 }
 export interface PostgresInjected {
-    sql: Sql<{}>;
+    sql: SqlClient;
 }
 export interface PostgresOptions {
     connection?: string | Record<string, unknown>;
@@ -23,7 +23,7 @@ export interface PostgresOptions {
     onQuery?: (query: string, durationMs: number, rowCount: number) => void;
 }
 export interface PostgresClient extends Middleware<Context, Context & PostgresInjected>, Closeable {
-    sql: Sql<{}>;
+    sql: SqlClient;
     /** Creates the migration tracking table (_weifuwu_migrations). Called once at startup. */
     migrate: () => Promise<void>;
     /** Record that a module's migration has been applied (idempotent). */

package/dist/queue/types.d.ts

@@ -22,7 +22,7 @@ export interface QueueOptions {
     pollInterval?: number;
     /** PostgreSQL client (required when store: 'pg'). */
     pg?: {
-        sql: import('../vendor.ts').Sql<{}>;
+        sql: import('../vendor.ts').SqlClient;
     };
 }
 export interface QueueInjected {

package/dist/react.d.ts

@@ -11,4 +11,4 @@ export { useLocale } from './client-locale.ts';
 export { useTheme, applyTheme } from './client-theme.ts';
 export { useFlashMessage } from './use-flash-message.ts';
 export { useAgentStream } from './use-agent-stream.ts';
-export type { UseAgentStreamOptions, UseAgentStreamReturn, AgentStreamState } from './use-agent-stream.ts';
+export type { UseAgentStreamOptions, UseAgentStreamReturn, AgentStreamState, } from './use-agent-stream.ts';

package/dist/react.js

@@ -95,42 +95,45 @@ function useAction(url, options) {
   const [error, setError] = useState2(null);
   const [pending, setPending] = useState2(false);
   const mountedRef = useRef2(true);
-  const submit = useCallback2(async (body) => {
-    setPending(true);
-    setError(null);
-    try {
-      const csrfToken = getCsrfToken();
-      const hdrs = { ...headers };
-      if (csrfToken) hdrs["x-csrf-token"] = csrfToken;
-      if (body && typeof body === "object" && !(body instanceof FormData)) {
-        hdrs["content-type"] = "application/json";
-      }
-      const res = await fetch(url, {
-        method,
-        headers: hdrs,
-        body: body instanceof FormData ? body : body !== void 0 ? JSON.stringify(body) : void 0
-      });
-      if (!res.ok) {
-        const text = await res.text();
-        throw new Error(text || `HTTP ${res.status}`);
-      }
-      const result = res.status === 204 ? void 0 : await res.json();
-      if (mountedRef.current) {
-        setData(result);
-        onSuccess?.(result);
-      }
-      return result;
-    } catch (err) {
-      const e = err instanceof Error ? err : new Error(String(err));
-      if (mountedRef.current) {
-        setError(e);
-        onError?.(e);
+  const submit = useCallback2(
+    async (body) => {
+      setPending(true);
+      setError(null);
+      try {
+        const csrfToken = getCsrfToken();
+        const hdrs = { ...headers };
+        if (csrfToken) hdrs["x-csrf-token"] = csrfToken;
+        if (body && typeof body === "object" && !(body instanceof FormData)) {
+          hdrs["content-type"] = "application/json";
+        }
+        const res = await fetch(url, {
+          method,
+          headers: hdrs,
+          body: body instanceof FormData ? body : body !== void 0 ? JSON.stringify(body) : void 0
+        });
+        if (!res.ok) {
+          const text = await res.text();
+          throw new Error(text || `HTTP ${res.status}`);
+        }
+        const result = res.status === 204 ? void 0 : await res.json();
+        if (mountedRef.current) {
+          setData(result);
+          onSuccess?.(result);
+        }
+        return result;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        if (mountedRef.current) {
+          setError(e);
+          onError?.(e);
+        }
+        return void 0;
+      } finally {
+        if (mountedRef.current) setPending(false);
       }
-      return void 0;
-    } finally {
-      if (mountedRef.current) setPending(false);
-    }
-  }, [url, method, headers, onSuccess, onError]);
+    },
+    [url, method, headers, onSuccess, onError]
+  );
   const reset = useCallback2(() => {
     setData(null);
     setError(null);
@@ -155,7 +158,15 @@ async function runInterceptors(url) {
 
 // tsx-context.ts
 import { useSyncExternalStore, createContext } from "react";
-var DEFAULT_CTX = { params: {}, query: {}, parsed: {}, loaderData: {}, env: {}, user: {}, flash: {} };
+var DEFAULT_CTX = {
+  params: {},
+  query: {},
+  parsed: {},
+  loaderData: {},
+  env: {},
+  user: {},
+  flash: {}
+};
 var KEY = "__WEIFUWU_CTX_STORE";
 function getStore() {
   if (typeof globalThis !== "undefined" && globalThis[KEY]) {
@@ -163,12 +174,22 @@ function getStore() {
   }
   const s = {
     _ctx: DEFAULT_CTX,
-    _snapshot: { params: DEFAULT_CTX.params, query: DEFAULT_CTX.query, user: DEFAULT_CTX.user, parsed: DEFAULT_CTX.parsed, theme: DEFAULT_CTX.theme, i18n: DEFAULT_CTX.i18n, loaderData: DEFAULT_CTX.loaderData, env: DEFAULT_CTX.env },
+    _snapshot: {
+      params: DEFAULT_CTX.params,
+      query: DEFAULT_CTX.query,
+      user: DEFAULT_CTX.user,
+      parsed: DEFAULT_CTX.parsed,
+      theme: DEFAULT_CTX.theme,
+      i18n: DEFAULT_CTX.i18n,
+      loaderData: DEFAULT_CTX.loaderData,
+      env: DEFAULT_CTX.env
+    },
     _listeners: /* @__PURE__ */ new Set(),
     _rebuilders: [],
     _alsGetStore: null
   };
   if (typeof globalThis !== "undefined") {
+    ;
     globalThis[KEY] = s;
   }
   return s;
@@ -192,7 +213,16 @@ function setCtx(value) {
     }
   }
   store._ctx = { ...store._ctx, ...value };
-  store._snapshot = { params: store._ctx.params, query: store._ctx.query, user: store._ctx.user, parsed: store._ctx.parsed, theme: store._ctx.theme, i18n: store._ctx.i18n, loaderData: store._ctx.loaderData, env: store._ctx.env };
+  store._snapshot = {
+    params: store._ctx.params,
+    query: store._ctx.query,
+    user: store._ctx.user,
+    parsed: store._ctx.parsed,
+    theme: store._ctx.theme,
+    i18n: store._ctx.i18n,
+    loaderData: store._ctx.loaderData,
+    env: store._ctx.env
+  };
   if (typeof window !== "undefined") {
     ;
     window.__WEIFUWU_CTX = { ...window.__WEIFUWU_CTX, ...value };
@@ -290,7 +320,9 @@ function applyHead(html) {
   const doc = new DOMParser().parseFromString(headHtml, "text/html");
   const newMeta = doc.querySelectorAll("meta");
   const existing = document.querySelectorAll("head meta");
-  const newNames = new Set(Array.from(newMeta).map((m) => m.getAttribute("name") || m.getAttribute("property") || ""));
+  const newNames = new Set(
+    Array.from(newMeta).map((m) => m.getAttribute("name") || m.getAttribute("property") || "")
+  );
   for (const el of existing) {
     const key = el.getAttribute("name") || el.getAttribute("property") || "";
     if (!newNames.has(key)) el.remove();
@@ -307,7 +339,8 @@ function applyHead(html) {
       }
     }
     if (existingEl) {
-      for (const attr of el.attributes) existingEl.setAttribute(attr.name, attr.value);
+      for (const attr of el.attributes)
+        existingEl.setAttribute(attr.name, attr.value);
     } else {
       document.head.appendChild(el.cloneNode());
     }
@@ -345,27 +378,37 @@ function Link({ href, children, onClick, prefetch, ...props }) {
       }
     }
     if (!el) return;
-    const observer = new IntersectionObserver(([entry]) => {
-      if (entry.isIntersecting) prefetchPage(href);
-    }, { rootMargin: "200px" });
+    const observer = new IntersectionObserver(
+      ([entry]) => {
+        if (entry.isIntersecting) prefetchPage(href);
+      },
+      { rootMargin: "200px" }
+    );
     observer.observe(el);
     return () => observer.disconnect();
   }, [href, prefetch]);
   const handleMouseEnter = useCallback3(() => {
     if (prefetch) prefetchPage(href);
   }, [href, prefetch]);
-  const handleClick = useCallback3((e) => {
-    if (e.button !== 0 || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
-    e.preventDefault();
-    doNavigate(href);
-    onClick?.(e);
-  }, [href, onClick, doNavigate]);
-  return createElement("a", {
-    href,
-    onClick: handleClick,
-    onMouseEnter: handleMouseEnter,
-    ...props
-  }, children);
+  const handleClick = useCallback3(
+    (e) => {
+      if (e.button !== 0 || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
+      e.preventDefault();
+      doNavigate(href);
+      onClick?.(e);
+    },
+    [href, onClick, doNavigate]
+  );
+  return createElement(
+    "a",
+    {
+      href,
+      onClick: handleClick,
+      onMouseEnter: handleMouseEnter,
+      ...props
+    },
+    children
+  );
 }
 async function prefetchPage(href) {
   const cached = prefetchCache.get(href);
@@ -400,10 +443,7 @@ function createStore(initial) {
       listeners.delete(listener);
     };
   };
-  const useStore = ((selector) => useSyncExternalStore2(
-    subscribe2,
-    () => selector ? selector(state) : state
-  ));
+  const useStore = ((selector) => useSyncExternalStore2(subscribe2, () => selector ? selector(state) : state));
   useStore.getState = getState;
   useStore.setState = setState;
   useStore.subscribe = subscribe2;
@@ -430,19 +470,23 @@ function useFetch(url, options) {
     let cancelled = false;
     const cached = dataCache.get(u);
     if (cached && Date.now() - cached.timestamp < ttl) {
-      if (!cancelled) setState({
-        data: cached.data,
-        error: cached.error,
-        loading: false
-      });
+      if (!cancelled)
+        setState({
+          data: cached.data,
+          error: cached.error,
+          loading: false
+        });
       return;
     }
     async function doFetch() {
       if (!inflight.has(u)) {
-        inflight.set(u, fetch(u).then((r) => {
-          if (!r.ok) throw new Error(r.statusText || `HTTP ${r.status}`);
-          return r.json();
-        }));
+        inflight.set(
+          u,
+          fetch(u).then((r) => {
+            if (!r.ok) throw new Error(r.statusText || `HTTP ${r.status}`);
+            return r.json();
+          })
+        );
       }
       const promise = inflight.get(u);
       try {
@@ -501,18 +545,21 @@ function useQueryState(key, defaultValue = "") {
     getSnapshot2,
     () => defaultValue
   );
-  const setValue = useCallback4((val) => {
-    if (typeof window === "undefined") return;
-    const resolved = typeof val === "function" ? val(getSnapshot2()) : val;
-    const url = new URL(window.location.href);
-    if (resolved === defaultValue || resolved === "") {
-      url.searchParams.delete(key);
-    } else {
-      url.searchParams.set(key, resolved);
-    }
-    window.history.replaceState(null, "", url.toString());
-    notifyQueryListeners();
-  }, [key, defaultValue]);
+  const setValue = useCallback4(
+    (val) => {
+      if (typeof window === "undefined") return;
+      const resolved = typeof val === "function" ? val(getSnapshot2()) : val;
+      const url = new URL(window.location.href);
+      if (resolved === defaultValue || resolved === "") {
+        url.searchParams.delete(key);
+      } else {
+        url.searchParams.set(key, resolved);
+      }
+      window.history.replaceState(null, "", url.toString());
+      notifyQueryListeners();
+    },
+    [key, defaultValue]
+  );
   return [value, setValue];
 }
 
@@ -593,7 +640,10 @@ addInterceptor(async (url) => {
       headers: { accept: "application/json" }
     });
     const data = await res.json();
-    window.__WEIFUWU_CTX = { ...window.__WEIFUWU_CTX, theme: { value: data.theme } };
+    window.__WEIFUWU_CTX = {
+      ...window.__WEIFUWU_CTX,
+      theme: { value: data.theme }
+    };
     setCtx({ theme: { value: data.theme } });
     applyTheme(data.theme);
   } catch {
@@ -633,20 +683,15 @@ function useAgentStream(opts) {
   const [streams, setStreams] = useState6({});
   const activeRef = useRef4(/* @__PURE__ */ new Set());
   const streamsRef = useRef4({});
-  const getAgentText = useCallback5(
-    (agentId) => streams[agentId] || "",
-    [streams]
-  );
-  const isAgentStreaming = useCallback5(
-    (agentId) => activeRef.current.has(agentId),
-    []
-  );
+  const getAgentText = useCallback5((agentId) => streams[agentId] || "", [streams]);
+  const isAgentStreaming = useCallback5((agentId) => activeRef.current.has(agentId), []);
   const streaming = activeRef.current.size > 0;
   useWebsocket(wsPath, {
     onMessage: (raw) => {
       try {
         const msg = JSON.parse(raw);
-        if (msg.type !== "agent_stream" && msg.type !== "agent_stream_end" && msg.type !== "agent_error") return;
+        if (msg.type !== "agent_stream" && msg.type !== "agent_stream_end" && msg.type !== "agent_error")
+          return;
         const agentId = msg.data?.agent_id;
         if (agentId === void 0 || agentId === null) return;
         switch (msg.type) {