@mnexium/sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1074 @@
+// src/errors.ts
+var MnexiumError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MnexiumError";
+  }
+};
+var AuthenticationError = class extends MnexiumError {
+  constructor(message = "Authentication failed") {
+    super(message);
+    this.name = "AuthenticationError";
+  }
+};
+var RateLimitError = class extends MnexiumError {
+  constructor(message = "Rate limit exceeded", options) {
+    super(message);
+    this.name = "RateLimitError";
+    this.retryAfter = options?.retryAfter;
+    this.current = options?.current;
+    this.limit = options?.limit;
+  }
+};
+var APIError = class extends MnexiumError {
+  constructor(message, status, code) {
+    super(message);
+    this.name = "APIError";
+    this.status = status;
+    this.code = code;
+  }
+};
+var NotFoundError = class extends APIError {
+  constructor(message = "Resource not found") {
+    super(message, 404, "not_found");
+    this.name = "NotFoundError";
+  }
+};
+
+// src/chat.ts
+var Chat = class {
+  constructor(client, subjectId, options = {}) {
+    this.client = client;
+    this.subjectId = subjectId;
+    this.id = options.chatId || crypto.randomUUID();
+    this.options = options;
+  }
+  async process(input) {
+    const options = typeof input === "string" ? { content: input } : input;
+    return this.client.process({
+      content: options.content,
+      chatId: this.id,
+      subjectId: this.subjectId,
+      model: options.model ?? this.options.model,
+      log: options.log ?? this.options.log,
+      learn: options.learn ?? this.options.learn,
+      recall: options.recall ?? this.options.recall,
+      profile: options.profile ?? this.options.profile,
+      history: options.history ?? this.options.history,
+      summarize: options.summarize ?? this.options.summarize,
+      systemPrompt: options.systemPrompt ?? this.options.systemPrompt,
+      maxTokens: options.maxTokens ?? this.options.maxTokens,
+      temperature: options.temperature ?? this.options.temperature,
+      stream: options.stream,
+      metadata: options.metadata ?? this.options.metadata,
+      regenerateKey: options.regenerateKey
+    });
+  }
+};
+
+// src/events.ts
+var EventStream = class {
+  constructor(client, subjectId, options) {
+    this.client = client;
+    this.subjectId = subjectId;
+    this.reader = null;
+    this.decoder = new TextDecoder();
+    this.connected = false;
+    this.abortController = new AbortController();
+    if (options?.signal) {
+      options.signal.addEventListener("abort", () => this.close());
+    }
+  }
+  async *[Symbol.asyncIterator]() {
+    const response = await this.client._requestRaw("GET", "/events/memories", {
+      query: { subject_id: this.subjectId }
+    });
+    if (!response.body) {
+      throw new Error("Response body is null \u2014 SSE not supported");
+    }
+    this.reader = response.body.getReader();
+    this.connected = true;
+    let buffer = "";
+    let currentEvent = "";
+    try {
+      while (true) {
+        const { value, done } = await this.reader.read();
+        if (done) break;
+        buffer += this.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("event:")) {
+            currentEvent = trimmed.slice(6).trim();
+            continue;
+          }
+          if (trimmed.startsWith("data:")) {
+            const data = trimmed.slice(5).trim();
+            if (!data) continue;
+            try {
+              const parsed = JSON.parse(data);
+              const eventType = currentEvent || "unknown";
+              currentEvent = "";
+              yield {
+                type: eventType,
+                data: parsed
+              };
+            } catch {
+            }
+          }
+          if (trimmed === "") {
+            currentEvent = "";
+          }
+        }
+      }
+    } finally {
+      this.connected = false;
+      if (this.reader) {
+        this.reader.releaseLock();
+        this.reader = null;
+      }
+    }
+  }
+  /** Close the event stream */
+  close() {
+    this.abortController.abort();
+    if (this.reader) {
+      this.reader.cancel().catch(() => {
+      });
+      this.reader = null;
+    }
+    this.connected = false;
+  }
+  /** Whether the stream is currently connected */
+  get isConnected() {
+    return this.connected;
+  }
+};
+
+// src/subject.ts
+var SubjectMemoriesResource = class {
+  constructor(client, subjectId) {
+    this.client = client;
+    this.subjectId = subjectId;
+  }
+  async search(query, options) {
+    const response = await this.client._request("GET", "/memories/search", {
+      query: {
+        subject_id: this.subjectId,
+        q: query,
+        limit: options?.limit,
+        min_score: options?.minScore
+      }
+    });
+    return response.data || [];
+  }
+  async add(text, options) {
+    return this.client._request("POST", "/memories", {
+      body: {
+        subject_id: this.subjectId,
+        text,
+        source: options?.source,
+        visibility: options?.visibility,
+        metadata: options?.metadata
+      }
+    });
+  }
+  async list(options) {
+    const response = await this.client._request("GET", "/memories", {
+      query: {
+        subject_id: this.subjectId,
+        limit: options?.limit,
+        offset: options?.offset
+      }
+    });
+    return response.data || [];
+  }
+  async get(memoryId) {
+    return this.client._request("GET", `/memories/${memoryId}`);
+  }
+  async update(memoryId, updates) {
+    return this.client._request("PATCH", `/memories/${memoryId}`, {
+      body: updates
+    });
+  }
+  async delete(memoryId) {
+    await this.client._request("DELETE", `/memories/${memoryId}`);
+  }
+  async superseded(options) {
+    const response = await this.client._request("GET", "/memories/superseded", {
+      query: {
+        subject_id: this.subjectId,
+        limit: options?.limit,
+        offset: options?.offset
+      }
+    });
+    return response.data || [];
+  }
+  async restore(memoryId) {
+    return this.client._request("POST", `/memories/${memoryId}/restore`);
+  }
+  async recalls(options) {
+    const response = await this.client._request("GET", "/memories/recalls", {
+      query: {
+        chat_id: options.chatId,
+        memory_id: options.memoryId
+      }
+    });
+    return response.data || [];
+  }
+  subscribe(options) {
+    return new EventStream(this.client, this.subjectId, options);
+  }
+};
+var SubjectProfileResource = class {
+  constructor(client, subjectId) {
+    this.client = client;
+    this.subjectId = subjectId;
+  }
+  async get() {
+    return this.client._request("GET", "/profiles", {
+      query: { subject_id: this.subjectId }
+    });
+  }
+  async update(updates) {
+    return this.client._request("PATCH", "/profiles", {
+      body: {
+        subject_id: this.subjectId,
+        updates
+      }
+    });
+  }
+  async deleteField(fieldKey) {
+    await this.client._request("DELETE", "/profiles", {
+      body: {
+        subject_id: this.subjectId,
+        field_key: fieldKey
+      }
+    });
+  }
+};
+var SubjectStateResource = class {
+  constructor(client, subjectId) {
+    this.client = client;
+    this.subjectId = subjectId;
+  }
+  async get(key) {
+    try {
+      return await this.client._request("GET", `/state/${key}`, {
+        headers: { "x-subject-id": this.subjectId }
+      });
+    } catch (error) {
+      if (error?.status === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async set(key, value, options) {
+    return this.client._request("PUT", `/state/${key}`, {
+      headers: { "x-subject-id": this.subjectId },
+      body: {
+        value,
+        ttl_seconds: options?.ttlSeconds
+      }
+    });
+  }
+  async delete(key) {
+    await this.client._request("DELETE", `/state/${key}`, {
+      headers: { "x-subject-id": this.subjectId }
+    });
+  }
+};
+var SubjectClaimsResource = class {
+  constructor(client, subjectId) {
+    this.client = client;
+    this.subjectId = subjectId;
+  }
+  async get(slot) {
+    try {
+      return await this.client._request("GET", `/claims/subject/${this.subjectId}/slot/${slot}`);
+    } catch (error) {
+      if (error?.status === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async set(predicate, value, options) {
+    return this.client._request("POST", "/claims", {
+      body: {
+        subject_id: this.subjectId,
+        predicate,
+        object_value: value,
+        confidence: options?.confidence,
+        source_type: options?.source
+      }
+    });
+  }
+  async list() {
+    return this.client._request("GET", `/claims/subject/${this.subjectId}/slots`);
+  }
+  async truth() {
+    return this.client._request("GET", `/claims/subject/${this.subjectId}/truth`);
+  }
+  async history() {
+    const response = await this.client._request("GET", `/claims/subject/${this.subjectId}/history`);
+    return response.data || response.claims || [];
+  }
+  async retract(claimId) {
+    return this.client._request("POST", `/claims/${claimId}/retract`);
+  }
+};
+var SubjectChatsResource = class {
+  constructor(client, subjectId) {
+    this.client = client;
+    this.subjectId = subjectId;
+  }
+  async list(options) {
+    const response = await this.client._request("GET", "/chat/history/list", {
+      query: {
+        subject_id: this.subjectId,
+        limit: options?.limit,
+        offset: options?.offset
+      }
+    });
+    return response.chats;
+  }
+  async read(chatId) {
+    const response = await this.client._request("GET", "/chat/history/read", {
+      query: {
+        subject_id: this.subjectId,
+        chat_id: chatId
+      }
+    });
+    return response.data || [];
+  }
+  async delete(chatId) {
+    await this.client._request("DELETE", "/chat/history/delete", {
+      query: {
+        subject_id: this.subjectId,
+        chat_id: chatId
+      }
+    });
+  }
+};
+var Subject = class {
+  constructor(client, subjectId) {
+    this.client = client;
+    this.id = subjectId;
+    this.memories = new SubjectMemoriesResource(client, subjectId);
+    this.profile = new SubjectProfileResource(client, subjectId);
+    this.state = new SubjectStateResource(client, subjectId);
+    this.claims = new SubjectClaimsResource(client, subjectId);
+    this.chats = new SubjectChatsResource(client, subjectId);
+  }
+  /**
+   * Process a message with an ephemeral chat (no persistent chatId)
+   * 
+   * @example
+   * const response = await alice.process("What's my favorite color?");
+   */
+  async process(input) {
+    const options = typeof input === "string" ? { content: input } : input;
+    return this.client.process({
+      ...options,
+      subjectId: this.id
+    });
+  }
+  /**
+   * Create a chat session for multi-turn conversation
+   * 
+   * @example
+   * const chat = alice.createChat({ history: true });
+   * await chat.process("Hello!");
+   * await chat.process("What did I just say?");
+   */
+  createChat(options) {
+    return this.client.createChat(this, options);
+  }
+};
+
+// src/providers.ts
+function detectProvider(model) {
+  const lowerModel = model.toLowerCase();
+  if (lowerModel.includes("claude")) {
+    return "anthropic";
+  }
+  if (lowerModel.includes("gemini") || lowerModel.includes("palm")) {
+    return "google";
+  }
+  if (lowerModel.includes("gpt") || lowerModel.includes("o1") || lowerModel.includes("o3") || lowerModel.includes("davinci")) {
+    return "openai";
+  }
+  return null;
+}
+function extractResponseContent(raw) {
+  if (raw.content && Array.isArray(raw.content)) {
+    let content = "";
+    for (const block of raw.content) {
+      if (block.type === "text") {
+        content += block.text || "";
+      }
+    }
+    return {
+      content,
+      usage: raw.usage ? {
+        prompt_tokens: raw.usage.input_tokens || 0,
+        completion_tokens: raw.usage.output_tokens || 0,
+        total_tokens: (raw.usage.input_tokens || 0) + (raw.usage.output_tokens || 0)
+      } : null
+    };
+  }
+  if (raw.candidates && Array.isArray(raw.candidates)) {
+    let content = "";
+    const parts = raw.candidates[0]?.content?.parts || [];
+    for (const part of parts) {
+      if (part.text) {
+        content += part.text;
+      }
+    }
+    return {
+      content,
+      usage: raw.usageMetadata ? {
+        prompt_tokens: raw.usageMetadata.promptTokenCount || 0,
+        completion_tokens: raw.usageMetadata.candidatesTokenCount || 0,
+        total_tokens: raw.usageMetadata.totalTokenCount || 0
+      } : null
+    };
+  }
+  return {
+    content: raw.choices?.[0]?.message?.content || "",
+    usage: raw.usage || null
+  };
+}
+
+// src/streaming.ts
+var StreamResponse = class {
+  constructor(response, metadata) {
+    /** The full accumulated content after streaming completes */
+    this.totalContent = "";
+    this.consumed = false;
+    if (!response.body) {
+      throw new Error("Response body is null \u2014 streaming not supported");
+    }
+    this.reader = response.body.getReader();
+    this.decoder = new TextDecoder();
+    this.chatId = metadata.chatId;
+    this.subjectId = metadata.subjectId;
+    this.model = metadata.model;
+    this.provisionedKey = metadata.provisionedKey;
+    this.claimUrl = metadata.claimUrl;
+  }
+  async *[Symbol.asyncIterator]() {
+    if (this.consumed) {
+      throw new Error("StreamResponse has already been consumed");
+    }
+    this.consumed = true;
+    let buffer = "";
+    try {
+      while (true) {
+        const { value, done } = await this.reader.read();
+        if (done) break;
+        buffer += this.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("event:") || !trimmed.startsWith("data:")) continue;
+          const data = trimmed.slice(5).trim();
+          if (!data || data === "[DONE]") continue;
+          try {
+            const json = JSON.parse(data);
+            const chunk = this._extractChunk(json);
+            if (chunk) {
+              this.totalContent += chunk.content;
+              yield chunk;
+            }
+            this._extractUsage(json);
+          } catch {
+          }
+        }
+      }
+    } finally {
+      this.reader.releaseLock();
+    }
+  }
+  /**
+   * Convenience: collect the full response as a string.
+   * Consumes the stream if not already consumed.
+   */
+  async text() {
+    if (!this.consumed) {
+      for await (const _ of this) {
+      }
+    }
+    return this.totalContent;
+  }
+  _extractChunk(json) {
+    const delta = json?.choices?.[0]?.delta;
+    if (delta?.content) {
+      return { content: delta.content, raw: json };
+    }
+    if (json?.type === "content_block_delta" && json?.delta?.type === "text_delta") {
+      return { content: json.delta.text || "", raw: json };
+    }
+    const parts = json?.candidates?.[0]?.content?.parts;
+    if (Array.isArray(parts)) {
+      const text = parts.map((p) => p.text || "").join("");
+      if (text) {
+        return { content: text, raw: json };
+      }
+    }
+    return null;
+  }
+  _extractUsage(json) {
+    if (json?.usage) {
+      this.usage = {
+        promptTokens: json.usage.prompt_tokens || 0,
+        completionTokens: json.usage.completion_tokens || 0,
+        totalTokens: json.usage.total_tokens || 0
+      };
+    }
+    if (json?.type === "message_delta" && json?.usage) {
+      this.usage = {
+        promptTokens: json.usage.input_tokens || 0,
+        completionTokens: json.usage.output_tokens || 0,
+        totalTokens: (json.usage.input_tokens || 0) + (json.usage.output_tokens || 0)
+      };
+    }
+    if (json?.usageMetadata) {
+      this.usage = {
+        promptTokens: json.usageMetadata.promptTokenCount || 0,
+        completionTokens: json.usageMetadata.candidatesTokenCount || 0,
+        totalTokens: json.usageMetadata.totalTokenCount || 0
+      };
+    }
+  }
+};
+
+// src/resources/chat.ts
+var ChatResource = class {
+  constructor(client) {
+    this.completions = new ChatCompletionsResource(client);
+  }
+};
+var ChatCompletionsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async create(options) {
+    const headers = {};
+    if (options.openaiKey) {
+      headers["x-openai-key"] = options.openaiKey;
+    } else if (options.anthropicKey) {
+      headers["x-anthropic-key"] = options.anthropicKey;
+    } else if (options.googleKey) {
+      headers["x-google-key"] = options.googleKey;
+    }
+    const body = {
+      model: options.model,
+      messages: options.messages,
+      stream: options.stream || false,
+      max_tokens: options.maxTokens,
+      temperature: options.temperature,
+      top_p: options.topP,
+      stop: options.stop,
+      mnx: {
+        subject_id: options.subjectId,
+        chat_id: options.chatId,
+        learn: options.learn,
+        recall: options.recall,
+        history: options.history,
+        log: options.log,
+        state: options.state,
+        system_prompt: options.systemPrompt,
+        metadata: options.metadata,
+        regenerate_key: options.regenerateKey
+      }
+    };
+    return this.client._request("POST", "/chat/completions", {
+      body,
+      headers
+    });
+  }
+};
+
+// src/resources/memories.ts
+var MemoriesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async create(options) {
+    return this.client._request("POST", "/memories", {
+      body: {
+        subject_id: options.subjectId,
+        text: options.text,
+        source: options.source,
+        visibility: options.visibility,
+        metadata: options.metadata
+      }
+    });
+  }
+  async get(id) {
+    return this.client._request("GET", `/memories/${id}`);
+  }
+  async list(subjectId, options) {
+    const response = await this.client._request("GET", "/memories", {
+      query: {
+        subject_id: subjectId,
+        limit: options?.limit,
+        offset: options?.offset
+      }
+    });
+    return response.memories;
+  }
+  async search(options) {
+    const response = await this.client._request("POST", "/memories/search", {
+      body: {
+        subject_id: options.subjectId,
+        query: options.query,
+        limit: options.limit,
+        min_score: options.minScore,
+        include_deleted: options.includeDeleted,
+        include_superseded: options.includeSuperseded
+      }
+    });
+    return response.results;
+  }
+  async delete(id) {
+    await this.client._request("DELETE", `/memories/${id}`);
+  }
+};
+
+// src/resources/claims.ts
+var ClaimsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async create(options) {
+    return this.client._request("POST", "/claims", {
+      body: {
+        subject_id: options.subjectId,
+        slot: options.slot,
+        value: options.value,
+        confidence: options.confidence,
+        source: options.source,
+        source_memory_id: options.sourceMemoryId
+      }
+    });
+  }
+  async get(id) {
+    return this.client._request("GET", `/claims/${id}`);
+  }
+  async getBySlot(subjectId, slot) {
+    try {
+      return await this.client._request("GET", `/claims/subject/${subjectId}/slot/${slot}`);
+    } catch (error) {
+      if (error instanceof NotFoundError) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async listSlots(subjectId) {
+    return this.client._request("GET", `/claims/subject/${subjectId}/slots`);
+  }
+  async retract(id) {
+    await this.client._request("POST", `/claims/${id}/retract`);
+  }
+};
+
+// src/resources/profiles.ts
+var ProfilesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async get(subjectId) {
+    return this.client._request("GET", "/profiles", {
+      query: { subject_id: subjectId }
+    });
+  }
+};
+
+// src/resources/state.ts
+var StateResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async get(key, subjectId) {
+    try {
+      return await this.client._request("GET", `/state/${key}`, {
+        query: subjectId ? { subject_id: subjectId } : void 0
+      });
+    } catch (error) {
+      if (error instanceof NotFoundError) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async set(options) {
+    return this.client._request("POST", `/state/${options.key}`, {
+      body: {
+        value: options.value,
+        subject_id: options.subjectId,
+        ttl_seconds: options.ttlSeconds
+      }
+    });
+  }
+  async delete(key, subjectId) {
+    await this.client._request("DELETE", `/state/${key}`, {
+      query: subjectId ? { subject_id: subjectId } : void 0
+    });
+  }
+};
+
+// src/resources/prompts.ts
+var PromptsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async create(options) {
+    const response = await this.client._request("POST", "/prompts", {
+      body: {
+        name: options.name,
+        prompt_text: options.promptText,
+        is_default: options.isDefault
+      }
+    });
+    return response.prompt;
+  }
+  async get(id) {
+    return this.client._request("GET", `/prompts/${id}`);
+  }
+  async list() {
+    const response = await this.client._request("GET", "/prompts");
+    return response.prompts;
+  }
+  async update(id, options) {
+    return this.client._request("PATCH", `/prompts/${id}`, {
+      body: {
+        name: options.name,
+        prompt_text: options.promptText,
+        is_default: options.isDefault
+      }
+    });
+  }
+  async delete(id) {
+    await this.client._request("DELETE", `/prompts/${id}`);
+  }
+  async resolve(options) {
+    return this.client._request("GET", "/prompts/resolve", {
+      query: {
+        subject_id: options?.subjectId,
+        chat_id: options?.chatId,
+        combined: options?.combined
+      }
+    });
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://mnexium.com/api/v1";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_MAX_RETRIES = 2;
+var Mnexium = class {
+  constructor(config = {}) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl?.replace(/\/$/, "") || DEFAULT_BASE_URL;
+    this.timeout = config.timeout || DEFAULT_TIMEOUT;
+    this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.openaiConfig = config.openai;
+    this.anthropicConfig = config.anthropic;
+    this.googleConfig = config.google;
+    this.defaults = {
+      model: config.defaults?.model || "gpt-4o-mini",
+      log: config.defaults?.log ?? true,
+      learn: config.defaults?.learn ?? true,
+      recall: config.defaults?.recall ?? false,
+      history: config.defaults?.history ?? true,
+      summarize: config.defaults?.summarize ?? false,
+      systemPrompt: config.defaults?.systemPrompt ?? true,
+      ...config.defaults
+    };
+    this.chat = new ChatResource(this);
+    this.memories = new MemoriesResource(this);
+    this.claims = new ClaimsResource(this);
+    this.profiles = new ProfilesResource(this);
+    this.state = new StateResource(this);
+    this.prompts = new PromptsResource(this);
+  }
+  async process(input) {
+    const options = typeof input === "string" ? { content: input } : input;
+    const model = options.model || this.defaults.model || "gpt-4o-mini";
+    const subjectId = options.subjectId || this.defaults.subjectId;
+    const chatId = options.chatId || this.defaults.chatId;
+    const log = options.log ?? this.defaults.log ?? true;
+    const learn = options.learn ?? this.defaults.learn ?? true;
+    const recall = options.recall ?? this.defaults.recall ?? false;
+    const profile = options.profile ?? this.defaults.profile ?? false;
+    const history = options.history ?? this.defaults.history ?? true;
+    const summarize = options.summarize ?? this.defaults.summarize ?? false;
+    const systemPrompt = options.systemPrompt ?? this.defaults.systemPrompt ?? true;
+    const metadata = options.metadata || this.defaults.metadata;
+    const maxTokens = options.maxTokens || this.defaults.maxTokens;
+    const temperature = options.temperature ?? this.defaults.temperature;
+    const regenerateKey = options.regenerateKey ?? this.defaults.regenerateKey ?? false;
+    const headers = {};
+    const provider = detectProvider(model);
+    if (provider === "anthropic" && this.anthropicConfig?.apiKey) {
+      headers["x-anthropic-key"] = this.anthropicConfig.apiKey;
+    } else if (provider === "google" && this.googleConfig?.apiKey) {
+      headers["x-google-key"] = this.googleConfig.apiKey;
+    } else if (this.openaiConfig?.apiKey) {
+      headers["x-openai-key"] = this.openaiConfig.apiKey;
+    } else if (this.anthropicConfig?.apiKey) {
+      headers["x-anthropic-key"] = this.anthropicConfig.apiKey;
+    } else if (this.googleConfig?.apiKey) {
+      headers["x-google-key"] = this.googleConfig.apiKey;
+    }
+    const body = {
+      model,
+      messages: [{ role: "user", content: options.content }],
+      stream: options.stream || false,
+      max_tokens: maxTokens,
+      temperature,
+      mnx: {
+        subject_id: subjectId,
+        chat_id: chatId,
+        log,
+        learn,
+        recall,
+        profile,
+        history,
+        summarize,
+        system_prompt: systemPrompt,
+        metadata,
+        regenerate_key: regenerateKey
+      }
+    };
+    if (options.stream) {
+      const response = await this._requestRaw("POST", "/chat/completions", {
+        body,
+        headers
+      });
+      return new StreamResponse(response, {
+        chatId: response.headers.get("X-Mnx-Chat-Id") || chatId || "",
+        subjectId: response.headers.get("X-Mnx-Subject-Id") || subjectId || "",
+        model,
+        provisionedKey: response.headers.get("X-Mnx-Key-Provisioned") || void 0,
+        claimUrl: response.headers.get("X-Mnx-Claim-Url") || void 0
+      });
+    }
+    const raw = await this._request("POST", "/chat/completions", {
+      body,
+      headers
+    });
+    const { content: extractedContent, usage: extractedUsage } = extractResponseContent(raw);
+    return {
+      content: extractedContent,
+      chatId: raw.mnx.chat_id,
+      subjectId: raw.mnx.subject_id,
+      model: raw.model,
+      usage: extractedUsage ? {
+        promptTokens: extractedUsage.prompt_tokens,
+        completionTokens: extractedUsage.completion_tokens,
+        totalTokens: extractedUsage.total_tokens
+      } : void 0,
+      provisionedKey: raw.mnx.provisioned_key,
+      claimUrl: raw.mnx.claim_url,
+      raw
+    };
+  }
+  /**
+   * Get the provisioned trial key (if auto-provisioned)
+   * @deprecated Use getTrialInfo() instead
+   */
+  getProvisionedKey() {
+    return this.provisionedKey;
+  }
+  /**
+   * Get trial key info including the key and claim URL
+   * 
+   * @example
+   * const trial = mnx.getTrialInfo();
+   * if (trial) {
+   *   console.log('Key:', trial.key);
+   *   console.log('Claim at:', trial.claimUrl);
+   * }
+   */
+  getTrialInfo() {
+    if (!this.provisionedKey) {
+      return null;
+    }
+    return {
+      key: this.provisionedKey,
+      claimUrl: "https://mnexium.com/claim"
+    };
+  }
+  /**
+   * Get a Subject handle for a given subject ID
+   * 
+   * Creating a Subject does NOT make a network call - it's a lightweight scoped handle.
+   * 
+   * @example
+   * const alice = mnx.subject("user_123");
+   * await alice.process("Hello!");
+   * await alice.memories.search("hobbies");
+   */
+  subject(subjectId) {
+    return new Subject(this, subjectId || crypto.randomUUID());
+  }
+  /**
+   * Create a chat for a subject
+   * 
+   * @example
+   * const alice = mnx.subject("user_123");
+   * const chat = mnx.createChat(alice, { history: true });
+   * // or with string:
+   * const chat = mnx.createChat("user_123", { history: true });
+   */
+  createChat(subject, options) {
+    const subjectId = typeof subject === "string" ? subject : subject.id;
+    return new Chat(this, subjectId, options);
+  }
+  /**
+   * @deprecated Use createChat(subject, options) instead
+   */
+  createChatSession(options = {}) {
+    const subjectId = options.subjectId || crypto.randomUUID();
+    return new Chat(this, subjectId, options);
+  }
+  /**
+   * Internal: Set provisioned key from response
+   */
+  _setProvisionedKey(key) {
+    this.provisionedKey = key;
+  }
+  /**
+   * Internal: Make a raw API request (returns Response, used for streaming)
+   */
+  async _requestRaw(method, path, options = {}) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    if (options.query) {
+      for (const [key, value] of Object.entries(options.query)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    const effectiveKey = this.apiKey || this.provisionedKey;
+    if (effectiveKey) {
+      headers["x-mnexium-key"] = effectiveKey;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    const response = await fetch(url.toString(), {
+      method,
+      headers,
+      body: options.body ? JSON.stringify(options.body) : void 0,
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    const provisionedKey = response.headers.get("x-mnx-key-provisioned");
+    if (provisionedKey) {
+      this._setProvisionedKey(provisionedKey);
+    }
+    if (!response.ok) {
+      const errorBody = await response.json().catch(() => ({}));
+      throw this._handleErrorResponse(response.status, errorBody);
+    }
+    return response;
+  }
+  /**
+   * Internal: Make an API request
+   */
+  async _request(method, path, options = {}) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    if (options.query) {
+      for (const [key, value] of Object.entries(options.query)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    const effectiveKey = this.apiKey || this.provisionedKey;
+    if (effectiveKey) {
+      headers["x-mnexium-key"] = effectiveKey;
+    }
+    let lastError;
+    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.toString(), {
+          method,
+          headers,
+          body: options.body ? JSON.stringify(options.body) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        const provisionedKey = response.headers.get("x-mnx-key-provisioned");
+        if (provisionedKey) {
+          this._setProvisionedKey(provisionedKey);
+        }
+        if (!response.ok) {
+          const errorBody = await response.json().catch(() => ({}));
+          throw this._handleErrorResponse(response.status, errorBody);
+        }
+        return await response.json();
+      } catch (error) {
+        lastError = error;
+        if (error instanceof APIError && error.status < 500 && !(error instanceof RateLimitError)) {
+          throw error;
+        }
+        if (attempt === this.maxRetries) {
+          throw error;
+        }
+        await this._sleep(Math.pow(2, attempt) * 1e3);
+      }
+    }
+    throw lastError || new MnexiumError("Request failed");
+  }
+  _handleErrorResponse(status, body) {
+    const message = body.message || body.error || "Unknown error";
+    const code = body.error;
+    switch (status) {
+      case 401:
+        return new AuthenticationError(message);
+      case 404:
+        return new NotFoundError(message);
+      case 429:
+        return new RateLimitError(message, {
+          current: body.current,
+          limit: body.limit
+        });
+      default:
+        return new APIError(message, status, code);
+    }
+  }
+  _sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+export {
+  APIError,
+  AuthenticationError,
+  Chat,
+  Chat as ChatSession,
+  EventStream,
+  Mnexium,
+  MnexiumError,
+  RateLimitError,
+  StreamResponse,
+  Subject
+};