nuabase 1.0.0 → 1.1.0

package/README.md

@@ -1,26 +1,25 @@
-# Nuabase TypeScript client
+## Nuabase TypeScript SDK
 
-Nuabase turns LLM prompts into type-safe functions in under five lines.
+Nuabase turns LLM prompts into type-safe functions in under five lines of code. Set up your free account now at [Nuabase](https://nuabase.com).
+
+With Nuabase, you write a prompt, specify the output schema, and get back a well-typed function. You can invoke it with input data, like any other code in your application, and receive data that matches the exact schema you specified.
 
 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.
+- Provide free-form text input for faster filling of complex HTML forms
+- Enrich a list of food items with nutrition facts
+- Tag sales leads with more details about the company
 
-You don't have to do any custom custom orchestration, or run polling, or schema validation.
+Behind the scenes, Nuabase runs the LLM transformation as async jobs, and once ready, call your server API with the results using Webhooks. It can also stream the result directly to your front-end using SSE. You can also see all requests and responses as they happen in the [Nuabase Console](https://console.nuabase.com). All outputs are guaranteed to match the schema you specified.
 
-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.
+One major reason I built Nuabase is the need for granular, row-level caching. For example, let's say you want to classify your bank transaction entries, and map them to your chart of accounts. With Nuabase's row-level caching, it will only send new entries to the LLM. Any specific entry that it has seen before will be returned from the cache. This also means you can make LLM requests multiple times with identical values, and after the first time, they will return immediately without needing to go through the LLM.
 
-## At a Glance
+## Usage 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.' },
-];
+const leads = [{ id: 'lead-101', notes: 'Growth-stage SaaS, ~80 employees, wants a demo.' }];
 ```
 
 **2. Desired shape.** Describe the structure you expect back:
@@ -35,10 +34,12 @@ const LeadInsights = z.object({
 **3. Declare the prompt.** Turn it into a typed function:
 
 ```ts
-const classifyLeads = new Nua().map({
-  name: 'insights',
-  output: LeadInsights,
+const classifyLeads = new Nua().createArrayFn({
   prompt: 'Classify each lead with industry and company_size bucket.',
+  output: {
+    name: 'leadInsights',
+    schema: LeadInsights,
+  },
 });
 ```
 
@@ -78,11 +79,13 @@ const LeadInsights = z.object({
   recommended_follow_up: z.enum(['Call', 'Email', 'Event']),
 });
 
-const enrichLeads = nua.map({
-  name: 'leadInsights',
-  output: LeadInsights,
+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 = [

package/dist/cjs/index.cjs

@@ -2,6 +2,16 @@
 
 var zod = require('zod');
 
+function resolveConfigValue(config, key, envVar) {
+  if (config[key]) return config[key];
+  const pe = globalThis.process;
+  const isNode = !!pe?.versions?.node;
+  if (isNode) {
+    return pe?.env?.[envVar];
+  }
+  return void 0;
+}
+
 async function parseErrorResponse(response, urlPath) {
   const fallbackMessage = `Request to ${urlPath} failed with status ${response.status}${response.statusText ? ` ${response.statusText}` : ""}`;
   let responseBody = "";
@@ -47,25 +57,29 @@ function getErrorMessageFromException(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";
+    this.apiKey = resolveConfigValue(config, "apiKey", "NUABASE_API_KEY") || "";
+    this.baseUrl = resolveConfigValue(config, "baseUrl", "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) {
+  async request(method, urlPath, params) {
     const url = `${this.baseUrl}/${urlPath}`;
     let response;
+    const hasBody = method !== "GET" && params !== void 0;
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`
+    };
+    if (hasBody) {
+      headers["Content-Type"] = "application/json";
+    }
     try {
       response = await fetch(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${this.apiKey}`
-        },
-        body: JSON.stringify(params)
+        method,
+        headers,
+        body: hasBody ? JSON.stringify(params) : void 0
       });
     } catch (e) {
       return { error: `Error calling Nuabase API: ${getErrorMessageFromException(e)}` };
@@ -83,22 +97,46 @@ class NuabaseAPIClient {
   }
 }
 
-const zs_MapResponseRecord = (primaryKeyName, outputKey, outputSchema) => {
+const zs_NuaQueuedResponse = zod.z.object({
+  id: zod.z.string(),
+  sseUrl: zod.z.string().min(1)
+}).strict();
+
+const validateArrayRequestParams = (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}'.`);
+    }
+  });
+};
+
+const zs_ResponseRecord = (primaryKeyName, outputKey, outputSchema) => {
   const primaryKeySchema = zod.z.any();
-  return zod.z.object({
+  const shape = {
     [primaryKeyName]: primaryKeySchema,
     [outputKey]: outputSchema
-  }).strict();
-};
-const zs_MapSuccessDataResult = (primaryKeyName, outputKey, outputSchema) => {
-  const recordSchema = zs_MapResponseRecord(primaryKeyName, outputKey, outputSchema);
-  return zod.z.array(recordSchema);
+  };
+  return zod.z.object(shape).strict();
 };
