memeloop 0.0.1 → 0.1.1

package/dist/browser.cjs

@@ -0,0 +1,1413 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/browser.ts
+var browser_exports = {};
+__export(browser_exports, {
+  ALL_CATEGORIES: () => ALL_CATEGORIES,
+  AgentCreationController: () => AgentCreationController,
+  AgentDefinitionEditorController: () => AgentDefinitionEditorController,
+  AgentSessionController: () => AgentSessionController,
+  OrchestrationError: () => OrchestrationError,
+  PromptPreviewController: () => PromptPreviewController,
+  REMOTE_ORCHESTRATION_PROTOCOL: () => REMOTE_ORCHESTRATION_PROTOCOL,
+  TiddlyWikiHttpStorage: () => TiddlyWikiHttpStorage,
+  createFetchOrchestrationTransport: () => createFetchOrchestrationTransport,
+  createNamespacedOrchestrationClient: () => createNamespacedOrchestrationClient,
+  createReadOnlyOrchestrationClient: () => createReadOnlyOrchestrationClient,
+  createRemoteOrchestrationClient: () => createRemoteOrchestrationClient,
+  createRemoteOrchestrationHandler: () => createRemoteOrchestrationHandler,
+  getCategoryConfig: () => getCategoryConfig,
+  isTaskCategory: () => isTaskCategory,
+  resolveCategory: () => resolveCategory
+});
+module.exports = __toCommonJS(browser_exports);
+
+// src/orchestration/errors.ts
+var OrchestrationError = class extends Error {
+  code;
+  retryable;
+  retryAfterMs;
+  reason;
+  details;
+  constructor(data) {
+    super(data.message);
+    this.name = "OrchestrationError";
+    this.code = data.code;
+    this.retryable = data.retryable;
+    this.retryAfterMs = data.retryAfterMs;
+    this.reason = data.reason;
+    this.details = data.details;
+  }
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      retryable: this.retryable,
+      retryAfterMs: this.retryAfterMs,
+      reason: this.reason,
+      details: this.details
+    };
+  }
+};
+
+// 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/categories.ts
+var CATEGORY_CONFIGS = {
+  "visual-engineering": {
+    model: "default",
+    temperature: 0.3,
+    description: "UI/UX visual engineering tasks requiring precise rendering and layout"
+  },
+  ultrabrain: {
+    model: "default",
+    temperature: 0.1,
+    description: "Deep logical reasoning, architecture decisions, and complex problem-solving"
+  },
+  artistry: {
+    model: "default",
+    temperature: 0.8,
+    description: "Creative writing, design, and artistic generation tasks"
+  },
+  quick: {
+    model: "default",
+    temperature: 0.2,
+    description: "Fast, straightforward tasks with minimal deliberation needed"
+  },
+  "unspecified-low": {
+    model: "default",
+    temperature: 0.5,
+    description: "Unclassified tasks of moderate complexity and effort"
+  },
+  "unspecified-high": {
+    model: "default",
+    temperature: 0.4,
+    description: "Unclassified tasks requiring substantial effort across multiple systems"
+  },
+  writing: {
+    model: "default",
+    temperature: 0.7,
+    description: "Documentation, prose, technical writing, and content generation"
+  }
+};
+function getCategoryConfig(category) {
+  const config = CATEGORY_CONFIGS[category];
+  if (!config) {
+    throw new Error(`Unknown task category: ${category}`);
+  }
+  return { ...config };
+}
+function isTaskCategory(value) {
+  return value in CATEGORY_CONFIGS;
+}
+var ALL_CATEGORIES = Object.keys(CATEGORY_CONFIGS);
+function resolveCategory(category) {
+  if (isTaskCategory(category)) {
+    return getCategoryConfig(category);
+  }
+  return getCategoryConfig("unspecified-low");
+}
+
+// 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 });
+  }
+};
+
+// src/orchestration/remoteClient.ts
+var REMOTE_ORCHESTRATION_PROTOCOL = "memeloop.resource.v1";
+var REMOTE_OPERATIONS = /* @__PURE__ */ new Set([
+  "capabilities",
+  "apply",
+  "get",
+  "list",
+  "watch",
+  "delete"
+]);
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function errorData(error) {
+  if (error instanceof OrchestrationError) {
+    return {
+      code: error.code,
+      message: error.message,
+      retryable: error.retryable,
+      ...error.retryAfterMs !== void 0 ? { retryAfterMs: error.retryAfterMs } : {},
+      ...error.reason !== void 0 ? { reason: error.reason } : {},
+      ...error.details !== void 0 ? { details: error.details } : {}
+    };
+  }
+  return {
+    code: "INTERNAL",
+    message: error instanceof Error ? error.message : String(error),
+    retryable: false
+  };
+}
+function throwResponseError(response) {
+  throw new OrchestrationError(response.error);
+}
+function assertResponse(request, response) {
+  if (!isRecord(response) || response.protocol !== REMOTE_ORCHESTRATION_PROTOCOL || response.requestId !== request.requestId || typeof response.ok !== "boolean" || response.ok && !("result" in response) || !response.ok && (!isRecord(response.error) || typeof response.error.code !== "string" || typeof response.error.message !== "string" || typeof response.error.retryable !== "boolean")) {
+    throw new OrchestrationError({
+      code: "INVALID",
+      message: "remote orchestration response correlation or protocol mismatch",
+      retryable: false
+    });
+  }
+}
+var requestSequence = 0;
+function createRemoteOrchestrationClient(transport, options = {}) {
+  const createRequestId = options.createRequestId ?? (() => `resource-${Date.now().toString(36)}-${(++requestSequence).toString(36)}`);
+  function makeRequest(operation, payload) {
+    return {
+      protocol: REMOTE_ORCHESTRATION_PROTOCOL,
+      requestId: createRequestId(),
+      operation,
+      payload
+    };
+  }
+  async function request(operation, payload, signal) {
+    const envelope = makeRequest(operation, payload);
+    const response = await transport.request(envelope, { signal });
+    assertResponse(envelope, response);
+    if (!response.ok) throwResponseError(response);
+    return response.result;
+  }
+  return {
+    getCapabilities() {
+      return request("capabilities", {});
+    },
+    apply(resource, applyOptions) {
+      return request("apply", {
+        resource,
+        ...applyOptions ? { options: applyOptions } : {}
+      });
+    },
+    get(reference, getOptions) {
+      return request("get", {
+        reference,
+        ...getOptions ? { options: getOptions } : {}
+      });
+    },
+    list(query, listOptions) {
+      return request("list", {
+        query,
+        ...listOptions ? { options: listOptions } : {}
+      });
+    },
+    async *watch(query, watchOptions) {
+      const envelope = makeRequest("watch", {
+        query,
+        ...watchOptions ? {
+          options: {
+            ...watchOptions,
+            signal: void 0
+          }
+        } : {}
+      });
+      for await (const response of transport.watch(envelope, {
+        signal: watchOptions?.signal
+      })) {
+        assertResponse(envelope, response);
+        if (!response.ok) throwResponseError(response);
+        yield response.result;
+      }
+    },
+    delete(reference, deleteOptions) {
+      return request("delete", {
+        reference,
+        ...deleteOptions ? { options: deleteOptions } : {}
+      });
+    }
+  };
+}
+function createReadOnlyOrchestrationClient(client, options = {}) {
+  const allowedKinds = options.allowedResourceKinds ? new Set(options.allowedResourceKinds) : void 0;
+  function assertAllowedKind(kind) {
+    if (!allowedKinds || allowedKinds.has(kind)) return;
+    throw new OrchestrationError({
+      code: "FORBIDDEN",
+      message: `remote orchestration access to resource kind '${kind}' is forbidden`,
+      retryable: false
+    });
+  }
+  function forbidden(operation) {
+    throw new OrchestrationError({
+      code: "FORBIDDEN",
+      message: `remote orchestration operation '${operation}' is read-only`,
+      retryable: false
+    });
+  }
+  return {
+    async getCapabilities() {
+      const capabilities = await client.getCapabilities();
+      return {
+        operations: ["get", "list", "watch"],
+        resourceKinds: capabilities.resourceKinds.filter((kind) => allowedKinds ? allowedKinds.has(kind) : true),
+        interfaces: capabilities.interfaces.includes("resource") ? ["resource"] : []
+      };
+    },
+    async apply() {
+      forbidden("apply");
+    },
+    async get(reference, getOptions) {
+      assertAllowedKind(reference.kind);
+      return await client.get(reference, getOptions);
+    },
+    async list(query, listOptions) {
+      assertAllowedKind(query.kind);
+      return await client.list(query, listOptions);
+    },
+    async *watch(query, watchOptions) {
+      assertAllowedKind(query.kind);
+      yield* client.watch(query, watchOptions);
+    },
+    async delete() {
+      forbidden("delete");
+    }
+  };
+}
+function createNamespacedOrchestrationClient(client, options) {
+  const namespace = options.namespace.trim();
+  if (!namespace || namespace.length > 253) {
+    throw new TypeError("namespace must contain between 1 and 253 characters");
+  }
+  const allowedKinds = new Set(options.allowedResourceKinds);
+  const mutableKinds = new Set(options.mutableResourceKinds ?? options.allowedResourceKinds);
+  for (const kind of mutableKinds) {
+    if (!allowedKinds.has(kind)) {
+      throw new TypeError(`mutable resource kind '${kind}' must also be allowed`);
+    }
+  }
+  function assertAllowedKind(kind) {
+    if (allowedKinds.has(kind)) return;
+    throw new OrchestrationError({
+      code: "FORBIDDEN",
+      message: `remote orchestration access to resource kind '${kind}' is forbidden`,
+      retryable: false
+    });
+  }
+  function bindNamespace(metadata) {
+    if (metadata.namespace !== void 0 && metadata.namespace !== namespace) {
+      throw new OrchestrationError({
+        code: "FORBIDDEN",
+        message: `remote orchestration access outside namespace '${namespace}' is forbidden`,
+        retryable: false
+      });
+    }
+    return { ...metadata, namespace };
+  }
+  function assertMutableKind(kind) {
+    assertAllowedKind(kind);
+    if (mutableKinds.has(kind)) return;
+    throw new OrchestrationError({
+      code: "FORBIDDEN",
+      message: `remote orchestration mutation of resource kind '${kind}' is forbidden`,
+      retryable: false
+    });
+  }
+  return {
+    async getCapabilities() {
+      const capabilities = await client.getCapabilities();
+      const resourceKinds = capabilities.resourceKinds.filter((kind) => allowedKinds.has(kind));
+      const resourceOperations = Object.fromEntries(
+        resourceKinds.map((kind) => {
+          const sourceOperations = capabilities.resourceOperations?.[kind] ?? capabilities.operations;
+          return [
+            kind,
+            sourceOperations.filter((operation) => mutableKinds.has(kind) || operation !== "apply" && operation !== "delete")
+          ];
+        })
+      );
+      return {
+        operations: capabilities.operations,
+        resourceKinds,
+        resourceOperations,
+        interfaces: capabilities.interfaces.includes("resource") ? ["resource"] : []
+      };
+    },
+    async apply(resource, applyOptions) {
+      assertMutableKind(resource.kind);
+      return await client.apply(
+        {
+          ...resource,
+          metadata: bindNamespace(resource.metadata)
+        },
+        applyOptions
+      );
+    },
+    async get(reference, getOptions) {
+      assertAllowedKind(reference.kind);
+      return await client.get(bindNamespace(reference), getOptions);
+    },
+    async list(query, listOptions) {
+      assertAllowedKind(query.kind);
+      return await client.list(bindNamespace(query), listOptions);
+    },
+    watch(query, watchOptions) {
+      assertAllowedKind(query.kind);
+      return client.watch(bindNamespace(query), watchOptions);
+    },
+    async delete(reference, deleteOptions) {
+      assertMutableKind(reference.kind);
+      return await client.delete(bindNamespace(reference), deleteOptions);
+    }
+  };
+}
+function requirePayload(payload, key) {
+  if (!(key in payload)) {
+    throw new OrchestrationError({
+      code: "INVALID",
+      message: `remote orchestration request is missing payload.${key}`,
+      retryable: false
+    });
+  }
+  return payload[key];
+}
+function success(request, result) {
+  return {
+    protocol: REMOTE_ORCHESTRATION_PROTOCOL,
+    requestId: request.requestId,
+    ok: true,
+    result
+  };
+}
+function failure(request, error) {
+  const requestRecord = isRecord(request) ? request : void 0;
+  return {
+    protocol: REMOTE_ORCHESTRATION_PROTOCOL,
+    requestId: typeof requestRecord?.requestId === "string" ? requestRecord.requestId : "invalid",
+    ok: false,
+    error: errorData(error)
+  };
+}
+function createRemoteOrchestrationHandler(client) {
+  function validate(request) {
+    if (!isRecord(request) || request.protocol !== REMOTE_ORCHESTRATION_PROTOCOL || typeof request.requestId !== "string" || !request.requestId || request.requestId.length > 256 || !REMOTE_OPERATIONS.has(request.operation) || !isRecord(request.payload)) {
+      throw new OrchestrationError({
+        code: "INVALID",
+        message: "invalid remote orchestration request envelope",
+        retryable: false
+      });
+    }
+  }
+  return {
+    async request(request) {
+      try {
+        validate(request);
+        const payload = request.payload;
+        switch (request.operation) {
+          case "capabilities":
+            return success(request, await client.getCapabilities());
+          case "apply":
+            return success(
+              request,
+              await client.apply(
+                requirePayload(payload, "resource"),
+                payload.options
+              )
+            );
+          case "get":
+            return success(
+              request,
+              await client.get(
+                requirePayload(payload, "reference"),
+                payload.options
+              )
+            );
+          case "list":
+            return success(
+              request,
+              await client.list(
+                requirePayload(payload, "query"),
+                payload.options
+              )
+            );
+          case "delete":
+            return success(
+              request,
+              await client.delete(
+                requirePayload(payload, "reference"),
+                payload.options
+              )
+            );
+          case "watch":
+            throw new OrchestrationError({
+              code: "INVALID",
+              message: "watch requests require the streaming protocol method",
+              retryable: false
+            });
+          default:
+            throw new OrchestrationError({
+              code: "UNSUPPORTED",
+              message: `unsupported remote orchestration operation '${String(request.operation)}'`,
+              retryable: false
+            });
+        }
+      } catch (error) {
+        return failure(request, error);
+      }
+    },
+    async *watch(request, options = {}) {
+      try {
+        validate(request);
+        if (request.operation !== "watch") {
+          throw new OrchestrationError({
+            code: "INVALID",
+            message: "streaming protocol accepts only watch operations",
+            retryable: false
+          });
+        }
+        const watchOptions = request.payload.options;
+        for await (const event of client.watch(
+          requirePayload(request.payload, "query"),
+          {
+            ...watchOptions,
+            signal: options.signal
+          }
+        )) {
+          yield success(request, event);
+        }
+      } catch (error) {
+        yield failure(request, error);
+      }
+    }
+  };
+}
+function createFetchOrchestrationTransport(options) {
+  const fetch_ = options.fetch ?? globalThis.fetch;
+  const maxResponseBytes = options.maxResponseBytes ?? 1024 * 1024;
+  const maxWatchLineBytes = options.maxWatchLineBytes ?? 1024 * 1024;
+  function assertWatchLineSize(line) {
+    if (new TextEncoder().encode(line).byteLength > maxWatchLineBytes) {
+      throw new OrchestrationError({
+        code: "EXHAUSTED",
+        message: `remote orchestration watch line exceeds ${maxWatchLineBytes} bytes`,
+        retryable: false
+      });
+    }
+  }
+  async function headers(accept) {
+    const additional = typeof options.headers === "function" ? await options.headers() : options.headers ?? {};
+    return {
+      Accept: accept,
+      "Content-Type": "application/json",
+      ...additional
+    };
+  }
+  async function post(request, accept, signal) {
+    const response = await fetch_(options.endpoint, {
+      method: "POST",
+      headers: await headers(accept),
+      body: JSON.stringify(request),
+      signal,
+      ...options.credentials ? { credentials: options.credentials } : {}
+    });
+    if (!response.ok) {
+      throw new OrchestrationError({
+        code: response.status === 401 || response.status === 403 ? "FORBIDDEN" : "UNAVAILABLE",
+        message: `remote orchestration endpoint returned HTTP ${response.status}`,
+        retryable: response.status >= 500
+      });
+    }
+    return response;
+  }
+  async function readBoundedText(response, limit) {
+    if (!response.body) return "";
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let size = 0;
+    let text = "";
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        size += value.byteLength;
+        if (size > limit) {
+          await reader.cancel();
+          throw new OrchestrationError({
+            code: "EXHAUSTED",
+            message: `remote orchestration response exceeds ${limit} bytes`,
+            retryable: false
+          });
+        }
+        text += decoder.decode(value, { stream: true });
+      }
+      return text + decoder.decode();
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  return {
+    async request(request, transportOptions = {}) {
+      const response = await post(request, "application/json", transportOptions.signal);
+      const text = await readBoundedText(response, maxResponseBytes);
+      return JSON.parse(text);
+    },
+    async *watch(request, transportOptions = {}) {
+      const response = await post(request, "application/x-ndjson", transportOptions.signal);
+      if (!response.body) {
+        throw new OrchestrationError({
+          code: "UNAVAILABLE",
+          message: "remote orchestration watch response has no body",
+          retryable: true
+        });
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let pending = "";
+      let streamCompleted = false;
+      try {
+        for (; ; ) {
+          const { done, value } = await reader.read();
+          if (done) {
+            streamCompleted = true;
+            break;
+          }
+          pending += decoder.decode(value, { stream: true });
+          let newline = pending.indexOf("\n");
+          while (newline >= 0) {
+            const line = pending.slice(0, newline).trim();
+            pending = pending.slice(newline + 1);
+            assertWatchLineSize(line);
+            if (line) yield JSON.parse(line);
+            newline = pending.indexOf("\n");
+          }
+          if (pending.length > maxWatchLineBytes) {
+            throw new OrchestrationError({
+              code: "EXHAUSTED",
+              message: `remote orchestration watch line exceeds ${maxWatchLineBytes} bytes`,
+              retryable: false
+            });
+          }
+        }
+        pending += decoder.decode();
+        if (pending.trim()) {
+          assertWatchLineSize(pending.trim());
+          yield JSON.parse(pending);
+        }
+      } finally {
+        if (!streamCompleted) {
+          await reader.cancel().catch(() => void 0);
+        }
+        reader.releaseLock();
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ALL_CATEGORIES,
+  AgentCreationController,
+  AgentDefinitionEditorController,
+  AgentSessionController,
+  OrchestrationError,
+  PromptPreviewController,
+  REMOTE_ORCHESTRATION_PROTOCOL,
+  TiddlyWikiHttpStorage,
+  createFetchOrchestrationTransport,
+  createNamespacedOrchestrationClient,
+  createReadOnlyOrchestrationClient,
+  createRemoteOrchestrationClient,
+  createRemoteOrchestrationHandler,
+  getCategoryConfig,
+  isTaskCategory,
+  resolveCategory
+});
+//# sourceMappingURL=browser.cjs.map