nuabase 1.0.0

package/LICENSE

@@ -0,0 +1,19 @@
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,210 @@
+# Nuabase TypeScript client
+
+Nuabase turns LLM prompts into type-safe functions in under five lines.
+
+Example use-cases:
+* Enrich a list of food items with nutrition facts
+* Tag sales leads with more details about the company
+* Convert free-form instructions into precise order forms—directly inside your application.
+
+You can describe the transformation once, and get back a well-typed function, and call it like any other code in your application.
+
+You don't have to do any custom custom orchestration, or run polling, or schema validation.
+
+Behind the scenes, Nuabase runs the async jobs, SSE streaming, webhooks, logging, caching, cost attribution, and strict JSON-schema enforcement. You also get an observability dashboard for every request so you always know what the LLM produced.
+
+## At a Glance
+
+**1. Input.** Start with the data you want to send to the LLM:
+
+```ts
+const leads = [
+  { id: 'lead-101', notes: 'Growth-stage SaaS, ~80 employees, wants a demo.' },
+];
+```
+
+**2. Desired shape.** Describe the structure you expect back:
+
+```ts
+const LeadInsights = z.object({
+  industry: z.string(),
+  company_size: z.enum(['SMB', 'Mid-market', 'Enterprise']),
+});
+```
+
+**3. Declare the prompt.** Turn it into a typed function:
+
+```ts
+const classifyLeads = new Nua().map({
+  name: 'insights',
+  output: LeadInsights,
+  prompt: 'Classify each lead with industry and company_size bucket.',
+});
+```
+
+**4. Invoke.** Call it like any other async function:
+
+```ts
+const result = await classifyLeads.now(leads, 'id');
+if (result.isError) throw new Error(result.error);
+console.log(result.data[0].insights);
+// -> { industry: 'Software', company_size: 'Mid-market' }
+```
+
+## Quick Start
+
+1. Add the Nuabase SDK along with Zod:
+
+```bash
+npm install nuabase zod
+```
+
+2. Get your API key from the [Nuabase Console](https://console.nuabase.com/dashboard/api-keys/new).
+
+3. Set `NUABASE_API_KEY` environment variable, or pass it directly in `new Nua({apiKey: "KEY"})`):
+
+## Lead Enrichment Example
+
+```ts
+import { Nua } from 'nuabase';
+import { z } from 'zod';
+
+const nua = new Nua({ apiKey: 'API-KEY' });
+
+const LeadInsights = z.object({
+  company_name: z.string(),
+  industry: z.string(),
+  company_size: z.enum(['SMB', 'Mid-market', 'Enterprise']),
+  recommended_follow_up: z.enum(['Call', 'Email', 'Event']),
+});
+
+const enrichLeads = nua.map({
+  name: 'leadInsights',
+  output: LeadInsights,
+  prompt:
+    'Summarize each inbound lead by extracting company_name, industry, company_size bucket (SMB, Mid-market, Enterprise), and the recommended_follow_up channel (Call, Email, or Event) based on their notes.',
+});
+
+const rows = [
+  {
+    leadId: 'lead-101',
+    name: 'Acme Analytics',
+    notes: 'Signed up after webinar, growth-stage SaaS, 80 employees. Wants a live demo next week.',
+  },
+  {
+    leadId: 'lead-102',
+    name: 'Bright Logistics',
+    notes: 'Regional freight operator asking for pricing via email. 12 depots across the Midwest.',
+  },
+  {
+    leadId: 'lead-103',
+    name: 'Nimbus Retail',
+    notes:
+      'Enterprise retailer. Mentioned they will send the procurement team to our booth at NRF.',
+  },
+];
+
+const response = await enrichLeads.now(rows, 'leadId'); // `leadId` is the primary key field
+
+if (response.isError) {
+  console.error(response.error);
+  return;
+}
+
+response.data.forEach(({ id, leadInsights }) => {
+  // leadInsights satisfies the LeadInsights schema
+  console.log(id, leadInsights.company_name, leadInsights.industry, leadInsights.company_size);
+});
+
+console.log(response.data);
+// -> [
+//   {
+//     id: 'lead-101',
+//     leadInsights: {
+//       company_name: 'Acme Analytics',
+//       industry: 'Software',
+//       company_size: 'Mid-market',
+//       recommended_follow_up: 'Call',
+//     },
+//   },
+//   // ...
+// ];
+```
+
+`map(data, primaryKey)` submits an asynchronous mapping job. But `map.now(data, primaryKey)` is immediate — it waits for completion and returns the full result.
+
+## Why Nuabase
+
+- Type-safe from prompt to runtime: Zod schemas compile to JSON Schema, and the SDK re-validates every response before you see it.
+- Zero glue code: Nuabase runs the queueing, retries, webhooks, SSE streaming, and polling so your application code stays clean.
+- Built-in performance: granular caching, cost attribution, and usage metrics come for free on every request.
+- Production visibility: every run shows up in the Nuabase dashboard with logs, prompt/response history, and tracing ids.
+
+## API Response
+
+Every call returns a discriminated union. When `isError` is `true`, you get a flat error object. Otherwise `isSuccess` is `true`, and `data` contains rows merged with your typed output—along with metadata for observability and caching.
+
+**Success**
+
+| Field               | Type                                                                     | Description                                                                 |
+| ------------------- | ------------------------------------------------------------------------ | --------------------------------------------------------------------------- |
+| `isSuccess`         | `true`                                                                   | Indicates that the request completed successfully.                          |
+| `data`              | `Array<{ [primaryKey]: unknown; [outputName]: z.infer<typeof output> }>` | Rows that merged the original primary key with the validated schema output. |
+| `llmRequestId`      | `string`                                                                 | Unique identifier for tracing each Nuabase LLM execution.                   |
+| `cacheHits`         | `number`                                                                 | Count of input rows served from Nuabase response cache.                     |
+| `rowsWithNoResults` | `string[]`                                                               | Primary keys that could not be resolved by the model.                       |
+| `isError`           | `false \| undefined`                                                     | Absent on success; included for type narrowing.                             |
+
+**Error**
+
+| Field     | Type     | Description                                              |
+| --------- | -------- | -------------------------------------------------------- |
+| `isError` | `true`   | Indicates the request failed.                            |
+| `error`   | `string` | Message describing the error returned by the API or SDK. |
+
+## SDK API
+
+**`new Nua(config?)`**
+Creates a client bound to your Nuabase account. Provide:
+
+- `apiKey?: string` – API key for authentication. Defaults to `process.env.NUABASE_API_KEY`.
+- `baseUrl?: string` – Override the API host. Defaults to `https://api.nuabase.com`.
+
+**`nua.map({ name, prompt, output })`**
+Declares a typed mapping function backed by Nuabase. Parameters:
+
+- `name: string` – Label applied to the enriched payload in each response row (e.g., `result.data[i][name]`).
+- `prompt: string` – Natural-language instructions sent to the LLM.
+- `output: ZodSchema` – Zod schema describing the output shape. Nuabase stores the JSON Schema twin and validates responses against it before returning.
+
+Returns a callable object (the mapper) with two entry points:
+
+- `mapper(data, primaryKey)` – Submits the job asynchronously and returns immediately with metadata and eventual results.
+- `mapper.now(data, primaryKey)` – Runs the job and waits until the full enriched result set is ready.
+
+Both entry points expect:
+
+- `data: Array<Record<string, unknown>>` – Rows you want Nuabase to enrich. Each row must include the primary key.
+- `primaryKey: string` – Field name that uniquely identifies each row within `data`. The SDK throws if the field is missing on any item.
+
+Both entry points resolve to either:
+
+- **Success** – `{ isSuccess: true, data, llmRequestId, cacheHits, rowsWithNoResults }`.
+- **Error** – `{ isError: true, error }`.
+
+## Next Steps
+
+- Create an API key or inspect request logs in the [Nuabase Console](https://console.nuabase.com/).
+- Explore more SDK usage patterns (SSE streaming, webhooks, caching) in the full docs at https://docs.nuabase.com.
+
+## Support
+
+Email us at [hello@nuabase.com](mailto:hello@nuabase.com). On X at [@NuabaseHQ](x.com/NuabaseHQ).
+
+## Credits
+
+The template for this package comes from https://github.com/rtivital/ts-package-template
+
+## License
+
+MIT

package/dist/cjs/index.cjs

@@ -0,0 +1,178 @@
+'use strict';
+
+var zod = require('zod');
+
+async function parseErrorResponse(response, urlPath) {
+  const fallbackMessage = `Request to ${urlPath} failed with status ${response.status}${response.statusText ? ` ${response.statusText}` : ""}`;
+  let responseBody = "";
+  try {
+    responseBody = (await response.text()).trim();
+  } catch {
+    return { error: fallbackMessage, isError: true };
+  }
+  if (!responseBody) {
+    return { error: fallbackMessage, isError: true };
+  }
+  const parsedBody = safeParseJson(responseBody);
+  if (parsedBody && typeof parsedBody === "object") {
+    const errorMessage = extractErrorMessage(parsedBody);
+    if (errorMessage) {
+      return { error: errorMessage, isError: true };
+    }
+  }
+  return { error: responseBody, isError: true };
+}
+function safeParseJson(payload) {
+  try {
+    return JSON.parse(payload);
+  } catch {
+    return void 0;
+  }
+}
+function extractErrorMessage(body) {
+  const e = body["error"];
+  if (e && typeof e === "string") return e;
+  return void 0;
+}
+
+function isErrorWithMessage(error) {
+  return typeof error === "object" && error !== null && "message" in error && typeof error.message === "string";
+}
+function getErrorMessageFromException(error) {
+  if (isErrorWithMessage(error)) {
+    return error.message;
+  }
+  return String(error);
+}
+
+class NuabaseAPIClient {
+  constructor(config = {}) {
+    this.apiKey = config.apiKey || process.env.NUABASE_API_KEY || "";
+    this.baseUrl = config.baseUrl || process.env.NUABASE_API_URL || "https://api.nuabase.com";
+    if (!this.apiKey) {
+      throw new Error(
+        "API key is required. Provide it via config.apiKey or NUABASE_API_KEY environment variable."
+      );
+    }
+  }
+  async request(urlPath, params) {
+    const url = `${this.baseUrl}/${urlPath}`;
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify(params)
+      });
+    } catch (e) {
+      return { error: `Error calling Nuabase API: ${getErrorMessageFromException(e)}` };
+    }
+    let result;
+    if (!response.ok) {
+      return await parseErrorResponse(response, urlPath);
+    }
+    try {
+      result = await response.json();
+    } catch {
+      return { error: "Invalid response received from Nuabase API call, unable to parse" };
+    }
+    return result;
+  }
+}
+
+const zs_MapResponseRecord = (primaryKeyName, outputKey, outputSchema) => {
+  const primaryKeySchema = zod.z.any();
+  return zod.z.object({
+    [primaryKeyName]: primaryKeySchema,
+    [outputKey]: outputSchema
+  }).strict();
+};
+const zs_MapSuccessDataResult = (primaryKeyName, outputKey, outputSchema) => {
+  const recordSchema = zs_MapResponseRecord(primaryKeyName, outputKey, outputSchema);
+  return zod.z.array(recordSchema);
+};
+const zs_MapRequestApiResponse_Success = (primaryKeyName, outputKey, outputSchema) => {
+  const dataSchema = zs_MapSuccessDataResult(primaryKeyName, outputKey, outputSchema);
+  return zod.z.object({
+    llmRequestId: zod.z.string(),
+    kind: zod.z.literal("map"),
+    data: dataSchema,
+    cacheHits: zod.z.number(),
+    rowsWithNoResults: zod.z.array(zod.z.string()),
+    isSuccess: zod.z.literal(true),
+    isError: zod.z.optional(zod.z.literal(false))
+  }).strict();
+};
+class Nua {
+  constructor(config) {
+    this.apiClient = new NuabaseAPIClient(config);
+  }
+  // Some of the checks here mirror type validation, but since our code could be run from
+  // untyped JavaScript, we still want runtime checks
+  static validateMapRequestParams(data, primaryKeyName) {
+    if (!Array.isArray(data)) {
+      throw new Error("`data` must be an array of objects.");
+    }
+    if (!primaryKeyName || typeof primaryKeyName !== "string") {
+      throw new Error("`primaryKeyName` must be a non-empty string.");
+    }
+    data.forEach((item, index) => {
+      if (item === null || typeof item !== "object" || Array.isArray(item)) {
+        throw new Error(`data[${index}] must be a non-null object.`);
+      }
+      if (!(primaryKeyName in item)) {
+        throw new Error(`data[${index}] must contain property '${primaryKeyName}'.`);
+      }
+    });
+  }
+  map(fnDef) {
+    const client = this.apiClient;
+    const outputJsonSchema = zod.z.toJSONSchema(fnDef.output);
+    const makeRequest = async (path, data, primaryKeyName) => {
+      Nua.validateMapRequestParams(data, primaryKeyName);
+      const response = await client.request(path, {
+        input: {
+          prompt: fnDef.prompt,
+          data,
+          primaryKey: primaryKeyName
+        },
+        output: {
+          schema: outputJsonSchema,
+          name: fnDef.name
+        }
+      });
+      if (response && typeof response === "object" && "error" in response)
+        return { error: String(response.error), isError: true };
+      const outputKey = fnDef.name;
+      const successSchema = zs_MapRequestApiResponse_Success(primaryKeyName, outputKey, fnDef.output);
+      const parsedResponse = successSchema.safeParse(response);
+      if (!parsedResponse.success) {
+        const emsg = zod.z.prettifyError(parsedResponse.error);
+        return { error: `Invalid data received from Nuabase API: ${emsg}`, isError: true };
+      }
+      return {
+        isSuccess: true,
+        llmRequestId: parsedResponse.data.llmRequestId,
+        kind: parsedResponse.data.kind,
+        data: parsedResponse.data.data,
+        rowsWithNoResults: parsedResponse.data.rowsWithNoResults,
+        cacheHits: parsedResponse.data.cacheHits
+      };
+    };
+    const baseInvoker = async (data, primaryKeyName) => {
+      return await makeRequest("map", data, primaryKeyName);
+    };
+    const nowInvoker = async (data, primaryKeyName) => {
+      return await makeRequest("map/now", data, primaryKeyName);
+    };
+    const fnReturnValue = Object.assign(baseInvoker, {
+      now: nowInvoker
+    });
+    return fnReturnValue;
+  }
+}
+
+exports.Nua = Nua;