-const zs_MapRequestApiResponse_Success = (primaryKeyName, outputKey, outputSchema) => {
-  const dataSchema = zs_MapSuccessDataResult(primaryKeyName, outputKey, outputSchema);
+const createNuaApiResponseCastArray = (primaryKeyName, outputKey, outputSchema) => {
+  const recordSchema = zs_ResponseRecord(
+    primaryKeyName,
+    outputKey,
+    outputSchema
+  );
+  const dataSchema = zod.z.array(recordSchema);
   return zod.z.object({
     llmRequestId: zod.z.string(),
-    kind: zod.z.literal("map"),
+    kind: zod.z.literal("cast/array"),
     data: dataSchema,
     cacheHits: zod.z.number(),
     rowsWithNoResults: zod.z.array(zod.z.string()),
@@ -106,72 +144,309 @@ const zs_MapRequestApiResponse_Success = (primaryKeyName, outputKey, outputSchem
     isError: zod.z.optional(zod.z.literal(false))
   }).strict();
 };
-class Nua {
-  constructor(config) {
-    this.apiClient = new NuabaseAPIClient(config);
+const zs_NuaApiResponse_CastArray = createNuaApiResponseCastArray;
+
+const zs_ArrayFnDef = zod.z.object({
+  prompt: zod.z.string(),
+  output: zod.z.object({
+    name: zod.z.string(),
+    schema: zod.z.custom(
+      (value) => value instanceof zod.z.ZodType,
+      "Expected a Zod schema"
+    )
+  })
+});
+const validateArrayFnDef = (fnDef) => {
+  const parsed = zs_ArrayFnDef.safeParse(fnDef);
+  if (!parsed.success) {
+    const message = zod.z.prettifyError(parsed.error);
+    throw new TypeError(`Invalid array function definition: ${message}`);
   }
-  // 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.");
+  return parsed.data;
+};
+
+function addOriginalInputRows(inputRows, outputRows, primaryKeyName) {
+  const lookup = /* @__PURE__ */ new Map();
+  for (const row of inputRows) {
+    lookup.set(row[primaryKeyName], row);
+  }
+  return outputRows.map((row) => {
+    const primaryKeyValue = row[primaryKeyName];
+    const sourceRow = lookup.get(primaryKeyValue);
+    if (!sourceRow) {
+      throw new Error(
+        `Unable to locate source row for primary key "${String(primaryKeyValue)}" in cast array response.`
+      );
     }
-    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
-      };
+    return {
+      ...row,
+      sourceRow
     };
-    const baseInvoker = async (data, primaryKeyName) => {
-      return await makeRequest("map", data, primaryKeyName);
+  });
+}
+const toCastArrayApiRequest = (prompt, data, primaryKeyName, outputName, outputSchema) => ({
+  input: {
+    prompt,
+    data,
+    primaryKey: primaryKeyName
+  },
+  output: {
+    schema: outputSchema,
+    name: outputName
+  }
+});
+const createArrayFn = (client, inputFnDef) => {
+  const fnDef = validateArrayFnDef(inputFnDef);
+  const outputJsonSchema = zod.z.toJSONSchema(fnDef.output.schema);
+  const toNuabaseError = (response) => {
+    if (response && typeof response === "object" && "error" in response)
+      return { error: String(response.error), isError: true };
+    return void 0;
+  };
+  const baseFn = async (data, primaryKeyName) => {
+    validateArrayRequestParams(data, primaryKeyName);
+    const response = await client.request(
+      "POST",
+      "cast/array",
+      toCastArrayApiRequest(
+        fnDef.prompt,
+        data,
+        primaryKeyName,
+        fnDef.output.name,
+        outputJsonSchema
+      )
+    );
+    const error = toNuabaseError(response);
+    if (error) return error;
+    const parsedResponse = zs_NuaQueuedResponse.safeParse(response);
+    if (!parsedResponse.success) {
+      const emsg = zod.z.prettifyError(parsedResponse.error);
+      return { error: `Invalid queued response received from Nuabase API: ${emsg}`, isError: true };
+    }
+    return parsedResponse.data;
+  };
+  const nowFn = async (data, primaryKeyName) => {
+    validateArrayRequestParams(data, primaryKeyName);
+    const response = await client.request(
+      "POST",
+      "cast/array/now",
+      toCastArrayApiRequest(
+        fnDef.prompt,
+        data,
+        primaryKeyName,
+        fnDef.output.name,
+        outputJsonSchema
+      )
+    );
+    const error = toNuabaseError(response);
+    if (error) return error;
+    const outputKey = fnDef.output.name;
+    const successSchema = zs_NuaApiResponse_CastArray(primaryKeyName, outputKey, fnDef.output.schema);
+    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: addOriginalInputRows(
+        data,
+        parsedResponse.data.data,
+        primaryKeyName
+      ),
+      rowsWithNoResults: parsedResponse.data.rowsWithNoResults,
+      cacheHits: parsedResponse.data.cacheHits
     };
-    const nowInvoker = async (data, primaryKeyName) => {
-      return await makeRequest("map/now", data, primaryKeyName);
+  };
+  return Object.assign(baseFn, {
+    now: nowFn
+  });
+};
+
+const createNuaApiResponseCastValue = (outputKey, outputSchema) => {
+  return zod.z.object({
+    llmRequestId: zod.z.string(),
+    kind: zod.z.literal("cast/value"),
+    data: outputSchema,
+    isCacheHit: zod.z.boolean(),
+    isSuccess: zod.z.literal(true),
+    isError: zod.z.optional(zod.z.literal(false))
+  }).strict();
+};
+const zs_NuaApiResponse_CastValue = createNuaApiResponseCastValue;
+
+const zs_ValueFnDef = zod.z.object({
+  prompt: zod.z.string(),
+  output: zod.z.object({
+    name: zod.z.string(),
+    schema: zod.z.custom(
+      (value) => value instanceof zod.z.ZodType,
+      "Expected a Zod schema for `output.schema`"
+    )
+  })
+});
+const validateValueFnDef = (fnDef) => {
+  const parsed = zs_ValueFnDef.safeParse(fnDef);
+  if (!parsed.success) {
+    const message = zod.z.prettifyError(parsed.error);
+    throw new TypeError(`Invalid value function definition: ${message}`);
+  }
+  return parsed.data;
+};
+
+const toCastValueApiRequest = (prompt, data, outputName, outputSchema) => ({
+  input: {
+    prompt,
+    data
+  },
+  output: {
+    schema: outputSchema,
+    name: outputName
+  }
+});
+const createValueFn = (client, inputFnDef) => {
+  const fnDef = validateValueFnDef(inputFnDef);
+  const outputJsonSchema = zod.z.toJSONSchema(fnDef.output.schema);
+  const toNuabaseError = (response) => {
+    if (response && typeof response === "object" && "error" in response)
+      return { error: String(response.error), isError: true };
+    return void 0;
+  };
+  const sendRequest = async (path, data) => client.request(
+    "POST",
+    path,
+    toCastValueApiRequest(fnDef.prompt, data, fnDef.output.name, outputJsonSchema)
+  );
+  const baseFn = async (data) => {
+    const response = await sendRequest("cast/value", data);
+    const error = toNuabaseError(response);
+    if (error) return error;
+    const parsedResponse = zs_NuaQueuedResponse.safeParse(response);
+    if (!parsedResponse.success) {
+      const emsg = zod.z.prettifyError(parsedResponse.error);
+      return { error: `Invalid queued response received from Nuabase API: ${emsg}`, isError: true };
+    }
+    return parsedResponse.data;
+  };
+  const nowFn = async (data) => {
+    const response = await sendRequest("cast/value/now", data);
+    const error = toNuabaseError(response);
+    if (error) return error;
+    const outputKey = fnDef.output.name;
+    const successSchema = zs_NuaApiResponse_CastValue(
+      outputKey,
+      fnDef.output.schema
+    );
+    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,
+      isCacheHit: parsedResponse.data.isCacheHit
     };
-    const fnReturnValue = Object.assign(baseInvoker, {
-      now: nowInvoker
-    });
-    return fnReturnValue;
+  };
+  return Object.assign(baseFn, {
+    now: nowFn
+  });
+};
+
+const errorParseFailed = {
+  kind: "internal-error",
+  message: "Unable to parse stored LLM result"
+};
+const dateFromIso = zod.z.preprocess(
+  (value) => {
+    if (value == null) return null;
+    if (value instanceof Date) return value;
+    if (typeof value === "string") {
+      const parsed = new Date(value);
+      if (!Number.isNaN(parsed.getTime())) return parsed;
+    }
+    return zod.z.NEVER;
+  },
+  zod.z.union([zod.z.date(), zod.z.null()])
+);
+const mandatoryDateFromIso = zod.z.preprocess((value) => {
+  if (value instanceof Date) return value;
+  if (typeof value === "string") {
+    const parsed = new Date(value);
+    if (!Number.isNaN(parsed.getTime())) return parsed;
+  }
+  return zod.z.NEVER;
+}, zod.z.date());
+const apiResponseSchema = zod.z.object({
+  id: zod.z.string(),
+  requestType: zod.z.string(),
+  llmStatus: zod.z.union([
+    zod.z.literal("pending"),
+    zod.z.literal("processing"),
+    zod.z.literal("success"),
+    zod.z.literal("failed")
+  ]),
+  sseStatus: zod.z.union([
+    zod.z.literal("n/a"),
+    zod.z.literal("pending"),
+    zod.z.literal("sent"),
+    zod.z.literal("failed")
+  ]),
+  webhookStatus: zod.z.union([
+    zod.z.literal("n/a"),
+    zod.z.literal("pending"),
+    zod.z.literal("sent"),
+    zod.z.literal("failed")
+  ]),
+  input: zod.z.object({
+    prompt: zod.z.union([zod.z.string(), zod.z.null()]),
+    data: zod.z.union([zod.z.string(), zod.z.null()]),
+    primaryKey: zod.z.union([zod.z.string(), zod.z.null()])
+  }),
+  output: zod.z.object({
+    name: zod.z.string(),
+    schema: zod.z.string(),
+    effectiveSchema: zod.z.string()
+  }),
+  result: zod.z.union([zod.z.record(zod.z.string(), zod.z.unknown()), zod.z.null()]).optional(),
+  error: zod.z.union([zod.z.string(), zod.z.null()]),
+  fullPrompt: zod.z.string(),
+  model: zod.z.string(),
+  provider: zod.z.string(),
+  startedAt: dateFromIso,
+  finishedAt: dateFromIso,
+  createdAt: mandatoryDateFromIso,
+  updatedAt: mandatoryDateFromIso
+});
+const isNuabaseError = (value) => Boolean(value && typeof value === "object" && "isError" in value && value.isError);
+async function getRequest(client, llmRequestId) {
+  const response = await client.request("GET", `requests/${encodeURIComponent(llmRequestId)}`);
+  if (isNuabaseError(response)) {
+    return response;
+  }
+  const parsedResponse = apiResponseSchema.safeParse(response);
+  if (!parsedResponse.success) {
+    return errorParseFailed;
+  }
+  return parsedResponse.data;
+}
+
+class Nua {
+  constructor(config) {
+    this.apiClient = new NuabaseAPIClient(config);
+  }
+  createArrayFn(fnDef) {
+    return createArrayFn(this.apiClient, fnDef);
+  }
+  createFn(fnDef) {
+    return createValueFn(this.apiClient, fnDef);
+  }
+  async getRequest(llmRequestId) {
+    return getRequest(this.apiClient, llmRequestId);
   }
 }
 

package/dist/esm/index.mjs

@@ -1,5 +1,15 @@
 import { z } from 'zod';
 
+function resolveConfigValue(config, key, envVar) {
+  if (config[key]) return config[key];
+  const pe = globalThis.process;
+  const isNode = !!pe?.versions?.node;
+  if (isNode) {
+    return pe?.env?.[envVar];
+  }
+  return void 0;
+}
+
 async function parseErrorResponse(response, urlPath) {
   const fallbackMessage = `Request to ${urlPath} failed with status ${response.status}${response.statusText ? ` ${response.statusText}` : ""}`;
   let responseBody = "";
@@ -45,25 +55,29 @@ function getErrorMessageFromException(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";
+    this.apiKey = resolveConfigValue(config, "apiKey", "NUABASE_API_KEY") || "";
+    this.baseUrl = resolveConfigValue(config, "baseUrl", "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) {
+  async request(method, urlPath, params) {
     const url = `${this.baseUrl}/${urlPath}`;
     let response;
+    const hasBody = method !== "GET" && params !== void 0;
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`
+    };
+    if (hasBody) {
+      headers["Content-Type"] = "application/json";
+    }
     try {
       response = await fetch(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${this.apiKey}`
-        },
-        body: JSON.stringify(params)
+        method,
+        headers,
+        body: hasBody ? JSON.stringify(params) : void 0
       });
     } catch (e) {
       return { error: `Error calling Nuabase API: ${getErrorMessageFromException(e)}` };
@@ -81,22 +95,46 @@ class NuabaseAPIClient {
   }
 }
 
-const zs_MapResponseRecord = (primaryKeyName, outputKey, outputSchema) => {
+const zs_NuaQueuedResponse = z.object({
+  id: z.string(),
+  sseUrl: z.string().min(1)
+}).strict();
+
+const validateArrayRequestParams = (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}'.`);
+    }
+  });
+};
+
+const zs_ResponseRecord = (primaryKeyName, outputKey, outputSchema) => {
   const primaryKeySchema = z.any();
-  return z.object({
+  const shape = {
     [primaryKeyName]: primaryKeySchema,
     [outputKey]: outputSchema
-  }).strict();
-};
-const zs_MapSuccessDataResult = (primaryKeyName, outputKey, outputSchema) => {
-  const recordSchema = zs_MapResponseRecord(primaryKeyName, outputKey, outputSchema);
-  return z.array(recordSchema);
+  };
+  return z.object(shape).strict();
 };
