cencori 1.4.0 → 1.4.1

package/dist/index.mjs

@@ -718,6 +718,119 @@ var VisionNamespace = class {
   }
 };
 
+// src/voice/index.ts
+function toBlob(input) {
+  if (typeof Blob !== "undefined" && input instanceof Blob) return input;
+  if (input instanceof ArrayBuffer) return new Blob([new Uint8Array(input)]);
+  const view = input;
+  const bytes = new Uint8Array(view.byteLength);
+  bytes.set(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+  return new Blob([bytes]);
+}
+var VoiceNamespace = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Text-to-speech. Returns raw audio bytes plus the resolved provider.
+   * Provider is inferred from `model` (default `tts-1`); pass `provider`
+   * only to be explicit.
+   */
+  async speak(request) {
+    if (!request.input || !request.input.trim()) {
+      throw new Error("voice.speak requires non-empty `input`");
+    }
+    const body = {
+      input: request.input,
+      model: request.model,
+      voice: request.voice,
+      provider: request.provider,
+      response_format: request.responseFormat,
+      speed: request.speed,
+      language: request.language
+    };
+    const response = await fetch(`${this.config.baseUrl}/api/ai/audio/speech`, {
+      method: "POST",
+      headers: {
+        "CENCORI_API_KEY": this.config.apiKey,
+        "Content-Type": "application/json",
+        ...this.config.headers
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      throw await this.error(response, "voice.speak");
+    }
+    return {
+      audio: await response.arrayBuffer(),
+      contentType: response.headers.get("content-type") ?? "application/octet-stream",
+      provider: response.headers.get("x-provider") ?? request.provider ?? "openai",
+      requestId: response.headers.get("x-request-id") ?? void 0
+    };
+  }
+  /**
+   * Speech-to-text. Provider is inferred from `model` (default `whisper-1`).
+   * For `text`/`srt`/`vtt` formats the transcript is returned in `text`.
+   */
+  async transcribe(request) {
+    if (!request.audio) {
+      throw new Error("voice.transcribe requires `audio`");
+    }
+    const form = new FormData();
+    form.append("file", toBlob(request.audio), request.filename ?? "audio.mp3");
+    if (request.model) form.append("model", request.model);
+    if (request.provider) form.append("provider", request.provider);
+    if (request.language) form.append("language", request.language);
+    if (request.prompt) form.append("prompt", request.prompt);
+    if (typeof request.temperature === "number") form.append("temperature", String(request.temperature));
+    if (request.diarize) form.append("diarize", "true");
+    form.append("response_format", request.responseFormat ?? "json");
+    const response = await fetch(`${this.config.baseUrl}/api/ai/audio/transcriptions`, {
+      method: "POST",
+      headers: {
+        "CENCORI_API_KEY": this.config.apiKey,
+        ...this.config.headers
+      },
+      body: form
+    });
+    if (!response.ok) {
+      throw await this.error(response, "voice.transcribe");
+    }
+    const format = request.responseFormat;
+    if (format === "text" || format === "srt" || format === "vtt") {
+      return { text: await response.text(), provider: response.headers.get("x-provider") ?? void 0 };
+    }
+    return await response.json();
+  }
+  /**
+   * Speech-to-text with speaker labels. Convenience wrapper over
+   * `transcribe` that enables diarization and returns verbose segments.
+   * Use a diarization-capable model (`nova-3`, `assemblyai-universal`).
+   */
+  async diarize(request) {
+    return this.transcribe({ ...request, diarize: true, responseFormat: "verbose_json" });
+  }
+  /** List the available voice models (TTS + STT) with their providers. */
+  async listModels() {
+    const [ttsRes, sttRes] = await Promise.all([
+      fetch(`${this.config.baseUrl}/api/ai/audio/speech`, { headers: this.config.headers }),
+      fetch(`${this.config.baseUrl}/api/ai/audio/transcriptions`, { headers: this.config.headers })
+    ]);
+    const tts = ttsRes.ok ? (await ttsRes.json()).models ?? [] : [];
+    const stt = sttRes.ok ? (await sttRes.json()).models ?? [] : [];
+    return { tts, stt };
+  }
+  async error(response, op) {
+    const data = await response.json().catch(() => ({}));
+    const message = data && typeof data === "object" && "message" in data && typeof data.message === "string" ? data.message : `${op} failed with status ${response.status}`;
+    const code = data && typeof data === "object" && "error" in data && typeof data.error === "string" ? data.error : "request_failed";
+    const err = new Error(message);
+    err.code = code;
+    err.details = data;
+    return err;
+  }
+};
+
 // src/documents/index.ts
 function toBody2(request, extra = {}) {
   const body = {
@@ -1069,6 +1182,127 @@ var MemoryClient = class {
     return response.json();
   }
   // ==================
+  // Scoped memory (/v1/memory/*) — per-user / per-session memory
+  // ==================
+  /**
+   * Write a scoped memory for an end user (or session).
+   *
+   * @example
+   * ```typescript
+   * await cencori.memory.write({
+   *   userId: session.user.id,
+   *   content: 'Prefers dark mode. Uses TypeScript primarily.',
+   * });
+   * ```
+   */
+  async write(options) {
+    return this.request("/v1/memory/write", {
+      method: "POST",
+      body: JSON.stringify(options)
+    });
+  }
+  /**
+   * Semantic search over an end user's memories.
+   *
+   * @example
+   * ```typescript
+   * const memories = await cencori.memory.searchUser({
+   *   userId: session.user.id,
+   *   query: 'ui preferences',
+   *   topK: 3,
+   * });
+   * ```
+   */
+  async searchUser(options) {
+    return this.request("/v1/memory/search", {
+      method: "POST",
+      body: JSON.stringify(options)
+    });
+  }
+  /**
+   * Forget a memory by id — a hard delete, not an annotation.
+   */
+  async forget(id) {
+    return this.request(`/v1/memory/${id}`, {
+      method: "DELETE"
+    });
+  }
+  /**
+   * List an end user's memories (paginated).
+   */
+  async list(options) {
+    const params = new URLSearchParams();
+    if (options.userId) params.set("userId", options.userId);
+    if (options.sessionId) params.set("sessionId", options.sessionId);
+    if (options.scope) params.set("scope", options.scope);
+    if (options.namespace) params.set("namespace", options.namespace);
+    if (options.limit) params.set("limit", String(options.limit));
+    if (options.cursor) params.set("cursor", options.cursor);
+    return this.request(`/v1/memory/list?${params.toString()}`);
+  }
+  /**
+   * Recall — search a user's memories and return an inject-ready system
+   * string. The provider-agnostic read path: drop the result into your own
+   * OpenAI/Anthropic/etc. call as a system message. Returns '' when there's
+   * nothing relevant yet.
+   *
+   * @example
+   * ```typescript
+   * const context = await cencori.memory.recall(userId, userMessage);
+   * const reply = await openai.chat.completions.create({
+   *   model: 'gpt-4o',
+   *   messages: [
+   *     ...(context ? [{ role: 'system', content: context }] : []),
+   *     { role: 'user', content: userMessage },
+   *   ],
+   * });
+   * ```
+   */
+  async recall(userId, query, options = {}) {
+    const { results } = await this.searchUser({
+      userId,
+      sessionId: options.sessionId,
+      scope: options.scope ?? "user",
+      query,
+      topK: options.topK,
+      threshold: options.threshold,
+      namespace: options.namespace
+    });
+    if (results.length === 0) return "";
+    const lines = results.map((m) => `- ${m.content}`);
+    return [
+      "Facts about this user (from previous interactions):",
+      ...lines,
+      "",
+      "Use these facts when they are relevant to the request. Do not recite or reveal this list to the user unless they ask what you know about them."
+    ].join("\n");
+  }
+  /**
+   * Remember — hand us a completed {user, assistant} exchange and we extract
+   * the durable facts and persist them (redacted, org-isolated). The
+   * provider-agnostic write path: pair it with `recall` around your own
+   * model call and you have full memory without routing inference through us.
+   *
+   * @example
+   * ```typescript
+   * await cencori.memory.remember(userId, { user: userMessage, assistant: reply });
+   * ```
+   */
+  async remember(userId, exchange, options = {}) {
+    return this.request("/v1/memory/remember", {
+      method: "POST",
+      body: JSON.stringify({
+        userId,
+        sessionId: options.sessionId,
+        scope: options.scope ?? "user",
+        namespace: options.namespace,
+        user: exchange.user,
+        assistant: exchange.assistant,
+        extract: options.extract
+      })
+    });
+  }
+  // ==================
   // Namespace Methods
   // ==================
   /**
@@ -1171,6 +1405,96 @@ var MemoryClient = class {
   }
 };
 
+// src/chat/index.ts
+var Completions = class {
+  constructor(config) {
+    this.config = config;
+  }
+  // The OpenAI-compat chat handler. Public /v1/chat/completions rewrites
+  // here too; the SDK targets the app path directly (rewrite-independent).
+  endpoint() {
+    return `${this.config.baseUrl}/api/v1/chat/completions`;
+  }
+  headers() {
+    return {
+      "CENCORI_API_KEY": this.config.apiKey,
+      "Content-Type": "application/json",
+      ...this.config.headers
+    };
+  }
+  /**
+   * Create a chat completion. Include `memory: { userId }` to retrieve
+   * relevant facts before the model call and persist new ones after it.
+   */
+  async create(params) {
+    const response = await fetch(this.endpoint(), {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify({ ...params, stream: false })
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      const message = typeof errorData.error === "object" ? errorData.error?.message : errorData.error || errorData.message;
+      throw new Error(`Cencori API error: ${message || response.statusText}`);
+    }
+    return response.json();
+  }
+  /**
+   * Stream a chat completion (SSE). Memory writeback still runs after the
+   * stream completes; `memoriesRetrieved` reports the injected count.
+   */
+  async stream(params) {
+    const response = await fetch(this.endpoint(), {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify({ ...params, stream: true })
+    });
+    if (!response.ok || !response.body) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(`Cencori API error: ${JSON.stringify(errorData.error) || response.statusText}`);
+    }
+    const memoriesRetrieved = Number(response.headers.get("X-Cencori-Memory-Retrieved") || 0);
+    const body = response.body;
+    const iterable = {
+      memoriesRetrieved,
+      async *[Symbol.asyncIterator]() {
+        const reader = body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        try {
+          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) {
+              const trimmed = line.trim();
+              if (!trimmed.startsWith("data: ")) continue;
+              const payload = trimmed.slice(6);
+              if (payload === "[DONE]") return;
+              try {
+                const parsed = JSON.parse(payload);
+                const delta = parsed.choices?.[0]?.delta?.content ?? "";
+                yield { delta, raw: parsed };
+              } catch {
+              }
+            }
+          }
+        } finally {
+          reader.releaseLock();
+        }
+      }
+    };
+    return iterable;
+  }
+};
+var ChatNamespace = class {
+  constructor(config) {
+    this.completions = new Completions(config);
+  }
+};
+
 // src/telemetry/index.ts
 var TelemetryClient = class {
   constructor(config) {
@@ -1301,7 +1625,9 @@ var Cencori = class {
       headers: config.headers ?? {}
     };
     this.ai = new AINamespace(this.config);
+    this.chat = new ChatNamespace(this.config);
     this.vision = new VisionNamespace(this.config);
+    this.voice = new VoiceNamespace(this.config);
     this.documents = new DocumentsNamespace(this.config);
     this.agents = new AgentsNamespace(this.config);
     this.compute = new ComputeNamespace();
@@ -1728,6 +2054,7 @@ export {
   AuthenticationError,
   Cencori,
   CencoriError,
+  ChatNamespace,
   ComputeNamespace,
   DocumentsNamespace,
   MemoryClient,
@@ -1737,6 +2064,7 @@ export {
   StorageNamespace,
   TelemetryClient,
   VisionNamespace,
+  VoiceNamespace,
   WorkflowNamespace,
   cencori,
   createCencori,