llmz 0.0.11 → 0.0.12

package/dist/chat.d.ts

@@ -0,0 +1,17 @@
+import { Component, RenderedComponent } from './component.js';
+import { Context } from './context.js';
+import { ValueOrGetter } from './getter.js';
+import { ExecutionResult } from './result.js';
+import { TranscriptArray, Transcript } from './transcript.js';
+export type MessageHandler = (input: RenderedComponent) => Promise<void> | void;
+export declare class Chat {
+    readonly handler: MessageHandler;
+    readonly transcript: ValueOrGetter<TranscriptArray, Context>;
+    readonly components: ValueOrGetter<Component[], Context>;
+    constructor(props: {
+        handler: MessageHandler;
+        components: ValueOrGetter<Component[], Context>;
+        transcript?: ValueOrGetter<Transcript.Message[], Context>;
+    });
+    onExecutionDone(_result: ExecutionResult): void;
+}

package/dist/chunk-276Q6EWP.cjs

@@ -0,0 +1,224 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+
+
+
+var _chunkUQOBUJIQcjs = require('./chunk-UQOBUJIQ.cjs');
+
+// src/utils.ts
+var _thicktoken = require('@bpinternal/thicktoken');
+var _zui = require('@bpinternal/zui');
+var tokenizer = null;
+var init = async () => {
+  if (tokenizer) {
+    return;
+  }
+  while (typeof _thicktoken.getWasmTokenizer !== "function") {
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+  tokenizer = await _thicktoken.getWasmTokenizer.call(void 0, );
+};
+var getTokenizer = () => {
+  if (!tokenizer) {
+    throw new Error("Tokenizer not initialized, make sure to call init() first and await it");
+  }
+  return tokenizer;
+};
+var Tokens = (min, max) => {
+  return _zui.z.string().superRefine((value, ctx) => {
+    const tokens = tokenizer.count(value);
+    if (value.length < min) {
+      ctx.addIssue({
+        code: "too_small",
+        minimum: min,
+        type: "string",
+        message: `Text is ${tokens} but expected at least ${min} tokens`,
+        inclusive: true
+      });
+    }
+    if (value.length > max) {
+      ctx.addIssue({
+        code: "too_big",
+        maximum: max,
+        type: "string",
+        message: `Text is ${tokens} tokens but expected at most ${max} tokens`,
+        inclusive: true
+      });
+    }
+    return value;
+  });
+};
+var Identifier = _zui.z.string().min(1).max(100).regex(
+  /^([a-zA-Z_][a-zA-Z0-9_]*)$/,
+  "Identifiers must start with a letter and can only contain letters, numbers and underscores"
+);
+function escapeString(str) {
+  if (typeof str !== "string") {
+    return "";
+  }
+  const rawStr = String.raw`${str}`;
+  const escapedStr = rawStr.replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/"/g, '\\"').replace(/'/g, "\\'");
+  if (escapedStr.includes("`")) {
+    return `"${escapedStr}"`;
+  } else if (escapedStr.includes("'")) {
+    return `"${escapedStr}"`;
+  } else {
+    return `'${escapedStr}'`;
+  }
+}
+var toPropertyKey = (key) => {
+  if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key)) {
+    return key;
+  }
+  return escapeString(key);
+};
+var trimEmptyLines = (lines) => {
+  var _a;
+  while (lines.length && !((_a = lines[0]) == null ? void 0 : _a.trim())) {
+    lines.shift();
+  }
+  while (lines.length && !lines[lines.length - 1].trim()) {
+    lines.pop();
+  }
+};
+var getMultilineComment = (description) => {
+  description = description == null ? void 0 : description.replace(/(\n(\s*)?){3,}/g, "\n\n");
+  const ensureLineStartsWithAsterisk = (line) => line.startsWith("* ") ? ` ${line}` : ` * ${line}`;
+  const escapeCommentEnd = (line) => line.replace(/\*\//g, "*\\/");
+  const descLines = (_nullishCoalesce(description, () => ( ""))).split("\n").map((line) => line.trim());
+  trimEmptyLines(descLines);
+  if (descLines.length) {
+    descLines[0] = descLines[0].replace(/^\/\*\*?/, "");
+    descLines[descLines.length - 1] = descLines[descLines.length - 1].replace(/\*\/$/, "");
+  }
+  trimEmptyLines(descLines);
+  return descLines.length === 0 ? "" : descLines.length === 1 ? `/** ${escapeCommentEnd(descLines[0])} */` : `/**
+${descLines.map(ensureLineStartsWithAsterisk).map(escapeCommentEnd).join("\n")}
+ */`;
+};
+var toValidFunctionName = (str) => {
+  let name = _chunkUQOBUJIQcjs.deburr_default.call(void 0, str);
+  name = name.replace(/[^a-zA-Z0-9_$]/g, "");
+  if (!/^[a-zA-Z_$]/.test(name)) {
+    name = `_${name}`;
+  }
+  return _chunkUQOBUJIQcjs.camelCase_default.call(void 0, name);
+};
+var awaitObject = async (obj) => {
+  const newObj = { ...obj };
+  const promises = [];
+  const setProp = async (key, value) => {
+    newObj[key] = await value;
+  };
+  for (const [key, value] of Object.entries(obj)) {
+    if (value instanceof Promise) {
+      promises.push(setProp(key, value));
+    } else if (_chunkUQOBUJIQcjs.isPlainObject_default.call(void 0, value)) {
+      promises.push(setProp(key, await awaitObject(value)));
+    }
+  }
+  await Promise.all(promises);
+  return newObj;
+};
+var toValidObjectName = (str) => {
+  let name = _chunkUQOBUJIQcjs.deburr_default.call(void 0, str);
+  name = name.split(/[^a-zA-Z0-9_$]/g).map(_chunkUQOBUJIQcjs.startCase_default).join("");
+  if (!/^[a-zA-Z_$]/.test(name)) {
+    name = `_${name}`;
+  }
+  return name.replaceAll(" ", "");
+};
+var stripInvalidIdentifiers = (object) => {
+  if (typeof object !== "object") {
+    return object;
+  }
+  if (Array.isArray(object)) {
+    return object.map(stripInvalidIdentifiers);
+  }
+  return _chunkUQOBUJIQcjs.pickBy_default.call(void 0, object, (__, key) => Identifier.safeParse(key).success);
+};
+var convertObjectToZuiLiterals = (obj, nested = false) => {
+  if (typeof obj === "string") {
+    return _zui.z.literal(obj).catch(() => obj);
+  }
+  if (typeof obj === "number") {
+    return _zui.z.literal(obj).catch(() => obj);
+  }
+  if (typeof obj === "boolean") {
+    return _zui.z.literal(obj).catch(() => obj);
+  }
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) {
+      return _zui.z.tuple([]).catch(() => obj);
+    }
+    return _zui.z.tuple([
+      // the tuple needs to have at least one element
+      convertObjectToZuiLiterals(obj[0]),
+      ...obj.slice(1).map((child) => convertObjectToZuiLiterals(child))
+    ]).catch(() => obj);
+  }
+  if (obj !== null && typeof obj === "object") {
+    const shape = {};
+    for (const key in obj) {
+      shape[key] = convertObjectToZuiLiterals(obj[key], true);
+    }
+    if (nested) {
+      return _zui.z.object(shape).catch(() => shape);
+    }
+    return shape;
+  }
+  if (obj === void 0) {
+    return _zui.z.undefined().catch(() => void 0);
+  }
+  if (obj === null) {
+    return _zui.z.null().catch(() => null);
+  }
+  throw new Error(`Unsupported object type ${typeof obj}, ${obj})`);
+};
+var isValidSchema = (schema) => {
+  try {
+    _zui.transforms.fromJSONSchemaLegacy(schema);
+    return typeof schema.type === "string";
+  } catch (e) {
+    return false;
+  }
+};
+function isZuiSchema(schema) {
+  return !!schema && typeof schema === "object" && schema.__type__ === "ZuiType";
+}
+function isJsonSchema(schema) {
+  return !!schema && typeof schema === "object" && ("$schema" in schema || "type" in schema || "properties" in schema);
+}
+function isValidIdentifier(name) {
+  if (typeof name !== "string") {
+    return false;
+  }
+  return /^[A-Z]{1,}[A-Z0-9_]{0,50}$/i.test(name);
+}
+function isValidMessageName(name) {
+  if (typeof name !== "string") {
+    return false;
+  }
+  return /^[A-Z]{1,50}$/i.test(name);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.init = init; exports.getTokenizer = getTokenizer; exports.Tokens = Tokens; exports.Identifier = Identifier; exports.escapeString = escapeString; exports.toPropertyKey = toPropertyKey; exports.getMultilineComment = getMultilineComment; exports.toValidFunctionName = toValidFunctionName; exports.awaitObject = awaitObject; exports.toValidObjectName = toValidObjectName; exports.stripInvalidIdentifiers = stripInvalidIdentifiers; exports.convertObjectToZuiLiterals = convertObjectToZuiLiterals; exports.isValidSchema = isValidSchema; exports.isZuiSchema = isZuiSchema; exports.isJsonSchema = isJsonSchema; exports.isValidIdentifier = isValidIdentifier; exports.isValidMessageName = isValidMessageName;

package/dist/chunk-4L6D2A6O.cjs

@@ -0,0 +1,283 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkJDABP4SDcjs = require('./chunk-JDABP4SD.cjs');
+
+
+
+
+var _chunk276Q6EWPcjs = require('./chunk-276Q6EWP.cjs');
+
+// src/typings.ts
+var _zui = require('@bpinternal/zui');
+
+// src/formatting.ts
+var _lrucache = require('lru-cache');
+var _babel = require('prettier/plugins/babel'); var _babel2 = _interopRequireDefault(_babel);
+var _estree = require('prettier/plugins/estree'); var _estree2 = _interopRequireDefault(_estree);
+var _typescript = require('prettier/plugins/typescript'); var _typescript2 = _interopRequireDefault(_typescript);
+var _standalone = require('prettier/standalone');
+var cache = new (0, _lrucache.LRUCache)({ max: 1e3 });
+async function formatTypings(typings, options) {
+  if (cache.has(typings)) {
+    return cache.get(typings);
+  }
+  try {
+    options ??= {};
+    options.throwOnError ??= true;
+    const result = (await _standalone.format.call(void 0, typings, {
+      singleAttributePerLine: true,
+      bracketSameLine: true,
+      semi: false,
+      ...options,
+      embeddedLanguageFormatting: "off",
+      plugins: [_estree2.default, _babel2.default, _typescript2.default],
+      parser: "typescript",
+      filepath: "tools.d.ts"
+    })).trim();
+    cache.set(typings, result);
+    return result;
+  } catch (err) {
+    if (options == null ? void 0 : options.throwOnError) {
+      throw new (0, _chunkJDABP4SDcjs.CodeFormattingError)(err instanceof Error ? err.message : _nullishCoalesce((err == null ? void 0 : err.toString()), () => ( "Unknown Error")), typings);
+    }
+    return typings;
+  }
+}
+
+// src/typings.ts
+var Primitives = [
+  "string",
+  "number",
+  "boolean",
+  "unknown",
+  "void",
+  "any",
+  "null",
+  "undefined",
+  "never",
+  "bigint",
+  "symbol",
+  "object"
+];
+var LARGE_DECLARATION_LINES = 5;
+var isPrimitive = (type) => Primitives.includes(type);
+var isArrayOfPrimitives = (type) => Primitives.map((p) => `${p}[]`).includes(type);
+var stripSpaces = (typings) => typings.replace(/ +/g, " ").trim();
+var KeyValue = class {
+  constructor(key, value) {
+    this.key = key;
+    this.value = value;
+  }
+};
+var FnParameters = class {
+  constructor(schema) {
+    this.schema = schema;
+  }
+};
+var FnReturn = class {
+  constructor(schema) {
+    this.schema = schema;
+  }
+};
+var Declaration = class {
+  constructor(schema, identifier) {
+    this.schema = schema;
+    this.identifier = identifier;
+  }
+};
+async function getTypings(schema, options) {
+  options ??= {};
+  options.declaration ??= false;
+  let wrappedSchema = schema;
+  if ((options == null ? void 0 : options.declaration) && schema instanceof _zui.z.Schema) {
+    const title = "title" in schema.ui ? schema.ui.title : null;
+    if (!title) {
+      throw new Error('Only schemas with "title" Zui property can be declared.');
+    }
+    wrappedSchema = new Declaration(schema, title);
+  }
+  let dts = await sUnwrapZodRecursive(wrappedSchema, { ...options });
+  dts = await formatTypings(dts, { throwOnError: false });
+  return dts;
+}
+async function sUnwrapZodRecursive(schema, options) {
+  return sUnwrapZod(schema, options);
+}
+async function sUnwrapZod(schema, options) {
+  var _a, _b;
+  const newOptions = {
+    ...options,
+    declaration: false,
+    parent: schema
+  };
+  if (schema instanceof Declaration) {
+    const description = _chunk276Q6EWPcjs.getMultilineComment.call(void 0, schema.schema.description);
+    const withoutDesc = schema.schema.describe("");
+    const typings = await sUnwrapZodRecursive(withoutDesc, { ...newOptions, declaration: true });
+    const isLargeDeclaration = typings.split("\n").length >= LARGE_DECLARATION_LINES;
+    const closingTag = isLargeDeclaration ? `// end of ${schema.identifier}` : "";
+    if (schema.schema instanceof _zui.z.ZodFunction) {
+      return stripSpaces(`${description}
+declare function ${schema.identifier}${typings};${closingTag}`);
+    }
+    return stripSpaces(`${description}
+declare const ${schema.identifier}: ${typings};${closingTag}`);
+  }
+  if (schema instanceof KeyValue) {
+    if (schema.value instanceof _zui.z.ZodOptional) {
+      let innerType = schema.value._def.innerType;
+      if (innerType instanceof _zui.z.Schema && !innerType.description && schema.value.description) {
+        innerType = innerType == null ? void 0 : innerType.describe(schema.value.description);
+      }
+      const optionalToken = schema.key.endsWith("?") ? "" : "?";
+      return sUnwrapZodRecursive(new KeyValue(schema.key + optionalToken, innerType), newOptions);
+    }
+    const description = _chunk276Q6EWPcjs.getMultilineComment.call(void 0, schema.value._def.description || schema.value.description);
+    const delimiter = (description == null ? void 0 : description.trim().length) > 0 ? "\n" : "";
+    const withoutDesc = schema.value.describe("");
+    return `${delimiter}${description}${delimiter}${schema.key}: ${await sUnwrapZodRecursive(withoutDesc, newOptions)}${delimiter}`;
+  }
+  if (schema instanceof FnParameters) {
+    if (schema.schema instanceof _zui.z.ZodTuple) {
+      let args = "";
+      for (let i = 0; i < schema.schema.items.length; i++) {
+        const argName = _nullishCoalesce(((_b = (_a = schema.schema.items[i]) == null ? void 0 : _a.ui) == null ? void 0 : _b.title), () => ( `arg${i}`));
+        const item = schema.schema.items[i];
+        args += `${await sUnwrapZodRecursive(new KeyValue(_chunk276Q6EWPcjs.toPropertyKey.call(void 0, argName), item), newOptions)}, `;
+      }
+      return args;
+    }
+    const isLiteral = schema.schema.naked() instanceof _zui.z.ZodLiteral;
+    const typings = (await sUnwrapZodRecursive(schema.schema, newOptions)).trim();
+    const startsWithPairs = typings.startsWith("{") && typings.endsWith("}") || typings.startsWith("[") && typings.endsWith("]") || typings.startsWith("(") && typings.endsWith(")") || typings.startsWith("Array<") && typings.endsWith(">") || typings.startsWith("Record<") && typings.endsWith(">") || isArrayOfPrimitives(typings);
+    if (startsWithPairs || isLiteral) {
+      return `args: ${typings}`;
+    } else {
+      return typings;
+    }
+  }
+  if (schema instanceof FnReturn) {
+    if (schema.schema instanceof _zui.z.ZodOptional) {
+      return `${await sUnwrapZodRecursive(schema.schema.unwrap(), newOptions)} | undefined`;
+    }
+    return sUnwrapZodRecursive(schema.schema, newOptions);
+  }
+  if (schema instanceof _zui.z.ZodDefault) {
+    return sUnwrapZodRecursive(schema._def.innerType, options);
+  }
+  if (schema instanceof _zui.z.ZodVoid) {
+    return "void";
+  }
+  if (schema instanceof _zui.z.ZodUnknown) {
+    return "unknown";
+  }
+  if (schema instanceof _zui.z.ZodAny) {
+    return "any";
+  }
+  if (schema instanceof _zui.z.ZodPromise) {
+    return `Promise<${await sUnwrapZodRecursive(schema.unwrap(), newOptions)}>`;
+  }
+  if (schema instanceof _zui.z.ZodFunction) {
+    const description = _chunk276Q6EWPcjs.getMultilineComment.call(void 0, schema._def.description);
+    const input = await sUnwrapZodRecursive(new FnParameters(schema._def.args), newOptions);
+    const output = await sUnwrapZodRecursive(new FnReturn(schema._def.returns), newOptions);
+    if (options == null ? void 0 : options.declaration) {
+      return `${description}
+(${input}): ${output}`;
+    }
+    return `${description}
+(${input}) => ${output}`;
+  }
+  if (schema instanceof _zui.z.ZodArray) {
+    const item = await sUnwrapZodRecursive(schema._def.type, newOptions);
+    if (isPrimitive(item)) {
+      return `${item}[]`;
+    }
+    return `Array<${item}>`;
+  }
+  if (schema instanceof _zui.z.ZodEnum) {
+    const values = schema._def.values.map(_chunk276Q6EWPcjs.escapeString);
+    return values.join(" | ");
+  }
+  if (schema instanceof _zui.z.ZodTuple) {
+    if (schema.items.length === 0) {
+      return "[]";
+    }
+    const items = await Promise.all(schema.items.map((i) => sUnwrapZodRecursive(i, newOptions)));
+    return `[${items.join(", ")}]`;
+  }
+  if (schema instanceof _zui.z.ZodNullable) {
+    return `${await sUnwrapZodRecursive(schema.unwrap(), options)} | null`;
+  }
+  if (schema instanceof _zui.z.ZodOptional) {
+    if ((options == null ? void 0 : options.declaration) || (options == null ? void 0 : options.parent) instanceof _zui.z.ZodRecord) {
+      return `${await sUnwrapZodRecursive(schema._def.innerType, newOptions)} | undefined`;
+    }
+    const optionalToken = options.parent instanceof KeyValue ? "| undefined" : "";
+    const val = `${await sUnwrapZodRecursive(schema._def.innerType, newOptions)}${optionalToken}`;
+    return val;
+  }
+  if (schema instanceof _zui.z.ZodObject) {
+    const props = await Promise.all(
+      Object.entries(schema.shape).map(async ([key, value]) => {
+        if (value instanceof _zui.z.Schema) {
+          return sUnwrapZodRecursive(new KeyValue(_chunk276Q6EWPcjs.toPropertyKey.call(void 0, key), value), newOptions);
+        }
+        return `${key}: unknown`;
+      })
+    );
+    return `{ ${props.join("; ")} }`;
+  }
+  if (schema instanceof _zui.z.ZodString) {
+    const description = _chunk276Q6EWPcjs.getMultilineComment.call(void 0, schema._def.description);
+    return `${description} string`.trim();
+  }
+  if (schema instanceof _zui.z.ZodUnion) {
+    const description = _chunk276Q6EWPcjs.getMultilineComment.call(void 0, schema._def.description);
+    const options2 = await Promise.all(
+      schema.options.map(async (option) => {
+        return sUnwrapZodRecursive(option, newOptions);
+      })
+    );
+    return `${description}
+${options2.join(" | ")}`;
+  }
+  if (schema instanceof _zui.z.ZodLiteral) {
+    const description = _chunk276Q6EWPcjs.getMultilineComment.call(void 0, schema._def.description);
+    return `${description}
+${typeof schema.value === "string" ? _chunk276Q6EWPcjs.escapeString.call(void 0, schema.value) : schema.value}`.trim();
+  }
+  if (schema instanceof _zui.z.ZodNumber) {
+    const description = _chunk276Q6EWPcjs.getMultilineComment.call(void 0, schema._def.description);
+    return `${description} number`.trim();
+  }
+  if (schema instanceof _zui.z.ZodBoolean) {
+    const description = _chunk276Q6EWPcjs.getMultilineComment.call(void 0, schema._def.description);
+    return `${description} boolean`.trim();
+  }
+  if (schema instanceof _zui.z.ZodCatch) {
+    return sUnwrapZodRecursive(schema.removeCatch(), newOptions);
+  }
+  if (schema instanceof _zui.z.ZodLazy) {
+    return sUnwrapZodRecursive(schema._def.getter(), newOptions);
+  }
+  if (schema instanceof _zui.z.ZodRecord) {
+    const description = _chunk276Q6EWPcjs.getMultilineComment.call(void 0, schema._def.description);
+    const keyType = await sUnwrapZodRecursive(schema._def.keyType, newOptions);
+    const valueType = await sUnwrapZodRecursive(schema._def.valueType, newOptions);
+    return `${description} { [key: (${keyType})]: (${valueType}) }`;
+  }
+  try {
+    let typings = schema == null ? void 0 : schema.toTypescriptType();
+    typings ??= "unknown";
+    return stripSpaces(typings);
+  } catch (error) {
+    console.error("Error in sUnwrapZod", { error, schema, parent: options == null ? void 0 : options.parent });
+    return "unknown";
+  }
+}
+
+
+
+
+exports.formatTypings = formatTypings; exports.getTypings = getTypings;