nuabase 1.0.0 → 1.0.1

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

@@ -83,22 +83,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();
+  };
+  return zod.z.object(shape).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);
+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 +130,202 @@ 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}`);
+  }
+  return parsed.data;
+};
+
+const toCastArrayApiRequest = (prompt, data, primaryKeyName, outputName, outputSchema) => ({
+  input: {
+    prompt,
+    data,
+    primaryKey: primaryKeyName
+  },
+  output: {
+    schema: outputSchema,
+    name: outputName
   }
-  // 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.");
+});
+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(
+      "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 };
     }
-    if (!primaryKeyName || typeof primaryKeyName !== "string") {
-      throw new Error("`primaryKeyName` must be a non-empty string.");
+    return parsedResponse.data;
+  };
+  const nowFn = async (data, primaryKeyName) => {
+    validateArrayRequestParams(data, primaryKeyName);
+    const response = await client.request(
+      "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 };
     }
-    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 {
+      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);
+  };
+  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(
+    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
+  });
+};
+
+class Nua {
+  constructor(config) {
+    this.apiClient = new NuabaseAPIClient(config);
+  }
+  createArrayFn(fnDef) {
+    return createArrayFn(this.apiClient, fnDef);
+  }
+  createFn(fnDef) {
+    return createValueFn(this.apiClient, fnDef);
   }
 }
 

package/dist/esm/index.mjs

@@ -81,22 +81,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();
+  };
+  return z.object(shape).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);
+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 +128,202 @@ 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}`);
+  }
+  return parsed.data;
+};
+
+const toCastArrayApiRequest = (prompt, data, primaryKeyName, outputName, outputSchema) => ({
+  input: {
+    prompt,
+    data,
+    primaryKey: primaryKeyName
+  },
+  output: {
+    schema: outputSchema,
+    name: outputName
   }
-  // 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.");
+});
+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(
+      "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 };
     }
-    if (!primaryKeyName || typeof primaryKeyName !== "string") {
-      throw new Error("`primaryKeyName` must be a non-empty string.");
+    return parsedResponse.data;
+  };
+  const nowFn = async (data, primaryKeyName) => {
+    validateArrayRequestParams(data, primaryKeyName);
+    const response = await client.request(
+      "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 };
     }
-    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 {
+      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);
+  };
+  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(
+    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
+  });
+};
+
+class Nua {
+  constructor(config) {
+    this.apiClient = new NuabaseAPIClient(config);
+  }
+  createArrayFn(fnDef) {
+    return createArrayFn(this.apiClient, fnDef);
+  }
+  createFn(fnDef) {
+    return createValueFn(this.apiClient, fnDef);
   }
 }
 

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/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: string[];
+    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,18 @@
+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>;
+export type ArrayFnResult<OutputZodSchema extends z.ZodTypeAny, OutputName extends string, PrimaryKeyName extends string, InputRecord extends PrimaryKeyedInputRecord<PrimaryKeyName>> = NuabaseError | NuaApiResponse_CastArray<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>>;
+};

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,10 @@
+import { NuabaseAPIClient, NuabaseConfig } from '../lib/api-client';
+import { ArrayFn, ArrayFnDef } from './cast_array/types';
+import { ValueFn, ValueFnDef } from './cast_value/types';
+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>;
+}

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

@@ -0,0 +1,4 @@
+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';

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.0.1",
   "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",