package/dist/esm/index.mjs

@@ -0,0 +1,176 @@
+import { z } from 'zod';
+
+async function parseErrorResponse(response, urlPath) {
+  const fallbackMessage = `Request to ${urlPath} failed with status ${response.status}${response.statusText ? ` ${response.statusText}` : ""}`;
+  let responseBody = "";
+  try {
+    responseBody = (await response.text()).trim();
+  } catch {
+    return { error: fallbackMessage, isError: true };
+  }
+  if (!responseBody) {
+    return { error: fallbackMessage, isError: true };
+  }
+  const parsedBody = safeParseJson(responseBody);
+  if (parsedBody && typeof parsedBody === "object") {
+    const errorMessage = extractErrorMessage(parsedBody);
+    if (errorMessage) {
+      return { error: errorMessage, isError: true };
+    }
+  }
+  return { error: responseBody, isError: true };
+}
+function safeParseJson(payload) {
+  try {
+    return JSON.parse(payload);
+  } catch {
+    return void 0;
+  }
+}
+function extractErrorMessage(body) {
+  const e = body["error"];
+  if (e && typeof e === "string") return e;
+  return void 0;
+}
+
+function isErrorWithMessage(error) {
+  return typeof error === "object" && error !== null && "message" in error && typeof error.message === "string";
+}
+function getErrorMessageFromException(error) {
+  if (isErrorWithMessage(error)) {
+    return error.message;
+  }
+  return String(error);
+}
+
+class NuabaseAPIClient {
+  constructor(config = {}) {
+    this.apiKey = config.apiKey || process.env.NUABASE_API_KEY || "";
+    this.baseUrl = config.baseUrl || process.env.NUABASE_API_URL || "https://api.nuabase.com";
+    if (!this.apiKey) {
+      throw new Error(
+        "API key is required. Provide it via config.apiKey or NUABASE_API_KEY environment variable."
+      );
+    }
+  }
+  async request(urlPath, params) {
+    const url = `${this.baseUrl}/${urlPath}`;
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify(params)
+      });
+    } catch (e) {
+      return { error: `Error calling Nuabase API: ${getErrorMessageFromException(e)}` };
+    }
+    let result;
+    if (!response.ok) {
+      return await parseErrorResponse(response, urlPath);
+    }
+    try {
+      result = await response.json();
+    } catch {
+      return { error: "Invalid response received from Nuabase API call, unable to parse" };
+    }
+    return result;
+  }
+}
+
+const zs_MapResponseRecord = (primaryKeyName, outputKey, outputSchema) => {
+  const primaryKeySchema = z.any();
+  return z.object({
+    [primaryKeyName]: primaryKeySchema,
+    [outputKey]: outputSchema
+  }).strict();
+};
+const zs_MapSuccessDataResult = (primaryKeyName, outputKey, outputSchema) => {
+  const recordSchema = zs_MapResponseRecord(primaryKeyName, outputKey, outputSchema);
+  return z.array(recordSchema);
+};
+const zs_MapRequestApiResponse_Success = (primaryKeyName, outputKey, outputSchema) => {
+  const dataSchema = zs_MapSuccessDataResult(primaryKeyName, outputKey, outputSchema);
+  return z.object({
+    llmRequestId: z.string(),
+    kind: z.literal("map"),
+    data: dataSchema,
+    cacheHits: z.number(),
+    rowsWithNoResults: z.array(z.string()),
+    isSuccess: z.literal(true),
+    isError: z.optional(z.literal(false))
+  }).strict();
+};
+class Nua {
+  constructor(config) {
+    this.apiClient = new NuabaseAPIClient(config);
+  }
+  // Some of the checks here mirror type validation, but since our code could be run from
+  // untyped JavaScript, we still want runtime checks
+  static validateMapRequestParams(data, primaryKeyName) {
+    if (!Array.isArray(data)) {
+      throw new Error("`data` must be an array of objects.");
+    }
+    if (!primaryKeyName || typeof primaryKeyName !== "string") {
+      throw new Error("`primaryKeyName` must be a non-empty string.");
+    }
+    data.forEach((item, index) => {
+      if (item === null || typeof item !== "object" || Array.isArray(item)) {
+        throw new Error(`data[${index}] must be a non-null object.`);
+      }
+      if (!(primaryKeyName in item)) {
+        throw new Error(`data[${index}] must contain property '${primaryKeyName}'.`);
+      }
+    });
+  }
+  map(fnDef) {
+    const client = this.apiClient;
+    const outputJsonSchema = z.toJSONSchema(fnDef.output);
+    const makeRequest = async (path, data, primaryKeyName) => {
+      Nua.validateMapRequestParams(data, primaryKeyName);
+      const response = await client.request(path, {
+        input: {
+          prompt: fnDef.prompt,
+          data,
+          primaryKey: primaryKeyName
+        },
+        output: {
+          schema: outputJsonSchema,
+          name: fnDef.name
+        }
+      });
+      if (response && typeof response === "object" && "error" in response)
+        return { error: String(response.error), isError: true };
+      const outputKey = fnDef.name;
+      const successSchema = zs_MapRequestApiResponse_Success(primaryKeyName, outputKey, fnDef.output);
+      const parsedResponse = successSchema.safeParse(response);
+      if (!parsedResponse.success) {
+        const emsg = z.prettifyError(parsedResponse.error);
+        return { error: `Invalid data received from Nuabase API: ${emsg}`, isError: true };
+      }
+      return {
+        isSuccess: true,
+        llmRequestId: parsedResponse.data.llmRequestId,
+        kind: parsedResponse.data.kind,
+        data: parsedResponse.data.data,
+        rowsWithNoResults: parsedResponse.data.rowsWithNoResults,
+        cacheHits: parsedResponse.data.cacheHits
+      };
+    };
+    const baseInvoker = async (data, primaryKeyName) => {
+      return await makeRequest("map", data, primaryKeyName);
+    };
+    const nowInvoker = async (data, primaryKeyName) => {
+      return await makeRequest("map/now", data, primaryKeyName);
+    };
+    const fnReturnValue = Object.assign(baseInvoker, {
+      now: nowInvoker
+    });
+    return fnReturnValue;
+  }
+}
+
+export { Nua };

