@neetru/sdk 3.1.9 → 3.1.11

package/dist/auth.d.cts

@@ -1,4 +1,4 @@
-import { G as NeetruClientConfig, B as NeetruClient } from './types-DDiVzgCT.cjs';
+import { S as NeetruClientConfig, R as NeetruClient } from './types-Cog9S-tC.cjs';
 import 'drizzle-orm/node-postgres';
 import './errors.cjs';
 

package/dist/auth.d.ts

@@ -1,4 +1,4 @@
-import { G as NeetruClientConfig, B as NeetruClient } from './types-HWDOUmlC.js';
+import { S as NeetruClientConfig, R as NeetruClient } from './types-dagUxKYz.js';
 import 'drizzle-orm/node-postgres';
 import './errors.js';
 

package/dist/auth.mjs

@@ -5497,6 +5497,235 @@ var MockNotifications = class {
   }
 };
 
+// src/ai.ts
+init_errors();
+init_http();
+var AI_CHAT_PATH = "/api/sdk/v1/ai/chat";
+var AI_NONSTREAM_TIMEOUT_MS = 12e4;
+function resolveAiBody(config, opts, stream) {
+  if (!opts || typeof opts !== "object") {
+    throw new NeetruError("validation_failed", "ai: options object is required");
+  }
+  if (typeof opts.model !== "string" || opts.model.length === 0) {
+    throw new NeetruError("validation_failed", "ai: model is required");
+  }
+  if (!Array.isArray(opts.messages) || opts.messages.length === 0) {
+    throw new NeetruError("validation_failed", "ai: messages must be a non-empty array");
+  }
+  for (const m of opts.messages) {
+    if (!m || typeof m !== "object" || typeof m.role !== "string" || m.role.length === 0 || typeof m.content !== "string") {
+      throw new NeetruError(
+        "validation_failed",
+        "ai: each message must be { role: string, content: string }"
+      );
+    }
+  }
+  const productId = opts.productId ?? config.productId;
+  const tenantId = opts.tenantId ?? config.tenantId;
+  if (!productId) {
+    throw new NeetruError(
+      "validation_failed",
+      "ai: productId required (pass to options or set on createNeetruClient)"
+    );
+  }
+  if (!tenantId) {
+    throw new NeetruError(
+      "validation_failed",
+      "ai: tenantId required (pass to options or set on createNeetruClient)"
+    );
+  }
+  assertValidSdkId("productId", productId);
+  assertValidSdkId("tenantId", tenantId);
+  const body = {
+    productId,
+    tenantId,
+    model: opts.model,
+    messages: opts.messages,
+    stream
+  };
+  if (opts.maxTokens !== void 0) {
+    if (!Number.isInteger(opts.maxTokens) || opts.maxTokens <= 0) {
+      throw new NeetruError("validation_failed", "ai: maxTokens must be a positive integer");
+    }
+    body.maxTokens = opts.maxTokens;
+  }
+  if (opts.temperature !== void 0) {
+    if (typeof opts.temperature !== "number" || !Number.isFinite(opts.temperature)) {
+      throw new NeetruError("validation_failed", "ai: temperature must be a finite number");
+    }
+    body.temperature = opts.temperature;
+  }
+  return body;
+}
+async function safeJson2(res) {
+  try {
+    const text = await res.text();
+    if (!text) return void 0;
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function statusToCode2(status) {
+  if (status === 401) return "unauthorized";
+  if (status === 403) return "forbidden";
+  if (status === 404) return "not_found";
+  if (status === 409) return "conflict";
+  if (status === 422 || status === 400) return "validation_failed";
+  if (status === 429) return "rate_limited";
+  if (status >= 500) return "server_error";
+  return "unknown";
+}
+function joinUrl(baseUrl, path) {
+  const base = baseUrl.replace(/\/+$/, "");
+  const p = path.startsWith("/") ? path : `/${path}`;
+  return `${base}${p}`;
+}
+async function aiFetch(config, body, signal, stream) {
+  if (!config.apiKey) {
+    throw new NeetruError(
+      "missing_api_key",
+      "ai requires an apiKey. Pass it to createNeetruClient({ apiKey }) or set NEETRU_API_KEY env var."
+    );
+  }
+  const url = joinUrl(config.baseUrl, AI_CHAT_PATH);
+  const headers = {
+    "content-type": "application/json",
+    accept: stream ? "text/event-stream" : "application/json",
+    authorization: `Bearer ${config.apiKey}`
+  };
+  const init = { method: "POST", headers, body: JSON.stringify(body) };
+  if (stream) {
+    if (signal) init.signal = signal;
+  } else {
+    init.signal = signal ?? AbortSignal.timeout(AI_NONSTREAM_TIMEOUT_MS);
+  }
+  let res;
+  try {
+    res = await config.fetch(url, init);
+  } catch (err) {
+    const message = err instanceof DOMException && err.name === "TimeoutError" ? `Network error: timeout after ${AI_NONSTREAM_TIMEOUT_MS / 1e3}s` : err instanceof DOMException && err.name === "AbortError" ? "Network error: request aborted" : `Network error: ${err instanceof Error ? err.message : "fetch failed"}`;
+    throw new NeetruError("network_error", message);
+  }
+  const requestId = res.headers.get("x-request-id") ?? res.headers.get("x-correlation-id") ?? void 0;
+  if (!res.ok) {
+    const parsed = await safeJson2(res);
+    let code = statusToCode2(res.status);
+    let message = `HTTP ${res.status}`;
+    if (parsed && typeof parsed === "object" && "error" in parsed) {
+      const errField = parsed.error;
+      if (typeof errField === "string") {
+        message = errField;
+      } else if (errField && typeof errField === "object") {
+        if (typeof errField.code === "string") code = errField.code;
+        if (typeof errField.message === "string") message = errField.message;
+      }
+    }
+    throw new NeetruError(code, message, res.status, requestId);
+  }
+  const coreVersion = res.headers.get("x-neetru-version");
+  if (coreVersion) checkCoreVersionCompat(coreVersion);
+  return res;
+}
+function readMeta(res) {
+  return {
+    provider: res.headers.get("x-neetru-provider") ?? "",
+    usageWarning: res.headers.get("x-neetru-ai-usage-warning") === "1"
+  };
+}
+function parseSseData(rawEvent) {
+  const dataLines = [];
+  for (const line of rawEvent.split("\n")) {
+    const trimmed = line.replace(/\r$/, "");
+    if (trimmed.startsWith("data:")) {
+      let v = trimmed.slice(5);
+      if (v.startsWith(" ")) v = v.slice(1);
+      dataLines.push(v);
+    }
+  }
+  if (dataLines.length === 0) return null;
+  const payload = dataLines.join("\n");
+  if (payload === "[DONE]") return { done: true };
+  try {
+    const obj = JSON.parse(payload);
+    const content = obj?.choices?.[0]?.delta?.content;
+    if (typeof content === "string" && content.length > 0) return { content };
+    return null;
+  } catch {
+    return null;
+  }
+}
+function createAiNamespace(config) {
+  return {
+    async chat(opts) {
+      const body = resolveAiBody(config, opts, false);
+      const res = await aiFetch(config, body, opts.signal, false);
+      const { provider: providerHeader, usageWarning } = readMeta(res);
+      const raw = await safeJson2(res);
+      if (!raw || raw.ok !== true || !Array.isArray(raw.choices)) {
+        throw new NeetruError("invalid_response", "ai.chat response missing ok/choices");
+      }
+      return {
+        choices: raw.choices,
+        usage: raw.usage ?? { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+        model: raw.model ?? opts.model,
+        provider: raw.provider ?? providerHeader ?? "",
+        usageWarning
+      };
+    },
+    stream(opts) {
+      const body = resolveAiBody(config, opts, true);
+      const responsePromise = aiFetch(config, body, opts.signal, true);
+      const meta = responsePromise.then(readMeta);
+      meta.catch(() => {
+      });
+      async function* iterate() {
+        const res = await responsePromise;
+        const stream = res.body;
+        if (!stream) {
+          throw new NeetruError("invalid_response", "ai.stream: response has no body");
+        }
+        const reader = stream.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 });
+            let sep;
+            while ((sep = buffer.indexOf("\n\n")) !== -1) {
+              const rawEvent = buffer.slice(0, sep);
+              buffer = buffer.slice(sep + 2);
+              const parsed = parseSseData(rawEvent);
+              if (parsed && "done" in parsed) return;
+              if (parsed && "content" in parsed) yield parsed.content;
+            }
+          }
+          const tail = buffer.trim();
+          if (tail) {
+            const parsed = parseSseData(tail);
+            if (parsed && "content" in parsed) yield parsed.content;
+          }
+        } finally {
+          try {
+            reader.releaseLock();
+          } catch {
+          }
+          try {
+            await stream.cancel();
+          } catch {
+          }
+        }
+      }
+      return {
+        meta,
+        [Symbol.asyncIterator]: iterate
+      };
+    }
+  };
+}
+
 // src/mocks.ts
 init_errors();
 var DEV_FIXTURE_USER = Object.freeze({
@@ -5782,6 +6011,57 @@ var MockEntitlements = class {
     this._denied.clear();
   }
 };
+var MockAi = class {
+  _calls = [];
+  _reply(opts) {
+    const last = [...opts.messages].reverse().find((m) => m.role === "user") ?? opts.messages[opts.messages.length - 1];
+    const content = last?.content ?? "";
+    return content ? `mock-reply: ${content}` : "mock-reply";
+  }
+  async chat(opts) {
+    if (!opts || typeof opts.model !== "string" || opts.model.length === 0) {
+      throw new NeetruError("validation_failed", "ai: model is required");
+    }
+    if (!Array.isArray(opts.messages) || opts.messages.length === 0) {
+      throw new NeetruError("validation_failed", "ai: messages must be a non-empty array");
+    }
+    this._calls.push({ model: opts.model, messages: opts.messages, stream: false });
+    const text = this._reply(opts);
+    const promptTokens = opts.messages.reduce((n, m) => n + (m.content?.length ?? 0), 0);
+    const completionTokens = text.length;
+    return {
+      choices: [{ message: { role: "assistant", content: text }, finish_reason: "stop" }],
+      usage: {
+        prompt_tokens: promptTokens,
+        completion_tokens: completionTokens,
+        total_tokens: promptTokens + completionTokens
+      },
+      model: opts.model,
+      provider: "mock",
+      usageWarning: false
+    };
+  }
+  stream(opts) {
+    if (!opts || typeof opts.model !== "string" || opts.model.length === 0) {
+      throw new NeetruError("validation_failed", "ai: model is required");
+    }
+    if (!Array.isArray(opts.messages) || opts.messages.length === 0) {
+      throw new NeetruError("validation_failed", "ai: messages must be a non-empty array");
+    }
+    this._calls.push({ model: opts.model, messages: opts.messages, stream: true });
+    const text = this._reply(opts);
+    const parts = text.match(/\S+\s*/g) ?? [text];
+    const meta = Promise.resolve({ provider: "mock", usageWarning: false });
+    async function* iterate() {
+      for (const p of parts) yield p;
+    }
+    return { meta, [Symbol.asyncIterator]: iterate };
+  }
+  /** Test helper — histórico de chamadas. */
+  __getCalls() {
+    return this._calls;
+  }
+};
 
 // src/auth.ts
 function readEnvApiKey() {
@@ -6223,6 +6503,7 @@ function createNeetruClient(config = {}) {
   const db = config.mocks?.db ?? createNeetruDb(resolved, config.db);
   const webhooks = config.mocks?.webhooks ?? (isDev ? new MockWebhooks() : createWebhooksNamespace(resolved));
   const notifications = config.mocks?.notifications ?? (isDev ? new MockNotifications() : createNotificationsNamespace(resolved));
+  const ai = config.mocks?.ai ?? (isDev ? new MockAi() : createAiNamespace(resolved));
   const client = Object.freeze({
     config: resolved,
     auth,
@@ -6234,7 +6515,8 @@ function createNeetruClient(config = {}) {
     db,
     checkout: createCheckoutNamespace(resolved),
     webhooks,
-    notifications
+    notifications,
+    ai
   });
   return client;
 }