llmz 0.0.2

package/dist/llmz-WY74UVE3.js

@@ -0,0 +1,1049 @@
+import {
+  runAsyncFunction
+} from "./chunk-RB2L33ZR.js";
+import "./chunk-7FIPXMZR.js";
+import {
+  Snapshot
+} from "./chunk-UG2GCPHF.js";
+import {
+  Tool
+} from "./chunk-DILHJIMP.js";
+import "./chunk-ZSRC3TN4.js";
+import {
+  AssignmentError,
+  CodeExecutionError,
+  InvalidCodeError,
+  LoopExceededError,
+  Signals,
+  SnapshotSignal,
+  ThinkSignal,
+  VMSignal
+} from "./chunk-RJHDQL4C.js";
+import {
+  Exit
+} from "./chunk-6QDFMQHA.js";
+import {
+  DualModePrompt
+} from "./chunk-QPSUMPLP.js";
+import "./chunk-Q4DEJGXD.js";
+import {
+  cleanStackTrace
+} from "./chunk-MSTBEKOQ.js";
+import {
+  assertValidComponent
+} from "./chunk-3T465BEW.js";
+import {
+  truncateWrappedContent,
+  wrapContent
+} from "./chunk-UVSOAH2H.js";
+import {
+  init,
+  stripInvalidIdentifiers
+} from "./chunk-DFZ6GX5C.js";
+import {
+  clamp_default,
+  cloneDeep_default,
+  isEqual_default,
+  isPlainObject_default,
+  omit_default
+} from "./chunk-7S3UY52U.js";
+import "./chunk-YSQDPG26.js";
+
+// src/llmz.ts
+import { Cognitive } from "@botpress/cognitive";
+import { z } from "@bpinternal/zui";
+import ms from "ms";
+
+// src/context.ts
+import { ulid } from "ulid";
+
+// 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/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 ms2 = (this.ended_ts ?? Date.now()) - this.started_ts;
+    const trailing = this.ended_ts ? "" : " (still running)";
+    return ms2.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;
+  transcript;
+  instructions;
+  objects;
+  tools;
+  exits;
+  components;
+  version = DualModePrompt;
+  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
+        }),
+        await 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
+        }),
+        await 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;
+    const instructions = await getValue(this.instructions, this);
+    const transcript = new TranscriptArray(await getValue(this.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(this.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);
+    }
+    const ReservedToolNames = [
+      "think",
+      "listen",
+      "return",
+      "exit",
+      "action",
+      "function",
+      "callback",
+      "code",
+      "execute",
+      "jsx",
+      "object",
+      "string",
+      "number",
+      "boolean",
+      "array"
+    ];
+    const MessageTool = (_a = tools.find((x) => {
+      var _a2;
+      return x.name.toLowerCase() === "message" || ((_a2 = x.aliases) == null ? void 0 : _a2.includes("message"));
+    })) == null ? void 0 : _a.clone();
+    if (MessageTool && !components.length) {
+      throw new Error("The Message tool is only available in chat mode. Please provide at least one component.");
+    }
+    if (!MessageTool && components.length) {
+      throw new Error('When using components, you need to provide a tool called "Message"');
+    }
+    if (MessageTool && components.length) {
+      MessageTool.aliases = Array.from(
+        /* @__PURE__ */ new Set([...MessageTool.aliases, ...components.flatMap((x) => [x.name, ...x.aliases ?? []])])
+      );
+    }
+    const nonMessageTools = tools.filter((x) => {
+      var _a2;
+      return x.name.toLowerCase() !== "message" && !((_a2 = x.aliases) == null ? void 0 : _a2.includes("message"));
+    });
+    const allTools = MessageTool ? [MessageTool, ...nonMessageTools] : nonMessageTools;
+    for (const tool of nonMessageTools) {
+      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.name.toLowerCase() === name || ((_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 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_${ulid()}`;
+    this.transcript = props.transcript;
+    this.instructions = props.instructions;
+    this.objects = props.objects;
+    this.tools = props.tools;
+    this.exits = props.exits;
+    this.components = props.components;
+    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.");
+    }
+  }
+};
+
+// src/llmz.ts
+var getErrorMessage = (err) => err instanceof Error ? err.message : JSON.stringify(err);
+var SLOW_TOOL_WARNING = ms("15s");
+var RESPONSE_LENGTH_BUFFER = {
+  MIN_TOKENS: 1e3,
+  MAX_TOKENS: 16e3,
+  PERCENTAGE: 0.1
+};
+var getModelOutputLimit = (inputLength) => clamp_default(
+  RESPONSE_LENGTH_BUFFER.PERCENTAGE * inputLength,
+  RESPONSE_LENGTH_BUFFER.MIN_TOKENS,
+  RESPONSE_LENGTH_BUFFER.MAX_TOKENS
+);
+var executeContext = async (props) => {
+  var _a, _b, _c;
+  await init();
+  const { signal, onIterationEnd, onTrace, onExit } = props;
+  const cognitive = props.client instanceof Cognitive ? props.client : new Cognitive({ client: props.client });
+  const cleanups = [];
+  const ctx = new Context({
+    instructions: props.instructions,
+    objects: props.objects,
+    tools: props.tools,
+    loop: (_a = props.options) == null ? void 0 : _a.loop,
+    temperature: (_b = props.options) == null ? void 0 : _b.temperature,
+    model: (_c = props.options) == null ? void 0 : _c.model,
+    transcript: props.transcript,
+    exits: props.exits,
+    components: props.components,
+    snapshot: props.snapshot
+  });
+  try {
+    while (true) {
+      if (ctx.iterations.length >= ctx.loop) {
+        return {
+          status: "error",
+          context: ctx,
+          error: `Loop limit exceeded. Maximum allowed loops: ${ctx.loop}`,
+          iterations: ctx.iterations
+        };
+      }
+      const iteration = await ctx.nextIteration();
+      cleanups.push(
+        iteration.traces.onPush((traces) => {
+          for (const trace of traces) {
+            onTrace == null ? void 0 : onTrace({ trace, iteration: ctx.iterations.length });
+          }
+        })
+      );
+      try {
+        await executeIteration({
+          iteration,
+          ctx,
+          cognitive,
+          abortSignal: signal,
+          onExit
+        });
+      } catch (err) {
+        iteration.end({
+          type: "execution_error",
+          execution_error: {
+            stack: cleanStackTrace(err.stack ?? "No stack trace available"),
+            message: "An unexpected error occurred: " + getErrorMessage(err)
+          }
+        });
+      }
+      try {
+        await (onIterationEnd == null ? void 0 : onIterationEnd(iteration));
+      } catch (err) {
+        console.error(err);
+      }
+      if (iteration.status.type === "exit_success") {
+        return {
+          status: "success",
+          context: ctx,
+          iterations: ctx.iterations
+        };
+      }
+      if (iteration.status.type === "callback_requested") {
+        return {
+          status: "interrupted",
+          context: ctx,
+          iterations: ctx.iterations,
+          signal: iteration.status.callback_requested.signal,
+          snapshot: Snapshot.fromSignal(iteration.status.callback_requested.signal)
+        };
+      }
+      if (iteration.status.type === "thinking_requested" || iteration.status.type === "exit_error" || iteration.status.type === "execution_error" || iteration.status.type === "invalid_code_error") {
+        continue;
+      }
+      return {
+        context: ctx,
+        error: iteration.error ?? `Unknown error. Status: ${iteration.status.type}`,
+        status: "error",
+        iterations: ctx.iterations
+      };
+    }
+  } catch (error) {
+    return {
+      status: "error",
+      iterations: ctx.iterations,
+      context: ctx,
+      error: error instanceof Error ? error.message : (error == null ? void 0 : error.toString()) ?? "Unknown error"
+    };
+  } finally {
+    for (const cleanup of cleanups) {
+      try {
+        cleanup();
+      } catch {
+      }
+    }
+  }
+};
+var executeIteration = async ({
+  iteration,
+  ctx,
+  cognitive,
+  abortSignal,
+  onExit
+}) => {
+  var _a, _b, _c, _d, _e;
+  let startedAt = Date.now();
+  const traces = iteration.traces;
+  const modelLimit = 128e3;
+  const responseLengthBuffer = getModelOutputLimit(modelLimit);
+  const messages = truncateWrappedContent({
+    messages: iteration.messages,
+    tokenLimit: modelLimit - responseLengthBuffer,
+    throwOnFailure: false
+  }).filter(
+    (x) => (
+      // Filter out empty messages, as they are not valid inputs for the LLM
+      // This can happen when a message is truncated and the content is empty
+      x.content.trim().length > 0
+    )
+  );
+  const output = await cognitive.generateContent({
+    signal: abortSignal,
+    systemPrompt: (_a = messages.find((x) => x.role === "system")) == null ? void 0 : _a.content,
+    model: ctx.model,
+    temperature: ctx.temperature,
+    responseFormat: "text",
+    messages: messages.filter((x) => x.role === "user" || x.role === "assistant").map(
+      (x) => ({
+        role: x.role === "user" ? "user" : "assistant",
+        type: "text",
+        content: x.content
+      })
+    ),
+    stopSequences: ctx.version.getStopTokens()
+  });
+  const out = ((_c = (_b = output.output.choices) == null ? void 0 : _b[0]) == null ? void 0 : _c.type) === "text" && typeof ((_d = output.output.choices) == null ? void 0 : _d[0].content) === "string" ? output.output.choices[0].content : null;
+  if (!out) {
+    throw new Error("No output from LLM");
+  }
+  const assistantResponse = ctx.version.parseAssistantResponse(out);
+  iteration.code = assistantResponse.code.trim();
+  iteration.llm = {
+    cached: output.meta.cached || false,
+    ended_at: Date.now(),
+    started_at: startedAt,
+    status: "success",
+    tokens: output.meta.tokens.input + output.meta.tokens.output,
+    spend: output.meta.cost.input + output.meta.cost.output,
+    output: assistantResponse.raw,
+    model: `${output.meta.model.integration}:${output.meta.model.model}`
+  };
+  traces.push({
+    type: "llm_call_success",
+    started_at: startedAt,
+    ended_at: iteration.llm.ended_at,
+    model: ctx.model ?? "",
+    code: iteration.code
+  });
+  const vmContext = { ...stripInvalidIdentifiers(iteration.variables) };
+  for (const obj of iteration.objects) {
+    const internalValues = {};
+    const instance = {};
+    for (const { name, value, writable, type } of obj.properties ?? []) {
+      internalValues[name] = value;
+      const initialValue = value;
+      const schema = type ?? z.any();
+      Object.defineProperty(instance, name, {
+        enumerable: true,
+        configurable: true,
+        get() {
+          return internalValues[name];
+        },
+        set(value2) {
+          if (isEqual_default(value2, internalValues[name])) {
+            return;
+          }
+          if (!writable) {
+            throw new AssignmentError(`Property ${obj.name}.${name} is read-only and cannot be modified`);
+          }
+          if (value2 === internalValues[name]) {
+            return;
+          }
+          const parsed = schema.safeParse(value2);
+          if (!parsed.success) {
+            throw new AssignmentError(
+              `Invalid value for Object property ${obj.name}.${name}: ${getErrorMessage(parsed.error)}`
+            );
+          }
+          internalValues[name] = parsed.data;
+          traces.push({
+            type: "property",
+            started_at: Date.now(),
+            object: obj.name,
+            property: name,
+            value: parsed.data
+          });
+          iteration.trackMutation({ object: obj.name, property: name, before: initialValue, after: parsed.data });
+        }
+      });
+    }
+    for (const tool of obj.tools ?? []) {
+      instance[tool.name] = wrapTool({ tool, traces, object: obj.name });
+    }
+    Object.preventExtensions(instance);
+    Object.seal(instance);
+    vmContext[obj.name] = instance;
+  }
+  for (const tool of iteration.tools) {
+    const wrapped = wrapTool({ tool, traces });
+    for (const key of [tool.name, ...tool.aliases ?? []]) {
+      vmContext[key] = wrapped;
+    }
+  }
+  if (abortSignal == null ? void 0 : abortSignal.aborted) {
+    traces.push({
+      type: "abort_signal",
+      started_at: Date.now(),
+      reason: "The operation was aborted by user."
+    });
+    return iteration.end({
+      type: "aborted",
+      aborted: {
+        reason: (abortSignal == null ? void 0 : abortSignal.reason) ?? "The operation was aborted"
+      }
+    });
+  }
+  startedAt = Date.now();
+  const result = await runAsyncFunction(vmContext, assistantResponse.code.trim(), traces, abortSignal).catch(
+    (err) => {
+      return {
+        success: false,
+        error: err,
+        lines_executed: [],
+        traces: [],
+        variables: {}
+      };
+    }
+  );
+  if (result.error && result.error instanceof InvalidCodeError) {
+    return iteration.end({
+      type: "invalid_code_error",
+      invalid_code_error: {
+        message: result.error.message
+      }
+    });
+  }
+  traces.push({
+    type: "code_execution",
+    lines_executed: result.lines_executed ?? 0,
+    started_at: startedAt,
+    ended_at: Date.now()
+  });
+  if (result.error && result.error instanceof CodeExecutionError) {
+    return iteration.end({
+      type: "execution_error",
+      execution_error: {
+        message: result.error.message,
+        stack: cleanStackTrace(result.error.stack ?? "No stack trace available")
+      }
+    });
+  }
+  if (abortSignal == null ? void 0 : abortSignal.aborted) {
+    return iteration.end({
+      type: "aborted",
+      aborted: {
+        reason: (abortSignal == null ? void 0 : abortSignal.reason) ?? "The operation was aborted"
+      }
+    });
+  }
+  if (!result.success) {
+    return iteration.end({
+      type: "execution_error",
+      execution_error: {
+        message: ((_e = result == null ? void 0 : result.error) == null ? void 0 : _e.message) ?? "Unknown error occurred",
+        stack: cleanStackTrace(result.error.stack ?? "No stack trace available")
+      }
+    });
+  }
+  if (result.signal instanceof ThinkSignal) {
+    return iteration.end({
+      type: "thinking_requested",
+      thinking_requested: {
+        variables: result.signal.variables,
+        reason: result.signal.reason
+      }
+    });
+  }
+  if (result.signal instanceof SnapshotSignal) {
+    return iteration.end({
+      type: "callback_requested",
+      callback_requested: {
+        signal: result.signal
+      }
+    });
+  }
+  const validActions = [...iteration.exits.map((x) => x.name.toLowerCase()), "think"];
+  let returnValue = result.success && result.return_value ? result.return_value : null;
+  const returnAction = returnValue == null ? void 0 : returnValue.action;
+  const returnExit = iteration.exits.find((x) => x.name.toLowerCase() === (returnAction == null ? void 0 : returnAction.toLowerCase())) ?? iteration.exits.find((x) => x.aliases.some((a) => a.toLowerCase() === (returnAction == null ? void 0 : returnAction.toLowerCase())));
+  if (returnAction === "think") {
+    const variables = omit_default(returnValue ?? {}, "action");
+    if (isPlainObject_default(variables) && Object.keys(variables).length > 0) {
+      return iteration.end({
+        type: "thinking_requested",
+        thinking_requested: {
+          variables,
+          reason: "Thinking requested"
+        }
+      });
+    }
+    return iteration.end({
+      type: "thinking_requested",
+      thinking_requested: {
+        reason: "Thinking requested",
+        variables: iteration.variables
+      }
+    });
+  }
+  if (!returnAction) {
+    return iteration.end({
+      type: "exit_error",
+      exit_error: {
+        exit: "n/a",
+        message: `Code did not return an action. Valid actions are: ${validActions.join(", ")}`,
+        return_value: returnValue
+      }
+    });
+  }
+  if (!returnExit) {
+    return iteration.end({
+      type: "exit_error",
+      exit_error: {
+        exit: returnAction,
+        message: `Exit "${returnAction}" not found. Valid actions are: ${validActions.join(", ")}`,
+        return_value: returnValue
+      }
+    });
+  }
+  if (returnExit.zSchema) {
+    const parsed = returnExit.zSchema.safeParse(returnValue == null ? void 0 : returnValue.value);
+    if (!parsed.success) {
+      return iteration.end({
+        type: "exit_error",
+        exit_error: {
+          exit: returnExit.name,
+          message: `Invalid return value for exit ${returnExit.name}: ${getErrorMessage(parsed.error)}`,
+          return_value: returnValue
+        }
+      });
+    }
+    returnValue = { action: returnExit.name, value: parsed.data };
+  }
+  try {
+    await (onExit == null ? void 0 : onExit(returnExit, returnValue == null ? void 0 : returnValue.value));
+  } catch (err) {
+    return iteration.end({
+      type: "exit_error",
+      exit_error: {
+        exit: returnExit.name,
+        message: `Error executing exit ${returnExit.name}: ${getErrorMessage(err)}`,
+        return_value: returnValue
+      }
+    });
+  }
+  return iteration.end({
+    type: "exit_success",
+    exit_success: {
+      exit_name: returnExit.name,
+      return_value: returnValue == null ? void 0 : returnValue.value
+    }
+  });
+};
+function wrapTool({ tool, traces, object }) {
+  const getToolInput = (input) => tool.zInput.safeParse(input).data ?? input;
+  return function(input) {
+    const alertSlowTool = setTimeout(
+      () => traces.push({
+        type: "tool_slow",
+        tool_name: tool.name,
+        started_at: Date.now(),
+        input: getToolInput(input),
+        object,
+        duration: SLOW_TOOL_WARNING
+      }),
+      SLOW_TOOL_WARNING
+    );
+    const cancelSlowTool = () => clearTimeout(alertSlowTool);
+    const toolStart = Date.now();
+    let output;
+    let error;
+    let success = true;
+    const handleSignals = (error2) => {
+      if (output === error2) {
+        return true;
+      }
+      if (error2 instanceof SnapshotSignal) {
+        error2.toolCall = {
+          name: tool.name,
+          inputSchema: tool.input,
+          outputSchema: tool.output,
+          input
+        };
+        error2.message = Signals.serializeError(error2);
+      }
+      if (error2 instanceof ThinkSignal) {
+        traces.push({
+          type: "think_signal",
+          started_at: Date.now(),
+          line: 0,
+          ended_at: Date.now()
+        });
+        success = true;
+        output = error2;
+        return true;
+      }
+      return false;
+    };
+    try {
+      const result = tool.execute(input);
+      if (result instanceof Promise || (result == null ? void 0 : result.then) && (result == null ? void 0 : result.catch)) {
+        return result.then((res) => {
+          output = res;
+          success = true;
+          return res;
+        }).catch((err) => {
+          if (!handleSignals(err)) {
+            success = false;
+            error = err;
+          }
+          throw err;
+        }).finally(() => {
+          cancelSlowTool();
+          traces.push({
+            type: "tool_call",
+            started_at: toolStart,
+            ended_at: Date.now(),
+            tool_name: tool.name,
+            object,
+            input: getToolInput(input),
+            output,
+            error,
+            success
+          });
+        });
+      }
+      success = true;
+      output = result;
+    } catch (err) {
+      if (!handleSignals(err)) {
+        success = false;
+        error = err;
+      }
+    }
+    cancelSlowTool();
+    traces.push({
+      type: "tool_call",
+      started_at: toolStart,
+      ended_at: Date.now(),
+      tool_name: tool.name,
+      object,
+      input: getToolInput(input),
+      output,
+      error,
+      success
+    });
+    if (!success) {
+      throw error;
+    }
+    if (output instanceof VMSignal) {
+      throw output;
+    }
+    return output;
+  };
+}
+var llmz = {
+  executeContext
+};
+export {
+  llmz
+};