@sinas/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,678 @@
+"use strict";
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  SinasAuthError: () => SinasAuthError,
+  SinasClient: () => SinasClient,
+  SinasError: () => SinasError,
+  SinasNotFoundError: () => SinasNotFoundError,
+  SinasPermissionError: () => SinasPermissionError,
+  SinasProvider: () => SinasProvider,
+  SinasTimeoutError: () => SinasTimeoutError,
+  createChat: () => createChat,
+  executeFunction: () => executeFunction,
+  executeQuery: () => executeQuery,
+  sendMessage: () => sendMessage,
+  stateDelete: () => stateDelete,
+  stateGet: () => stateGet,
+  stateList: () => stateList,
+  stateSet: () => stateSet,
+  streamMessage: () => streamMessage,
+  useChat: () => useChat,
+  useExecute: () => useExecute,
+  useQuery: () => useQuery,
+  useSinas: () => useSinas,
+  useStateStore: () => useStateStore
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/client/errors.ts
+var SinasError = class extends Error {
+  constructor(message, status = 0, detail) {
+    super(message);
+    this.name = "SinasError";
+    this.status = status;
+    this.detail = detail || message;
+  }
+};
+var SinasAuthError = class extends SinasError {
+  constructor(message = "Authentication required") {
+    super(message, 401);
+    this.name = "SinasAuthError";
+  }
+};
+var SinasPermissionError = class extends SinasError {
+  constructor(message = "Permission denied") {
+    super(message, 403);
+    this.name = "SinasPermissionError";
+  }
+};
+var SinasNotFoundError = class extends SinasError {
+  constructor(resource) {
+    super(`${resource} not found`, 404);
+    this.name = "SinasNotFoundError";
+  }
+};
+var SinasTimeoutError = class extends SinasError {
+  constructor(message = "Request timed out") {
+    super(message, 408);
+    this.name = "SinasTimeoutError";
+  }
+};
+
+// src/client/SinasClient.ts
+var SinasClient = class {
+  constructor(config) {
+    this.configOverride = config;
+  }
+  getConfig() {
+    const config = this.configOverride || window.__SINAS_CONFIG__;
+    if (!config) {
+      return {
+        apiBase: "",
+        component: { namespace: "", name: "", version: "" },
+        resources: {
+          enabledAgents: [],
+          enabledFunctions: [],
+          enabledQueries: [],
+          enabledComponents: [],
+          stateNamespacesReadonly: [],
+          stateNamespacesReadwrite: []
+        },
+        input: {}
+      };
+    }
+    return config;
+  }
+  getInput() {
+    return this.getConfig().input || {};
+  }
+  getAuthHeaders() {
+    const token = window.__SINAS_AUTH_TOKEN__;
+    const headers = { "Content-Type": "application/json" };
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    return headers;
+  }
+  getProxyBase() {
+    const config = this.getConfig();
+    const comp = config.component;
+    return `${config.apiBase}/components/${comp.namespace}/${comp.name}/proxy`;
+  }
+  async fetch(url, options = {}) {
+    const res = await fetch(url, {
+      ...options,
+      headers: {
+        ...this.getAuthHeaders(),
+        ...options.headers || {}
+      }
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({ detail: res.statusText }));
+      const message = body.detail || body.message || res.statusText;
+      if (res.status === 401) throw new SinasAuthError(message);
+      if (res.status === 403) throw new SinasPermissionError(message);
+      if (res.status === 404) throw new SinasNotFoundError(message);
+      throw new SinasError(message, res.status);
+    }
+    return res;
+  }
+};
+
+// src/client/queries.ts
+function parseRef(ref) {
+  const parts = ref.split("/");
+  if (parts.length !== 2) {
+    throw new Error(`Invalid query ref "${ref}": expected "namespace/name"`);
+  }
+  return [parts[0], parts[1]];
+}
+async function executeQuery(client, ref, input = {}) {
+  const [ns, name] = parseRef(ref);
+  const base = client.getProxyBase();
+  const res = await client.fetch(`${base}/queries/${ns}/${name}/execute`, {
+    method: "POST",
+    body: JSON.stringify({ input })
+  });
+  const data = await res.json();
+  return {
+    success: data.success,
+    operation: data.operation,
+    data: data.data,
+    rowCount: data.row_count,
+    affectedRows: data.affected_rows,
+    durationMs: data.duration_ms
+  };
+}
+
+// src/client/functions.ts
+function parseRef2(ref) {
+  const parts = ref.split("/");
+  if (parts.length !== 2) {
+    throw new Error(`Invalid function ref "${ref}": expected "namespace/name"`);
+  }
+  return [parts[0], parts[1]];
+}
+async function executeFunction(client, ref, input = {}, timeout) {
+  const [ns, name] = parseRef2(ref);
+  const base = client.getProxyBase();
+  const body = { input };
+  if (timeout !== void 0) {
+    body.timeout = timeout;
+  }
+  const res = await client.fetch(`${base}/functions/${ns}/${name}/execute`, {
+    method: "POST",
+    body: JSON.stringify(body)
+  });
+  const data = await res.json();
+  return {
+    status: data.status,
+    executionId: data.execution_id,
+    result: data.result,
+    error: data.error
+  };
+}
+
+// src/client/states.ts
+async function stateGet(client, ns, key) {
+  const base = client.getProxyBase();
+  const res = await client.fetch(`${base}/states/${ns}`, {
+    method: "POST",
+    body: JSON.stringify({ action: "get", key })
+  });
+  return res.json();
+}
+async function stateSet(client, ns, key, value, visibility = "private") {
+  const base = client.getProxyBase();
+  await client.fetch(`${base}/states/${ns}`, {
+    method: "POST",
+    body: JSON.stringify({ action: "set", key, value, visibility })
+  });
+}
+async function stateDelete(client, ns, key) {
+  const base = client.getProxyBase();
+  await client.fetch(`${base}/states/${ns}`, {
+    method: "POST",
+    body: JSON.stringify({ action: "delete", key })
+  });
+}
+async function stateList(client, ns) {
+  const base = client.getProxyBase();
+  const res = await client.fetch(`${base}/states/${ns}`, {
+    method: "POST",
+    body: JSON.stringify({ action: "list" })
+  });
+  return res.json();
+}
+
+// src/client/chat.ts
+async function createChat(client, agentRef, input) {
+  const [ns, name] = agentRef.split("/");
+  if (!ns || !name) {
+    throw new Error(`Invalid agent ref "${agentRef}": expected "namespace/name"`);
+  }
+  const config = client.getConfig();
+  const res = await client.fetch(`${config.apiBase}/agents/${ns}/${name}/chats`, {
+    method: "POST",
+    body: JSON.stringify({ input: input || {} })
+  });
+  const data = await res.json();
+  return {
+    id: data.id,
+    agentNamespace: data.agent_namespace,
+    agentName: data.agent_name,
+    title: data.title
+  };
+}
+async function sendMessage(client, chatId, content) {
+  const config = client.getConfig();
+  const res = await client.fetch(`${config.apiBase}/chats/${chatId}/messages`, {
+    method: "POST",
+    body: JSON.stringify({ content })
+  });
+  const data = await res.json();
+  return {
+    id: data.id,
+    chatId: data.chat_id,
+    role: data.role,
+    content: data.content,
+    createdAt: data.created_at
+  };
+}
+function parseSSE(buffer) {
+  const chunks = [];
+  const lines = buffer.split("\n");
+  let event = "";
+  let data = "";
+  let remaining = "";
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (i === lines.length - 1 && !buffer.endsWith("\n")) {
+      remaining = line;
+      break;
+    }
+    if (line.startsWith("event:")) {
+      event = line.slice(6).trim();
+    } else if (line.startsWith("data:")) {
+      data = line.slice(5).trim();
+    } else if (line === "") {
+      if (event || data) {
+        chunks.push({ event: event || "message", data });
+        event = "";
+        data = "";
+      }
+    }
+  }
+  return { chunks, remaining };
+}
+function streamMessage(client, chatId, content, onChunk, onDone, onError) {
+  const controller = new AbortController();
+  const config = client.getConfig();
+  (async () => {
+    try {
+      const res = await fetch(`${config.apiBase}/chats/${chatId}/messages/stream`, {
+        method: "POST",
+        headers: client.getAuthHeaders(),
+        body: JSON.stringify({ content }),
+        signal: controller.signal
+      });
+      if (!res.ok) {
+        const body = await res.json().catch(() => ({ detail: res.statusText }));
+        throw new Error(body.detail || "Stream request failed");
+      }
+      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 { chunks, remaining } = parseSSE(buffer);
+        buffer = remaining;
+        for (const chunk of chunks) {
+          onChunk(chunk);
+          if (chunk.event === "done") {
+            onDone?.();
+            return;
+          }
+        }
+      }
+      if (buffer.trim()) {
+        const { chunks } = parseSSE(buffer + "\n\n");
+        for (const chunk of chunks) {
+          onChunk(chunk);
+        }
+      }
+      onDone?.();
+    } catch (err) {
+      if (err.name === "AbortError") return;
+      onError?.(err);
+    }
+  })();
+  return controller;
+}
+
+// src/hooks/useQuery.ts
+var import_react2 = __toESM(require("react"), 1);
+
+// src/hooks/context.ts
+var import_react = __toESM(require("react"), 1);
+var SinasContext = import_react.default.createContext(null);
+function SinasProvider({ client, children }) {
+  const value = import_react.default.useMemo(() => client || new SinasClient(), [client]);
+  return import_react.default.createElement(SinasContext.Provider, { value }, children);
+}
+function useClient() {
+  const client = import_react.default.useContext(SinasContext);
+  if (client) return client;
+  return defaultClient;
+}
+var defaultClient = new SinasClient();
+
+// src/hooks/useQuery.ts
+function useQuery(ref, input = {}, options = {}) {
+  const client = useClient();
+  const { enabled = true, refetchInterval = null } = options;
+  const [data, setData] = import_react2.default.useState(null);
+  const [loading, setLoading] = import_react2.default.useState(false);
+  const [error, setError] = import_react2.default.useState(null);
+  const [rowCount, setRowCount] = import_react2.default.useState(null);
+  const abortRef = import_react2.default.useRef(null);
+  const inputJson = JSON.stringify(input);
+  const execute = import_react2.default.useCallback(
+    async (overrideInput) => {
+      abortRef.current?.abort();
+      const controller = new AbortController();
+      abortRef.current = controller;
+      setLoading(true);
+      setError(null);
+      try {
+        const result = await executeQuery(
+          client,
+          ref,
+          overrideInput || JSON.parse(inputJson)
+        );
+        if (!controller.signal.aborted) {
+          setData(result.data || null);
+          setRowCount(result.rowCount ?? result.affectedRows ?? null);
+        }
+        return result;
+      } catch (e) {
+        if (!controller.signal.aborted) {
+          setError(e.message);
+        }
+      } finally {
+        if (!controller.signal.aborted) {
+          setLoading(false);
+        }
+      }
+    },
+    [client, ref, inputJson]
+  );
+  import_react2.default.useEffect(() => {
+    if (enabled) {
+      execute();
+    }
+    return () => {
+      abortRef.current?.abort();
+    };
+  }, [enabled, execute]);
+  import_react2.default.useEffect(() => {
+    if (refetchInterval && enabled) {
+      const id = setInterval(execute, refetchInterval);
+      return () => clearInterval(id);
+    }
+  }, [refetchInterval, enabled, execute]);
+  return { data, loading, error, rowCount, refetch: execute };
+}
+
+// src/hooks/useExecute.ts
+var import_react3 = __toESM(require("react"), 1);
+function useExecute(ref) {
+  const client = useClient();
+  const [result, setResult] = import_react3.default.useState(null);
+  const [loading, setLoading] = import_react3.default.useState(false);
+  const [error, setError] = import_react3.default.useState(null);
+  const [executionId, setExecutionId] = import_react3.default.useState(null);
+  const execute = import_react3.default.useCallback(
+    async (input = {}, timeout) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const data = await executeFunction(client, ref, input, timeout);
+        setResult(data.result);
+        setExecutionId(data.executionId);
+        if (data.status === "error") {
+          setError(data.error || "Function execution failed");
+        } else if (data.status === "timeout") {
+          setError("Function execution timed out");
+        }
+        return data;
+      } catch (e) {
+        setError(e.message);
+      } finally {
+        setLoading(false);
+      }
+    },
+    [client, ref]
+  );
+  return { execute, result, loading, error, executionId };
+}
+
+// src/hooks/useStateStore.ts
+var import_react4 = __toESM(require("react"), 1);
+function useStateStore(ns, key) {
+  const client = useClient();
+  const [value, setValue] = import_react4.default.useState(null);
+  const [loading, setLoading] = import_react4.default.useState(true);
+  const [error, setError] = import_react4.default.useState(null);
+  const load = import_react4.default.useCallback(async () => {
+    if (!key) {
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await stateGet(client, ns, key);
+      if (result.found) {
+        setValue(result.value);
+      } else {
+        setValue(null);
+      }
+    } catch (e) {
+      setError(e.message);
+    } finally {
+      setLoading(false);
+    }
+  }, [client, ns, key]);
+  const save = import_react4.default.useCallback(
+    async (newValue, opts) => {
+      if (!key) throw new Error("Cannot save without a key");
+      setValue(newValue);
+      setError(null);
+      try {
+        await stateSet(client, ns, key, newValue, opts?.visibility);
+      } catch (e) {
+        setError(e.message);
+        throw e;
+      }
+    },
+    [client, ns, key]
+  );
+  const remove = import_react4.default.useCallback(async () => {
+    if (!key) throw new Error("Cannot delete without a key");
+    setValue(null);
+    setError(null);
+    try {
+      await stateDelete(client, ns, key);
+    } catch (e) {
+      setError(e.message);
+      throw e;
+    }
+  }, [client, ns, key]);
+  const list = import_react4.default.useCallback(async () => {
+    setError(null);
+    try {
+      return await stateList(client, ns);
+    } catch (e) {
+      setError(e.message);
+    }
+  }, [client, ns]);
+  import_react4.default.useEffect(() => {
+    load();
+  }, [load]);
+  return { value, loading, error, save, remove, refetch: load, list };
+}
+
+// src/hooks/useChat.ts
+var import_react5 = __toESM(require("react"), 1);
+function useChat(agentRef) {
+  const client = useClient();
+  const [chatId, setChatId] = import_react5.default.useState(null);
+  const [messages, setMessages] = import_react5.default.useState([]);
+  const [loading, setLoading] = import_react5.default.useState(false);
+  const [streaming, setStreaming] = import_react5.default.useState(false);
+  const [error, setError] = import_react5.default.useState(null);
+  const abortRef = import_react5.default.useRef(null);
+  import_react5.default.useEffect(() => {
+    return () => {
+      abortRef.current?.abort();
+    };
+  }, []);
+  const doCreateChat = import_react5.default.useCallback(
+    async (input) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const result = await createChat(client, agentRef, input);
+        setChatId(result.id);
+        setMessages([]);
+        return result.id;
+      } catch (e) {
+        setError(e.message);
+      } finally {
+        setLoading(false);
+      }
+    },
+    [client, agentRef]
+  );
+  const doSendMessage = import_react5.default.useCallback(
+    async (content) => {
+      if (!chatId) {
+        setError("No active chat. Call createChat first.");
+        return;
+      }
+      setLoading(true);
+      setError(null);
+      const userMsg = {
+        id: `tmp-${Date.now()}`,
+        chatId,
+        role: "user",
+        content,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      setMessages((prev) => [...prev, userMsg]);
+      try {
+        const msg = await sendMessage(client, chatId, content);
+        setMessages((prev) => [...prev, msg]);
+        return msg;
+      } catch (e) {
+        setError(e.message);
+      } finally {
+        setLoading(false);
+      }
+    },
+    [client, chatId]
+  );
+  const doStreamMessage = import_react5.default.useCallback(
+    (content) => {
+      if (!chatId) {
+        setError("No active chat. Call createChat first.");
+        return;
+      }
+      abortRef.current?.abort();
+      setStreaming(true);
+      setError(null);
+      const userMsg = {
+        id: `tmp-${Date.now()}`,
+        chatId,
+        role: "user",
+        content,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      setMessages((prev) => [...prev, userMsg]);
+      const assistantId = `stream-${Date.now()}`;
+      const assistantMsg = {
+        id: assistantId,
+        chatId,
+        role: "assistant",
+        content: "",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      setMessages((prev) => [...prev, assistantMsg]);
+      const controller = streamMessage(
+        client,
+        chatId,
+        content,
+        (chunk) => {
+          if (chunk.event === "content" || chunk.event === "message") {
+            setMessages(
+              (prev) => prev.map(
+                (m) => m.id === assistantId ? { ...m, content: m.content + chunk.data } : m
+              )
+            );
+          }
+        },
+        () => {
+          setStreaming(false);
+        },
+        (err) => {
+          setError(err.message);
+          setStreaming(false);
+        }
+      );
+      abortRef.current = controller;
+      return controller;
+    },
+    [client, chatId]
+  );
+  return {
+    chatId,
+    messages,
+    loading,
+    streaming,
+    error,
+    createChat: doCreateChat,
+    sendMessage: doSendMessage,
+    streamMessage: doStreamMessage
+  };
+}
+
+// src/hooks/useSinas.ts
+function useSinas() {
+  const client = useClient();
+  return {
+    config: client.getConfig(),
+    input: client.getInput(),
+    client,
+    useQuery,
+    useExecute,
+    useStateStore,
+    useChat
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SinasAuthError,
+  SinasClient,
+  SinasError,
+  SinasNotFoundError,
+  SinasPermissionError,
+  SinasProvider,
+  SinasTimeoutError,
+  createChat,
+  executeFunction,
+  executeQuery,
+  sendMessage,
+  stateDelete,
+  stateGet,
+  stateList,
+  stateSet,
+  streamMessage,
+  useChat,
+  useExecute,
+  useQuery,
+  useSinas,
+  useStateStore
+});
+//# sourceMappingURL=index.cjs.map