aimeat 2.0.0 → 2.2.0

package/dist/static/sdk-libs/dist/aimeat-agents.js

@@ -0,0 +1,348 @@
+// GENERATED FILE — do not edit directly. Source: src/static/sdk-libs/agents/ (+ _core/).
+// Rebuild: pnpm build:sdk  ·  Served at /v1/libs/aimeat-agents.js (with a per-node config prelude).
+"use strict";
+(() => {
+  // src/static/sdk-libs/_core/session.js
+  function getSession(libLabel) {
+    const auth = window.AIMEAT && window.AIMEAT.auth;
+    if (!auth) {
+      throw new Error("AIMEAT.auth is required. Include aimeat-auth.js before " + (libLabel || "this library"));
+    }
+    const s = auth.getSession();
+    if (!s) throw new Error("Not logged in. Call AIMEAT.auth.login() first.");
+    return s;
+  }
+  function authFetch(path, opts, libLabel) {
+    return getSession(libLabel).fetch(path, opts);
+  }
+  function makeSession(libLabel) {
+    return {
+      getSession: () => getSession(libLabel),
+      authFetch: (path, opts) => authFetch(path, opts, libLabel)
+    };
+  }
+
+  // src/static/sdk-libs/_core/namespace.js
+  function namespace() {
+    if (!window.AIMEAT) window.AIMEAT = {};
+    return window.AIMEAT;
+  }
+  function attach(key, value) {
+    const ns = namespace();
+    ns[key] = value;
+    return ns;
+  }
+
+  // src/static/sdk-libs/agents/index.js
+  var { authFetch: authFetch2 } = makeSession("aimeat-agents.js");
+  var enc = encodeURIComponent;
+  function unwrap(r, action) {
+    if (!r || !r.ok) {
+      var err = (
+        /** @type {Error & { code?: string }} */
+        new Error(r && r.error && r.error.message || action + " failed")
+      );
+      err.code = r && r.error && r.error.code || "UNKNOWN";
+      throw err;
+    }
+    return r.data;
+  }
+  var _agentsCache = null;
+  var _cancelSetCache = null;
+  var agents = {
+    /** List the owner's agents. opts.activeOnly filters to ones seen recently.
+     *  opts.fresh bypasses the 30s cache. */
+    async list(opts) {
+      var now = Date.now();
+      if (!(opts && opts.fresh) && _agentsCache && now - _agentsCache.t < 3e4) return _agentsCache.v;
+      var data = unwrap(await authFetch2("/v1/agents"), "list agents");
+      var v = data.agents || [];
+      _agentsCache = { v, t: now };
+      return opts && opts.activeOnly ? v.filter(function(a) {
+        return !!a.last_seen;
+      }) : v;
+    },
+    /** One agent by name (or GAII), or null. */
+    async get(name) {
+      var all = await agents.list();
+      return all.find(function(a) {
+        return a.name === name || a.gaii === name;
+      }) || null;
+    },
+    /** Commission a task for an agent. Returns the created task ({ id, status, ... }).
+     *  Created 'queued' by default; task-runner agents auto-activate it.
+     *
+     *  task.scope: [{ name, value, type }] — app-defined tags stored ON the task. This is how
+     *  an app finds its own runs again later: filter `tasks({status:'done'})` on a tag you set,
+     *  instead of trying to parse the agent's memory-key slug. Pass the same array in a
+     *  schedule's `task_template.scope` so scheduled runs carry it too.
+     *  task.verification: { user_expects, technical_checks } — what a good result looks like.
+     *  Both were silently dropped before v1.1.0. */
+    async createTask(name, task) {
+      if (!task || !task.description) throw new Error("createTask requires { description }");
+      var body = {
+        title: task.title || task.description.slice(0, 80),
+        description: task.description,
+        status: task.status || "queued"
+      };
+      if (Array.isArray(task.scope) && task.scope.length) {
+        body.scope = task.scope.map(function(s) {
+          return {
+            name: s.name,
+            value: String(s.value),
+            type: s.type || "text",
+            ...s.description ? { description: s.description } : {}
+          };
+        });
+      }
+      if (task.verification) {
+        var v = task.verification;
+        body.verification = {
+          user_expects: v.user_expects != null ? v.user_expects : v.userExpects || "",
+          technical_checks: v.technical_checks || v.technicalChecks || []
+        };
+      }
+      if (task.rules) body.rules = task.rules;
+      if (task.resources) body.resources = task.resources;
+      var data = unwrap(await authFetch2("/v1/agents/" + enc(name) + "/tasks", {
+        method: "POST",
+        body: JSON.stringify(body)
+      }), "create task");
+      return data.task;
+    },
+    /** Get a single task. */
+    async getTask(name, id) {
+      return unwrap(await authFetch2("/v1/agents/" + enc(name) + "/tasks/" + enc(id)), "get task").task;
+    },
+    /** List an agent's tasks. opts.status filters (queued|active|done|failed|...). */
+    async tasks(name, opts) {
+      var q = "?per_page=100" + (opts && opts.status ? "&status=" + enc(opts.status) : "");
+      return unwrap(await authFetch2("/v1/agents/" + enc(name) + "/tasks" + q), "list tasks").tasks || [];
+    },
+    /** The task's event log (oldest-first). */
+    async events(name, id) {
+      return unwrap(await authFetch2("/v1/agents/" + enc(name) + "/tasks/" + enc(id) + "/events"), "list events").events || [];
+    },
+    /** Live-watch a task: calls onUpdate(task, events) on every server change
+     *  (SSE) plus a periodic poll as a safety net. Returns an unsubscribe fn. */
+    watch(name, id, onUpdate, opts) {
+      var stopped = false, es = null, pollTimer = null, debTimer = null;
+      var pollMs = opts && opts.pollMs || 15e3;
+      async function refresh() {
+        if (stopped) return;
+        try {
+          var task = await agents.getTask(name, id);
+          var events = await agents.events(name, id);
+          if (!stopped && typeof onUpdate === "function") onUpdate(task, events);
+        } catch {
+        }
+      }
+      function debounced() {
+        clearTimeout(debTimer);
+        debTimer = setTimeout(refresh, 400);
+      }
+      refresh();
+      pollTimer = setInterval(refresh, pollMs);
+      (async function() {
+        try {
+          var tk = unwrap(await authFetch2("/v1/events/ticket", { method: "POST" }), "open event stream");
+          if (stopped || !tk || !tk.ticket) return;
+          es = new EventSource("/v1/events?ticket=" + enc(tk.ticket));
+          es.onmessage = debounced;
+        } catch {
+        }
+      })();
+      return function unsubscribe() {
+        stopped = true;
+        if (es) {
+          try {
+            es.close();
+          } catch {
+          }
+          es = null;
+        }
+        clearInterval(pollTimer);
+        clearTimeout(debTimer);
+      };
+    },
+    /** Read the task's published deliverable (task.deliverableKey) from the
+     *  agent's memory. Returns { key, value } | { key, gone:true } | null. */
+    async deliverable(name, id) {
+      var task = await agents.getTask(name, id);
+      if (!task) return null;
+      var key = task.deliverableKey;
+      if (key) {
+        var data = unwrap(await authFetch2("/v1/memory?agent=" + enc(task.agentGaii) + "&prefix=" + enc(key) + "&per_page=20"), "read deliverable");
+        var found = (data.items || []).find(function(i) {
+          return i.key === key;
+        });
+        return found ? { key, value: found.value } : { key, gone: true };
+      }
+      var byTag = unwrap(await authFetch2("/v1/memory?agent=" + enc(task.agentGaii) + "&tags=" + enc("task:" + id) + "&per_page=20"), "read deliverable by tag");
+      var items = (byTag.items || []).slice().sort(function(a, b) {
+        return String(b.updated_at || "").localeCompare(String(a.updated_at || ""));
+      });
+      if (items.length) return { key: items[0].key, value: items[0].value, viaTag: true };
+      return null;
+    },
+    /** Read a specific memory entry under an agent's namespace (or null). */
+    async memory(name, key) {
+      var a = await agents.get(name);
+      var gaii = a && a.gaii || name;
+      var data = unwrap(await authFetch2("/v1/memory?agent=" + enc(gaii) + "&prefix=" + enc(key) + "&per_page=20"), "read agent memory");
+      var items = data.items || [];
+      var found = items.find(function(i) {
+        return i.key === key;
+      });
+      return found ? found.value : null;
+    },
+    /** Agent questions awaiting an answer: outbound option-prompts with no reply
+     *  yet. Each is { message_id, prompt_id, question, options, allow_other }. */
+    async pendingPrompts(name) {
+      var data = unwrap(await authFetch2("/v1/agents/" + enc(name) + "/messages?per_page=100"), "list messages");
+      var msgs = data.messages || [];
+      var answered = {};
+      msgs.forEach(function(m) {
+        var pa = m.metadata && (m.metadata.promptAnswer || m.metadata.prompt_answer);
+        var pid = pa && (pa.promptId || pa.prompt_id);
+        if (pid) answered[pid] = true;
+      });
+      var out = [];
+      msgs.forEach(function(m) {
+        if (m.direction !== "outbound") return;
+        var p = m.metadata && m.metadata.prompt;
+        if (!p) return;
+        var pid = p.promptId || p.prompt_id;
+        if (!pid || answered[pid]) return;
+        out.push({
+          message_id: m.id,
+          prompt_id: pid,
+          question: p.question,
+          options: p.options || [],
+          allow_other: (p.allowOther != null ? p.allowOther : p.allow_other) !== false
+        });
+      });
+      return out;
+    },
+    /** Answer an agent's option-prompt (owner -> agent). choice is the chosen
+     *  option text, or free text when is_other is true. */
+    async answerPrompt(name, ans) {
+      if (!ans || !ans.prompt_id || !ans.choice) throw new Error("answerPrompt requires { prompt_id, choice }");
+      return unwrap(await authFetch2("/v1/agents/" + enc(name) + "/messages", {
+        method: "POST",
+        body: JSON.stringify({
+          content: ans.choice,
+          direction: "inbound",
+          metadata: { prompt_answer: { prompt_id: ans.prompt_id, choice: ans.choice, is_other: !!ans.is_other } }
+        })
+      }), "answer prompt");
+    },
+    /** Commission + watch until done/failed/stalled, then resolve
+     *  { task, deliverable }. Best for task-runner agents (which auto-activate).
+     *  opts: { onProgress(task, events), timeoutMs, pollMs }. */
+    async run(name, task, opts) {
+      var created = await agents.createTask(name, task);
+      var id = created.id;
+      return await new Promise(function(resolve, reject) {
+        var done = false, to = null;
+        var stop = agents.watch(name, id, async function(t, events) {
+          if (opts && opts.onProgress) {
+            try {
+              opts.onProgress(t, events);
+            } catch {
+            }
+          }
+          if (!done && (t.status === "done" || t.status === "failed" || t.status === "stalled")) {
+            done = true;
+            if (to) clearTimeout(to);
+            stop();
+            var deliverable = t.status === "done" ? await agents.deliverable(name, id).catch(function() {
+              return null;
+            }) : null;
+            resolve({ task: t, deliverable });
+          }
+        }, opts);
+        if (opts && opts.timeoutMs > 0) {
+          to = setTimeout(function() {
+            if (!done) {
+              done = true;
+              stop();
+              var e = (
+                /** @type {Error & { code?: string, taskId?: string }} */
+                new Error("run() timed out")
+              );
+              e.code = "TIMEOUT";
+              e.taskId = id;
+              reject(e);
+            }
+          }, opts.timeoutMs);
+        }
+      });
+    },
+    /** Cooperative-cancel a task. Writes a cancel marker the worker daemon
+     *  honours before its next kickoff (so abandoned/speculative subtasks never
+     *  start), AND, for immediate effect, natively pauses an active task or
+     *  deletes a queued one (owner-only ops; best-effort). Returns
+     *  { marked:true, native:'paused'|'deleted'|null }. */
+    async cancelTask(name, taskId, opts) {
+      await authFetch2("/v1/memory", { method: "POST", body: JSON.stringify({
+        key: "agents.cancel.task." + taskId,
+        value: [taskId],
+        visibility: "owner"
+      }) });
+      var native = null;
+      try {
+        var t = await agents.getTask(name, taskId);
+        var st = t && t.status;
+        if (st === "active") {
+          var r = await authFetch2("/v1/agents/" + enc(name) + "/tasks/" + enc(taskId) + "/pause", { method: "POST" });
+          if (r && r.ok) native = "paused";
+        } else if (st === "queued" || st === "draft") {
+          var r2 = await authFetch2("/v1/agents/" + enc(name) + "/tasks/" + enc(taskId), { method: "DELETE" });
+          if (r2 && r2.ok) native = "deleted";
+        }
+      } catch {
+      }
+      if (opts && opts.invalidate !== false) _cancelSetCache = null;
+      return { marked: true, native };
+    },
+    /** Cancel a whole run/batch: write one marker listing many task ids
+     *  (key agents.cancel.run.<run>). Workers union all agents.cancel.* markers. */
+    async cancelRun(run, taskIds) {
+      if (!run || !Array.isArray(taskIds)) throw new Error("cancelRun requires (run, taskIds[])");
+      await authFetch2("/v1/memory", { method: "POST", body: JSON.stringify({
+        key: "agents.cancel.run." + run,
+        value: taskIds.map(String),
+        visibility: "owner"
+      }) });
+      _cancelSetCache = null;
+      return { marked: true, count: taskIds.length };
+    },
+    /** The set (array) of task ids cancelled via any agents.cancel.* marker
+     *  visible to the owner. 10s cache. */
+    async cancelledTaskIds(opts) {
+      var now = Date.now();
+      if (!(opts && opts.fresh) && _cancelSetCache && now - _cancelSetCache.t < 1e4) return _cancelSetCache.v;
+      var data = unwrap(await authFetch2("/v1/memory?owner_scope=true&prefix=" + enc("agents.cancel.") + "&per_page=100"), "read cancel markers");
+      var set = {};
+      (data.items || []).forEach(function(it) {
+        var v2 = it.value;
+        if (Array.isArray(v2)) v2.forEach(function(x) {
+          set[String(x)] = true;
+        });
+        else if (v2 && typeof v2 === "object") Object.keys(v2).forEach(function(k) {
+          set[k] = true;
+        });
+      });
+      var v = Object.keys(set);
+      _cancelSetCache = { v, t: now };
+      return v;
+    },
+    /** Clear the cached agent list (call after creating/deleting an agent). */
+    invalidateCache() {
+      _agentsCache = null;
+      _cancelSetCache = null;
+    }
+  };
+  attach("agents", agents);
+})();