package/dist/types/index.d.cts

@@ -0,0 +1,3 @@
+export { type NuabaseConfig } from './lib/api-client';
+export { type NuabaseError } from './lib/error-response';
+export { Nua } from './nua';

package/dist/types/index.d.mts

@@ -0,0 +1,3 @@
+export { type NuabaseConfig } from './lib/api-client';
+export { type NuabaseError } from './lib/error-response';
+export { Nua } from './nua';

package/dist/types/lib/api-client.d.ts

@@ -0,0 +1,11 @@
+import { NuabaseError } from './error-response';
+export type NuabaseConfig = {
+    apiKey?: string;
+    baseUrl?: string;
+};
+export declare class NuabaseAPIClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    constructor(config?: NuabaseConfig);
+    request(urlPath: string, params: object): Promise<NuabaseError | unknown>;
+}

package/dist/types/lib/error-response.d.ts

@@ -0,0 +1,6 @@
+export type NuabaseError = {
+    error: string;
+    isError: true;
+    isSuccess?: false;
+};
+export declare function parseErrorResponse(response: Response, urlPath: string): Promise<NuabaseError>;

package/dist/types/lib/error-utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Safely extracts an error message from an unknown value.
+ * @param error The unknown value caught in a catch block.
+ * @returns A string representing the error message.
+ */
+export declare function getErrorMessageFromException(error: unknown): string;

