nuabase 1.2.0 → 2.0.0

package/README.md

@@ -31,23 +31,22 @@ const LeadInsights = z.object({
 });
 ```
 
-**3. Declare the prompt.** Turn it into a typed function:
+**3. Call the API.** Use `list()` for array operations:
 
 ```ts
-const classifyLeads = new Nua().createArrayFn({
-  prompt: 'Classify each lead with industry and company_size bucket.',
-  output: {
-    name: 'leadInsights',
-    schema: LeadInsights,
-  },
+const nua = Nua.gateway({ apiKey: 'YOUR_API_KEY' });
+
+const result = await nua.list('Classify each lead with industry and company_size bucket.', {
+  input: leads,
+  primaryKey: 'id',
+  output: { name: 'leadInsights', schema: LeadInsights },
 });
 ```
 
-**4. Invoke.** Call it like any other async function:
+**4. Use the result.** Check for success and access typed data:
 
 ```ts
-const result = await classifyLeads(leads, 'id');
-if (result.isError) throw new Error(result.error);
+if (!result.success) throw new Error(result.error);
 console.log(result.data[0].leadInsights);
 // -> { industry: 'Software', company_size: 'Mid-market' }
 ```
@@ -62,7 +61,7 @@ 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"})`):
+3. Set `NUABASE_API_KEY` environment variable, or pass it directly in `Nua.gateway({ apiKey: "KEY" })`:
 
 ## Lead Enrichment Example
 
@@ -70,7 +69,7 @@ npm install nuabase zod
 import { Nua } from 'nuabase';
 import { z } from 'zod';
 
-const nua = new Nua({ apiKey: 'API-KEY' });
+const nua = Nua.gateway({ apiKey: 'API-KEY' });
 
 const LeadInsights = z.object({
   company_name: z.string(),
@@ -79,15 +78,6 @@ const LeadInsights = z.object({
   recommended_follow_up: z.enum(['Call', 'Email', 'Event']),
 });
 
-const enrichLeads = nua.createArrayFn({
-  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.',
-  output: {
-    name: 'leadInsights',
-    schema: LeadInsights,
-  },
-});
-
 const rows = [
   {
     leadId: 'lead-101',
@@ -107,9 +97,16 @@ const rows = [
   },
 ];
 
-const response = await enrichLeads(rows, 'leadId'); // `leadId` is the primary key field
+const response = await nua.list(
+  '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.',
+  {
+    input: rows,
+    primaryKey: 'leadId',
+    output: { name: 'leadInsights', schema: LeadInsights },
+  }
+);
 
-if (response.isError) {
+if (!response.success) {
   console.error(response.error);
   return;
 }
@@ -129,13 +126,12 @@ console.log(response.data);
 //       company_size: 'Mid-market',
 //       recommended_follow_up: 'Call',
 //     },
-//     sourceRow: { leadId: 'lead-101', name: 'Acme Analytics', notes: '...' },
 //   },
 //   // ...
 // ];
 ```
 
-The default invocation waits for completion and returns the full result. Use `.queue(data, primaryKey)` to submit an asynchronous job and receive streaming updates via SSE.
+The default invocation waits for completion and returns the full result. Use `nua.queueList()` to submit an asynchronous job and receive streaming updates via SSE.
 
 ## Why Nuabase
 
@@ -146,61 +142,103 @@ The default invocation waits for completion and returns the full result. Use `.q
 
 ## 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.
+Every call returns a discriminated union. When `success` is `false`, you get an error object. Otherwise `success` is `true`, and `data` contains your typed output along with metadata.
 
 **Success**
 
-| Field               | Type                                                                                           | Description                                                                                                                  |
-| ------------------- | ---------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
-| `isSuccess`         | `true`                                                                                         | Indicates that the request completed successfully.                                                                           |
-| `data`              | `Array<{ [primaryKey]: unknown; [outputName]: z.infer<typeof output>; sourceRow: InputRow }>` | Rows that merged the original primary key with the validated schema output, plus the full `sourceRow` for convenience.      |
-| `llmRequestId`      | `string`                                                                                       | Unique identifier for tracing each Nuabase LLM execution.                                                                    |
-| `usage`             | `{ promptTokens: number; completionTokens: number; totalTokens: number }`                      | Token usage statistics for the LLM request.                                                                                  |
-| `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.                                                                              |
+| Field       | Type                                                      | Description                                             |
+| ----------- | --------------------------------------------------------- | ------------------------------------------------------- |
+| `success`   | `true`                                                    | Indicates that the request completed successfully.      |
+| `data`      | `T` (for `get`) or `Array<{ [pk]: value; [output]: T }>` (for `list`) | The typed result matching your schema.    |
+| `usage`     | `{ promptTokens, completionTokens, totalTokens }`         | Token usage statistics for the LLM request.             |
+| `model`     | `string`                                                  | The LLM model used for this request.                    |
+| `latencyMs` | `number`                                                  | Request latency in milliseconds.                        |
+| `source`    | `'gateway'` \| `'direct'`                                 | Which backend processed the request.                    |
+| `meta`      | `object`                                                  | Additional metadata (varies by source).                 |
+
+**Gateway-specific metadata** (`meta` when `source` is `'gateway'`):
+
+| Field        | Type      | Description                                    |
+| ------------ | --------- | ---------------------------------------------- |
+| `requestId`  | `string`  | Unique identifier for tracing.                 |
+| `cached`     | `boolean` | Whether the result was served from cache.      |
+| `llmUsage`   | `object`  | Token usage from LLM calls.                    |
+| `cacheUsage` | `object`  | Token usage served from cache.                 |
 
 **Error**
 
-| Field     | Type     | Description                                              |
-| --------- | -------- | -------------------------------------------------------- |
-| `isError` | `true`   | Indicates the request failed.                            |
-| `error`   | `string` | Message describing the error returned by the API or SDK. |
+| Field       | Type                          | Description                                              |
+| ----------- | ----------------------------- | -------------------------------------------------------- |
+| `success`   | `false`                       | Indicates the request failed.                            |
+| `error`     | `string`                      | Message describing the error.                            |
+| `source`    | `'gateway'` \| `'direct'`     | Which backend returned the error.                        |
+| `latencyMs` | `number`                      | Time until failure in milliseconds.                      |
 
 ## SDK API
 
-**`new Nua(config?)`**
-Creates a client bound to your Nuabase account. Provide:
+### Constructors
+
+**`Nua.gateway(config?)`**
+Creates a client that connects to the Nuabase API gateway. Use this for production deployments with caching, request tracking, and async job support.
 
 - `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.createArrayFn({ prompt, output })`**
-Declares a typed array mapping function backed by Nuabase. Parameters:
+**`Nua.direct(config)`**
+Creates a client that calls LLM providers directly (in-process). Use this for serverless, edge functions, or CLI tools where you don't need the gateway infrastructure.
 
-- `prompt: string` – Natural-language instructions sent to the LLM.
-- `output: { name: string; schema: ZodSchema }` – Output configuration with a name and Zod schema describing the output shape.
+- `model: string` – The model to use (e.g., `'gpt-4o-mini'`).
+- `providers: { openai?: { apiKey: string }, ... }` – Provider credentials.
 
-Returns a callable function with two modes:
+### Methods
 
-- `fn(data, primaryKey)` – Default mode. Runs the job and waits until the full enriched result set is ready.
-- `fn.queue(data, primaryKey)` – Submits the job asynchronously and returns streaming metadata via SSE.
+**`nua.get(prompt)`**
+Returns a simple string response from the LLM.
 
-Both modes expect:
+```ts
+const result = await nua.get("Tell me a joke");
+if (result.success) console.log(result.data); // string
+```
 
-- `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.
+**`nua.get(prompt, options)`**
+Returns a typed single value. Parameters:
 
-Both modes resolve to either:
+- `prompt: string` – Natural-language instructions sent to the LLM.
+- `options.input?: unknown` – Optional input data to include in the prompt.
+- `options.output: { name: string; schema: ZodSchema }` – Output name and Zod schema.
 
-- **Success** – `{ isSuccess: true, data, llmRequestId, usage, cacheHits, rowsWithNoResults }`.
-- **Error** – `{ isError: true, error }`.
+```ts
+const result = await nua.get("Extract the address", {
+  input: "123 Main St, Springfield, IL 62701",
+  output: { name: 'address', schema: AddressSchema },
+});
+if (result.success) console.log(result.data); // typed as z.infer<typeof AddressSchema>
+```
 
-**`nua.createFn({ prompt, output })`**
-Declares a typed single-value function backed by Nuabase. Similar to `createArrayFn` but for processing a single input value instead of an array. Returns a function that accepts a single input value.
+**`nua.list(prompt, options)`**
+Processes an array of items. Parameters:
 
-**`nua.getRequest(llmRequestId)`**
-Retrieves request details for a completed LLM execution using its request ID.
+- `prompt: string` – Natural-language instructions for each item.
+- `options.input: Array<Record<string, unknown>>` – Rows to process.
+- `options.primaryKey: string` – Field that uniquely identifies each row.
+- `options.output: { name: string; schema: ZodSchema }` – Output configuration.
+
+```ts
+const result = await nua.list("Classify each lead", {
+  input: leads,
+  primaryKey: 'id',
+  output: { name: 'classification', schema: ClassificationSchema },
+});
+if (result.success) {
+  result.data.forEach(row => console.log(row.id, row.classification));
+}
+```
+
+**`nua.queueGet(prompt, options?)`** *(Gateway mode only)*
+Submits an async job for single-value operations. Returns `{ success: true, jobId }`.
+
+**`nua.queueList(prompt, options)`** *(Gateway mode only)*
+Submits an async job for array operations. Returns `{ success: true, jobId }`.
 
 ## Next Steps
 
@@ -211,6 +249,10 @@ Retrieves request details for a completed LLM execution using its request ID.
 
 Email us at [hello@nuabase.com](mailto:hello@nuabase.com). On X at [@NuabaseHQ](x.com/NuabaseHQ).
 
+## Tests
+
+See [TESTING.md](TESTING.md)
+
 ## Credits
 
 The template for this package comes from https://github.com/rtivital/ts-package-template