@akumi/sdk 0.1.0

package/README.md

@@ -0,0 +1,87 @@
+# Akumi TypeScript SDK
+
+The official TypeScript client for [Akumi](https://akumi.cloud), the
+EU-sovereign, OpenAI-compatible inference API. Native `fetch`, zero runtime
+dependencies. One `base_url` for every model, governed and metered, with your
+regulated data kept in the EU.
+
+- **Drop-in OpenAI-compatible.** Chat completions, embeddings, and models under one key.
+- **EU-sovereign by default.** The egress guard fails closed on non-EU routing.
+- **Governed, not just hosted.** PII firewall, per-request residency, and a metadata-only audit trail on every call.
+- **Dependable.** Async streaming and automatic retries on transient errors.
+
+## Requirements
+
+Node 18 or newer.
+
+## Install
+
+```bash
+npm install @akumi/sdk
+```
+
+## Quickstart
+
+Create an API key under app.akumi.cloud -> Platform -> API keys:
+
+```ts
+import { Akumi } from "@akumi/sdk";
+
+const akumi = Akumi.fromApiKey("mk_...");
+
+const response = (await akumi.chat.create({
+  model: "mistral/mistral-large-latest",
+  messages: [{ role: "user", content: "Explain EU data residency in one sentence." }],
+})) as { choices: { message: { content: string } }[] };
+
+console.log(response.choices[0].message.content);
+```
+
+## Streaming
+
+`createStreamed()` yields OpenAI-compatible chunks:
+
+```ts
+for await (const chunk of akumi.chat.createStreamed({
+  model: "mistral/mistral-large-latest",
+  messages: [{ role: "user", content: "Write a haiku about Frankfurt." }],
+})) {
+  const c = chunk as { choices: { delta: { content?: string } }[] };
+  process.stdout.write(c.choices[0]?.delta?.content ?? "");
+}
+```
+
+## Embeddings
+
+```ts
+const embeddings = (await akumi.embeddings.create({
+  model: "mistral/mistral-embed",
+  input: "The quarterly report is ready for review.",
+})) as { data: { embedding: number[] }[] };
+
+const vector = embeddings.data[0].embedding;
+```
+
+## More resources
+
+- `akumi.models.list()` lists the models available to your key.
+- `akumi.memory.forget(...)` and `akumi.memoryThreads.list()` manage long-term memory and threads.
+- `akumi.auditLogs.list()` reads your metadata-only audit trail.
+
+## Configuration
+
+`fromApiKey()` targets `https://api.akumi.cloud/v1` and retries transient
+failures (429, 502, 503, 504). Pass a config object to override the base URL,
+timeout, or retry policy.
+
+## Documentation
+
+- Guides: https://akumi.cloud/docs
+- API reference: https://akumi.cloud/docs/api-reference
+
+## About
+
+Generated from the Akumi OpenAPI specification, so it tracks the API
+automatically. Issues: https://github.com/akumi-cloud/ts-sdk.
+
+MIT licensed.

package/dist/index.cjs

@@ -0,0 +1,377 @@
+"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, {
+  Akumi: () => Akumi,
+  AkumiError: () => AkumiError,
+  ApiError: () => ApiError,
+  AuditLogsResource: () => AuditLogsResource,
+  AuthenticationError: () => AuthenticationError,
+  ChatResource: () => ChatResource,
+  EmbeddingsResource: () => EmbeddingsResource,
+  InvalidRequestError: () => InvalidRequestError,
+  ModelsResource: () => ModelsResource,
+  RateLimitError: () => RateLimitError,
+  RecallResource: () => RecallResource
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var AkumiError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+var ApiError = class extends AkumiError {
+  status;
+  body;
+  constructor(message, status, body = {}) {
+    super(message);
+    this.status = status;
+    this.body = body;
+  }
+};
+var AuthenticationError = class extends ApiError {
+};
+var RateLimitError = class extends ApiError {
+};
+var InvalidRequestError = class extends ApiError {
+};
+function messageFor(status, body) {
+  const error = body.error;
+  if (error && typeof error === "object" && "message" in error) {
+    const message = error.message;
+    if (typeof message === "string") {
+      return message;
+    }
+  }
+  return `HTTP ${status}`;
+}
+function mapError(status, body) {
+  const message = messageFor(status, body);
+  if (status === 401 || status === 403) {
+    return new AuthenticationError(message, status, body);
+  }
+  if (status === 429) {
+    return new RateLimitError(message, status, body);
+  }
+  if (status >= 400 && status < 500) {
+    return new InvalidRequestError(message, status, body);
+  }
+  return new ApiError(message, status, body);
+}
+
+// src/streaming/sse.ts
+var DONE_SENTINEL = "[DONE]";
+function parseSseChunk(buffer, onEvent) {
+  let rest = buffer;
+  let newlineIndex = rest.indexOf("\n");
+  while (newlineIndex !== -1) {
+    const line = rest.slice(0, newlineIndex).replace(/\r$/, "");
+    rest = rest.slice(newlineIndex + 1);
+    const event = parseSseLine(line);
+    if (event !== null) {
+      onEvent(event);
+    }
+    newlineIndex = rest.indexOf("\n");
+  }
+  return rest;
+}
+function parseSseLine(line) {
+  if (!line.startsWith("data:")) {
+    return null;
+  }
+  const data = line.slice(5).trim();
+  if (data === "" || data === DONE_SENTINEL) {
+    return null;
+  }
+  return JSON.parse(data);
+}
+
+// src/client/config.ts
+function resolveConfig(config) {
+  return {
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl ?? "https://api.akumi.cloud/v1",
+    maxRetries: config.maxRetries ?? 2,
+    retryOn: config.retryOn ?? [429, 500, 502, 503, 504]
+  };
+}
+
+// src/client/transport.ts
+var Transport = class {
+  config;
+  constructor(config) {
+    this.config = resolveConfig(config);
+  }
+  async request(method, path, query, body) {
+    const response = await this.dispatch(method, path, query, body, false);
+    const text = await response.text();
+    if (text === "") {
+      return {};
+    }
+    const decoded = JSON.parse(text);
+    return typeof decoded === "object" && decoded !== null ? decoded : {};
+  }
+  async *stream(method, path, body) {
+    const response = await this.dispatch(method, path, null, body, true);
+    const stream = response.body;
+    if (stream === null) {
+      return;
+    }
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    const events = [];
+    let buffer = "";
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        buffer = parseSseChunk(buffer, (event2) => events.push(event2));
+        while (events.length > 0) {
+          yield events.shift();
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    const event = parseSseLine(buffer.replace(/\r$/, ""));
+    if (event !== null) {
+      yield event;
+    }
+  }
+  async dispatch(method, path, query, body, stream) {
+    let url = this.config.baseUrl.replace(/\/$/, "") + path;
+    if (query !== null) {
+      const search = new URLSearchParams();
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== null && value !== void 0) {
+          search.append(key, String(value));
+        }
+      }
+      const queryString = search.toString();
+      if (queryString !== "") {
+        url += `?${queryString}`;
+      }
+    }
+    const headers = {
+      Authorization: `Bearer ${this.config.apiKey}`,
+      Accept: stream ? "text/event-stream" : "application/json"
+    };
+    const init = { method, headers };
+    if (body !== null) {
+      headers["Content-Type"] = "application/json";
+      init.body = JSON.stringify(body);
+    }
+    let attempt = 0;
+    for (; ; ) {
+      const response = await fetch(url, init);
+      if (response.status < 400) {
+        return response;
+      }
+      const shouldRetry = attempt < this.config.maxRetries && this.config.retryOn.includes(response.status);
+      if (shouldRetry) {
+        attempt += 1;
+        await delay(250 * 2 ** (attempt - 1));
+        continue;
+      }
+      const text = await response.text();
+      let parsed = {};
+      if (text !== "") {
+        const decoded = safeJsonParse(text);
+        if (typeof decoded === "object" && decoded !== null) {
+          parsed = decoded;
+        }
+      }
+      throw mapError(response.status, parsed);
+    }
+  }
+};
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function safeJsonParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+// src/resources/recall.ts
+var RecallResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async listThreads(query = {}) {
+    return this.transport.request("GET", "/recall/threads", query, null);
+  }
+  async createThread() {
+    return this.transport.request("POST", "/recall/threads", null, null);
+  }
+  async getThread(thread) {
+    return this.transport.request("GET", `/recall/threads/${thread}`, null, null);
+  }
+  async deleteThread(thread) {
+    return this.transport.request("DELETE", `/recall/threads/${thread}`, null, null);
+  }
+  async search(params = {}) {
+    return this.transport.request("POST", "/recall/search", null, params);
+  }
+  async searchFacts(params = {}) {
+    return this.transport.request("POST", "/recall/facts/search", null, params);
+  }
+  async listFacts(query = {}) {
+    return this.transport.request("GET", "/recall/facts", query, null);
+  }
+  async rememberFact(params = {}) {
+    return this.transport.request("POST", "/recall/facts", null, params);
+  }
+  async forgetFact(id) {
+    return this.transport.request("DELETE", `/recall/facts/${id}`, null, null);
+  }
+  async export(query = {}) {
+    return this.transport.request("GET", "/recall/export", query, null);
+  }
+  async erase() {
+    return this.transport.request("DELETE", "/recall", null, null);
+  }
+  async searchDocuments(params = {}) {
+    return this.transport.request("POST", "/recall/documents/search", null, params);
+  }
+  async listDocuments(query = {}) {
+    return this.transport.request("GET", "/recall/documents", query, null);
+  }
+  async ingestDocument(params = {}) {
+    return this.transport.request("POST", "/recall/documents", null, params);
+  }
+  async getDocument(document) {
+    return this.transport.request("GET", `/recall/documents/${document}`, null, null);
+  }
+  async deleteDocument(document) {
+    return this.transport.request("DELETE", `/recall/documents/${document}`, null, null);
+  }
+  async listCollections(query = {}) {
+    return this.transport.request("GET", "/recall/collections", query, null);
+  }
+  async createCollection(params = {}) {
+    return this.transport.request("POST", "/recall/collections", null, params);
+  }
+  async getCollection(slug) {
+    return this.transport.request("GET", `/recall/collections/${slug}`, null, null);
+  }
+  async deleteCollection(slug) {
+    return this.transport.request("DELETE", `/recall/collections/${slug}`, null, null);
+  }
+  async updateCollection(slug, params = {}) {
+    return this.transport.request("PATCH", `/recall/collections/${slug}`, null, params);
+  }
+};
+
+// src/resources/auditLogs.ts
+var AuditLogsResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async list(query = {}) {
+    return this.transport.request("GET", "/audit-logs", query, null);
+  }
+  async get(uuid) {
+    return this.transport.request("GET", `/audit-logs/${uuid}`, null, null);
+  }
+};
+
+// src/resources/chat.ts
+var ChatResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async create(params = {}) {
+    return this.transport.request("POST", "/chat/completions", null, params);
+  }
+  async *createStreamed(params = {}) {
+    yield* this.transport.stream("POST", "/chat/completions", params);
+  }
+};
+
+// src/resources/embeddings.ts
+var EmbeddingsResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async create(params = {}) {
+    return this.transport.request("POST", "/embeddings", null, params);
+  }
+};
+
+// src/resources/models.ts
+var ModelsResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async list() {
+    return this.transport.request("GET", "/models", null, null);
+  }
+};
+
+// src/client.ts
+var Akumi = class _Akumi {
+  transport;
+  recall;
+  auditLogs;
+  chat;
+  embeddings;
+  models;
+  constructor(config) {
+    this.transport = new Transport(config);
+    this.recall = new RecallResource(this.transport);
+    this.auditLogs = new AuditLogsResource(this.transport);
+    this.chat = new ChatResource(this.transport);
+    this.embeddings = new EmbeddingsResource(this.transport);
+    this.models = new ModelsResource(this.transport);
+  }
+  static fromApiKey(apiKey) {
+    return new _Akumi({ apiKey });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Akumi,
+  AkumiError,
+  ApiError,
+  AuditLogsResource,
+  AuthenticationError,
+  ChatResource,
+  EmbeddingsResource,
+  InvalidRequestError,
+  ModelsResource,
+  RateLimitError,
+  RecallResource
+});

