llmz 0.1.5 → 0.2.0

package/dist/{chunk-ZPHRTTQX.cjs → chunk-YQT5G77W.cjs}

@@ -142,6 +142,7 @@ var _MessageContentParser = (_class = class {
 }, _class);
 var _createRegex = () => new RegExp(REGEXP, "g");
 var _renderRemainingWrappers = (content) => content.replace(_createRegex(), "$2");
+var stripTruncationTags = (content) => _renderRemainingWrappers(content);
 var _countTotalTokens = (parts) => parts.reduce((acc, x) => acc + x.reduce((acc2, y) => acc2 + y.tokens, 0), 0);
 var _getTwoBiggestTruncables = (parts) => {
   var _a, _b;
@@ -168,4 +169,5 @@ var _getTwoBiggestTruncables = (parts) => {
 
 
 
-exports.wrapContent = wrapContent; exports.truncateWrappedContent = truncateWrappedContent;
+
+exports.wrapContent = wrapContent; exports.truncateWrappedContent = truncateWrappedContent; exports.stripTruncationTags = stripTruncationTags;

package/dist/compiler/compiler.d.ts

@@ -2,8 +2,6 @@ import { type TransformOptions } from '@babel/core';
 import { ToolCallEntry } from './plugins/track-tool-calls.js';
 export declare const DEFAULT_TRANSFORM_OPTIONS: TransformOptions;
 export declare const Identifiers: {
-    JSXFnIdentifier: string;
-    AsyncIterYieldFnIdentifier: string;
     ConsoleObjIdentifier: string;
     LineTrackingFnIdentifier: string;
     VariableTrackingFnIdentifier: string;
@@ -12,6 +10,13 @@ export declare const Identifiers: {
     CommentFnIdentifier: string;
 };
 export type CompiledCode = ReturnType<typeof compile>;
+/**
+ * Whether the code contains a top-level `return` statement (one that would
+ * return from the generated code itself, not from a nested function). Unlike a
+ * regex, this ignores `return` inside comments, strings and nested functions.
+ * Falls back to a word-boundary match if the code cannot be parsed.
+ */
+export declare function hasTopLevelReturn(code: string): boolean;
 export declare function compile(code: string): {
     code: string;
     codeWithMarkers: string;

package/dist/compiler/index.d.ts

@@ -1,2 +1,2 @@
-export { Identifiers, compile } from './compiler.js';
+export { Identifiers, compile, hasTopLevelReturn } from './compiler.js';
 export type { CompiledCode } from './compiler.js';

package/dist/compiler/plugins/async-wrapper.d.ts

@@ -0,0 +1,11 @@
+export declare const USER_CODE_START_MARKER = "/* __LLMZ_USER_CODE_START__ */";
+export declare const USER_CODE_END_MARKER = "/* __LLMZ_USER_CODE_END__ */";
+/**
+ * Wraps user code in an async function so top-level `await` and `return` parse,
+ * and so plugins can target the `__fn__` declaration. The wrapper is removed
+ * after transformation — drivers re-wrap the bare statements themselves.
+ */
+export declare const AsyncWrapper: {
+    preProcessing: (code: string) => string;
+    postProcessing: (code: string) => string;
+};

package/dist/component-2NYFY6CW.cjs

@@ -0,0 +1,14 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+var _chunkI56MPOVGcjs = require('./chunk-I56MPOVG.cjs');
+require('./chunk-5ZF6NTYI.cjs');
+require('./chunk-HC2QZTVT.cjs');
+
+
+
+
+
+exports.Component = _chunkI56MPOVGcjs.Component; exports.assertValidComponent = _chunkI56MPOVGcjs.assertValidComponent; exports.isAnyComponent = _chunkI56MPOVGcjs.isAnyComponent; exports.isComponent = _chunkI56MPOVGcjs.isComponent;

package/dist/{component-2Z3KLWLX.js → component-ASNZHQUR.js}

@@ -1,18 +1,14 @@
 import {
   Component,
   assertValidComponent,
-  getComponentReference,
   isAnyComponent,
-  isComponent,
-  renderToTsx
-} from "./chunk-3T5IU7OU.js";
+  isComponent
+} from "./chunk-KWQTYXAT.js";
 import "./chunk-XTEHT2TK.js";
 import "./chunk-34GJUS6U.js";
 export {
   Component,
   assertValidComponent,
-  getComponentReference,
   isAnyComponent,
-  isComponent,
-  renderToTsx
+  isComponent
 };

package/dist/component.d.ts

@@ -10,13 +10,12 @@ export type ComponentChild = {
     component: ComponentDefinition;
 };
 export declare function assertValidComponent(component: ComponentDefinition): asserts component is ComponentDefinition;
-export declare function getComponentReference(component: ComponentDefinition): string;
 export type DefaultComponentDefinition<T extends z.ZodObject<any> = z.ZodObject<any>> = {
     type: 'default';
     name: string;
     aliases: string[];
     description: string;
-    examples: ExampleUsage[];
+    examples?: ExampleUsage[];
     default: {
         props: T;
         children: Array<ComponentChild>;
@@ -27,7 +26,7 @@ export type LeafComponentDefinition<T extends z.ZodObject<any> = z.ZodObject<any
     name: string;
     description: string;
     aliases?: string[];
-    examples: ExampleUsage[];
+    examples?: ExampleUsage[];
     leaf: {
         props: T;
     };
@@ -37,7 +36,7 @@ export type ContainerComponentDefinition<T extends z.ZodObject<any> = z.ZodObjec
     name: string;
     description: string;
     aliases?: string[];
-    examples: ExampleUsage[];
+    examples?: ExampleUsage[];
     container: {
         props: T;
         children: Array<ComponentChild>;
@@ -54,10 +53,4 @@ export declare class Component<T extends ComponentDefinition = ComponentDefiniti
 }
 export declare function isComponent<T extends ComponentDefinition>(rendered: RenderedComponent<any>, component: Component<T>): rendered is RenderedComponent<ExtractComponentProps<T>>;
 export declare function isAnyComponent(message: unknown): message is RenderedComponent;
-/**
- * Converts a RenderedComponent back to TSX code
- * @param component The rendered component to convert
- * @returns A string containing the TSX representation of the component
- */
-export declare function renderToTsx(component: RenderedComponent): string;
 export {};

package/dist/context.d.ts

@@ -7,11 +7,49 @@ import { Exit } from './exit.js';
 import { ValueOrGetter } from './getter.js';
 import { HookedArray } from './handlers.js';
 import { ObjectInstance } from './objects.js';
-import { LLMzPrompts, Prompt } from './prompts/prompt.js';
+import { LLMzPrompts, ParsedNext, ParsedSend, Prompt } from './prompts/prompt.js';
 import { Snapshot } from './snapshots.js';
 import { Tool } from './tool.js';
 import { Transcript, TranscriptArray } from './transcript.js';
 import { ObjectMutation, Serializable, Trace } from './types.js';
+/**
+ * Tokenizer-measured size of each part of the prompt, before truncation.
+ * Useful to understand what is eating up the context window.
+ */
+export type ContextTokens = {
+    /** Total measured size of the prompt (sum of all the parts below). */
+    total: number;
+    /** Static prompt scaffolding: response format, VM rules, security guidelines, recap. */
+    framework: number;
+    /** The identity / instructions section. */
+    instructions: number;
+    /** tools.d.ts — tools, objects and variable typings. */
+    tools: number;
+    /** The conversation transcript. */
+    transcript: number;
+    /** The ■ protocol reference documenting components and exits. */
+    protocol: number;
+    /** Messages carried over from previous iterations (assistant responses, execution results, errors). */
+    iterations: number;
+};
+/** Token usage of a single iteration's LLM call. */
+export type TokenUsage = {
+    /** Input tokens consumed, as reported by the LLM provider. Zero until the call completes. */
+    input: number;
+    /** Output tokens produced, as reported by the LLM provider. Zero until the call completes. */
+    output: number;
+    /** Total tokens (input + output). */
+    total: number;
+    /**
+     * The effective context window limit of this call, in tokens:
+     * `min(options.maxTokens, model's max input tokens)`. Use it to compute the
+     * percentage of context used (e.g. `context.total / limit`).
+     * Undefined until the LLM call starts.
+     */
+    limit?: number;
+    /** Measured context size by part of the prompt (pre-truncation). */
+    context: ContextTokens;
+};
 export type IterationParameters = {
     transcript: TranscriptArray;
     tools: Tool[];
@@ -51,7 +89,8 @@ export declare namespace IterationStatuses {
         type: 'thinking_requested';
         thinking_requested: {
             reason?: string;
-            variables: Record<string, unknown>;
+            /** The value returned by the executed code (or the context provided by a ThinkSignal). */
+            variables: unknown;
             metadata?: Record<string, unknown>;
         };
     };
@@ -327,7 +366,10 @@ export declare namespace Iteration {
             spend: number;
             output: string;
             model: string;
+            time_to_first_token?: number;
+            time_to_last_token?: number;
         };
+        tokens?: TokenUsage;
         transcript: Transcript.Message[];
         tools: Tool.JSON[];
         objects: ObjectInstance.JSON[];
@@ -342,8 +384,18 @@ export declare class Iteration implements Serializable<Iteration.JSON> {
     id: string;
     messages: LLMzPrompts.Message[];
     code?: string;
+    /** Messages (`■send` blocks) parsed from the assistant response, in order. */
+    sends?: ParsedSend[];
+    /** The `■next` exit parsed from the assistant response, if any. */
+    next?: ParsedNext;
     traces: HookedArray<Trace>;
     variables: Record<string, any>;
+    /**
+     * Token usage of this iteration's LLM call. The `context` breakdown is measured
+     * when the prompt is assembled; `input`/`output` are filled in once the LLM call
+     * completes, from the provider-reported usage.
+     */
+    tokens?: TokenUsage;
     started_ts: number;
     ended_ts?: number;
     status: IterationStatus;
@@ -369,6 +421,10 @@ export declare class Iteration implements Serializable<Iteration.JSON> {
         spend: number;
         output: string;
         model: string;
+        /** Milliseconds between the LLM call start and the first streamed token. Only set on streaming clients. */
+        time_to_first_token?: number;
+        /** Milliseconds between the LLM call start and the last streamed token. Only set on streaming clients. */
+        time_to_last_token?: number;
         usage: {
             inputCost: number;
             outputCost: number;
@@ -420,6 +476,10 @@ export declare class Iteration implements Serializable<Iteration.JSON> {
             spend: number;
             output: string;
             model: string;
+            /** Milliseconds between the LLM call start and the first streamed token. Only set on streaming clients. */
+            time_to_first_token?: number;
+            /** Milliseconds between the LLM call start and the last streamed token. Only set on streaming clients. */
+            time_to_last_token?: number;
             usage: {
                 inputCost: number;
                 outputCost: number;
@@ -427,6 +487,7 @@ export declare class Iteration implements Serializable<Iteration.JSON> {
                 outputTokens: number;
             };
         } | undefined;
+        tokens: TokenUsage | undefined;
         transcript: Transcript.Message[];
         tools: {
             name: string;
@@ -493,12 +554,30 @@ export declare class Context implements Serializable<Context.JSON> {
     version: Prompt;
     timeout: number;
     loop: number;
+    /**
+     * Optional cap on the model's context window. The effective limit is
+     * `min(maxTokens, model's max input tokens)`.
+     */
+    maxTokens?: number;
+    /**
+     * Maximum time to wait for the first streamed token, in milliseconds,
+     * before the cognitive service falls back to the next model/provider.
+     */
+    maxTimeToFirstToken?: number;
     metadata: Record<string, any>;
     snapshot?: Snapshot;
     iteration: number;
     iterations: Iteration[];
     nextIteration(): Promise<Iteration>;
     private _getIterationVariables;
+    /**
+     * Measures the token size of each part of the prompt (pre-truncation).
+     * The named parts come from the system prompt; everything else in the system
+     * message is `framework`. Non-system messages count towards `iterations`,
+     * except the very first user message of a fresh execution (task recap),
+     * which is prompt scaffolding.
+     */
+    private _measureContextTokens;
     private _getIterationMessages;
     private _refreshIterationParameters;
     constructor(props: {
@@ -514,6 +593,8 @@ export declare class Context implements Serializable<Context.JSON> {
         metadata?: Record<string, any>;
         snapshot?: Snapshot;
         timeout?: number;
+        maxTokens?: number;
+        maxTimeToFirstToken?: number;
     });
     toJSON(): {
         id: string;
@@ -539,6 +620,10 @@ export declare class Context implements Serializable<Context.JSON> {
                 spend: number;
                 output: string;
                 model: string;
+                /** Milliseconds between the LLM call start and the first streamed token. Only set on streaming clients. */
+                time_to_first_token?: number;
+                /** Milliseconds between the LLM call start and the last streamed token. Only set on streaming clients. */
+                time_to_last_token?: number;
                 usage: {
                     inputCost: number;
                     outputCost: number;
@@ -546,6 +631,7 @@ export declare class Context implements Serializable<Context.JSON> {
                     outputTokens: number;
                 };
             } | undefined;
+            tokens: TokenUsage | undefined;
             transcript: Transcript.Message[];
             tools: {
                 name: string;

package/dist/{dual-modes-HEXPFVUE.js → dual-modes-RMF7V7ZQ.js}

@@ -1,10 +1,8 @@
 import {
   DualModePrompt
-} from "./chunk-2O3UTPVH.js";
+} from "./chunk-E5NHK3FS.js";
 import "./chunk-YEAWWJSJ.js";
-import "./chunk-3T5IU7OU.js";
-import "./chunk-XTEHT2TK.js";
-import "./chunk-L74UZONX.js";
+import "./chunk-HM5H556L.js";
 import "./chunk-YX27XM67.js";
 import "./chunk-34GJUS6U.js";
 export {

package/dist/dual-modes-ZZY6QPYT.cjs

@@ -0,0 +1,10 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkYGKQEVQQcjs = require('./chunk-YGKQEVQQ.cjs');
+require('./chunk-KIN7Y247.cjs');
+require('./chunk-YQT5G77W.cjs');
+require('./chunk-FPLSJF4S.cjs');
+require('./chunk-HC2QZTVT.cjs');
+
+
+exports.DualModePrompt = _chunkYGKQEVQQcjs.DualModePrompt;