memeloop 0.0.1 → 0.1.1

package/dist/chunk-YMNXDNDW.js

@@ -0,0 +1,798 @@
+import {
+  OrchestrationError
+} from "./chunk-FWSY5HOA.js";
+
+// src/storage/tiddlyWikiHttpStorage.ts
+var PREFIX = "$:/memeloop";
+var DEFAULT_MAX_INLINE_BLOB = 256 * 1024;
+var DEFAULT_CAS_ATTEMPTS = 3;
+function bytesToBase64(bytes) {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+function base64ToBytes(value) {
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+  return bytes;
+}
+function escapeFilterValue(value) {
+  return value.replace(/["\\[\]]/g, (character) => `\\${character}`);
+}
+var TiddlyWikiHttpStorage = class {
+  baseUrl;
+  recipe;
+  fetchImpl;
+  credentialHandle;
+  credentialResolver;
+  maxInlineBlobBytes;
+  maxCasAttempts;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.recipe = options.recipe ?? "default";
+    this.fetchImpl = options.fetchImpl ?? globalThis.fetch.bind(globalThis);
+    this.maxInlineBlobBytes = options.maxInlineBlobBytes ?? DEFAULT_MAX_INLINE_BLOB;
+    this.maxCasAttempts = options.maxCasAttempts ?? DEFAULT_CAS_ATTEMPTS;
+    if (options.credentialHandle === void 0 !== (options.credentialResolver === void 0)) {
+      throw new OrchestrationError({
+        code: "INVALID",
+        message: "credentialHandle and credentialResolver must be provided together",
+        retryable: false
+      });
+    }
+    this.credentialHandle = options.credentialHandle;
+    this.credentialResolver = options.credentialResolver;
+  }
+  eventTitle(conversationId, messageId) {
+    return `${PREFIX}/e/${conversationId}/${messageId}`;
+  }
+  metaTitle(conversationId) {
+    return `${PREFIX}/meta/${conversationId}`;
+  }
+  blobTitle(contentHash) {
+    return `${PREFIX}/blob/${contentHash}`;
+  }
+  definitionTitle(id) {
+    return `${PREFIX}/def/${id}`;
+  }
+  instanceTitle(id) {
+    return `${PREFIX}/inst/${id}`;
+  }
+  imTitle(channelId, imUserId) {
+    return `${PREFIX}/im/${channelId}/${imUserId}`;
+  }
+  tiddlerUrl(title) {
+    return `${this.baseUrl}/recipes/${encodeURIComponent(this.recipe)}/tiddlers/${encodeURIComponent(title)}`;
+  }
+  filterUrl(filter) {
+    return `${this.baseUrl}/recipes/${encodeURIComponent(this.recipe)}/tiddlers.json?filter=${encodeURIComponent(filter)}`;
+  }
+  async headers(url, method, extra = {}) {
+    const credentialHeaders = this.credentialHandle && this.credentialResolver ? await this.credentialResolver.resolveHeaders(this.credentialHandle, { url, method }) : {};
+    return {
+      "content-type": "application/json",
+      "x-requested-with": "TiddlyWiki",
+      ...credentialHeaders,
+      ...extra
+    };
+  }
+  /** GET a tiddler; returns null on 404. Includes the ETag when the server sends one. */
+  async readTiddler(title) {
+    const url = this.tiddlerUrl(title);
+    const response = await this.fetchImpl(url, { headers: await this.headers(url, "GET") });
+    if (response.status === 404) return null;
+    if (!response.ok) {
+      throw new OrchestrationError({ code: "UNAVAILABLE", message: `tiddler read failed: HTTP ${response.status}`, retryable: true });
+    }
+    const tiddler = await response.json();
+    const etag = response.headers.get("etag") ?? void 0;
+    return { tiddler, ...etag ? { etag } : {} };
+  }
+  /** CAS write: If-Match when an ETag is known; bounded retries on 412/409. */
+  async writeTiddler(title, build) {
+    for (let attempt = 1; attempt <= this.maxCasAttempts; attempt += 1) {
+      const current = await this.readTiddler(title);
+      if (current && !current.etag) {
+        throw new OrchestrationError({ code: "CONFLICT", message: `tiddler '${title}' has no ETag for a safe update`, retryable: false });
+      }
+      const next = build(current?.tiddler ?? null);
+      const url = this.tiddlerUrl(title);
+      const precondition = current ? { "if-match": current.etag } : { "if-none-match": "*" };
+      const response = await this.fetchImpl(url, {
+        method: "PUT",
+        headers: await this.headers(url, "PUT", precondition),
+        body: JSON.stringify(next)
+      });
+      if (response.ok) return;
+      if (response.status === 412 || response.status === 409) {
+        if (attempt === this.maxCasAttempts) {
+          throw new OrchestrationError({
+            code: "CONFLICT",
+            message: `tiddler '${title}' was modified concurrently after ${attempt} CAS attempts`,
+            retryable: true
+          });
+        }
+        continue;
+      }
+      throw new OrchestrationError({ code: "UNAVAILABLE", message: `tiddler write failed: HTTP ${response.status}`, retryable: true });
+    }
+  }
+  async listByPrefix(prefix) {
+    const filter = `[prefix["${escapeFilterValue(prefix)}"]]`;
+    const url = this.filterUrl(filter);
+    const response = await this.fetchImpl(url, { headers: await this.headers(url, "GET") });
+    if (!response.ok) {
+      throw new OrchestrationError({ code: "UNAVAILABLE", message: `tiddler list failed: HTTP ${response.status}`, retryable: true });
+    }
+    return await response.json();
+  }
+  parsePayload(tiddler) {
+    return JSON.parse(tiddler.text ?? "{}");
+  }
+  async listConversations(options = {}) {
+    const tiddlers = await this.listByPrefix(`${PREFIX}/meta/`);
+    const metas = tiddlers.map((tiddler) => this.parsePayload(tiddler));
+    metas.sort((a, b) => (b.lastMessageTimestamp ?? 0) - (a.lastMessageTimestamp ?? 0));
+    const offset = options.offset ?? 0;
+    const limit = options.limit ?? metas.length;
+    return metas.slice(offset, offset + limit);
+  }
+  async getMessages(conversationId, _options = {}) {
+    const tiddlers = await this.listByPrefix(`${PREFIX}/e/${conversationId}/`);
+    const messages = tiddlers.map((tiddler) => this.parsePayload(tiddler));
+    messages.sort((a, b) => (a.lamportClock ?? 0) - (b.lamportClock ?? 0));
+    return messages;
+  }
+  async appendMessage(message) {
+    await this.writeTiddler(this.eventTitle(message.conversationId, message.messageId), () => ({
+      title: this.eventTitle(message.conversationId, message.messageId),
+      text: JSON.stringify(message)
+    }));
+  }
+  async insertMessagesIfAbsent(messages) {
+    for (const message of messages) {
+      const title = this.eventTitle(message.conversationId, message.messageId);
+      const existing = await this.readTiddler(title);
+      if (!existing) {
+        await this.writeTiddler(title, () => ({ title, text: JSON.stringify(message) }));
+      }
+    }
+  }
+  async getMaxLamportClockForConversation(conversationId) {
+    const messages = await this.getMessages(conversationId);
+    return messages.reduce((max, message) => Math.max(max, message.lamportClock ?? 0), 0);
+  }
+  async upsertConversationMetadata(meta) {
+    const title = this.metaTitle(meta.conversationId);
+    await this.writeTiddler(title, () => ({ title, text: JSON.stringify(meta) }));
+  }
+  async getConversationMeta(conversationId) {
+    const result = await this.readTiddler(this.metaTitle(conversationId));
+    return result ? this.parsePayload(result.tiddler) : null;
+  }
+  async saveAttachment(reference, data) {
+    if (data.byteLength > this.maxInlineBlobBytes) {
+      throw new OrchestrationError({
+        code: "INVALID",
+        message: `blob of ${data.byteLength} bytes exceeds the inline limit ${this.maxInlineBlobBytes}; store it in an external BlobStore and keep the reference`,
+        retryable: false,
+        details: { maxInlineBlobBytes: this.maxInlineBlobBytes }
+      });
+    }
+    const title = this.blobTitle(reference.contentHash);
+    await this.writeTiddler(title, () => ({
+      title,
+      text: JSON.stringify({ reference, dataBase64: bytesToBase64(data) })
+    }));
+  }
+  async getAttachment(contentHash) {
+    const result = await this.readTiddler(this.blobTitle(contentHash));
+    if (!result) return null;
+    return this.parsePayload(result.tiddler).reference;
+  }
+  async readAttachmentData(contentHash) {
+    const result = await this.readTiddler(this.blobTitle(contentHash));
+    if (!result) return null;
+    return base64ToBytes(this.parsePayload(result.tiddler).dataBase64);
+  }
+  async getAgentDefinition(id) {
+    const result = await this.readTiddler(this.definitionTitle(id));
+    return result ? this.parsePayload(result.tiddler) : null;
+  }
+  async saveAgentDefinition(definition) {
+    const title = this.definitionTitle(definition.id);
+    await this.writeTiddler(title, () => ({ title, text: JSON.stringify(definition) }));
+  }
+  async saveAgentInstance(meta) {
+    const title = this.instanceTitle(meta.instanceId);
+    await this.writeTiddler(title, () => ({ title, text: JSON.stringify(meta) }));
+  }
+  async getImBinding(channelId, imUserId) {
+    const result = await this.readTiddler(this.imTitle(channelId, imUserId));
+    return result ? this.parsePayload(result.tiddler) : null;
+  }
+  async setImBinding(record) {
+    const title = this.imTitle(record.channelId, record.imUserId);
+    await this.writeTiddler(title, () => ({ title, text: JSON.stringify(record) }));
+  }
+};
+
+// src/agent-management/AgentSessionController.ts
+var AgentSessionController = class {
+  options;
+  listener = null;
+  snapshot = {
+    agent: null,
+    loading: false,
+    error: null,
+    messages: [],
+    orderedMessageIds: [],
+    streamingMessageIds: /* @__PURE__ */ new Set()
+  };
+  unsubAgentUpdates = null;
+  unsubMessages = null;
+  pollingTimer = null;
+  agentId = null;
+  constructor(options) {
+    this.options = {
+      pollInterval: 500,
+      ...options
+    };
+  }
+  // ── Lifecycle ─────────────────────────────────────────────────
+  /**
+   * Start a session for the given agent ID.
+   * Fetches the agent, subscribes to live updates, and loads messages.
+   */
+  async start(agentId) {
+    this.agentId = agentId;
+    this.emitPartial({ loading: true, error: null });
+    try {
+      const [agent, rawMessages] = await Promise.all([
+        this.options.agentInstanceClient.fetchAgent(agentId),
+        this.options.conversationClient.getMessages(agentId)
+      ]);
+      const orderedMessageIds = rawMessages.map((m) => m.messageId);
+      const messagesMap = /* @__PURE__ */ new Map();
+      for (const m of rawMessages) messagesMap.set(m.messageId, m);
+      this.emitPartial({
+        agent,
+        loading: false,
+        messages: rawMessages,
+        orderedMessageIds,
+        streamingMessageIds: /* @__PURE__ */ new Set()
+      });
+      this.unsubAgentUpdates = this.options.agentInstanceClient.subscribeToUpdates(
+        agentId,
+        this.handleAgentUpdate
+      );
+      this.unsubMessages = this.options.conversationClient.subscribeToMessages(
+        agentId,
+        this.handleNewMessage
+      );
+      this.startPolling(agentId);
+    } catch (error_) {
+      this.emitPartial({
+        loading: false,
+        error: error_ instanceof Error ? error_ : new Error(String(error_))
+      });
+    }
+  }
+  /** Stop the session and clean up subscriptions. */
+  stop() {
+    this.stopPolling();
+    this.unsubAgentUpdates?.();
+    this.unsubAgentUpdates = null;
+    this.unsubMessages?.();
+    this.unsubMessages = null;
+    this.agentId = null;
+  }
+  // ── Actions ───────────────────────────────────────────────────
+  /** Send a user message. */
+  async sendMessage(content, file, wikiTiddlers) {
+    if (!this.agentId) return;
+    this.emitPartial({ error: null });
+    try {
+      await this.options.conversationClient.sendMessage(this.agentId, content, file, wikiTiddlers);
+    } catch (error_) {
+      this.emitPartial({
+        error: error_ instanceof Error ? error_ : new Error(String(error_))
+      });
+    }
+  }
+  /** Cancel the current agent operation. */
+  async cancel() {
+    if (!this.agentId) return;
+    try {
+      await this.options.agentInstanceClient.cancelAgent(this.agentId);
+    } catch (error_) {
+      this.emitPartial({
+        error: error_ instanceof Error ? error_ : new Error(String(error_))
+      });
+    }
+  }
+  /** Delete a turn starting at the given user message ID. */
+  async deleteTurn(userMessageId) {
+    return this.options.conversationClient.deleteTurn(userMessageId);
+  }
+  /** Retry a turn starting at the given user message ID. */
+  async retryTurn(userMessageId) {
+    return this.options.conversationClient.retryTurn(userMessageId);
+  }
+  // ── Subscription ──────────────────────────────────────────────
+  /** Subscribe to snapshot changes. Returns unsubscribe function. */
+  subscribe(listener) {
+    this.listener = listener;
+    listener({ ...this.snapshot, streamingMessageIds: new Set(this.snapshot.streamingMessageIds) });
+    return () => {
+      if (this.listener === listener) this.listener = null;
+    };
+  }
+  /** Get current snapshot without subscribing. */
+  getSnapshot() {
+    return this.snapshot;
+  }
+  // ── Private helpers ───────────────────────────────────────────
+  emitPartial(partial) {
+    this.snapshot = { ...this.snapshot, ...partial };
+    if (this.listener) {
+      this.listener({
+        ...this.snapshot,
+        streamingMessageIds: new Set(this.snapshot.streamingMessageIds)
+      });
+    }
+  }
+  handleAgentUpdate = (update) => {
+    if (this.snapshot.agent) {
+      this.emitPartial({ agent: { ...this.snapshot.agent, ...update } });
+    }
+  };
+  handleNewMessage = (message) => {
+    const messages = [...this.snapshot.messages.filter((m) => m.messageId !== message.messageId), message];
+    const orderedMessageIds = [.../* @__PURE__ */ new Set([...this.snapshot.orderedMessageIds, message.messageId])];
+    this.emitPartial({ messages, orderedMessageIds });
+  };
+  startPolling(agentId) {
+    this.stopPolling();
+    this.pollingTimer = setInterval(async () => {
+      try {
+        const agent = await this.options.agentInstanceClient.fetchAgent(agentId);
+        this.emitPartial({ agent });
+      } catch {
+      }
+    }, this.options.pollInterval);
+  }
+  stopPolling() {
+    if (this.pollingTimer !== null) {
+      clearInterval(this.pollingTimer);
+      this.pollingTimer = null;
+    }
+  }
+};
+
+// src/agent-management/AgentDefinitionEditorController.ts
+var AgentDefinitionEditorController = class {
+  options;
+  listener = null;
+  state = {
+    agentDefinition: null,
+    agentName: "",
+    previewAgentId: null,
+    isLoading: false,
+    isSaving: false,
+    promptSchema: null
+  };
+  autosaveTimer = null;
+  constructor(options) {
+    this.options = {
+      autosaveDebounceMs: 1e3,
+      ...options
+    };
+  }
+  // ── Lifecycle ─────────────────────────────────────────────────
+  /** Load an agent definition and its prompt schema. */
+  async loadDefinition(definitionId) {
+    this.emit({ isLoading: true });
+    try {
+      const [definition, previewAgentId] = await Promise.all([
+        this.options.definitionRepository.getAgentDef(definitionId),
+        this.findOrCreatePreviewAgent(definitionId)
+      ]);
+      if (!definition) {
+        this.emit({ isLoading: false });
+        return;
+      }
+      let promptSchema = null;
+      if (definition.agentFrameworkID) {
+        try {
+          promptSchema = await this.options.agentInstanceClient.getFrameworkConfigSchema(
+            definition.agentFrameworkID
+          );
+        } catch {
+          promptSchema = null;
+        }
+      }
+      this.state = {
+        agentDefinition: definition,
+        agentName: definition.name ?? "",
+        previewAgentId,
+        isLoading: false,
+        isSaving: false,
+        promptSchema
+      };
+      this.emit(this.state);
+    } catch {
+      this.emit({ isLoading: false });
+    }
+  }
+  /** Update the agent definition field. Triggers debounced autosave. */
+  updateDefinition(change) {
+    if (!this.state.agentDefinition) return;
+    const updated = { ...this.state.agentDefinition, ...change };
+    this.state = { ...this.state, agentDefinition: updated, agentName: updated.name ?? "" };
+    this.emit({ agentDefinition: updated, agentName: this.state.agentName });
+    this.scheduleAutosave(updated);
+  }
+  /** Force an immediate save to the repository. */
+  async saveNow() {
+    if (!this.state.agentDefinition) return;
+    this.emit({ isSaving: true });
+    try {
+      await this.options.definitionRepository.updateAgentDef({
+        id: this.state.agentDefinition.id,
+        name: this.state.agentName,
+        description: this.state.agentDefinition.description,
+        agentFrameworkConfig: this.state.agentDefinition.agentFrameworkConfig,
+        aiApiConfig: this.state.agentDefinition.aiApiConfig,
+        agentTools: this.state.agentDefinition.agentTools,
+        heartbeat: this.state.agentDefinition.heartbeat
+      });
+    } catch {
+    } finally {
+      this.emit({ isSaving: false });
+    }
+  }
+  /** Reload the prompt schema for a framework ID. */
+  async reloadSchema(frameworkId) {
+    try {
+      const schema = await this.options.agentInstanceClient.getFrameworkConfigSchema(frameworkId);
+      this.emit({ promptSchema: schema });
+    } catch {
+      this.emit({ promptSchema: null });
+    }
+  }
+  // ── Preview agent lifecycle ───────────────────────────────────
+  /** Get or create a preview agent instance tied to this definition. */
+  async findOrCreatePreviewAgent(definitionId) {
+    try {
+      const result = await this.options.agentInstanceClient.createAgent(definitionId, {
+        preview: true
+      });
+      return result.id;
+    } catch {
+      return null;
+    }
+  }
+  // ── Scheduled tasks ───────────────────────────────────────────
+  async loadScheduledTasks() {
+    if (!this.state.previewAgentId) return [];
+    return this.options.scheduledTaskClient.listScheduledTasksForAgent(
+      this.state.previewAgentId
+    );
+  }
+  async saveScheduledTask(input) {
+    return this.options.scheduledTaskClient.createScheduledTask(input);
+  }
+  async deleteScheduledTask(taskId) {
+    return this.options.scheduledTaskClient.deleteScheduledTask(taskId);
+  }
+  // ── Subscription ──────────────────────────────────────────────
+  subscribe(listener) {
+    this.listener = listener;
+    listener(this.state);
+    return () => {
+      if (this.listener === listener) this.listener = null;
+    };
+  }
+  getState() {
+    return this.state;
+  }
+  // ── Private ───────────────────────────────────────────────────
+  emit(change) {
+    this.listener?.(change);
+  }
+  scheduleAutosave(definition) {
+    if (this.autosaveTimer !== null) clearTimeout(this.autosaveTimer);
+    this.autosaveTimer = setTimeout(() => {
+      this.options.definitionRepository.updateAgentDef({
+        id: definition.id,
+        name: definition.name,
+        description: definition.description,
+        agentFrameworkConfig: definition.agentFrameworkConfig,
+        aiApiConfig: definition.aiApiConfig,
+        agentTools: definition.agentTools,
+        heartbeat: definition.heartbeat
+      }).catch(() => {
+      });
+    }, this.options.autosaveDebounceMs);
+  }
+};
+
+// src/agent-management/AgentCreationController.ts
+var AgentCreationController = class {
+  options;
+  listener = null;
+  state = {
+    currentStep: 0,
+    agentName: "",
+    selectedTemplate: null,
+    temporaryAgentDefinition: null,
+    previewAgentId: null,
+    isLoading: false,
+    promptSchema: null
+  };
+  constructor(options) {
+    this.options = {
+      defaultFrameworkId: "memeloopAgentToolLoop",
+      ...options
+    };
+  }
+  /** Initialize the creation wizard, optionally from a saved tab state. */
+  async start(definitionId, templateDefinitionId) {
+    this.emit({ isLoading: true });
+    try {
+      if (definitionId) {
+        const temporaryDefinition = await this.options.definitionRepository.getAgentDef(definitionId);
+        if (temporaryDefinition) {
+          this.state = {
+            ...this.state,
+            temporaryAgentDefinition: temporaryDefinition,
+            agentName: temporaryDefinition.name ?? "",
+            isLoading: false
+          };
+          this.emit(this.state);
+          if (templateDefinitionId) {
+            const template = await this.options.definitionRepository.getAgentDef(templateDefinitionId);
+            if (template) {
+              this.state = { ...this.state, selectedTemplate: template };
+              this.emit(this.state);
+            }
+          }
+          return;
+        }
+      }
+      this.emit({ isLoading: false });
+    } catch {
+      this.emit({ isLoading: false });
+    }
+  }
+  /** Select a template for the new agent. */
+  selectTemplate(template) {
+    this.state = { ...this.state, selectedTemplate: template };
+    this.emit(this.state);
+  }
+  /** Update the agent name. */
+  setAgentName(name) {
+    this.state = { ...this.state, agentName: name };
+    this.emit(this.state);
+  }
+  /** Advance to the next wizard step. */
+  nextStep() {
+    this.state = { ...this.state, currentStep: Math.min(this.state.currentStep + 1, 2) };
+    this.emit(this.state);
+  }
+  /** Go back to the previous wizard step. */
+  previousStep() {
+    this.state = { ...this.state, currentStep: Math.max(this.state.currentStep - 1, 0) };
+    this.emit(this.state);
+  }
+  /** Set the current wizard step directly. */
+  setStep(step) {
+    this.state = { ...this.state, currentStep: Math.max(0, Math.min(step, 2)) };
+    this.emit(this.state);
+  }
+  /** Update the temporary agent definition. */
+  updateTemporaryDefinition(change) {
+    const updated = this.state.temporaryAgentDefinition ? { ...this.state.temporaryAgentDefinition, ...change } : null;
+    this.state = { ...this.state, temporaryAgentDefinition: updated };
+    this.emit(this.state);
+  }
+  /** Set the prompt schema for the selected framework. */
+  setPromptSchema(schema) {
+    this.state = { ...this.state, promptSchema: schema };
+    this.emit(this.state);
+  }
+  /**
+   * Create a preview agent instance for the chat-preview step.
+   * Should be called when entering step 2 (or the chat preview step).
+   */
+  async createPreviewAgent(definitionId) {
+    this.emit({ isLoading: true });
+    try {
+      const result = await this.options.agentInstanceClient.createAgent(definitionId, {
+        preview: true
+      });
+      this.state = { ...this.state, previewAgentId: result.id, isLoading: false };
+      this.emit(this.state);
+    } catch {
+      this.emit({ isLoading: false });
+    }
+  }
+  /**
+   * Finalize creation: persist the temporary definition and create the actual
+   * agent instance. Returns the final agent instance ID, or null on failure.
+   */
+  async finalize() {
+    if (!this.state.temporaryAgentDefinition) return null;
+    try {
+      const definition = await this.options.definitionRepository.createAgentDef(
+        this.state.temporaryAgentDefinition
+      );
+      const instance = await this.options.agentInstanceClient.createAgent(definition.id);
+      return instance.id;
+    } catch {
+      return null;
+    }
+  }
+  /** Clean up temporary resources. */
+  async cleanup() {
+    if (this.state.previewAgentId) {
+      try {
+        await this.options.agentInstanceClient.deleteAgent(this.state.previewAgentId);
+      } catch {
+      }
+    }
+  }
+  // ── Subscription ──────────────────────────────────────────────
+  subscribe(listener) {
+    this.listener = listener;
+    listener({ ...this.state });
+    return () => {
+      if (this.listener === listener) this.listener = null;
+    };
+  }
+  getState() {
+    return this.state;
+  }
+  // ── Private ───────────────────────────────────────────────────
+  emit(change) {
+    this.state = { ...this.state, ...change };
+    this.listener?.({ ...this.state });
+  }
+};
+
+// src/agent-management/PromptPreviewController.ts
+var PromptPreviewController = class {
+  options;
+  listener = null;
+  state = {
+    open: false,
+    baseMode: "preview",
+    activeTab: "tree",
+    loading: false,
+    progress: 0,
+    currentStep: "",
+    currentPlugin: null,
+    result: null,
+    lastUpdated: null,
+    formFieldsToScrollTo: []
+  };
+  constructor(options) {
+    this.options = options;
+  }
+  /** Open the dialog with an optional base mode. */
+  open(baseMode) {
+    this.state = {
+      ...this.state,
+      open: true,
+      baseMode: baseMode ?? "preview",
+      loading: false,
+      progress: 0,
+      currentStep: "Starting...",
+      currentPlugin: null,
+      result: null,
+      lastUpdated: null,
+      formFieldsToScrollTo: []
+    };
+    this.emit();
+  }
+  /** Close the dialog. */
+  close() {
+    this.state = {
+      ...this.state,
+      open: false,
+      baseMode: "preview",
+      lastUpdated: null,
+      formFieldsToScrollTo: []
+    };
+    this.emit();
+  }
+  /** Set the active tab in the dialog. */
+  setActiveTab(tab) {
+    this.state = { ...this.state, activeTab: tab };
+    this.emit();
+  }
+  /** Set form fields to scroll to (for edit mode navigation). */
+  setFormFieldsToScrollTo(fieldPaths) {
+    this.state = { ...this.state, formFieldsToScrollTo: fieldPaths };
+    this.emit();
+  }
+  /**
+   * Generate a preview of the prompt tree.
+   * @param agentFrameworkConfig  The agent's framework configuration
+   * @param messages              Current conversation messages
+   * @param inputText             Optional input text to include in the preview
+   */
+  async generate(agentFrameworkConfig, messages, inputText) {
+    this.state = {
+      ...this.state,
+      loading: true,
+      progress: 0,
+      currentStep: "Preparing..."
+    };
+    this.emit();
+    try {
+      const result = await this.options.previewClient.generatePreview(
+        agentFrameworkConfig,
+        messages,
+        inputText,
+        (progress) => {
+          this.state = {
+            ...this.state,
+            progress: progress.progress,
+            currentStep: progress.step,
+            currentPlugin: progress.currentPlugin ?? null
+          };
+          this.emit();
+        }
+      );
+      this.state = {
+        ...this.state,
+        loading: false,
+        progress: 1,
+        currentStep: "Complete",
+        currentPlugin: null,
+        result,
+        lastUpdated: /* @__PURE__ */ new Date()
+      };
+      this.emit();
+      return result;
+    } catch {
+      this.state = {
+        ...this.state,
+        loading: false,
+        progress: 0,
+        currentStep: "Error occurred",
+        currentPlugin: null,
+        result: null
+      };
+      this.emit();
+      return null;
+    }
+  }
+  // ── Subscription ──────────────────────────────────────────────
+  subscribe(listener) {
+    this.listener = listener;
+    listener({ ...this.state });
+    return () => {
+      if (this.listener === listener) this.listener = null;
+    };
+  }
+  getState() {
+    return this.state;
+  }
+  // ── Private ───────────────────────────────────────────────────
+  emit() {
+    this.listener?.({ ...this.state });
+  }
+};
+
+export {
+  TiddlyWikiHttpStorage,
+  AgentSessionController,
+  AgentDefinitionEditorController,
+  AgentCreationController,
+  PromptPreviewController
+};
+//# sourceMappingURL=chunk-YMNXDNDW.js.map