llmz 0.0.4 → 0.0.5

package/dist/chunk-MU4LFVY7.cjs

@@ -0,0 +1,608 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } var _class; var _class2;
+
+
+
+var _chunk6WT5VZBGcjs = require('./chunk-6WT5VZBG.cjs');
+
+
+var _chunk4QTK5ALHcjs = require('./chunk-4QTK5ALH.cjs');
+
+
+var _chunkJDABP4SDcjs = require('./chunk-JDABP4SD.cjs');
+
+
+var _chunk4I7UPBLNcjs = require('./chunk-4I7UPBLN.cjs');
+
+
+var _chunkEJRCDWBAcjs = require('./chunk-EJRCDWBA.cjs');
+
+
+var _chunkFIVFS4HGcjs = require('./chunk-FIVFS4HG.cjs');
+
+
+
+var _chunkUQOBUJIQcjs = require('./chunk-UQOBUJIQ.cjs');
+
+// src/snapshots.ts
+var _ulid = require('ulid');
+var MAX_SNAPSHOT_SIZE_BYTES = 4e3;
+var Snapshot = class _Snapshot {
+  
+  
+  
+  
+  
+  #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 = _chunk6WT5VZBGcjs.extractType.call(void 0, value);
+      const bytes = JSON.stringify(value || "").length;
+      const truncated = bytes > MAX_SNAPSHOT_SIZE_BYTES;
+      return truncated ? { name, type, bytes, truncated: true, preview: _nullishCoalesce(_chunk6WT5VZBGcjs.inspect.call(void 0, value, name), () => ( "N/A")) } : { name, type, bytes, truncated: false, value };
+    });
+    return new _Snapshot({
+      id: "snapshot_" + _ulid.ulid.call(void 0, ),
+      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
+
+
+// src/handlers.ts
+var Emitter = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this); }
+  __init() {this._handlers = []}
+  __init2() {this.subscribe = (fn) => {
+    this._handlers.push(fn);
+    return () => {
+      this._handlers = this._handlers.filter((handler) => handler !== fn);
+    };
+  }}
+  emit(event) {
+    this._handlers.forEach((handler) => handler(event));
+  }
+}, _class);
+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 (0, _chunk4I7UPBLNcjs.Exit)({
+  name: "think",
+  description: "Think about the current situation and provide a response"
+});
+var ListenExit = new (0, _chunk4I7UPBLNcjs.Exit)({
+  name: "listen",
+  description: "Listen to the user and provide a response"
+});
+var Iteration = class {
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  get mutations() {
+    return [...this._mutations.values()];
+  }
+  trackMutation(mutation) {
+    this._mutations.set(`${_nullishCoalesce(mutation.object, () => ( "global"))}:${mutation.property}`, mutation);
+  }
+  
+  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;
+  }
+  
+  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 = (_nullishCoalesce(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 = (_class2 = class {
+  
+  
+  
+  
+  
+  
+  __init3() {this.version = _chunk6WT5VZBGcjs.DualModePrompt}
+  __init4() {this.timeout = 6e4}
+  // Default timeout of 60 seconds
+  
+  
+  
+  
+  
+  __init5() {this.iteration = 0}
+  
+  async nextIteration() {
+    if (this.iterations.length >= this.loop) {
+      throw new (0, _chunkJDABP4SDcjs.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 (_chunkUQOBUJIQcjs.isPlainObject_default.call(void 0, lastThinkingVariables)) {
+        Object.assign(variables, _chunkUQOBUJIQcjs.cloneDeep_default.call(void 0, lastThinkingVariables));
+      }
+    }
+    if (_chunkUQOBUJIQcjs.isPlainObject_default.call(void 0, lastIteration == null ? void 0 : lastIteration.variables)) {
+      Object.assign(variables, _chunkUQOBUJIQcjs.cloneDeep_default.call(void 0, _nullishCoalesce((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: _chunkFIVFS4HGcjs.wrapContent.call(void 0, _nullishCoalesce(((_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: _chunkFIVFS4HGcjs.wrapContent.call(void 0, _nullishCoalesce(((_d = lastIteration.llm) == null ? void 0 : _d.output), () => ( "")), { preserve: "top", flex: 4, minTokens: 25 })
+        },
+        await this.version.getInvalidCodeMessage({
+          code: _nullishCoalesce(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: _chunkFIVFS4HGcjs.wrapContent.call(void 0, _nullishCoalesce(((_e = lastIteration.llm) == null ? void 0 : _e.output), () => ( "")), { preserve: "top", flex: 4, minTokens: 25 })
+        },
+        await this.version.getInvalidCodeMessage({
+          code: _nullishCoalesce(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: _chunkFIVFS4HGcjs.wrapContent.call(void 0, _nullishCoalesce(((_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(_nullishCoalesce(((_a = this.chat) == null ? void 0 : _a.transcript), () => ( [])), this));
+    const tools = _chunk4QTK5ALHcjs.Tool.withUniqueNames(await _asyncNullishCoalesce(await getValue(this.tools, this), async () => ( [])));
+    const objects = await _asyncNullishCoalesce(await getValue(this.objects, this), async () => ( []));
+    const exits = await _asyncNullishCoalesce(await getValue(this.exits, this), async () => ( []));
+    const components = await getValue(_nullishCoalesce(((_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) {
+      _chunkEJRCDWBAcjs.assertValidComponent.call(void 0, 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 (0, _chunk4QTK5ALHcjs.Tool)({
+      name: "Message",
+      description: "Send a message to the user",
+      aliases: Array.from(
+        /* @__PURE__ */ new Set(["message", ...components.flatMap((x) => [x.definition.name, ..._nullishCoalesce(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) {;_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);
+    this.id = `llmz_${_ulid.ulid.call(void 0, )}`;
+    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, _nullishCoalesce(props.timeout, () => ( 6e4))));
+    this.loop = _nullishCoalesce(props.loop, () => ( 3));
+    this.temperature = _nullishCoalesce(props.temperature, () => ( 0.7));
+    this.model = props.model;
+    this.iterations = [];
+    this.metadata = _nullishCoalesce(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.");
+    }
+  }
+}, _class2);
+
+
+
+
+
+
+
+exports.Snapshot = Snapshot; exports.getValue = getValue; exports.ThinkExit = ThinkExit; exports.ListenExit = ListenExit; exports.Context = Context;

package/dist/{chunk-S6WICIDW.js → chunk-S6FOL2HY.js}

@@ -40,8 +40,8 @@ var Exit = class _Exit {
   is(exit) {
     return this.name === exit.name;
   }
-  parse(exit, value) {
-    return !!value && exit.name === this.name;
+  match(result) {
+    return result.exit instanceof _Exit && this.name === result.exit.name;
   }
   constructor(props) {
     if (!isValidIdentifier(props.name)) {