@aiassist-secure/core 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,223 @@
+/**
+ * AiAssist SDK Types
+ */
+interface Message {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+    name?: string;
+}
+interface ChatCompletionChoice {
+    index: number;
+    message: Message;
+    finish_reason: 'stop' | 'length' | 'content_filter' | null;
+}
+interface Usage {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+}
+interface ChatCompletion {
+    id: string;
+    object: 'chat.completion';
+    created: number;
+    model: string;
+    choices: ChatCompletionChoice[];
+    usage?: Usage;
+}
+interface ChatCompletionChunkDelta {
+    role?: 'assistant';
+    content?: string;
+}
+interface ChatCompletionChunkChoice {
+    index: number;
+    delta: ChatCompletionChunkDelta;
+    finish_reason: 'stop' | 'length' | 'content_filter' | null;
+}
+interface ChatCompletionChunk {
+    id: string;
+    object: 'chat.completion.chunk';
+    created: number;
+    model: string;
+    choices: ChatCompletionChunkChoice[];
+}
+interface ChatCompletionCreateParams {
+    messages: Message[];
+    model?: string;
+    temperature?: number;
+    max_tokens?: number;
+    top_p?: number;
+    stream?: boolean;
+    provider?: string;
+}
+type WorkspaceMode = 'ai' | 'shadow' | 'takeover';
+type WorkspaceStatus = 'active' | 'archived' | 'deleted';
+type MessageRole = 'user' | 'ai' | 'human' | 'system';
+interface Workspace {
+    id: string;
+    mode: WorkspaceMode;
+    status: WorkspaceStatus;
+    metadata?: Record<string, unknown>;
+    created_at?: string;
+    updated_at?: string;
+}
+interface WorkspaceMessage {
+    id: string;
+    role: MessageRole;
+    content: string;
+    created_at?: string;
+    workspace_id?: string;
+}
+interface WorkspaceCreateParams {
+    initial_message?: string;
+    client_id?: string;
+    system_prompt?: string;
+    context?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+interface WorkspaceCreateResponse {
+    workspace: Workspace;
+    messages: WorkspaceMessage[];
+}
+interface SendMessageResponse {
+    user_message: WorkspaceMessage;
+    responses: WorkspaceMessage[];
+    mode: WorkspaceMode;
+    pending_approval?: boolean;
+}
+interface WorkspaceByClientResponse {
+    workspace: Workspace | null;
+    messages: WorkspaceMessage[];
+    exists: boolean;
+}
+interface Model {
+    id: string;
+    object: 'model';
+    owned_by: string;
+    created?: number;
+}
+interface ModelList {
+    object: 'list';
+    data: Model[];
+}
+interface LeadInfo {
+    leadId: string;
+    email: string;
+}
+interface AiAssistClientOptions {
+    apiKey: string;
+    baseURL?: string;
+    timeout?: number;
+    maxRetries?: number;
+    defaultHeaders?: Record<string, string>;
+}
+declare class AiAssistError extends Error {
+    status?: number;
+    code?: string;
+    constructor(message: string, status?: number, code?: string);
+}
+declare class AuthenticationError extends AiAssistError {
+    constructor(message?: string);
+}
+declare class RateLimitError extends AiAssistError {
+    retryAfter?: number;
+    constructor(message?: string, retryAfter?: number);
+}
+declare class APIError extends AiAssistError {
+    constructor(message: string, status?: number, code?: string);
+}
+
+/**
+ * AiAssist API Client
+ *
+ * Framework-agnostic TypeScript client for the AiAssist API.
+ * Works in Node.js and browsers.
+ *
+ * Full feature parity with React and Vanilla SDKs including:
+ * - Shadow mode support (pending_approval)
+ * - Human-in-the-loop mode detection
+ * - Typing preview
+ * - Conversation management
+ */
+
+declare class AiAssistClient {
+    private apiKey;
+    private baseURL;
+    private timeout;
+    private maxRetries;
+    private defaultHeaders;
+    chat: ChatAPI;
+    models: ModelsAPI;
+    workspaces: WorkspacesAPI;
+    constructor(options: AiAssistClientOptions);
+    private getHeaders;
+    request<T>(method: string, path: string, options?: {
+        body?: unknown;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    requestSilent(method: string, path: string, options?: {
+        body?: unknown;
+    }): Promise<void>;
+    stream(method: string, path: string, body: unknown): AsyncGenerator<ChatCompletionChunk, void, unknown>;
+    private sleep;
+}
+declare class ChatAPI {
+    completions: ChatCompletionsAPI;
+    constructor(client: AiAssistClient);
+}
+declare class ChatCompletionsAPI {
+    private client;
+    constructor(client: AiAssistClient);
+    create(params: ChatCompletionCreateParams & {
+        stream?: false;
+    }): Promise<ChatCompletion>;
+    create(params: ChatCompletionCreateParams & {
+        stream: true;
+    }): Promise<AsyncGenerator<ChatCompletionChunk, void, unknown>>;
+    create(params: ChatCompletionCreateParams): Promise<ChatCompletion | AsyncGenerator<ChatCompletionChunk, void, unknown>>;
+}
+declare class ModelsAPI {
+    private client;
+    constructor(client: AiAssistClient);
+    list(): Promise<Model[]>;
+}
+declare class WorkspacesAPI {
+    private client;
+    constructor(client: AiAssistClient);
+    /**
+     * Create a new workspace with optional system prompt and context.
+     *
+     * @param params - Workspace creation options
+     * @returns Workspace and initial messages
+     */
+    create(params?: WorkspaceCreateParams): Promise<WorkspaceCreateResponse>;
+    /**
+     * Get workspace by ID.
+     */
+    get(workspaceId: string): Promise<Workspace>;
+    /**
+     * Get workspace by client ID.
+     * Returns null if not found.
+     */
+    getByClientId(clientId: string): Promise<WorkspaceByClientResponse>;
+    /**
+     * Send a message to a workspace.
+     * Returns user message, AI/human responses, mode, and shadow mode approval status.
+     */
+    sendMessage(workspaceId: string, content: string): Promise<SendMessageResponse>;
+    /**
+     * Get all messages in a workspace.
+     */
+    getMessages(workspaceId: string): Promise<WorkspaceMessage[]>;
+    /**
+     * Send typing preview to workspace (for real-time typing indicators).
+     * Fails silently - non-critical operation.
+     */
+    sendTypingPreview(workspaceId: string, text: string): Promise<void>;
+    /**
+     * End a conversation/workspace.
+     * Fails silently - non-critical operation.
+     */
+    endConversation(workspaceId: string): Promise<void>;
+}
+
+export { APIError, AiAssistClient, type AiAssistClientOptions, AiAssistError, AuthenticationError, type ChatCompletion, type ChatCompletionChoice, type ChatCompletionChunk, type ChatCompletionChunkChoice, type ChatCompletionChunkDelta, type ChatCompletionCreateParams, type LeadInfo, type Message, type MessageRole, type Model, type ModelList, RateLimitError, type SendMessageResponse, type Usage, type Workspace, type WorkspaceByClientResponse, type WorkspaceCreateParams, type WorkspaceCreateResponse, type WorkspaceMessage, type WorkspaceMode, type WorkspaceStatus };

package/dist/index.js

@@ -0,0 +1,345 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  APIError: () => APIError,
+  AiAssistClient: () => AiAssistClient,
+  AiAssistError: () => AiAssistError,
+  AuthenticationError: () => AuthenticationError,
+  RateLimitError: () => RateLimitError
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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`, {});
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APIError,
+  AiAssistClient,
+  AiAssistError,
+  AuthenticationError,
+  RateLimitError
+});