-const zs_MapRequestApiResponse_Success = (primaryKeyName, outputKey, outputSchema) => {
-  const dataSchema = zs_MapSuccessDataResult(primaryKeyName, outputKey, outputSchema);
+const createNuaApiResponseCastArray = (primaryKeyName, outputKey, outputSchema) => {
+  const recordSchema = zs_ResponseRecord(
+    primaryKeyName,
+    outputKey,
+    outputSchema
+  );
+  const dataSchema = z.array(recordSchema);
   return z.object({
     llmRequestId: z.string(),
-    kind: z.literal("map"),
+    kind: z.literal("cast/array"),
     data: dataSchema,
     cacheHits: z.number(),
     rowsWithNoResults: z.array(z.string()),
@@ -104,72 +142,309 @@ const zs_MapRequestApiResponse_Success = (primaryKeyName, outputKey, outputSchem
     isError: z.optional(z.literal(false))
   }).strict();
 };
-class Nua {
-  constructor(config) {
-    this.apiClient = new NuabaseAPIClient(config);
+const zs_NuaApiResponse_CastArray = createNuaApiResponseCastArray;
+
+const zs_ArrayFnDef = z.object({
+  prompt: z.string(),
+  output: z.object({
+    name: z.string(),
+    schema: z.custom(
+      (value) => value instanceof z.ZodType,
+      "Expected a Zod schema"
+    )
+  })
+});
+const validateArrayFnDef = (fnDef) => {
+  const parsed = zs_ArrayFnDef.safeParse(fnDef);
+  if (!parsed.success) {
+    const message = z.prettifyError(parsed.error);
+    throw new TypeError(`Invalid array function definition: ${message}`);
   }
-  // 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.");
+  return parsed.data;
+};
+
+function addOriginalInputRows(inputRows, outputRows, primaryKeyName) {
+  const lookup = /* @__PURE__ */ new Map();
+  for (const row of inputRows) {
+    lookup.set(row[primaryKeyName], row);
+  }
+  return outputRows.map((row) => {
+    const primaryKeyValue = row[primaryKeyName];
+    const sourceRow = lookup.get(primaryKeyValue);
+    if (!sourceRow) {
+      throw new Error(
+        `Unable to locate source row for primary key "${String(primaryKeyValue)}" in cast array response.`
+      );
     }
-    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
-      };
+    return {
+      ...row,
+      sourceRow
     };
-    const baseInvoker = async (data, primaryKeyName) => {
-      return await makeRequest("map", data, primaryKeyName);
+  });
+}
+const toCastArrayApiRequest = (prompt, data, primaryKeyName, outputName, outputSchema) => ({
+  input: {
+    prompt,
+    data,
+    primaryKey: primaryKeyName
+  },
+  output: {
+    schema: outputSchema,
+    name: outputName
+  }
+});
+const createArrayFn = (client, inputFnDef) => {
+  const fnDef = validateArrayFnDef(inputFnDef);
+  const outputJsonSchema = z.toJSONSchema(fnDef.output.schema);
+  const toNuabaseError = (response) => {
+    if (response && typeof response === "object" && "error" in response)
+      return { error: String(response.error), isError: true };
+    return void 0;
+  };
+  const baseFn = async (data, primaryKeyName) => {
+    validateArrayRequestParams(data, primaryKeyName);
+    const response = await client.request(
+      "POST",
+      "cast/array",
+      toCastArrayApiRequest(
+        fnDef.prompt,
+        data,
+        primaryKeyName,
+        fnDef.output.name,
+        outputJsonSchema
+      )
+    );
+    const error = toNuabaseError(response);
+    if (error) return error;
+    const parsedResponse = zs_NuaQueuedResponse.safeParse(response);
+    if (!parsedResponse.success) {
+      const emsg = z.prettifyError(parsedResponse.error);
+      return { error: `Invalid queued response received from Nuabase API: ${emsg}`, isError: true };
+    }
+    return parsedResponse.data;
+  };
+  const nowFn = async (data, primaryKeyName) => {
+    validateArrayRequestParams(data, primaryKeyName);
+    const response = await client.request(
+      "POST",
+      "cast/array/now",
+      toCastArrayApiRequest(
+        fnDef.prompt,
+        data,
+        primaryKeyName,
+        fnDef.output.name,
+        outputJsonSchema
+      )
+    );
+    const error = toNuabaseError(response);
+    if (error) return error;
+    const outputKey = fnDef.output.name;
+    const successSchema = zs_NuaApiResponse_CastArray(primaryKeyName, outputKey, fnDef.output.schema);
+    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: addOriginalInputRows(
+        data,
+        parsedResponse.data.data,
+        primaryKeyName
+      ),
+      rowsWithNoResults: parsedResponse.data.rowsWithNoResults,
+      cacheHits: parsedResponse.data.cacheHits
     };
-    const nowInvoker = async (data, primaryKeyName) => {
-      return await makeRequest("map/now", data, primaryKeyName);
+  };
+  return Object.assign(baseFn, {
+    now: nowFn
+  });
+};
+
+const createNuaApiResponseCastValue = (outputKey, outputSchema) => {
+  return z.object({
+    llmRequestId: z.string(),
+    kind: z.literal("cast/value"),
+    data: outputSchema,
+    isCacheHit: z.boolean(),
+    isSuccess: z.literal(true),
+    isError: z.optional(z.literal(false))
+  }).strict();
+};
+const zs_NuaApiResponse_CastValue = createNuaApiResponseCastValue;
+
+const zs_ValueFnDef = z.object({
+  prompt: z.string(),
+  output: z.object({
+    name: z.string(),
+    schema: z.custom(
+      (value) => value instanceof z.ZodType,
+      "Expected a Zod schema for `output.schema`"
+    )
+  })
+});
+const validateValueFnDef = (fnDef) => {
+  const parsed = zs_ValueFnDef.safeParse(fnDef);
+  if (!parsed.success) {
+    const message = z.prettifyError(parsed.error);
+    throw new TypeError(`Invalid value function definition: ${message}`);
+  }
+  return parsed.data;
+};
+
+const toCastValueApiRequest = (prompt, data, outputName, outputSchema) => ({
+  input: {
+    prompt,
+    data
+  },
+  output: {
+    schema: outputSchema,
+    name: outputName
+  }
+});
+const createValueFn = (client, inputFnDef) => {
+  const fnDef = validateValueFnDef(inputFnDef);
+  const outputJsonSchema = z.toJSONSchema(fnDef.output.schema);
+  const toNuabaseError = (response) => {
+    if (response && typeof response === "object" && "error" in response)
+      return { error: String(response.error), isError: true };
+    return void 0;
+  };
+  const sendRequest = async (path, data) => client.request(
+    "POST",
+    path,
+    toCastValueApiRequest(fnDef.prompt, data, fnDef.output.name, outputJsonSchema)
+  );
+  const baseFn = async (data) => {
+    const response = await sendRequest("cast/value", data);
+    const error = toNuabaseError(response);
+    if (error) return error;
+    const parsedResponse = zs_NuaQueuedResponse.safeParse(response);
+    if (!parsedResponse.success) {
+      const emsg = z.prettifyError(parsedResponse.error);
+      return { error: `Invalid queued response received from Nuabase API: ${emsg}`, isError: true };
+    }
+    return parsedResponse.data;
+  };
+  const nowFn = async (data) => {
+    const response = await sendRequest("cast/value/now", data);
+    const error = toNuabaseError(response);
+    if (error) return error;
+    const outputKey = fnDef.output.name;
+    const successSchema = zs_NuaApiResponse_CastValue(
+      outputKey,
+      fnDef.output.schema
+    );
+    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,
+      isCacheHit: parsedResponse.data.isCacheHit
     };
-    const fnReturnValue = Object.assign(baseInvoker, {
-      now: nowInvoker
-    });
-    return fnReturnValue;
+  };
+  return Object.assign(baseFn, {
+    now: nowFn
+  });
+};
+
+const errorParseFailed = {
+  kind: "internal-error",
+  message: "Unable to parse stored LLM result"
+};
+const dateFromIso = z.preprocess(
+  (value) => {
+    if (value == null) return null;
+    if (value instanceof Date) return value;
+    if (typeof value === "string") {
+      const parsed = new Date(value);
+      if (!Number.isNaN(parsed.getTime())) return parsed;
+    }
+    return z.NEVER;
+  },
+  z.union([z.date(), z.null()])
+);
+const mandatoryDateFromIso = z.preprocess((value) => {
+  if (value instanceof Date) return value;
+  if (typeof value === "string") {
+    const parsed = new Date(value);
+    if (!Number.isNaN(parsed.getTime())) return parsed;
+  }
+  return z.NEVER;
+}, z.date());
+const apiResponseSchema = z.object({
+  id: z.string(),
+  requestType: z.string(),
+  llmStatus: z.union([
+    z.literal("pending"),
+    z.literal("processing"),
+    z.literal("success"),
+    z.literal("failed")
+  ]),
+  sseStatus: z.union([
+    z.literal("n/a"),
+    z.literal("pending"),
+    z.literal("sent"),
+    z.literal("failed")
+  ]),
+  webhookStatus: z.union([
+    z.literal("n/a"),
+    z.literal("pending"),
+    z.literal("sent"),
+    z.literal("failed")
+  ]),
+  input: z.object({
+    prompt: z.union([z.string(), z.null()]),
+    data: z.union([z.string(), z.null()]),
+    primaryKey: z.union([z.string(), z.null()])
+  }),
+  output: z.object({
+    name: z.string(),
+    schema: z.string(),
+    effectiveSchema: z.string()
+  }),
+  result: z.union([z.record(z.string(), z.unknown()), z.null()]).optional(),
+  error: z.union([z.string(), z.null()]),
+  fullPrompt: z.string(),
+  model: z.string(),
+  provider: z.string(),
+  startedAt: dateFromIso,
+  finishedAt: dateFromIso,
+  createdAt: mandatoryDateFromIso,
+  updatedAt: mandatoryDateFromIso
+});
+const isNuabaseError = (value) => Boolean(value && typeof value === "object" && "isError" in value && value.isError);
+async function getRequest(client, llmRequestId) {
+  const response = await client.request("GET", `requests/${encodeURIComponent(llmRequestId)}`);
+  if (isNuabaseError(response)) {
+    return response;
+  }
+  const parsedResponse = apiResponseSchema.safeParse(response);
+  if (!parsedResponse.success) {
+    return errorParseFailed;
+  }
+  return parsedResponse.data;
+}
+
+class Nua {
+  constructor(config) {
+    this.apiClient = new NuabaseAPIClient(config);
+  }
+  createArrayFn(fnDef) {
+    return createArrayFn(this.apiClient, fnDef);
+  }
+  createFn(fnDef) {
+    return createValueFn(this.apiClient, fnDef);
+  }
+  async getRequest(llmRequestId) {
+    return getRequest(this.apiClient, llmRequestId);
   }
 }
 

package/dist/types/__tests__/utils/sse.d.ts

@@ -0,0 +1,12 @@
+import z from 'zod';
+export declare const processedSchema: z.ZodObject<{
+    processed_id: z.ZodString;
+}, z.core.$strip>;
+export declare const sseResponseSchema: z.ZodObject<{
+    isSuccess: z.ZodLiteral<true>;
+    llmRequestId: z.ZodString;
+    kind: z.ZodLiteral<"cast/value">;
+    data: z.ZodUnknown;
+    isCacheHit: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+export declare const waitForSuccessfulSseMessage: (sseUrl: string, timeoutMs?: number) => Promise<Record<string, unknown>>;

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

@@ -7,5 +7,5 @@ export declare class NuabaseAPIClient {
     private readonly apiKey;
     private readonly baseUrl;
     constructor(config?: NuabaseConfig);
-    request(urlPath: string, params: object): Promise<NuabaseError | unknown>;
+    request(method: 'GET' | 'POST', urlPath: string, params?: object): Promise<NuabaseError | unknown>;
 }

package/dist/types/lib/env.d.ts

@@ -0,0 +1 @@
+export declare function resolveConfigValue<T extends Record<string, any>>(config: T, key: keyof T, envVar: string): string | undefined;

package/dist/types/nua/cast_array/factory.d.ts

@@ -0,0 +1,4 @@
+import { NuabaseAPIClient } from '../../lib/api-client';
+import { ArrayFn, ArrayFnDef } from './types';
+import { z } from 'zod';
+export declare const createArrayFn: <OutputName extends string, OutputZodSchema extends z.ZodTypeAny>(client: NuabaseAPIClient, inputFnDef: ArrayFnDef<OutputName, OutputZodSchema>) => ArrayFn<OutputZodSchema, OutputName>;

package/dist/types/nua/cast_array/request-validation.d.ts

@@ -0,0 +1 @@
+export declare const validateArrayRequestParams: (data: unknown, primaryKeyName: unknown) => void;

package/dist/types/nua/cast_array/response-schema.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export type UserDataPKValue = string | number;
+export type PrimaryKeyedInputRecord<PrimaryKeyName extends string> = Record<PrimaryKeyName, UserDataPKValue> & Record<string, unknown>;
+type ResponseRow<OutputZodSchema extends z.ZodTypeAny, OutputName extends string, PrimaryKeyName extends string, InputRecord extends PrimaryKeyedInputRecord<PrimaryKeyName>> = Pick<InputRecord, PrimaryKeyName> & Record<OutputName, z.infer<OutputZodSchema>>;
+type NuaApiResponseShape<OutputZodSchema extends z.ZodTypeAny, OutputName extends string, PrimaryKeyName extends string, InputRecord extends PrimaryKeyedInputRecord<PrimaryKeyName>> = {
+    llmRequestId: string;
+    kind: 'cast/array';
+    data: Array<ResponseRow<OutputZodSchema, OutputName, PrimaryKeyName, InputRecord>>;
+    cacheHits: number;
+    rowsWithNoResults: UserDataPKValue[];
+    isSuccess: true;
+    isError?: false;
+};
+type NuaApiResponseCastArrayBuilder = <OutputZodSchema extends z.ZodTypeAny, OutputName extends string, PrimaryKeyName extends string, InputRecord extends PrimaryKeyedInputRecord<PrimaryKeyName>>(primaryKeyName: PrimaryKeyName, outputKey: OutputName, outputSchema: OutputZodSchema) => z.ZodType<NuaApiResponseShape<OutputZodSchema, OutputName, PrimaryKeyName, InputRecord>>;
+export declare const zs_NuaApiResponse_CastArray: NuaApiResponseCastArrayBuilder;
+export type NuaApiResponse_CastArray<OutputZodSchema extends z.ZodTypeAny, OutputName extends string, PrimaryKeyName extends string, InputRecord extends PrimaryKeyedInputRecord<PrimaryKeyName>> = z.infer<ReturnType<typeof zs_NuaApiResponse_CastArray<OutputZodSchema, OutputName, PrimaryKeyName, InputRecord>>>;
+export {};

package/dist/types/nua/cast_array/types.d.ts

@@ -0,0 +1,33 @@
+import { NuabaseError } from '../../lib/error-response';
+import { NuaQueuedResponse } from '../common/queued-response';
+import type { NuaApiResponse_CastArray, PrimaryKeyedInputRecord } from './response-schema';
+import { z } from 'zod';
+export type ArrayFnDef<OutputName extends string, OutputZodSchema extends z.ZodTypeAny> = {
+    prompt: string;
+    output: {
+        name: OutputName;
+        schema: OutputZodSchema;
+    };
+};
+export declare const validateArrayFnDef: <OutputName extends string, OutputZodSchema extends z.ZodTypeAny>(fnDef: ArrayFnDef<OutputName, OutputZodSchema>) => ArrayFnDef<OutputName, OutputZodSchema>;
+type CastArraySuccessFromApi<OutputZodSchema extends z.ZodTypeAny, OutputName extends string, PrimaryKeyName extends string, InputRecord extends PrimaryKeyedInputRecord<PrimaryKeyName>> = NuaApiResponse_CastArray<OutputZodSchema, OutputName, PrimaryKeyName, InputRecord>;
+type CastArraySourceRowAugmentation<PrimaryKeyName extends string, InputRecord extends PrimaryKeyedInputRecord<PrimaryKeyName>> = {
+    /**
+     * SDK-added field containing the full input row for convenience; not returned by the API.
+     */
+    sourceRow: InputRecord;
+};
+type CastArraySuccessRowWithSource<OutputZodSchema extends z.ZodTypeAny, OutputName extends string, PrimaryKeyName extends string, InputRecord extends PrimaryKeyedInputRecord<PrimaryKeyName>> = CastArraySuccessFromApi<OutputZodSchema, OutputName, PrimaryKeyName, InputRecord>['data'][number] & CastArraySourceRowAugmentation<PrimaryKeyName, InputRecord>;
+export type CastArraySuccessWithSource<OutputZodSchema extends z.ZodTypeAny, OutputName extends string, PrimaryKeyName extends string, InputRecord extends PrimaryKeyedInputRecord<PrimaryKeyName>> = Omit<CastArraySuccessFromApi<OutputZodSchema, OutputName, PrimaryKeyName, InputRecord>, 'data'> & {
+    /**
+     * Each row mirrors the API payload and includes the SDK-provided `sourceRow`.
+     */
+    data: CastArraySuccessRowWithSource<OutputZodSchema, OutputName, PrimaryKeyName, InputRecord>[];
+};
+export type ArrayFnResult<OutputZodSchema extends z.ZodTypeAny, OutputName extends string, PrimaryKeyName extends string, InputRecord extends PrimaryKeyedInputRecord<PrimaryKeyName>> = NuabaseError | CastArraySuccessWithSource<OutputZodSchema, OutputName, PrimaryKeyName, InputRecord>;
+export type ArrayFnQueuedResult = NuabaseError | NuaQueuedResponse;
+export type ArrayFn<OutputZodSchema extends z.ZodTypeAny, OutputName extends string> = {
+    <PrimaryKeyName extends string, InputRecord extends PrimaryKeyedInputRecord<PrimaryKeyName>>(data: InputRecord[], primaryKeyName: PrimaryKeyName): Promise<ArrayFnQueuedResult>;
+    now: <PrimaryKeyName extends string, InputRecord extends PrimaryKeyedInputRecord<PrimaryKeyName>>(data: InputRecord[], primaryKeyName: PrimaryKeyName) => Promise<ArrayFnResult<OutputZodSchema, OutputName, PrimaryKeyName, InputRecord>>;
+};
+export {};

package/dist/types/nua/cast_value/factory.d.ts

@@ -0,0 +1,4 @@
+import { NuabaseAPIClient } from '../../lib/api-client';
+import { ValueFn, ValueFnDef } from './types';
+import { z } from 'zod';
+export declare const createValueFn: <OutputName extends string, OutputZodSchema extends z.ZodTypeAny>(client: NuabaseAPIClient, inputFnDef: ValueFnDef<OutputName, OutputZodSchema>) => ValueFn<OutputZodSchema, OutputName>;

package/dist/types/nua/cast_value/response-schema.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+type NuaApiResponseShape<OutputZodSchema extends z.ZodTypeAny> = {
+    llmRequestId: string;
+    kind: 'cast/value';
+    data: z.infer<OutputZodSchema>;
+    isCacheHit: boolean;
+    isSuccess: true;
+    isError?: false;
+};
+type NuaApiResponseCastValueBuilder = <OutputZodSchema extends z.ZodTypeAny, OutputName extends string>(outputKey: OutputName, outputSchema: OutputZodSchema) => z.ZodType<NuaApiResponseShape<OutputZodSchema>>;
+export declare const zs_NuaApiResponse_CastValue: NuaApiResponseCastValueBuilder;
+export type NuaApiResponse_CastValue<OutputZodSchema extends z.ZodTypeAny, OutputName extends string> = z.infer<ReturnType<typeof zs_NuaApiResponse_CastValue<OutputZodSchema, OutputName>>>;
+export {};

package/dist/types/nua/cast_value/types.d.ts

@@ -0,0 +1,18 @@
+import { NuabaseError } from '../../lib/error-response';
+import { NuaQueuedResponse } from '../common/queued-response';
+import { NuaApiResponse_CastValue } from './response-schema';
+import { z } from 'zod';
+export type ValueFnDef<OutputName extends string, OutputZodSchema extends z.ZodTypeAny> = {
+    prompt: string;
+    output: {
+        name: OutputName;
+        schema: OutputZodSchema;
+    };
+};
+export declare const validateValueFnDef: <OutputName extends string, OutputZodSchema extends z.ZodTypeAny>(fnDef: ValueFnDef<OutputName, OutputZodSchema>) => ValueFnDef<OutputName, OutputZodSchema>;
+export type ValueFnResult<OutputZodSchema extends z.ZodTypeAny, OutputName extends string> = NuabaseError | NuaApiResponse_CastValue<OutputZodSchema, OutputName>;
+export type ValueFnQueuedResult = NuabaseError | NuaQueuedResponse;
+export type ValueFn<OutputZodSchema extends z.ZodTypeAny, OutputName extends string> = {
+    (data: unknown): Promise<ValueFnQueuedResult>;
+    now: (data: unknown) => Promise<ValueFnResult<OutputZodSchema, OutputName>>;
+};

package/dist/types/nua/common/queued-response.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export declare const zs_NuaQueuedResponse: z.ZodObject<{
+    id: z.ZodString;
+    sseUrl: z.ZodString;
+}, z.core.$strict>;
+export type NuaQueuedResponse = z.infer<typeof zs_NuaQueuedResponse>;

package/dist/types/nua/core.d.ts

@@ -0,0 +1,12 @@
+import { NuabaseAPIClient, NuabaseConfig } from '../lib/api-client';
+import { ArrayFn, ArrayFnDef } from './cast_array/types';
+import { ValueFn, ValueFnDef } from './cast_value/types';
+import { GetRequestResult } from './get-request';
+import { z } from 'zod';
+export declare class Nua {
+    apiClient: NuabaseAPIClient;
+    constructor(config?: NuabaseConfig);
+    createArrayFn<OutputName extends string, OutputZodSchema extends z.ZodTypeAny>(fnDef: ArrayFnDef<OutputName, OutputZodSchema>): ArrayFn<OutputZodSchema, OutputName>;
+    createFn<OutputName extends string, OutputZodSchema extends z.ZodTypeAny>(fnDef: ValueFnDef<OutputName, OutputZodSchema>): ValueFn<OutputZodSchema, OutputName>;
+    getRequest(llmRequestId: string): Promise<GetRequestResult>;
+}

package/dist/types/nua/get-request/index.d.ts

@@ -0,0 +1,6 @@
+import { NuabaseAPIClient } from '../../lib/api-client';
+import { NuabaseError } from '../../lib/error-response';
+import { ApiResponseLlmRequest, NuaInternalError } from './types';
+export type GetRequestResult = ApiResponseLlmRequest | NuaInternalError | NuabaseError;
+export declare function getRequest(client: NuabaseAPIClient, llmRequestId: string): Promise<GetRequestResult>;
+export type { ApiResponseLlmRequest, LlmRequestStatus, NuaInternalError, SseRequestStatus, WebhookRequestStatus, } from './types';

package/dist/types/nua/get-request/types.d.ts

@@ -0,0 +1,34 @@
+export type LlmRequestType = string;
+export type LlmRequestStatus = 'pending' | 'processing' | 'success' | 'failed';
+export type SseRequestStatus = 'n/a' | 'pending' | 'sent' | 'failed';
+export type WebhookRequestStatus = 'n/a' | 'pending' | 'sent' | 'failed';
+export type NuaInternalError = {
+    kind: 'internal-error';
+    message: string;
+};
+export type ApiResponseLlmRequest = {
+    id: string;
+    requestType: LlmRequestType;
+    llmStatus: LlmRequestStatus;
+    sseStatus: SseRequestStatus;
+    webhookStatus: WebhookRequestStatus;
+    input: {
+        prompt: string | null;
+        data: string | null;
+        primaryKey: string | null;
+    };
+    output: {
+        name: string;
+        schema: string;
+        effectiveSchema: string;
+    };
+    result?: Record<string, unknown> | null;
+    error: string | null;
+    fullPrompt: string;
+    model: string;
+    provider: string;
+    startedAt: Date | null;
+    finishedAt: Date | null;
+    createdAt: Date;
+    updatedAt: Date;
+};

package/dist/types/nua/index.d.ts

@@ -0,0 +1,5 @@
+export { Nua } from './core';
+export { createArrayFn } from './cast_array/factory';
+export { validateArrayRequestParams } from './cast_array/request-validation';
+export type { ArrayFn, ArrayFnDef } from './cast_array/types';
+export type { ApiResponseLlmRequest, GetRequestResult, LlmRequestStatus, NuaInternalError, SseRequestStatus, WebhookRequestStatus, } from './get-request';

package/dist/types/nua.d.ts

@@ -1,33 +1,3 @@
-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 {};
+export { Nua } from './nua/index';
+export { createArrayFn, validateArrayRequestParams } from './nua/index';
+export type { ArrayFn, ArrayFnDef } from './nua/index';

package/package.json

@@ -2,7 +2,7 @@
   "name": "nuabase",
   "description": "Nuabase TypeScript client to create typed functions from LLM prompts",
   "packageManager": "yarn@4.10.3+sha512.c38cafb5c7bb273f3926d04e55e1d8c9dfa7d9c3ea1f36a4868fa028b9e5f72298f0b7f401ad5eb921749eb012eb1c3bb74bf7503df3ee43fd600d14a018266f",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "type": "module",
   "author": "Jasim A Basheer <jasim@nuabase.com>",
   "engines": {
@@ -69,6 +69,7 @@
     "chalk": "^5.6.2",
     "esbuild": "^0.25.9",
     "eslint": "^9.35.0",
+    "eventsource": "^4.0.0",
     "fs-extra": "^11.3.1",
     "jest": "^30.1.3",
     "knip": "^5.63.1",