package/dist/index.d.cts

@@ -0,0 +1,187 @@
+interface ClientConfig {
+    apiKey: string;
+    baseUrl?: string;
+    maxRetries?: number;
+    retryOn?: number[];
+}
+
+/**
+ * Builds and sends HTTP requests for the SDK: bearer auth, JSON encoding,
+ * status-to-error mapping, retries with backoff, and incremental SSE reads.
+ * The API key is sent only on the Authorization header and never logged.
+ */
+declare class Transport {
+    private readonly config;
+    constructor(config: ClientConfig);
+    request(method: string, path: string, query: Record<string, unknown> | null, body: Record<string, unknown> | null): Promise<Record<string, unknown>>;
+    stream(method: string, path: string, body: Record<string, unknown> | null): AsyncGenerator<Record<string, unknown>>;
+    private dispatch;
+}
+
+declare class RecallResource {
+    private readonly transport;
+    constructor(transport: Transport);
+    listThreads(query?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    createThread(): Promise<Record<string, unknown>>;
+    getThread(thread: string): Promise<Record<string, unknown>>;
+    deleteThread(thread: string): Promise<Record<string, unknown>>;
+    search(params?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    searchFacts(params?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    listFacts(query?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    rememberFact(params?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    forgetFact(id: string): Promise<Record<string, unknown>>;
+    export(query?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    erase(): Promise<Record<string, unknown>>;
+    searchDocuments(params?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    listDocuments(query?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    ingestDocument(params?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    getDocument(document: string): Promise<Record<string, unknown>>;
+    deleteDocument(document: string): Promise<Record<string, unknown>>;
+    listCollections(query?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    createCollection(params?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    getCollection(slug: string): Promise<Record<string, unknown>>;
+    deleteCollection(slug: string): Promise<Record<string, unknown>>;
+    updateCollection(slug: string, params?: Record<string, unknown>): Promise<Record<string, unknown>>;
+}
+
+declare class AuditLogsResource {
+    private readonly transport;
+    constructor(transport: Transport);
+    list(query?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    get(uuid: string): Promise<Record<string, unknown>>;
+}
+
+declare class ChatResource {
+    private readonly transport;
+    constructor(transport: Transport);
+    create(params?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    createStreamed(params?: Record<string, unknown>): AsyncGenerator<Record<string, unknown>>;
+}
+
+declare class EmbeddingsResource {
+    private readonly transport;
+    constructor(transport: Transport);
+    create(params?: Record<string, unknown>): Promise<Record<string, unknown>>;
+}
+
+declare class ModelsResource {
+    private readonly transport;
+    constructor(transport: Transport);
+    list(): Promise<Record<string, unknown>>;
+}
+
+declare class Akumi {
+    private readonly transport;
+    readonly recall: RecallResource;
+    readonly auditLogs: AuditLogsResource;
+    readonly chat: ChatResource;
+    readonly embeddings: EmbeddingsResource;
+    readonly models: ModelsResource;
+    constructor(config: ClientConfig);
+    static fromApiKey(apiKey: string): Akumi;
+}
+
+declare class AkumiError extends Error {
+    constructor(message: string);
+}
+declare class ApiError extends AkumiError {
+    readonly status: number;
+    readonly body: Record<string, unknown>;
+    constructor(message: string, status: number, body?: Record<string, unknown>);
+}
+declare class AuthenticationError extends ApiError {
+}
+declare class RateLimitError extends ApiError {
+}
+declare class InvalidRequestError extends ApiError {
+}
+
+interface AuditLogApiResource {
+    id: string;
+    component: string;
+    action: string;
+    actorId: number | null;
+    ipAddress: string | null;
+    userAgent: string | null;
+    target: unknown | null;
+    metadata: unknown[] | null;
+    createdAt: string;
+}
+
+interface ChatCompletionsRequest {
+    model: string;
+    messages: unknown[];
+    temperature?: number | null;
+    max_tokens?: number | null;
+    stream?: boolean | null;
+    firewall?: boolean | null;
+    rag?: string | null;
+    user?: string | null;
+    thread?: string | null;
+    top_p?: number | null;
+    presence_penalty?: number | null;
+    frequency_penalty?: number | null;
+    n?: number | null;
+    seed?: number | null;
+    logprobs?: boolean | null;
+    top_logprobs?: number | null;
+    max_completion_tokens?: number | null;
+    tool_choice?: string | null;
+    parallel_tool_calls?: boolean | null;
+    cache?: boolean | null;
+    stop?: string[] | null;
+    logit_bias?: number[] | null;
+    response_format?: unknown;
+    tools?: unknown[] | null;
+}
+
+interface EmbeddingsRequest {
+    model: string;
+    input: string[];
+    encoding_format?: string | null;
+    dimensions?: number | null;
+    user?: string | null;
+}
+
+interface IngestDocumentRequest {
+    title: string;
+    text: string;
+    source?: string | null;
+    collection?: string | null;
+}
+
+interface RememberFactRequest {
+    content: string;
+    user_ref: string;
+}
+
+interface SearchDocumentsRequest {
+    query: string;
+    collection: string;
+    user_ref?: string | null;
+    limit?: number | null;
+}
+
+interface SearchFactsRequest {
+    query: string;
+    user_ref?: string | null;
+    limit?: number | null;
+}
+
+interface SearchRequest {
+    query: string;
+    user_ref?: string | null;
+    limit?: number | null;
+}
+
+interface StoreCollectionRequest {
+    name: string;
+}
+
+interface ThreadMessageViewModel {
+}
+
+interface ThreadViewModel {
+}
+
+export { Akumi, AkumiError, ApiError, type AuditLogApiResource, AuditLogsResource, AuthenticationError, type ChatCompletionsRequest, ChatResource, type ClientConfig, type EmbeddingsRequest, EmbeddingsResource, type IngestDocumentRequest, InvalidRequestError, ModelsResource, RateLimitError, RecallResource, type RememberFactRequest, type SearchDocumentsRequest, type SearchFactsRequest, type SearchRequest, type StoreCollectionRequest, type ThreadMessageViewModel, type ThreadViewModel };

package/dist/index.d.ts

@@ -0,0 +1,187 @@
+interface ClientConfig {
+    apiKey: string;
+    baseUrl?: string;
+    maxRetries?: number;
+    retryOn?: number[];
+}
+
+/**
+ * Builds and sends HTTP requests for the SDK: bearer auth, JSON encoding,
+ * status-to-error mapping, retries with backoff, and incremental SSE reads.
+ * The API key is sent only on the Authorization header and never logged.
+ */
+declare class Transport {
+    private readonly config;
+    constructor(config: ClientConfig);
+    request(method: string, path: string, query: Record<string, unknown> | null, body: Record<string, unknown> | null): Promise<Record<string, unknown>>;
+    stream(method: string, path: string, body: Record<string, unknown> | null): AsyncGenerator<Record<string, unknown>>;
+    private dispatch;
+}
+
+declare class RecallResource {
+    private readonly transport;
+    constructor(transport: Transport);
+    listThreads(query?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    createThread(): Promise<Record<string, unknown>>;
+    getThread(thread: string): Promise<Record<string, unknown>>;
+    deleteThread(thread: string): Promise<Record<string, unknown>>;
+    search(params?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    searchFacts(params?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    listFacts(query?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    rememberFact(params?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    forgetFact(id: string): Promise<Record<string, unknown>>;
+    export(query?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    erase(): Promise<Record<string, unknown>>;
+    searchDocuments(params?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    listDocuments(query?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    ingestDocument(params?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    getDocument(document: string): Promise<Record<string, unknown>>;
+    deleteDocument(document: string): Promise<Record<string, unknown>>;
+    listCollections(query?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    createCollection(params?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    getCollection(slug: string): Promise<Record<string, unknown>>;
+    deleteCollection(slug: string): Promise<Record<string, unknown>>;
+    updateCollection(slug: string, params?: Record<string, unknown>): Promise<Record<string, unknown>>;
+}
+
+declare class AuditLogsResource {
+    private readonly transport;
+    constructor(transport: Transport);
+    list(query?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    get(uuid: string): Promise<Record<string, unknown>>;
+}
+
+declare class ChatResource {
+    private readonly transport;
+    constructor(transport: Transport);
+    create(params?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    createStreamed(params?: Record<string, unknown>): AsyncGenerator<Record<string, unknown>>;
+}
+
+declare class EmbeddingsResource {
+    private readonly transport;
+    constructor(transport: Transport);
+    create(params?: Record<string, unknown>): Promise<Record<string, unknown>>;
+}
+
+declare class ModelsResource {
+    private readonly transport;
+    constructor(transport: Transport);
+    list(): Promise<Record<string, unknown>>;
+}
+
+declare class Akumi {
+    private readonly transport;
+    readonly recall: RecallResource;
+    readonly auditLogs: AuditLogsResource;
+    readonly chat: ChatResource;
+    readonly embeddings: EmbeddingsResource;
+    readonly models: ModelsResource;
+    constructor(config: ClientConfig);
+    static fromApiKey(apiKey: string): Akumi;
+}
+
+declare class AkumiError extends Error {
+    constructor(message: string);
+}
+declare class ApiError extends AkumiError {
+    readonly status: number;
+    readonly body: Record<string, unknown>;
+    constructor(message: string, status: number, body?: Record<string, unknown>);
+}
+declare class AuthenticationError extends ApiError {
+}
+declare class RateLimitError extends ApiError {
+}
+declare class InvalidRequestError extends ApiError {
+}
+
+interface AuditLogApiResource {
+    id: string;
+    component: string;
+    action: string;
+    actorId: number | null;
+    ipAddress: string | null;
+    userAgent: string | null;
+    target: unknown | null;
+    metadata: unknown[] | null;
+    createdAt: string;
+}
+
+interface ChatCompletionsRequest {
+    model: string;
+    messages: unknown[];
+    temperature?: number | null;
+    max_tokens?: number | null;
+    stream?: boolean | null;
+    firewall?: boolean | null;
+    rag?: string | null;
+    user?: string | null;
+    thread?: string | null;
+    top_p?: number | null;
+    presence_penalty?: number | null;
+    frequency_penalty?: number | null;
+    n?: number | null;
+    seed?: number | null;
+    logprobs?: boolean | null;
+    top_logprobs?: number | null;
+    max_completion_tokens?: number | null;
+    tool_choice?: string | null;
+    parallel_tool_calls?: boolean | null;
+    cache?: boolean | null;
+    stop?: string[] | null;
+    logit_bias?: number[] | null;
+    response_format?: unknown;
+    tools?: unknown[] | null;
+}
+
+interface EmbeddingsRequest {
+    model: string;
+    input: string[];
+    encoding_format?: string | null;
+    dimensions?: number | null;
+    user?: string | null;
+}
+
+interface IngestDocumentRequest {
+    title: string;
+    text: string;
+    source?: string | null;
+    collection?: string | null;
+}
+
+interface RememberFactRequest {
+    content: string;
+    user_ref: string;
+}
+
+interface SearchDocumentsRequest {
+    query: string;
+    collection: string;
+    user_ref?: string | null;
+    limit?: number | null;
+}
+
+interface SearchFactsRequest {
+    query: string;
+    user_ref?: string | null;
+    limit?: number | null;
+}
+
+interface SearchRequest {
+    query: string;
+    user_ref?: string | null;
+    limit?: number | null;
+}
+
+interface StoreCollectionRequest {
+    name: string;
+}
+
+interface ThreadMessageViewModel {
+}
+
+interface ThreadViewModel {
+}
+
+export { Akumi, AkumiError, ApiError, type AuditLogApiResource, AuditLogsResource, AuthenticationError, type ChatCompletionsRequest, ChatResource, type ClientConfig, type EmbeddingsRequest, EmbeddingsResource, type IngestDocumentRequest, InvalidRequestError, ModelsResource, RateLimitError, RecallResource, type RememberFactRequest, type SearchDocumentsRequest, type SearchFactsRequest, type SearchRequest, type StoreCollectionRequest, type ThreadMessageViewModel, type ThreadViewModel };

package/dist/index.js

@@ -0,0 +1,340 @@
+// src/errors.ts
+var AkumiError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+var ApiError = class extends AkumiError {
+  status;
+  body;
+  constructor(message, status, body = {}) {
+    super(message);
+    this.status = status;
+    this.body = body;
+  }
+};
+var AuthenticationError = class extends ApiError {
+};
+var RateLimitError = class extends ApiError {
+};
+var InvalidRequestError = class extends ApiError {
+};
+function messageFor(status, body) {
+  const error = body.error;
+  if (error && typeof error === "object" && "message" in error) {
+    const message = error.message;
+    if (typeof message === "string") {
+      return message;
+    }
+  }
+  return `HTTP ${status}`;
+}
+function mapError(status, body) {
+  const message = messageFor(status, body);
+  if (status === 401 || status === 403) {
+    return new AuthenticationError(message, status, body);
+  }
+  if (status === 429) {
+    return new RateLimitError(message, status, body);
+  }
+  if (status >= 400 && status < 500) {
+    return new InvalidRequestError(message, status, body);
+  }
+  return new ApiError(message, status, body);
+}
+
+// src/streaming/sse.ts
+var DONE_SENTINEL = "[DONE]";
+function parseSseChunk(buffer, onEvent) {
+  let rest = buffer;
+  let newlineIndex = rest.indexOf("\n");
+  while (newlineIndex !== -1) {
+    const line = rest.slice(0, newlineIndex).replace(/\r$/, "");
+    rest = rest.slice(newlineIndex + 1);
+    const event = parseSseLine(line);
+    if (event !== null) {
+      onEvent(event);
+    }
+    newlineIndex = rest.indexOf("\n");
+  }
+  return rest;
+}
+function parseSseLine(line) {
+  if (!line.startsWith("data:")) {
+    return null;
+  }
+  const data = line.slice(5).trim();
+  if (data === "" || data === DONE_SENTINEL) {
+    return null;
+  }
+  return JSON.parse(data);
+}
+
+// src/client/config.ts
+function resolveConfig(config) {
+  return {
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl ?? "https://api.akumi.cloud/v1",
+    maxRetries: config.maxRetries ?? 2,
+    retryOn: config.retryOn ?? [429, 500, 502, 503, 504]
+  };
+}
+
+// src/client/transport.ts
+var Transport = class {
+  config;
+  constructor(config) {
+    this.config = resolveConfig(config);
+  }
+  async request(method, path, query, body) {
+    const response = await this.dispatch(method, path, query, body, false);
+    const text = await response.text();
+    if (text === "") {
+      return {};
+    }
+    const decoded = JSON.parse(text);
+    return typeof decoded === "object" && decoded !== null ? decoded : {};
+  }
+  async *stream(method, path, body) {
+    const response = await this.dispatch(method, path, null, body, true);
+    const stream = response.body;
+    if (stream === null) {
+      return;
+    }
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    const events = [];
+    let buffer = "";
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        buffer = parseSseChunk(buffer, (event2) => events.push(event2));
+        while (events.length > 0) {
+          yield events.shift();
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    const event = parseSseLine(buffer.replace(/\r$/, ""));
+    if (event !== null) {
+      yield event;
+    }
+  }
+  async dispatch(method, path, query, body, stream) {
+    let url = this.config.baseUrl.replace(/\/$/, "") + path;
+    if (query !== null) {
+      const search = new URLSearchParams();
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== null && value !== void 0) {
+          search.append(key, String(value));
+        }
+      }
+      const queryString = search.toString();
+      if (queryString !== "") {
+        url += `?${queryString}`;
+      }
+    }
+    const headers = {
+      Authorization: `Bearer ${this.config.apiKey}`,
+      Accept: stream ? "text/event-stream" : "application/json"
+    };
+    const init = { method, headers };
+    if (body !== null) {
+      headers["Content-Type"] = "application/json";
+      init.body = JSON.stringify(body);
+    }
+    let attempt = 0;
+    for (; ; ) {
+      const response = await fetch(url, init);
+      if (response.status < 400) {
+        return response;
+      }
+      const shouldRetry = attempt < this.config.maxRetries && this.config.retryOn.includes(response.status);
+      if (shouldRetry) {
+        attempt += 1;
+        await delay(250 * 2 ** (attempt - 1));
+        continue;
+      }
+      const text = await response.text();
+      let parsed = {};
+      if (text !== "") {
+        const decoded = safeJsonParse(text);
+        if (typeof decoded === "object" && decoded !== null) {
+          parsed = decoded;
+        }
+      }
+      throw mapError(response.status, parsed);
+    }
+  }
+};
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function safeJsonParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+// src/resources/recall.ts
+var RecallResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async listThreads(query = {}) {
+    return this.transport.request("GET", "/recall/threads", query, null);
+  }
+  async createThread() {
+    return this.transport.request("POST", "/recall/threads", null, null);
+  }
+  async getThread(thread) {
+    return this.transport.request("GET", `/recall/threads/${thread}`, null, null);
+  }
+  async deleteThread(thread) {
+    return this.transport.request("DELETE", `/recall/threads/${thread}`, null, null);
+  }
+  async search(params = {}) {
+    return this.transport.request("POST", "/recall/search", null, params);
+  }
+  async searchFacts(params = {}) {
+    return this.transport.request("POST", "/recall/facts/search", null, params);
+  }
+  async listFacts(query = {}) {
+    return this.transport.request("GET", "/recall/facts", query, null);
+  }
+  async rememberFact(params = {}) {
+    return this.transport.request("POST", "/recall/facts", null, params);
+  }
+  async forgetFact(id) {
+    return this.transport.request("DELETE", `/recall/facts/${id}`, null, null);
+  }
+  async export(query = {}) {
+    return this.transport.request("GET", "/recall/export", query, null);
+  }
+  async erase() {
+    return this.transport.request("DELETE", "/recall", null, null);
+  }
+  async searchDocuments(params = {}) {
+    return this.transport.request("POST", "/recall/documents/search", null, params);
+  }
+  async listDocuments(query = {}) {
+    return this.transport.request("GET", "/recall/documents", query, null);
+  }
+  async ingestDocument(params = {}) {
+    return this.transport.request("POST", "/recall/documents", null, params);
+  }
+  async getDocument(document) {
+    return this.transport.request("GET", `/recall/documents/${document}`, null, null);
+  }
+  async deleteDocument(document) {
+    return this.transport.request("DELETE", `/recall/documents/${document}`, null, null);
+  }
+  async listCollections(query = {}) {
+    return this.transport.request("GET", "/recall/collections", query, null);
+  }
+  async createCollection(params = {}) {
+    return this.transport.request("POST", "/recall/collections", null, params);
+  }
+  async getCollection(slug) {
+    return this.transport.request("GET", `/recall/collections/${slug}`, null, null);
+  }
+  async deleteCollection(slug) {
+    return this.transport.request("DELETE", `/recall/collections/${slug}`, null, null);
+  }
+  async updateCollection(slug, params = {}) {
+    return this.transport.request("PATCH", `/recall/collections/${slug}`, null, params);
+  }
+};
+
+// src/resources/auditLogs.ts
+var AuditLogsResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async list(query = {}) {
+    return this.transport.request("GET", "/audit-logs", query, null);
+  }
+  async get(uuid) {
+    return this.transport.request("GET", `/audit-logs/${uuid}`, null, null);
+  }
+};
+
+// src/resources/chat.ts
+var ChatResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async create(params = {}) {
+    return this.transport.request("POST", "/chat/completions", null, params);
+  }
+  async *createStreamed(params = {}) {
+    yield* this.transport.stream("POST", "/chat/completions", params);
+  }
+};
+
+// src/resources/embeddings.ts
+var EmbeddingsResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async create(params = {}) {
+    return this.transport.request("POST", "/embeddings", null, params);
+  }
+};
+
+// src/resources/models.ts
+var ModelsResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async list() {
+    return this.transport.request("GET", "/models", null, null);
+  }
+};
+
+// src/client.ts
+var Akumi = class _Akumi {
+  transport;
+  recall;
+  auditLogs;
+  chat;
+  embeddings;
+  models;
+  constructor(config) {
+    this.transport = new Transport(config);
+    this.recall = new RecallResource(this.transport);
+    this.auditLogs = new AuditLogsResource(this.transport);
+    this.chat = new ChatResource(this.transport);
+    this.embeddings = new EmbeddingsResource(this.transport);
+    this.models = new ModelsResource(this.transport);
+  }
+  static fromApiKey(apiKey) {
+    return new _Akumi({ apiKey });
+  }
+};
+export {
+  Akumi,
+  AkumiError,
+  ApiError,
+  AuditLogsResource,
+  AuthenticationError,
+  ChatResource,
+  EmbeddingsResource,
+  InvalidRequestError,
+  ModelsResource,
+  RateLimitError,
+  RecallResource
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@akumi/sdk",
+  "version": "0.1.0",
+  "description": "Official TypeScript SDK for the Akumi EU-sovereign inference API.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}