llmz 0.0.2 → 0.0.5

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 { TranscriptArray, TranscriptMessage } from './transcript.js';
+import { ExecutionResult } from './types.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<TranscriptMessage[], Context>;
+    });
+    onExecutionDone(_result: ExecutionResult): void;
+}

package/dist/chunk-3U57H7GT.js

@@ -0,0 +1,608 @@
+import {
+  DualModePrompt,
+  extractType,
+  inspect
+} from "./chunk-WLUVY5QU.js";
+import {
+  Tool
+} from "./chunk-QBXIE6EY.js";
+import {
+  LoopExceededError
+} from "./chunk-JKVVQN2P.js";
+import {
+  Exit
+} from "./chunk-S6FOL2HY.js";
+import {
+  assertValidComponent
+} from "./chunk-HP7RKM25.js";
+import {
+  wrapContent
+} from "./chunk-QT4QF3YA.js";
+import {
+  cloneDeep_default,
+  isPlainObject_default
+} from "./chunk-7WRN4E42.js";
+
+// src/snapshots.ts
+import { ulid } from "ulid";
+var MAX_SNAPSHOT_SIZE_BYTES = 4e3;
+var Snapshot = class _Snapshot {
+  id;
+  reason;
+  stack;
+  variables;
+  toolCall;
+  #status;
+  get status() {
+    return Object.freeze({ ...this.#status });
+  }
+  constructor(props) {
+    this.id = props.id;
+    this.stack = props.stack;
+    this.reason = props.reason;
+    this.variables = props.variables;
+    this.toolCall = props.toolCall;
+    this.#status = props.status;
+  }
+  static fromSignal(signal) {
+    const variables = Object.entries(signal.variables).map(([name, value]) => {
+      const type = extractType(value);
+      const bytes = JSON.stringify(value || "").length;
+      const truncated = bytes > MAX_SNAPSHOT_SIZE_BYTES;
+      return truncated ? { name, type, bytes, truncated: true, preview: inspect(value, name) ?? "N/A" } : { name, type, bytes, truncated: false, value };
+    });
+    return new _Snapshot({
+      id: "snapshot_" + ulid(),
+      reason: signal.message,
+      stack: signal.truncatedCode,
+      variables,
+      toolCall: signal.toolCall,
+      status: { type: "pending" }
+    });
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      reason: this.reason,
+      stack: this.stack,
+      variables: this.variables,
+      toolCall: this.toolCall,
+      status: this.#status
+    };
+  }
+  static fromJSON(json) {
+    return new _Snapshot({
+      id: json.id,
+      reason: json.reason,
+      stack: json.stack,
+      variables: json.variables,
+      toolCall: json.toolCall,
+      status: json.status
+    });
+  }
+  clone() {
+    return new _Snapshot({
+      id: this.id,
+      reason: this.reason,
+      stack: this.stack,
+      variables: this.variables,
+      toolCall: this.toolCall,
+      status: this.#status
+    });
+  }
+  reset() {
+    this.#status = { type: "pending" };
+  }
+  resolve(value) {
+    if (this.#status.type !== "pending") {
+      throw new Error(`Cannot resolve snapshot because it is already settled: ${this.#status.type}`);
+    }
+    this.#status = { type: "resolved", value };
+  }
+  reject(error) {
+    if (this.#status.type !== "pending") {
+      throw new Error(`Cannot reject snapshot because it is already settled: ${this.#status.type}`);
+    }
+    this.#status = { type: "rejected", error };
+  }
+};
+
+// src/getter.ts
+var getValue = async (valueOrGetter, ctx) => {
+  if (typeof valueOrGetter === "function") {
+    try {
+      return await valueOrGetter(ctx);
+    } catch (e) {
+      throw new Error(`Error while getting value for ${valueOrGetter}: ${e}`);
+    }
+  } else {
+    return valueOrGetter;
+  }
+};
+
+// src/context.ts
+import { ulid as ulid2 } from "ulid";
+
+// src/handlers.ts
+var Emitter = class {
+  _handlers = [];
+  subscribe = (fn) => {
+    this._handlers.push(fn);
+    return () => {
+      this._handlers = this._handlers.filter((handler) => handler !== fn);
+    };
+  };
+  emit(event) {
+    this._handlers.forEach((handler) => handler(event));
+  }
+};
+var HookedArray = class extends Array {
+  #listeners = new Emitter();
+  constructor(...items) {
+    super(...items);
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  push(...items) {
+    try {
+      this.#listeners.emit(items);
+    } finally {
+      return super.push(...items);
+    }
+  }
+  onPush(fn) {
+    return this.#listeners.subscribe(fn);
+  }
+};
+
+// src/transcript.ts
+var MAX_MESSAGE_LENGTH = 5e3;
+var TranscriptArray = class extends Array {
+  constructor(items = []) {
+    items = Array.isArray(items) ? items : [];
+    super(...items);
+    items.forEach((item) => {
+      if (!["user", "assistant"].includes(item.role)) {
+        throw new Error(`Invalid role "${item.role}" in transcript message`);
+      }
+      if (item.name && typeof item.name !== "string") {
+        throw new Error(`Invalid name for transcript message. Expected a string, but got type "${typeof item.name}"`);
+      }
+      if (typeof item.content !== "string") {
+        throw new Error(
+          `Invalid content for transcript message. Expected a string, but got type "${typeof item.content}"`
+        );
+      }
+    });
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  toString() {
+    if (!this.length) {
+      return "";
+    }
+    return this.map((item, idx) => {
+      var _a;
+      const msgIdx = "message-" + String(idx + 1).padStart(3, "0");
+      const shouldTruncate = item.content.length > MAX_MESSAGE_LENGTH;
+      const preview = shouldTruncate ? item.content.slice(0, MAX_MESSAGE_LENGTH) + "\n... (truncated)" : item.content;
+      const tags = [];
+      tags.push({ key: "role", value: item.role });
+      if ((_a = item.name) == null ? void 0 : _a.length) {
+        tags.push({ key: "name", value: item.name });
+      }
+      const tagsString = tags.map(({ key, value }) => `${key}="${value}"`).join(" ");
+      return `<${msgIdx} ${tagsString}>
+${preview.trim()}
+</${msgIdx}>`;
+    }).join("\n");
+  }
+};
+
+// src/context.ts
+var ThinkExit = new Exit({
+  name: "think",
+  description: "Think about the current situation and provide a response"
+});
+var ListenExit = new Exit({
+  name: "listen",
+  description: "Listen to the user and provide a response"
+});
+var Iteration = class {
+  id;
+  messages;
+  code;
+  traces;
+  variables;
+  started_ts;
+  ended_ts;
+  status;
+  _mutations;
+  get mutations() {
+    return [...this._mutations.values()];
+  }
+  trackMutation(mutation) {
+    this._mutations.set(`${mutation.object ?? "global"}:${mutation.property}`, mutation);
+  }
+  _parameters;
+  get transcript() {
+    return this._parameters.transcript;
+  }
+  get tools() {
+    return this._parameters.tools;
+  }
+  get objects() {
+    return this._parameters.objects;
+  }
+  get exits() {
+    const exits = [...this._parameters.exits, ThinkExit];
+    if (this.isChatEnabled) {
+      exits.push(ListenExit);
+    }
+    return exits;
+  }
+  get instructions() {
+    return this._parameters.instructions;
+  }
+  llm;
+  hasExited() {
+    return ["exit_success"].includes(this.status.type);
+  }
+  hasExitedWith(exit) {
+    return this.status.type === "exit_success" && this.status.exit_success.exit_name === exit.name;
+  }
+  isSuccessful() {
+    return ["callback_requested", "exit_success", "thinking_requested"].includes(
+      this.status.type
+    );
+  }
+  isFailed() {
+    return [
+      "generation_error",
+      "invalid_code_error",
+      "execution_error",
+      "exit_error",
+      "aborted"
+    ].includes(this.status.type);
+  }
+  get duration() {
+    const ms = (this.ended_ts ?? Date.now()) - this.started_ts;
+    const trailing = this.ended_ts ? "" : " (still running)";
+    return ms.toLocaleString("en-US", { style: "unit", unit: "millisecond" }) + trailing;
+  }
+  get error() {
+    if (this.status.type === "generation_error") {
+      return `CodeGenerationError: ${this.status.generation_error.message}`;
+    }
+    if (this.status.type === "invalid_code_error") {
+      return `InvalidCodeError: ${this.status.invalid_code_error.message}`;
+    }
+    if (this.status.type === "execution_error") {
+      return `CodeExecutionError: ${this.status.execution_error.message}`;
+    }
+    if (this.status.type === "exit_error") {
+      return `ExitError: ${this.status.exit_error.message}`;
+    }
+    if (this.status.type === "aborted") {
+      return `Aborted: ${this.status.aborted.reason}`;
+    }
+    return null;
+  }
+  get isChatEnabled() {
+    return this._parameters.tools.find((x) => x.name.toLowerCase() === "message") !== void 0;
+  }
+  constructor(props) {
+    this.id = props.id;
+    this.status = { type: "pending" };
+    this.traces = new HookedArray();
+    this._mutations = /* @__PURE__ */ new Map();
+    this.messages = props.messages;
+    this.variables = props.variables;
+    this._parameters = props.parameters;
+    this.started_ts = Date.now();
+  }
+  end(status) {
+    if (this.status.type !== "pending") {
+      throw new Error(`Iteration ${this.id} has already ended with status ${this.status.type}`);
+    }
+    this.ended_ts = Date.now();
+    this.status = status;
+  }
+};
+var Context = class {
+  id;
+  chat;
+  instructions;
+  objects;
+  tools;
+  exits;
+  version = DualModePrompt;
+  timeout = 6e4;
+  // Default timeout of 60 seconds
+  loop;
+  temperature;
+  model;
+  metadata;
+  snapshot;
+  iteration = 0;
+  iterations;
+  async nextIteration() {
+    if (this.iterations.length >= this.loop) {
+      throw new LoopExceededError();
+    }
+    if (this.snapshot && this.snapshot.status.type === "pending") {
+      throw new Error(
+        `Cannot resume execution from a snapshot that is still pending: ${this.snapshot.id}. Please resolve() or reject() it first.`
+      );
+    }
+    const parameters = await this._refreshIterationParameters();
+    const messages = await this._getIterationMessages(parameters);
+    const iteration = new Iteration({
+      id: `${this.id}_${this.iterations.length + 1}`,
+      variables: this._getIterationVariables(),
+      parameters,
+      messages
+    });
+    this.iterations.push(iteration);
+    this.iteration = this.iterations.length;
+    this.snapshot = void 0;
+    return iteration;
+  }
+  _getIterationVariables() {
+    const lastIteration = this.iterations.at(-1);
+    const variables = {};
+    if ((lastIteration == null ? void 0 : lastIteration.status.type) === "thinking_requested") {
+      const lastThinkingVariables = lastIteration.status.thinking_requested.variables;
+      if (isPlainObject_default(lastThinkingVariables)) {
+        Object.assign(variables, cloneDeep_default(lastThinkingVariables));
+      }
+    }
+    if (isPlainObject_default(lastIteration == null ? void 0 : lastIteration.variables)) {
+      Object.assign(variables, cloneDeep_default((lastIteration == null ? void 0 : lastIteration.variables) ?? {}));
+    }
+    return variables;
+  }
+  async _getIterationMessages(parameters) {
+    var _a, _b, _c, _d, _e, _f;
+    const lastIteration = this.iterations.at(-1);
+    if (((_a = this.snapshot) == null ? void 0 : _a.status.type) === "resolved") {
+      return [
+        await this.version.getSystemMessage({
+          globalTools: parameters.tools,
+          objects: parameters.objects,
+          instructions: parameters.instructions,
+          transcript: parameters.transcript,
+          exits: parameters.exits,
+          components: parameters.components
+        }),
+        this.version.getSnapshotResolvedMessage({
+          snapshot: this.snapshot
+        })
+      ];
+    }
+    if (((_b = this.snapshot) == null ? void 0 : _b.status.type) === "rejected") {
+      return [
+        await this.version.getSystemMessage({
+          globalTools: parameters.tools,
+          objects: parameters.objects,
+          instructions: parameters.instructions,
+          transcript: parameters.transcript,
+          exits: parameters.exits,
+          components: parameters.components
+        }),
+        this.version.getSnapshotRejectedMessage({
+          snapshot: this.snapshot
+        })
+      ];
+    }
+    if (!lastIteration) {
+      return [
+        await this.version.getSystemMessage({
+          globalTools: parameters.tools,
+          objects: parameters.objects,
+          instructions: parameters.instructions,
+          transcript: parameters.transcript,
+          exits: parameters.exits,
+          components: parameters.components
+        }),
+        await this.version.getInitialUserMessage({
+          globalTools: parameters.tools,
+          objects: parameters.objects,
+          instructions: parameters.instructions,
+          transcript: parameters.transcript,
+          exits: parameters.exits,
+          components: parameters.components
+        })
+      ];
+    }
+    const lastIterationMessages = [
+      await this.version.getSystemMessage({
+        globalTools: parameters.tools,
+        objects: parameters.objects,
+        instructions: parameters.instructions,
+        transcript: parameters.transcript,
+        exits: parameters.exits,
+        components: parameters.components
+      }),
+      ...lastIteration.messages.filter((x) => x.role !== "system")
+    ];
+    if ((lastIteration == null ? void 0 : lastIteration.status.type) === "thinking_requested") {
+      return [
+        ...lastIterationMessages,
+        {
+          role: "assistant",
+          content: wrapContent(((_c = lastIteration.llm) == null ? void 0 : _c.output) ?? "", { preserve: "top", flex: 4, minTokens: 25 })
+        },
+        await this.version.getThinkingMessage({
+          reason: lastIteration.status.thinking_requested.reason,
+          variables: lastIteration.status.thinking_requested.variables
+        })
+      ];
+    }
+    if ((lastIteration == null ? void 0 : lastIteration.status.type) === "exit_error") {
+      return [
+        ...lastIterationMessages,
+        {
+          role: "assistant",
+          content: wrapContent(((_d = lastIteration.llm) == null ? void 0 : _d.output) ?? "", { preserve: "top", flex: 4, minTokens: 25 })
+        },
+        await this.version.getInvalidCodeMessage({
+          code: lastIteration.code ?? "// No code generated",
+          message: `Invalid return statement (action: ${lastIteration.status.exit_error.exit}): ${lastIteration.status.exit_error.message}`
+        })
+      ];
+    }
+    if ((lastIteration == null ? void 0 : lastIteration.status.type) === "invalid_code_error") {
+      return [
+        ...lastIterationMessages,
+        {
+          role: "assistant",
+          content: wrapContent(((_e = lastIteration.llm) == null ? void 0 : _e.output) ?? "", { preserve: "top", flex: 4, minTokens: 25 })
+        },
+        await this.version.getInvalidCodeMessage({
+          code: lastIteration.code ?? "// No code generated",
+          message: lastIteration.status.invalid_code_error.message
+        })
+      ];
+    }
+    if ((lastIteration == null ? void 0 : lastIteration.status.type) === "execution_error") {
+      return [
+        ...lastIterationMessages,
+        {
+          role: "assistant",
+          content: wrapContent(((_f = lastIteration.llm) == null ? void 0 : _f.output) ?? "", { preserve: "top", flex: 4, minTokens: 25 })
+        },
+        await this.version.getCodeExecutionErrorMessage({
+          message: lastIteration.status.execution_error.message,
+          stacktrace: lastIteration.status.execution_error.stack
+        })
+      ];
+    }
+    throw new Error(
+      `Unexpected iteration status: ${lastIteration == null ? void 0 : lastIteration.status.type}. This is likely a bug, please report it.`
+    );
+  }
+  async _refreshIterationParameters() {
+    var _a, _b;
+    const instructions = await getValue(this.instructions, this);
+    const transcript = new TranscriptArray(await getValue(((_a = this.chat) == null ? void 0 : _a.transcript) ?? [], this));
+    const tools = Tool.withUniqueNames(await getValue(this.tools, this) ?? []);
+    const objects = await getValue(this.objects, this) ?? [];
+    const exits = await getValue(this.exits, this) ?? [];
+    const components = await getValue(((_b = this.chat) == null ? void 0 : _b.components) ?? [], this);
+    if (objects && objects.length > 100) {
+      throw new Error("Too many objects. Expected at most 100 objects.");
+    }
+    if (tools && tools.length > 100) {
+      throw new Error("Too many tools. Expected at most 100 tools.");
+    }
+    for (const component of components) {
+      assertValidComponent(component.definition);
+    }
+    const ReservedToolNames = [
+      "think",
+      "listen",
+      "return",
+      "exit",
+      "action",
+      "function",
+      "callback",
+      "code",
+      "execute",
+      "jsx",
+      "object",
+      "string",
+      "number",
+      "boolean",
+      "array"
+    ];
+    const MessageTool = this.chat && components.length ? new Tool({
+      name: "Message",
+      description: "Send a message to the user",
+      aliases: Array.from(
+        /* @__PURE__ */ new Set(["message", ...components.flatMap((x) => [x.definition.name, ...x.definition.aliases ?? []])])
+      ),
+      handler: async (message) => {
+        var _a2, _b2;
+        return await ((_b2 = (_a2 = this.chat) == null ? void 0 : _a2.handler) == null ? void 0 : _b2.call(_a2, message));
+      }
+    }) : null;
+    const allTools = MessageTool ? [MessageTool, ...tools] : tools;
+    for (const tool of tools) {
+      for (let name of [...tool.aliases, tool.name]) {
+        name = name.toLowerCase();
+        if (ReservedToolNames.includes(name)) {
+          throw new Error(`Tool name "${name}" (${tool.name}) is reserved. Please choose a different name.`);
+        }
+        if (components.find(
+          (x) => {
+            var _a2;
+            return x.definition.name.toLowerCase() === name || ((_a2 = x.definition.aliases) == null ? void 0 : _a2.map((x2) => x2.toLowerCase()).includes(name));
+          }
+        )) {
+          throw new Error(
+            `Tool name "${name}" (${tool.name}) is already used by a component. Please choose a different name.`
+          );
+        }
+        if (exits.find((x) => x.name.toLowerCase() === name) || exits.find((x) => {
+          var _a2;
+          return (_a2 = x.aliases) == null ? void 0 : _a2.map((x2) => x2.toLowerCase()).includes(name);
+        })) {
+          throw new Error(
+            `Tool name "${name}" (${tool.name}) is already used by an exit. Please choose a different name.`
+          );
+        }
+      }
+    }
+    if (exits && exits.length > 100) {
+      throw new Error("Too many exits. Expected at most 100 exits.");
+    }
+    if (components && components.length > 100) {
+      throw new Error("Too many components. Expected at most 100 components.");
+    }
+    if (instructions && instructions.length > 1e6) {
+      throw new Error("Instructions are too long. Expected at most 1,000,000 characters.");
+    }
+    if (transcript && transcript.length > 250) {
+      throw new Error("Too many transcript messages. Expected at most 250 messages.");
+    }
+    if (!components.length && !exits.length) {
+      throw new Error("When no components are provided, at least one exit is required.");
+    }
+    return {
+      transcript,
+      tools: allTools,
+      objects,
+      exits,
+      instructions,
+      components
+    };
+  }
+  constructor(props) {
+    this.id = `llmz_${ulid2()}`;
+    this.instructions = props.instructions;
+    this.objects = props.objects;
+    this.tools = props.tools;
+    this.exits = props.exits;
+    this.chat = props.chat;
+    this.timeout = Math.min(999999999, Math.max(0, props.timeout ?? 6e4));
+    this.loop = props.loop ?? 3;
+    this.temperature = props.temperature ?? 0.7;
+    this.model = props.model;
+    this.iterations = [];
+    this.metadata = props.metadata ?? {};
+    this.snapshot = props.snapshot;
+    if (this.loop < 1 || this.loop > 100) {
+      throw new Error("Invalid loop. Expected a number between 1 and 100.");
+    }
+    if (this.temperature < 0 || this.temperature > 2) {
+      throw new Error("Invalid temperature. Expected a number between 0 and 2.");
+    }
+  }
+};
+
+export {
+  Snapshot,
+  getValue,
+  ThinkExit,
+  ListenExit,
+  Context
+};