@aiassist-secure/core 1.0.0

package/dist/index.mjs

@@ -0,0 +1,314 @@
+// src/types.ts
+var AiAssistError = class extends Error {
+  constructor(message, status, code) {
+    super(message);
+    this.name = "AiAssistError";
+    this.status = status;
+    this.code = code;
+  }
+};
+var AuthenticationError = class extends AiAssistError {
+  constructor(message = "Invalid API key") {
+    super(message, 401, "invalid_api_key");
+    this.name = "AuthenticationError";
+  }
+};
+var RateLimitError = class extends AiAssistError {
+  constructor(message = "Rate limit exceeded", retryAfter) {
+    super(message, 429, "rate_limit_exceeded");
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var APIError = class extends AiAssistError {
+  constructor(message, status, code) {
+    super(message, status, code);
+    this.name = "APIError";
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.aiassist.net";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_MAX_RETRIES = 3;
+var VERSION = "1.0.0";
+function normalizeRole(role) {
+  if (role === "assistant" || role === "ai") return "ai";
+  if (role === "human") return "human";
+  if (role === "system") return "system";
+  return "user";
+}
+var AiAssistClient = class {
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.baseURL = options.baseURL ?? DEFAULT_BASE_URL;
+    this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
+    this.maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.defaultHeaders = options.defaultHeaders ?? {};
+    this.chat = new ChatAPI(this);
+    this.models = new ModelsAPI(this);
+    this.workspaces = new WorkspacesAPI(this);
+  }
+  getHeaders() {
+    return {
+      "Content-Type": "application/json",
+      "X-API-Key": this.apiKey,
+      "Authorization": `Bearer ${this.apiKey}`,
+      "User-Agent": `aiassist-js/${VERSION}`,
+      ...this.defaultHeaders
+    };
+  }
+  async request(method, path, options) {
+    const url = `${this.baseURL}${path}`;
+    const headers = { ...this.getHeaders(), ...options?.headers };
+    let lastError = null;
+    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const response = await fetch(url, {
+          method,
+          headers,
+          body: options?.body ? JSON.stringify(options.body) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (response.status === 401) {
+          throw new AuthenticationError();
+        }
+        if (response.status === 429) {
+          const retryAfter = parseInt(response.headers.get("Retry-After") ?? "5", 10);
+          if (attempt < this.maxRetries - 1) {
+            await this.sleep(retryAfter * 1e3);
+            continue;
+          }
+          throw new RateLimitError("Rate limit exceeded", retryAfter);
+        }
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({}));
+          throw new APIError(
+            errorData.detail ?? `HTTP ${response.status}`,
+            response.status,
+            errorData.code
+          );
+        }
+        return await response.json();
+      } catch (error) {
+        lastError = error;
+        if (error instanceof AiAssistError) {
+          throw error;
+        }
+        if (attempt < this.maxRetries - 1) {
+          await this.sleep(Math.pow(2, attempt) * 1e3);
+          continue;
+        }
+      }
+    }
+    throw new APIError(`Request failed: ${lastError?.message}`);
+  }
+  async requestSilent(method, path, options) {
+    try {
+      await this.request(method, path, options);
+    } catch {
+    }
+  }
+  async *stream(method, path, body) {
+    const url = `${this.baseURL}${path}`;
+    const headers = this.getHeaders();
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      if (response.status === 401) throw new AuthenticationError();
+      if (response.status === 429) throw new RateLimitError();
+      const errorData = await response.json().catch(() => ({}));
+      throw new APIError(errorData.detail ?? `HTTP ${response.status}`, response.status);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) throw new APIError("Response body is not readable");
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          const data = line.slice(6);
+          if (data === "[DONE]") return;
+          try {
+            yield JSON.parse(data);
+          } catch {
+          }
+        }
+      }
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+var ChatAPI = class {
+  constructor(client) {
+    this.completions = new ChatCompletionsAPI(client);
+  }
+};
+var ChatCompletionsAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async create(params) {
+    if (params.stream) {
+      return this.client.stream("POST", "/v1/chat/completions", params);
+    }
+    return this.client.request("POST", "/v1/chat/completions", {
+      body: params
+    });
+  }
+};
+var ModelsAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list() {
+    const response = await this.client.request("GET", "/v1/models");
+    return response.data;
+  }
+};
+var WorkspacesAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Create a new workspace with optional system prompt and context.
+   * 
+   * @param params - Workspace creation options
+   * @returns Workspace and initial messages
+   */
+  async create(params) {
+    const body = {};
+    if (params?.initial_message) body.initial_message = params.initial_message;
+    if (params?.client_id) body.client_id = params.client_id;
+    if (params?.system_prompt) body.system_prompt = params.system_prompt;
+    if (params?.context) body.context = params.context;
+    if (params?.metadata) body.metadata = params.metadata;
+    const data = await this.client.request("POST", "/api/workspaces", { body });
+    return {
+      workspace: {
+        id: data.workspace.id,
+        mode: data.workspace.mode,
+        status: data.workspace.status || "active"
+      },
+      messages: (data.messages || []).map((m) => ({
+        id: m.id,
+        role: normalizeRole(m.role),
+        content: m.content,
+        created_at: m.created_at
+      }))
+    };
+  }
+  /**
+   * Get workspace by ID.
+   */
+  async get(workspaceId) {
+    const data = await this.client.request("GET", `/api/workspaces/${workspaceId}`);
+    const ws = data.workspace || data;
+    return {
+      id: ws.id,
+      mode: ws.mode || "ai",
+      status: ws.status || "active"
+    };
+  }
+  /**
+   * Get workspace by client ID.
+   * Returns null if not found.
+   */
+  async getByClientId(clientId) {
+    try {
+      const data = await this.client.request("GET", `/api/workspaces/by-client/${clientId}`);
+      return {
+        workspace: data.workspace ? {
+          id: data.workspace.id,
+          mode: data.workspace.mode,
+          status: "active"
+        } : null,
+        messages: (data.messages || []).map((m) => ({
+          id: m.id,
+          role: normalizeRole(m.role),
+          content: m.content,
+          created_at: m.created_at
+        })),
+        exists: data.exists
+      };
+    } catch (error) {
+      if (error instanceof APIError && error.status === 404) {
+        return { workspace: null, messages: [], exists: false };
+      }
+      throw error;
+    }
+  }
+  /**
+   * Send a message to a workspace.
+   * Returns user message, AI/human responses, mode, and shadow mode approval status.
+   */
+  async sendMessage(workspaceId, content) {
+    const data = await this.client.request("POST", `/api/workspaces/${workspaceId}/messages`, {
+      body: { content }
+    });
+    return {
+      user_message: {
+        id: data.user_message.id,
+        role: "user",
+        content: data.user_message.content,
+        created_at: data.user_message.created_at
+      },
+      responses: data.responses.map((r) => ({
+        id: r.id,
+        role: normalizeRole(r.role),
+        content: r.content,
+        created_at: r.created_at
+      })),
+      mode: data.mode,
+      pending_approval: data.pending_approval
+    };
+  }
+  /**
+   * Get all messages in a workspace.
+   */
+  async getMessages(workspaceId) {
+    const data = await this.client.request("GET", `/api/workspaces/${workspaceId}/messages`);
+    return (data.messages || []).map((m) => ({
+      id: m.id,
+      role: normalizeRole(m.role),
+      content: m.content,
+      created_at: m.created_at
+    }));
+  }
+  /**
+   * Send typing preview to workspace (for real-time typing indicators).
+   * Fails silently - non-critical operation.
+   */
+  async sendTypingPreview(workspaceId, text) {
+    await this.client.requestSilent("POST", `/api/workspaces/${workspaceId}/typing`, {
+      body: { text }
+    });
+  }
+  /**
+   * End a conversation/workspace.
+   * Fails silently - non-critical operation.
+   */
+  async endConversation(workspaceId) {
+    await this.client.requestSilent("POST", `/api/workspaces/${workspaceId}/end`, {});
+  }
+};
+export {
+  APIError,
+  AiAssistClient,
+  AiAssistError,
+  AuthenticationError,
+  RateLimitError
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@aiassist-secure/core",
+  "version": "1.0.0",
+  "description": "AiAssist Secure TypeScript SDK - Framework-agnostic API client",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  },
+  "keywords": [
+    "aiassist",
+    "aiassist-secure",
+    "ai",
+    "llm",
+    "openai",
+    "groq",
+    "chat",
+    "api",
+    "sdk"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aiassistsecure/aiassist-js"
+  },
+  "homepage": "https://aiassist.net",
+  "bugs": {
+    "url": "https://github.com/aiassistsecure/aiassist-js/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}