llmist 9.1.2 → 9.2.0

package/dist/index.js

@@ -1260,7 +1260,11 @@ var init_messages = __esm({
         parts.push("\n=================\n");
         for (const gadget of gadgets) {
           const gadgetName = gadget.name ?? gadget.constructor.name;
-          const instruction = gadget.getInstruction(this.argPrefix);
+          const instruction = gadget.getInstruction({
+            argPrefix: this.argPrefix,
+            startPrefix: this.startPrefix,
+            endPrefix: this.endPrefix
+          });
           const schemaMarker = "\n\nInput Schema (BLOCK):";
           const schemaIndex = instruction.indexOf(schemaMarker);
           const description = (schemaIndex !== -1 ? instruction.substring(0, schemaIndex) : instruction).trim();
@@ -6004,13 +6008,13 @@ var init_openai = __esm({
       async generateSpeech(options) {
         const client = this.client;
         const spec = getOpenAISpeechModelSpec(options.model);
-        const format = options.responseFormat ?? spec?.defaultFormat ?? "mp3";
+        const format2 = options.responseFormat ?? spec?.defaultFormat ?? "mp3";
         const voice = options.voice ?? spec?.defaultVoice ?? "alloy";
         const response = await client.audio.speech.create({
           model: options.model,
           input: options.input,
           voice,
-          response_format: format,
+          response_format: format2,
           speed: options.speed ?? 1
         });
         const audioBuffer = await response.arrayBuffer();
@@ -6022,7 +6026,7 @@ var init_openai = __esm({
             characterCount: options.input.length
           },
           cost,
-          format
+          format: format2
         };
       }
       buildApiRequest(options, descriptor, spec, messages) {
@@ -11847,17 +11851,17 @@ init_gadget_output_store();
 // src/agent/hints.ts
 init_prompt_config();
 function iterationProgressHint(options) {
-  const { timing = "always", showUrgency = true, template } = options ?? {};
+  const { timing: timing2 = "always", showUrgency = true, template } = options ?? {};
   return {
     controllers: {
       beforeLLMCall: async (ctx) => {
         const iteration = ctx.iteration + 1;
         const maxIterations = ctx.maxIterations;
         const progress = iteration / maxIterations;
-        if (timing === "late" && progress < 0.5) {
+        if (timing2 === "late" && progress < 0.5) {
           return { action: "proceed" };
         }
-        if (timing === "urgent" && progress < 0.8) {
+        if (timing2 === "urgent" && progress < 0.8) {
           return { action: "proceed" };
         }
         const remaining = maxIterations - iteration;
@@ -12018,6 +12022,24 @@ init_typed_gadget();
 
 // src/gadgets/helpers.ts
 init_input_content();
+function gadgetSuccess(data = {}) {
+  return JSON.stringify({ success: true, ...data });
+}
+function gadgetError(message, details) {
+  return JSON.stringify({ error: message, ...details });
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function withErrorHandling(execute) {
+  return async (params, ctx) => {
+    try {
+      return await execute(params, ctx);
+    } catch (error) {
+      return gadgetError(getErrorMessage(error));
+    }
+  };
+}
 function createMediaOutput(kind, data, mimeType, options) {
   const buffer = data instanceof Buffer ? data : Buffer.from(data);
   return {
@@ -12213,7 +12235,313 @@ init_anthropic();
 init_discovery();
 init_gemini();
 init_openai();
+
+// src/utils/format.ts
+function truncate(text3, maxLength, suffix = "...") {
+  if (text3.length <= maxLength) return text3;
+  const truncateAt = maxLength - suffix.length;
+  if (truncateAt <= 0) return suffix.slice(0, maxLength);
+  return text3.slice(0, truncateAt) + suffix;
+}
+function formatBytes(bytes, decimals = 1) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB", "PB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  const size = bytes / Math.pow(k, i);
+  const formatted = size % 1 === 0 ? size.toString() : size.toFixed(decimals);
+  return `${formatted} ${sizes[i]}`;
+}
+function formatDate(isoDate, options = {
+  year: "numeric",
+  month: "short",
+  day: "numeric",
+  hour: "2-digit",
+  minute: "2-digit"
+}) {
+  try {
+    const date = new Date(isoDate);
+    return date.toLocaleString(void 0, options);
+  } catch {
+    return isoDate;
+  }
+}
+function formatDuration(ms, options = {}) {
+  if (ms < 1e3) {
+    return `${Math.round(ms)}ms`;
+  }
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  if (hours > 0) {
+    const remainingMinutes = minutes % 60;
+    const remainingSeconds = seconds % 60;
+    if (options.compact) {
+      return `${hours}h ${remainingMinutes}m`;
+    }
+    return remainingSeconds > 0 ? `${hours}h ${remainingMinutes}m ${remainingSeconds}s` : `${hours}h ${remainingMinutes}m`;
+  }
+  if (minutes > 0) {
+    const remainingSeconds = seconds % 60;
+    return remainingSeconds > 0 ? `${minutes}m ${remainingSeconds}s` : `${minutes}m`;
+  }
+  const secs = ms / 1e3;
+  return secs % 1 === 0 ? `${secs}s` : `${secs.toFixed(1)}s`;
+}
+var format = {
+  truncate,
+  bytes: formatBytes,
+  date: formatDate,
+  duration: formatDuration
+};
+
+// src/utils/timing.ts
+function randomDelay(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+async function humanDelay(min = 50, max = 150) {
+  const delay = randomDelay(min, max);
+  return new Promise((resolve) => setTimeout(resolve, delay));
+}
+async function withTimeout(fn, timeoutMs, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new Error("Operation aborted"));
+      return;
+    }
+    let settled = false;
+    const timeoutId = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        reject(new Error(`Operation timed out after ${timeoutMs}ms`));
+      }
+    }, timeoutMs);
+    const abortHandler = () => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timeoutId);
+        reject(new Error("Operation aborted"));
+      }
+    };
+    signal?.addEventListener("abort", abortHandler);
+    fn().then((result) => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timeoutId);
+        signal?.removeEventListener("abort", abortHandler);
+        resolve(result);
+      }
+    }).catch((error) => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timeoutId);
+        signal?.removeEventListener("abort", abortHandler);
+        reject(error);
+      }
+    });
+  });
+}
+async function withRetry(fn, options = {}) {
+  const {
+    maxRetries = 3,
+    delay = 1e3,
+    backoff = "exponential",
+    maxDelay = 3e4,
+    shouldRetry = () => true,
+    onRetry
+  } = options;
+  let lastError;
+  let currentDelay = delay;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt >= maxRetries || !shouldRetry(error, attempt)) {
+        throw error;
+      }
+      const waitTime = Math.min(currentDelay, maxDelay);
+      onRetry?.(error, attempt + 1, waitTime);
+      await new Promise((resolve) => setTimeout(resolve, waitTime));
+      if (backoff === "exponential") {
+        currentDelay *= 2;
+      } else {
+        currentDelay += delay;
+      }
+    }
+  }
+  throw lastError;
+}
+var timing = {
+  randomDelay,
+  humanDelay,
+  withTimeout,
+  withRetry
+};
+
+// src/session/manager.ts
+var BaseSessionManager = class {
+  /** Map of session ID to session object */
+  sessions = /* @__PURE__ */ new Map();
+  /** Counter for generating unique session IDs */
+  idCounter = 0;
+  /**
+   * Generate a unique session ID with the given prefix.
+   *
+   * @param prefix - Prefix for the ID (e.g., "p" for pages, "b" for browsers)
+   * @returns Unique ID like "p1", "p2", etc.
+   */
+  generateId(prefix) {
+    return `${prefix}${++this.idCounter}`;
+  }
+  /**
+   * Get a session by ID.
+   */
+  getSession(id) {
+    return this.sessions.get(id);
+  }
+  /**
+   * Get a session by ID, throwing if not found.
+   */
+  requireSession(id) {
+    const session = this.sessions.get(id);
+    if (!session) {
+      throw new Error(`Session not found: ${id}`);
+    }
+    return session;
+  }
+  /**
+   * List all active session IDs.
+   */
+  listSessions() {
+    return Array.from(this.sessions.keys());
+  }
+  /**
+   * Check if a session exists.
+   */
+  hasSession(id) {
+    return this.sessions.has(id);
+  }
+  /**
+   * Close all sessions.
+   * Closes sessions in reverse order (most recent first).
+   */
+  async closeAll() {
+    const ids = this.listSessions().reverse();
+    for (const id of ids) {
+      try {
+        await this.closeSession(id);
+      } catch {
+      }
+    }
+  }
+};
+var SimpleSessionManager = class extends BaseSessionManager {
+  /**
+   * Create a session by storing the provided data.
+   */
+  async createSession(data) {
+    const id = this.generateId("s");
+    if (data !== void 0) {
+      this.sessions.set(id, data);
+    }
+    return id;
+  }
+  /**
+   * Close a session by removing it from the map.
+   */
+  async closeSession(id) {
+    this.sessions.delete(id);
+  }
+  /**
+   * Set session data directly.
+   */
+  setSession(id, data) {
+    this.sessions.set(id, data);
+  }
+};
+
+// src/agent/subagent.ts
 function getHostExports(ctx) {
+  if (!ctx?.hostExports) {
+    throw new Error(
+      "hostExports not available. Subagent gadgets must be run via llmist agent. Ensure you are using llmist >= 6.2.0 and running through the CLI or AgentBuilder."
+    );
+  }
+  return ctx.hostExports;
+}
+function createSubagent(ctx, options) {
+  const {
+    name,
+    gadgets,
+    systemPrompt,
+    model: runtimeModel,
+    defaultModel = "sonnet",
+    maxIterations: runtimeMaxIterations,
+    defaultMaxIterations = 15,
+    hooks,
+    temperature
+  } = options;
+  const { AgentBuilder: AgentBuilder2, LLMist: LLMist2 } = getHostExports(ctx);
+  const client = new LLMist2();
+  const model = resolveSubagentModel(ctx, name, runtimeModel, defaultModel);
+  const maxIterations = resolveValue(ctx, name, {
+    runtime: runtimeMaxIterations,
+    subagentKey: "maxIterations",
+    defaultValue: defaultMaxIterations
+  });
+  let builder = new AgentBuilder2(client).withModel(model).withGadgets(...gadgets).withMaxIterations(maxIterations).withParentContext(ctx);
+  if (systemPrompt) {
+    builder = builder.withSystem(systemPrompt);
+  }
+  if (hooks) {
+    builder = builder.withHooks(hooks);
+  }
+  if (temperature !== void 0) {
+    builder = builder.withTemperature(temperature);
+  }
+  if (ctx.logger) {
+    builder = builder.withLogger(ctx.logger);
+  }
+  return builder;
+}
+function hasHostExports(ctx) {
+  return ctx?.hostExports !== void 0;
+}
+
+// src/package/manifest.ts
+function parseManifest(packageJson) {
+  const llmist = packageJson.llmist;
+  if (!llmist || typeof llmist !== "object") {
+    return void 0;
+  }
+  return llmist;
+}
+function hasPreset(manifest, presetName) {
+  return manifest?.presets?.[presetName] !== void 0;
+}
+function getPresetGadgets(manifest, presetName) {
+  const preset = manifest?.presets?.[presetName];
+  if (preset === void 0) return void 0;
+  return preset;
+}
+function hasSubagents(manifest) {
+  return manifest?.subagents !== void 0 && Object.keys(manifest.subagents).length > 0;
+}
+function getSubagent(manifest, name) {
+  return manifest?.subagents?.[name];
+}
+function listSubagents(manifest) {
+  if (!manifest?.subagents) return [];
+  return Object.keys(manifest.subagents);
+}
+function listPresets(manifest) {
+  if (!manifest?.presets) return [];
+  return Object.keys(manifest.presets);
+}
+
+// src/index.ts
+function getHostExports2(ctx) {
   if (!ctx?.hostExports) {
     throw new Error(
       "hostExports not available. Gadgets that create subagents must be run via llmist agent, not standalone. Ensure you are using llmist >= 6.2.0."
@@ -12227,6 +12555,7 @@ export {
   Agent,
   AgentBuilder,
   AnthropicMessagesProvider,
+  BaseSessionManager,
   CompactionManager,
   ConversationManager,
   DEFAULT_COMPACTION_CONFIG,
@@ -12255,6 +12584,7 @@ export {
   ModelIdentifierParser,
   ModelRegistry,
   OpenAIChatProvider,
+  SimpleSessionManager,
   SlidingWindowStrategy,
   StreamProcessor,
   SummarizationStrategy,
@@ -12273,6 +12603,7 @@ export {
   createLogger,
   createMediaOutput,
   createOpenAIProviderFromEnv,
+  createSubagent,
   defaultLogger,
   detectAudioMimeType,
   detectImageMimeType,
@@ -12281,12 +12612,25 @@ export {
   filterByDepth,
   filterByParent,
   filterRootEvents,
+  format,
+  formatBytes,
+  formatDate,
+  formatDuration,
   formatLLMError,
-  getHostExports,
+  gadgetError,
+  gadgetSuccess,
+  getErrorMessage,
+  getHostExports2 as getHostExports,
   getModelId,
+  getPresetGadgets,
   getProvider,
+  getSubagent,
   groupByParent,
+  hasHostExports,
+  hasPreset,
   hasProviderPrefix,
+  hasSubagents,
+  humanDelay,
   imageFromBase64,
   imageFromBuffer,
   imageFromUrl,
@@ -12301,9 +12645,13 @@ export {
   isSubagentEvent,
   isTextPart,
   iterationProgressHint,
+  listPresets,
+  listSubagents,
   normalizeMessageContent,
   parallelGadgetHint,
   parseDataUrl,
+  parseManifest,
+  randomDelay,
   resolveConfig,
   resolveHintTemplate,
   resolveModel,
@@ -12321,10 +12669,15 @@ export {
   schemaToJSONSchema,
   stream,
   text,
+  timing,
   toBase64,
+  truncate,
   validateAndApplyDefaults,
   validateGadgetParams,
   validateGadgetSchema,
+  withErrorHandling,
+  withRetry,
+  withTimeout,
   z5 as z
 };
 //# sourceMappingURL=index.js.map