package/dist/static/sdk-libs/dist/aimeat-ai.js

@@ -0,0 +1,168 @@
+// GENERATED FILE — do not edit directly. Source: src/static/sdk-libs/ai/ (+ _core/).
+// Rebuild: pnpm build:sdk  ·  Served at /v1/libs/aimeat-ai.js (with a per-node config prelude).
+"use strict";
+(() => {
+  // src/static/sdk-libs/_core/session.js
+  function getSession(libLabel) {
+    const auth = window.AIMEAT && window.AIMEAT.auth;
+    if (!auth) {
+      throw new Error("AIMEAT.auth is required. Include aimeat-auth.js before " + (libLabel || "this library"));
+    }
+    const s = auth.getSession();
+    if (!s) throw new Error("Not logged in. Call AIMEAT.auth.login() first.");
+    return s;
+  }
+  function authFetch(path, opts, libLabel) {
+    return getSession(libLabel).fetch(path, opts);
+  }
+  function makeSession(libLabel) {
+    return {
+      getSession: () => getSession(libLabel),
+      authFetch: (path, opts) => authFetch(path, opts, libLabel)
+    };
+  }
+
+  // src/static/sdk-libs/_core/namespace.js
+  function namespace() {
+    if (!window.AIMEAT) window.AIMEAT = {};
+    return window.AIMEAT;
+  }
+  function attach(key, value) {
+    const ns = namespace();
+    ns[key] = value;
+    return ns;
+  }
+
+  // src/static/sdk-libs/ai/index.js
+  var { authFetch: authFetch2 } = makeSession("aimeat-ai.js");
+  var _availCache = null;
+  var _modelsCache = null;
+  var ai = {
+    /**
+     * Returns true if the user has AI configured (an OpenRouter key, or a keyless
+     * self-hosted provider). Cached 60 seconds. Apps should call this before showing
+     * "Use AI" buttons. Uses GET /v1/ai/available, which an app-grant token (a sandboxed
+     * app on the isolated app origin) can call with the ai:use scope — unlike the
+     * owner-only /v1/openrouter/settings. Falls back to that settings probe on older nodes.
+     */
+    async isAvailable() {
+      const now = Date.now();
+      if (_availCache && now - _availCache.t < 6e4) return _availCache.v;
+      try {
+        const r = await authFetch2("/v1/ai/available");
+        if (r && r.ok && r.data && typeof r.data.available === "boolean") {
+          _availCache = { v: r.data.available, t: now };
+          return r.data.available;
+        }
+        const s = await authFetch2("/v1/openrouter/settings");
+        const v = !!(s && s.ok && s.data && (s.data.hasApiKey || s.data.has_api_key));
+        _availCache = { v, t: now };
+        return v;
+      } catch {
+        return false;
+      }
+    },
+    /**
+     * Run a single completion. Returns { content, model, usage, budget }.
+     * Throws an Error with .code set on quota/permission/auth failures.
+     *
+     * Recognized error codes (see routes/ai.ts):
+     *   NO_API_KEY            — user hasn't set up a key yet
+     *   QUOTA_EXHAUSTED       — daily user budget hit
+     *   APP_QUOTA_EXHAUSTED   — per-app daily quota hit
+     *   APP_NOT_ALLOWED       — app_id not in user's allowlist
+     *   APP_ID_REQUIRED       — user has an allowlist; app must pass app_id
+     *   INVALID_API_KEY       — provider rejected the key
+     *   RATE_LIMITED          — provider rate limit
+     *   PROVIDER_ERROR        — upstream provider failed
+     */
+    async complete(opts) {
+      if (!opts || typeof opts !== "object") throw new Error("opts object required");
+      if (!opts.prompt) throw new Error("opts.prompt required");
+      const body = {
+        prompt: opts.prompt,
+        systemPrompt: opts.systemPrompt,
+        model: opts.model,
+        modelRole: opts.modelRole,
+        temperature: opts.temperature,
+        top_p: opts.top_p,
+        max_tokens: opts.max_tokens,
+        app_id: opts.app_id
+      };
+      const r = await authFetch2("/v1/ai/complete", {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      if (!r || !r.ok) {
+        const code = r && r.error && r.error.code || "UNKNOWN";
+        const msg = r && r.error && r.error.message || "AI call failed";
+        const err = (
+          /** @type {Error & { code?: string }} */
+          new Error(msg)
+        );
+        err.code = code;
+        throw err;
+      }
+      return r.data;
+    },
+    /**
+     * Convenience: complete + JSON.parse. Adds a "return ONLY valid JSON"
+     * suffix to systemPrompt. On parse failure, retries ONCE with a stronger
+     * instruction. Further failures throw — the user can retry by clicking.
+     */
+    async completeJson(opts) {
+      const suffix = "\nReturn ONLY valid JSON, no prose, no markdown fences.";
+      const first = await ai.complete({
+        ...opts,
+        systemPrompt: (opts.systemPrompt || "") + suffix
+      });
+      try {
+        return { ...first, parsed: JSON.parse(first.content) };
+      } catch {
+        const retry = await ai.complete({
+          ...opts,
+          systemPrompt: (opts.systemPrompt || "") + suffix + "\nIMPORTANT: your previous attempt was not valid JSON. Output ONLY the JSON object, starting with { and ending with }. No other text.",
+          temperature: typeof opts.temperature === "number" ? Math.max(0, opts.temperature - 0.3) : 0.2
+        });
+        try {
+          return { ...retry, parsed: JSON.parse(retry.content) };
+        } catch {
+          const err = (
+            /** @type {Error & { code?: string }} */
+            new Error("AI returned invalid JSON twice. Original response: " + retry.content.slice(0, 200))
+          );
+          err.code = "JSON_PARSE_FAILED";
+          throw err;
+        }
+      }
+    },
+    /**
+     * List the models the user's account can hit. Cached 1 hour.
+     */
+    async models() {
+      const now = Date.now();
+      if (_modelsCache && now - _modelsCache.t < 36e5) return _modelsCache.v;
+      const r = await authFetch2("/v1/openrouter/models");
+      if (!r || !r.ok) throw new Error(r && r.error && r.error.message || "Failed to list models");
+      const v = r.data && r.data.models ? r.data.models : [];
+      _modelsCache = { v, t: now };
+      return v;
+    },
+    /**
+     * Today's spend snapshot (owner-only). Useful for "AI used: $0.04 / $1.00".
+     */
+    async usage() {
+      const r = await authFetch2("/v1/ai/usage");
+      if (!r || !r.ok) throw new Error(r && r.error && r.error.message || "Failed to read usage");
+      return r.data;
+    },
+    /**
+     * Clear browser-side caches. Call after the user toggles their key/budget.
+     */
+    invalidateCache() {
+      _availCache = null;
+      _modelsCache = null;
+    }
+  };
+  attach("ai", ai);
+})();