package/dist/types/nua.d.ts

@@ -0,0 +1,33 @@
+import { NuabaseAPIClient, NuabaseConfig } from './lib/api-client';
+import { NuabaseError } from './lib/error-response';
+import { z } from 'zod';
+type MappingFnDef<OutputName extends string, OutputZodSchema extends z.ZodTypeAny> = {
+    name: OutputName;
+    prompt: string;
+    output: OutputZodSchema;
+};
+type MapResponseRecord<OutputZodSchema extends z.ZodTypeAny, OutputName extends string, InputRecord extends Record<string, unknown>, PrimaryKeyName extends keyof InputRecord & string> = {
+    [Key in PrimaryKeyName | OutputName]: Key extends PrimaryKeyName ? InputRecord[PrimaryKeyName] : z.infer<OutputZodSchema>;
+};
+type MapSuccessDataResult<OutputZodSchema extends z.ZodTypeAny, OutputName extends string, InputRecord extends Record<string, unknown>, PrimaryKeyName extends keyof InputRecord & string> = Array<MapResponseRecord<OutputZodSchema, OutputName, InputRecord, PrimaryKeyName>>;
+type MapRequestApiResponse_Success<OutputZodSchema extends z.ZodTypeAny, OutputName extends string, InputRecord extends Record<string, unknown>, PrimaryKeyName extends keyof InputRecord & string> = {
+    data: MapSuccessDataResult<OutputZodSchema, OutputName, InputRecord, PrimaryKeyName>;
+    cacheHits: number;
+    llmRequestId: string;
+    kind: 'map';
+    rowsWithNoResults: string[];
+    isSuccess: true;
+    isError?: false;
+};
+type MapResult<OutputZodSchema extends z.ZodTypeAny, OutputName extends string, InputRecord extends Record<string, unknown>, PrimaryKeyName extends keyof InputRecord & string> = NuabaseError | MapRequestApiResponse_Success<OutputZodSchema, OutputName, InputRecord, PrimaryKeyName>;
+type MapInvoker<OutputZodSchema extends z.ZodTypeAny, OutputName extends string> = {
+    <InputRecord extends Record<string, unknown>, PrimaryKeyName extends keyof InputRecord & string>(data: InputRecord[], primaryKeyName: PrimaryKeyName): Promise<MapResult<OutputZodSchema, OutputName, InputRecord, PrimaryKeyName>>;
+    now: <InputRecord extends Record<string, unknown>, PrimaryKeyName extends keyof InputRecord & string>(data: InputRecord[], primaryKeyName: PrimaryKeyName) => Promise<MapResult<OutputZodSchema, OutputName, InputRecord, PrimaryKeyName>>;
+};
+export declare class Nua {
+    apiClient: NuabaseAPIClient;
+    constructor(config?: NuabaseConfig);
+    static validateMapRequestParams(data: unknown, primaryKeyName: unknown): void;
+    map<OutputName extends string, OutputZodSchema extends z.ZodTypeAny>(fnDef: MappingFnDef<OutputName, OutputZodSchema>): MapInvoker<OutputZodSchema, OutputName>;
+}
+export {};

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "nuabase",
+  "description": "Nuabase TypeScript client to create typed functions from LLM prompts",
+  "packageManager": "yarn@4.10.3+sha512.c38cafb5c7bb273f3926d04e55e1d8c9dfa7d9c3ea1f36a4868fa028b9e5f72298f0b7f401ad5eb921749eb012eb1c3bb74bf7503df3ee43fd600d14a018266f",
+  "version": "1.0.0",
+  "type": "module",
+  "author": "Jasim A Basheer <jasim@nuabase.com>",
+  "engines": {
+    "node": ">=16.6.0"
+  },
+  "keywords": [
+    "typescript",
+    "nuabase",
+    "ai",
+    "llm"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nuabase/ts-sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/nuabase/ts-sdk/issues"
+  },
+  "homepage": "https://github.com/nuabase/ts-sdk#readme",
+  "main": "./dist/cjs/index.cjs",
+  "types": "./dist/types/index.d.cts",
+  "module": "./dist/esm/index.mjs",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/types/index.d.mts",
+        "default": "./dist/esm/index.mjs"
+      },
+      "require": {
+        "types": "./dist/types/index.d.cts",
+        "default": "./dist/cjs/index.cjs"
+      }
+    }
+  },
+  "peerDependencies": {
+    "zod": "^4.1.5"
+  },
+  "scripts": {
+    "clean": "rimraf dist",
+    "generate-dts": "tsx scripts/generate-dts",
+    "build": "rollup -c rollup.config.js && npm run generate-dts",
+    "pack:test": "tsx scripts/pack-test",
+    "prettier:check": "prettier --check \"**/*.{ts,tsx}\"",
+    "prettier:write": "prettier --write \"**/*.{ts,tsx}\"",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint --cache .",
+    "jest": "jest",
+    "test": "npm run prettier:check && npm run typecheck && npm run lint && npm run jest && npm run build && npm run pack:test",
+    "release": "npm test && tsx scripts/release",
+    "knip": "knip"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.35.0",
+    "@ianvs/prettier-plugin-sort-imports": "^4.7.0",
+    "@rollup/plugin-commonjs": "^28.0.6",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-replace": "^6.0.2",
+    "@types/fs-extra": "^11",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24.3.3",
+    "@types/signale": "^1",
+    "@types/yargs": "^17.0.33",
+    "chalk": "^5.6.2",
+    "esbuild": "^0.25.9",
+    "eslint": "^9.35.0",
+    "fs-extra": "^11.3.1",
+    "jest": "^30.1.3",
+    "knip": "^5.63.1",
+    "new-github-release-url": "^2.0.0",
+    "open": "^10.2.0",
+    "prettier": "^3.6.2",
+    "rimraf": "^6.0.1",
+    "rollup": "^4.50.1",
+    "rollup-plugin-esbuild": "^6.2.1",
+    "rollup-plugin-node-externals": "^8.1.1",
+    "signale": "^1.4.0",
+    "simple-git": "^3.28.0",
+    "ts-jest": "^29.4.1",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.43.0",
+    "version-next": "^1.0.2",
+    "yargs": "^18.0.0",
+    "zod": "^4.1.5",
+    "zx": "^8.8.1"
+  }
+}