@oneie/sdk 0.7.0 → 0.9.0

package/dist/client.js

@@ -1,4 +1,6 @@
 import { accept as payAccept, request as payRequest, status as payStatus } from "./pay.js";
+import { skillsImport } from "./skills.js";
+import { getToken, clearToken } from "./storage.js";
 import { AuthError, RateLimitError, SubstrateError, TimeoutError, ValidationError } from "./errors.js";
 import { resolveApiKey, resolveBaseUrl } from "./urls.js";
 import { emit } from "./telemetry.js";
@@ -41,9 +43,14 @@ async function withRetry(fn, config) {
 }
 async function req(baseUrl, path, init = {}, apiKey) {
     const headers = { "Content-Type": "application/json" };
-    if (apiKey)
-        headers["Authorization"] = `Bearer ${apiKey}`;
+    // Prefer explicit API key; fall back to persisted session token.
+    const bearer = apiKey ?? getToken();
+    if (bearer)
+        headers["Authorization"] = `Bearer ${bearer}`;
     const res = await fetch(`${baseUrl}${path}`, { ...init, headers });
+    // On 401, the persisted token is no longer valid — clear it so the caller gets a clean state.
+    if (res.status === 401)
+        clearToken();
     if (!res.ok)
         throwForStatus(res.status, init.method ?? "GET", path);
     return res.json();
@@ -55,6 +62,8 @@ export class SubstrateClient {
     validateMode;
     /** Pay module — accept, request, status. Bound to this client's baseUrl + apiKey. */
     pay;
+    /** Skills module — import a skill by ref or content. */
+    skills;
     constructor(cfg = {}) {
         this.baseUrl = resolveBaseUrl(cfg.baseUrl);
         this.apiKey = resolveApiKey(cfg.apiKey);
@@ -66,6 +75,10 @@ export class SubstrateClient {
             request: (opts) => payRequest(opts, cfg),
             status: (ref) => payStatus(ref, cfg),
         };
+        // Bind skills module methods to this client's resolved baseUrl + apiKey
+        this.skills = {
+            import: (opts) => skillsImport({ baseUrl: this.baseUrl, apiKey: this.apiKey ?? "" }, opts),
+        };
     }
     static fromApiKey(key, baseUrl) {
         return new SubstrateClient({ apiKey: key, baseUrl });
@@ -73,14 +86,17 @@ export class SubstrateClient {
     r(path, init = {}) {
         return withRetry(() => req(this.baseUrl, path, init, this.apiKey), this.retryConfig);
     }
-    async signal(sender, receiver, data) {
-        const result = await this.r("/api/signal", { method: "POST", body: JSON.stringify({ sender, receiver, data }) });
+    async signal(receiver, data) {
+        const result = await this.r(`/api/signal/${encodeURIComponent(receiver)}`, { method: "POST", body: JSON.stringify({ data }) });
         emit("toolkit:sdk:signal", ["sdk", "method-signal", result.success ? "200" : "error"]);
         return result;
     }
-    async ask(receiver, data, timeout, from) {
+    async emitAgentEvent(slug, agentId, event, payload) {
+        return this.r("/api/agent-events", { method: "POST", body: JSON.stringify({ slug, agentId, event: `custom:${event}`, payload }) });
+    }
+    async ask(receiver, data, timeoutMs) {
         const t = Date.now();
-        const raw = await this.r("/api/ask", { method: "POST", body: JSON.stringify({ receiver, data, timeout, from }) });
+        const raw = await this.r(`/api/ask/${encodeURIComponent(receiver)}`, { method: "POST", body: JSON.stringify({ data, timeoutMs }) });
         const kind = "result" in raw ? "result"
             : "timeout" in raw ? "timeout"
                 : "dissolved" in raw ? "dissolved"
@@ -89,96 +105,306 @@ export class SubstrateClient {
         emit("toolkit:sdk:ask", ["sdk", "method-ask", `outcome-${kind}`], { latencyMs: Date.now() - t });
         return result;
     }
-    async mark(edge, scores) {
-        const result = await this.r("/api/loop/mark-dims", { method: "POST", body: JSON.stringify({ edge, ...(scores ?? { fit: 1, form: 1, truth: 1, taste: 1 }) }) });
+    async mark(edge, strength = 1) {
+        const result = await this.r(`/api/mark/${encodeURIComponent(edge)}`, { method: "POST", body: JSON.stringify({ strength }) });
         emit("toolkit:sdk:mark", ["sdk", "method-mark"]);
         return result;
     }
-    async warn(edge, scores) {
-        const result = await this.r("/api/loop/mark-dims", { method: "POST", body: JSON.stringify({ edge, ...(scores ?? { fit: 0, form: 0, truth: 0, taste: 0 }) }) });
+    async warn(edge, strength = 1) {
+        const result = await this.r(`/api/warn/${encodeURIComponent(edge)}`, { method: "POST", body: JSON.stringify({ strength }) });
         emit("toolkit:sdk:warn", ["sdk", "method-warn"]);
         return result;
     }
-    async fade(trailRate, resistanceRate) {
-        const result = await this.r("/api/decay-cycle", { method: "POST", body: JSON.stringify({ trailRate, resistanceRate }) });
+    async fade(rate) {
+        const result = await this.r("/api/fade", { method: "POST", body: JSON.stringify({ rate }) });
         emit("toolkit:sdk:fade", ["sdk", "method-fade"]);
         return result;
     }
-    async highways(limit = 10) {
-        const result = await this.r(`/api/loop/highways?limit=${limit}`);
+    async highways(limit = 50, from) {
+        const params = new URLSearchParams({ limit: String(limit) });
+        if (from)
+            params.set("from", from);
+        const result = await this.r(`/api/export/highways?${params}`);
         emit("toolkit:sdk:highways", ["sdk", "method-highways"]);
         return result;
     }
-    async recall(status) {
-        const qs = status ? `?status=${encodeURIComponent(status)}` : "";
-        const result = await this.r(`/api/hypotheses${qs}`);
+    async recall(status, search, limit = 20) {
+        const params = new URLSearchParams({ limit: String(limit) });
+        if (status)
+            params.set("status", status);
+        if (search)
+            params.set("search", search);
+        const result = await this.r(`/api/learning?${params}`);
         emit("toolkit:sdk:recall", ["sdk", "method-recall"]);
         return result;
     }
-    async reveal(uid) {
-        const result = await this.r(`/api/memory/reveal/${encodeURIComponent(uid)}`);
+    async reveal(uid, field) {
+        const qs = field ? `?field=${encodeURIComponent(field)}` : "";
+        const result = await this.r(`/api/pii/reveal/${encodeURIComponent(uid)}${qs}`);
         emit("toolkit:sdk:reveal", ["sdk", "method-reveal"]);
         return result;
     }
-    async forget(uid) {
-        const result = await this.r(`/api/memory/forget/${encodeURIComponent(uid)}`, { method: "DELETE" });
+    async forget(uid, source) {
+        const result = await this.r("/api/forget", { method: "POST", body: JSON.stringify({ actorId: uid, source: source ?? "sdk" }) });
         emit("toolkit:sdk:forget", ["sdk", "method-forget"]);
         return result;
     }
-    async frontier(uid) {
-        const result = await this.r(`/api/memory/frontier/${encodeURIComponent(uid)}`);
+    async frontier(limit = 50) {
+        const result = await this.r(`/api/frontiers?limit=${limit}`);
         emit("toolkit:sdk:frontier", ["sdk", "method-frontier"]);
         return result;
     }
-    async know() {
-        const result = await this.r("/api/tick");
-        emit("toolkit:sdk:know", ["sdk", "method-know", "stage:advocate"]);
+    async follow(tag) {
+        const result = await this.r(`/api/follow?tag=${encodeURIComponent(tag)}`);
+        emit("toolkit:sdk:follow", ["sdk", "method-follow"]);
         return result;
     }
+    /** @deprecated No server-side tick endpoint. Use fade() on a schedule instead. */
+    async know() {
+        return {};
+    }
     async walletFor(uid) {
-        const result = await this.r(`/api/identity/${encodeURIComponent(uid)}/address`);
+        const result = await this.ask("identity:address", { uid });
         emit("toolkit:sdk:walletFor", ["sdk", "method-walletFor", "stage:wallet"]);
-        return { uid: result.uid, address: result.address };
+        return "result" in result && result.result ? result.result : { uid, address: "" };
     }
     async signIn(opts) {
-        const result = await this.r("/api/auth/sign-in/email", { method: "POST", body: JSON.stringify(opts) });
+        const result = await this.ask("auth:sign-in", opts);
         emit("toolkit:sdk:signIn", ["sdk", "method-signIn", "stage:sign-in:human"]);
-        return result;
+        return "result" in result && result.result ? result.result : { sessionId: "", userId: "" };
     }
     async signOut() {
-        await this.r("/api/auth/sign-out", { method: "POST", body: JSON.stringify({}) });
+        await this.signal("auth:sign-out");
         emit("toolkit:sdk:signOut", ["sdk", "method-signOut", "stage:sign-in:human"]);
     }
     async join(opts) {
-        const result = await this.r("/api/board/join", { method: "POST", body: JSON.stringify(opts) });
+        const result = await this.ask("board:join", opts);
         emit("toolkit:sdk:join", ["sdk", "method-join", "stage:join-board"]);
+        return "result" in result && result.result ? result.result : { ok: false, uid: opts.uid, group: opts.group ?? "", role: "" };
+    }
+    async createGroup(opts) {
+        const result = await this.r("/api/groups", { method: "POST", body: JSON.stringify(opts) });
+        emit("toolkit:sdk:createGroup", ["sdk", "method-createGroup", "stage:groups"]);
+        return result;
+    }
+    async listGroups() {
+        const result = await this.r("/api/groups");
+        emit("toolkit:sdk:listGroups", ["sdk", "method-listGroups", "stage:groups"]);
+        return result;
+    }
+    async joinGroup(gid) {
+        await this.signal("groups:join", { gid });
+        emit("toolkit:sdk:joinGroup", ["sdk", "method-joinGroup", "stage:groups"]);
+        return { ok: true, gid, role: "member" };
+    }
+    async leaveGroup(gid) {
+        await this.signal("groups:leave", { gid });
+        emit("toolkit:sdk:leaveGroup", ["sdk", "method-leaveGroup", "stage:groups"]);
+        return { ok: true };
+    }
+    async groupMembers(gid) {
+        const result = await this.ask("groups:members", { gid });
+        emit("toolkit:sdk:groupMembers", ["sdk", "method-groupMembers", "stage:groups"]);
+        return "result" in result && result.result ? result.result : { gid, members: [] };
+    }
+    async inviteMember(gid, uid, role = "member") {
+        await this.signal("groups:invite", { gid, uid, role });
+        emit("toolkit:sdk:inviteMember", ["sdk", "method-inviteMember", "stage:groups"]);
+        return { ok: true };
+    }
+    async bridge(from, to) {
+        const result = await this.ask("paths:bridge", { from, to });
+        emit("toolkit:sdk:bridge", ["sdk", "method-bridge", "stage:groups"]);
+        return "result" in result && result.result ? result.result : {};
+    }
+    async inbox(uid, opts) {
+        const result = await this.ask(`inbox:${uid}`, opts);
+        emit("toolkit:sdk:inbox", ["sdk", "method-inbox", "stage:groups"]);
+        return "result" in result && result.result ? result.result : { uid, signals: [] };
+    }
+    /**
+     * Publish an agent.md to a workspace. The content is the full markdown
+     * (frontmatter + body). The server writes it to R2 at
+     * `{slug}/agents/{name}.md` and the next chat request loads it as the
+     * system prompt.
+     *
+     * Auth: this method requires the SDK to be configured with a token whose
+     * scope includes the target slug (use `<slug>:<token>` for owner-scoped
+     * publishes, or the SERVER_SECRET for CI/internal tooling).
+     *
+     * Mirrors the CLI flow: `oneie agent publish --slug <slug> <path>`.
+     */
+    async publishAgent(opts) {
+        const result = await this.r("/api/agents/publish", { method: "POST", body: JSON.stringify(opts) });
+        emit("toolkit:sdk:publishAgent", ["sdk", "method-publishAgent", "stage:author:publish"]);
+        return result;
+    }
+    /**
+     * Pull a previously published agent.md back from the workspace. Returns
+     * the file content verbatim — caller decides whether to write to disk,
+     * diff, or hand to compileAgent. Auth: same Bearer scope as publishAgent.
+     */
+    async pullAgent(opts) {
+        const qs = `slug=${encodeURIComponent(opts.slug)}&name=${encodeURIComponent(opts.name)}`;
+        const result = await this.r(`/api/agents/publish?${qs}`, { method: "GET" });
+        emit("toolkit:sdk:pullAgent", ["sdk", "method-pullAgent", "stage:author:pull"]);
+        return result;
+    }
+    /**
+     * Unpublish — remove a previously uploaded agent from the workspace.
+     * Idempotent: deleting a non-existent agent returns ok with removed=false.
+     */
+    async unpublishAgent(opts) {
+        const qs = `slug=${encodeURIComponent(opts.slug)}&name=${encodeURIComponent(opts.name)}`;
+        const result = await this.r(`/api/agents/publish?${qs}`, { method: "DELETE" });
+        emit("toolkit:sdk:unpublishAgent", ["sdk", "method-unpublishAgent", "stage:author:unpublish"]);
         return result;
     }
     async deployOnBehalf(opts) {
-        const result = await this.r("/api/agents/deploy-on-behalf", { method: "POST", body: JSON.stringify(opts) });
+        const result = await this.ask("agents:deploy-on-behalf", opts);
         emit("toolkit:sdk:deployOnBehalf", ["sdk", "method-deployOnBehalf", "stage:team-deploy:on-behalf"]);
+        return "result" in result && result.result ? result.result : { ok: false, uid: "", owner: opts.owner, inheritedPaths: [] };
+    }
+    async sub(opts) {
+        await this.signal("subscriptions:register", opts);
+        emit("toolkit:sdk:sub", ["sdk", "method-sub", "stage:subscribe"]);
+        return { ok: true };
+    }
+    /** @deprecated Use sub() */
+    subscribe = this.sub;
+    async select(tag) {
+        const qs = tag ? `?tag=${encodeURIComponent(tag)}` : "";
+        const result = await this.r(`/api/select${qs}`);
+        emit("toolkit:sdk:select", ["sdk", "method-select"]);
         return result;
     }
-    async subscribe(opts) {
-        const result = await this.r("/api/subscribe", { method: "POST", body: JSON.stringify(opts) });
-        emit("toolkit:sdk:subscribe", ["stage:list"]);
-        return result;
+    groups(filters) {
+        const self = this;
+        const q = new URLSearchParams();
+        if (filters?.type)
+            q.set('type', filters.type);
+        if (filters?.after)
+            q.set('after', filters.after);
+        if (filters?.limit)
+            q.set('limit', String(filters.limit));
+        const iter = (async function* () {
+            const data = await self.r(`/api/export/groups${q.toString() ? `?${q}` : ''}`);
+            yield* (data.groups ?? []);
+        })();
+        return Object.assign(iter, {
+            get: (gid) => self.r(`/api/export/groups/${encodeURIComponent(gid)}`)
+        });
     }
-    async select() {
-        const result = await this.r("/api/loop/stage", { method: "POST", body: JSON.stringify({}) });
-        emit("toolkit:sdk:select", ["sdk", "method-select"]);
-        return result;
+    actors(filters) {
+        const self = this;
+        const q = new URLSearchParams();
+        if (filters?.type)
+            q.set('type', filters.type);
+        if (filters?.tag)
+            q.set('tag', filters.tag);
+        if (filters?.after)
+            q.set('after', filters.after);
+        if (filters?.limit)
+            q.set('limit', String(filters.limit));
+        const iter = (async function* () {
+            const data = await self.r(`/api/export/actors${q.toString() ? `?${q}` : ''}`);
+            yield* (data.actors ?? []);
+        })();
+        return Object.assign(iter, {
+            get: (aid) => self.r(`/api/actors/${encodeURIComponent(aid)}`)
+        });
+    }
+    things(filters) {
+        const self = this;
+        const q = new URLSearchParams();
+        if (filters?.type)
+            q.set('type', filters.type);
+        if (filters?.tag)
+            q.set('tag', filters.tag);
+        if (filters?.after)
+            q.set('after', filters.after);
+        if (filters?.limit)
+            q.set('limit', String(filters.limit));
+        const iter = (async function* () {
+            const data = await self.r(`/api/things${q.toString() ? `?${q}` : ''}`);
+            yield* (data.things ?? []);
+        })();
+        return Object.assign(iter, {
+            get: (tid) => self.r(`/api/things/${encodeURIComponent(tid)}`)
+        });
+    }
+    paths(filters) {
+        const self = this;
+        const q = new URLSearchParams();
+        if (filters?.source)
+            q.set('source', filters.source);
+        if (filters?.target)
+            q.set('target', filters.target);
+        if (filters?.minStrength)
+            q.set('minStrength', String(filters.minStrength));
+        if (filters?.after)
+            q.set('after', filters.after);
+        if (filters?.limit)
+            q.set('limit', String(filters.limit));
+        const iter = (async function* () {
+            const data = await self.r(`/api/export/paths${q.toString() ? `?${q}` : ''}`);
+            yield* (data.paths ?? []);
+        })();
+        return Object.assign(iter, {
+            get: (edge) => self.r(`/api/export/paths/${encodeURIComponent(edge)}`)
+        });
+    }
+    events(filters) {
+        const self = this;
+        const q = new URLSearchParams();
+        if (filters?.actor)
+            q.set('actor', filters.actor);
+        if (filters?.tag)
+            q.set('tag', filters.tag);
+        if (filters?.from)
+            q.set('from', filters.from);
+        if (filters?.to)
+            q.set('to', filters.to);
+        if (filters?.limit)
+            q.set('limit', String(filters.limit));
+        const iter = (async function* () {
+            const data = await self.r(`/api/events${q.toString() ? `?${q}` : ''}`);
+            yield* (data.events ?? []);
+        })();
+        return Object.assign(iter, {
+            get: (id) => self.r(`/api/events/${encodeURIComponent(id)}`)
+        });
+    }
+    learning(filters) {
+        const self = this;
+        const q = new URLSearchParams();
+        if (filters?.status)
+            q.set('status', filters.status);
+        if (filters?.actor)
+            q.set('actor', filters.actor);
+        if (filters?.tag)
+            q.set('tag', filters.tag);
+        if (filters?.limit)
+            q.set('limit', String(filters.limit));
+        const iter = (async function* () {
+            const data = await self.r(`/api/learning${q.toString() ? `?${q}` : ''}`);
+            yield* (data.hypotheses ?? []);
+        })();
+        return Object.assign(iter, {
+            get: (hid) => self.r(`/api/learning/${encodeURIComponent(hid)}`)
+        });
     }
     async authAgent(opts = {}) {
-        const result = await this.r("/api/auth/agent", { method: "POST", body: JSON.stringify(opts) });
-        emit("toolkit:sdk:authAgent", ["sdk", "method-authAgent", result.returning ? "returning" : "new", "stage:sign-in:agent"]);
-        return result;
+        const result = await this.ask("auth:agent", opts);
+        const out = "result" in result && result.result ? result.result : { uid: "", name: "", kind: "agent", wallet: null, apiKey: "", keyId: "", returning: false };
+        emit("toolkit:sdk:authAgent", ["sdk", "method-authAgent", out.returning ? "returning" : "new", "stage:sign-in:agent"]);
+        return out;
     }
     async syncAgent(input) {
-        const body = typeof input === "string" ? { markdown: input } : input;
-        const result = await this.r("/api/agents/sync", { method: "POST", body: JSON.stringify(body) });
+        const data = typeof input === "string" ? { markdown: input } : input;
+        const result = await this.ask("agents:sync", data);
         emit("toolkit:sdk:syncAgent", ["sdk", "method-syncAgent", "stage:team-deploy"]);
-        return result;
+        return "result" in result && result.result ? result.result : { ok: false, uid: "", skills: [] };
     }
     async discover(skill, limit = 10) {
         const result = await this.r(`/api/agents/discover?skill=${encodeURIComponent(skill)}&limit=${limit}`);
@@ -186,44 +412,44 @@ export class SubstrateClient {
         return result;
     }
     async register(uid, opts = {}) {
-        const result = await this.r("/api/agents/register", { method: "POST", body: JSON.stringify({ uid, ...opts }) });
+        const result = await this.ask("agents:register", { uid, ...opts });
         emit("toolkit:sdk:register", ["sdk", "method-register", "stage:sell"]);
-        return result;
+        return "result" in result && result.result ? result.result : { ok: false, uid, status: "pending", kind: "agent", wallet: null, walletLinked: false, capabilities: 0 };
     }
     async payWeight(from, to, task, amount) {
-        const result = await this.r("/api/pay", { method: "POST", body: JSON.stringify({ from, to, task, amount }) });
+        const result = await this.ask("pay:weight", { from, to, task, amount });
         emit("toolkit:sdk:payWeight", ["sdk", "method-payWeight", "stage:buy"]);
-        return result;
+        return "result" in result && result.result ? result.result : { ok: false, from, to, task, amount, sui: null };
     }
     async claw(name, opts = {}) {
-        const result = await this.r("/api/claw", { method: "POST", body: JSON.stringify({ name, ...opts }) });
+        const result = await this.ask(`claw:${name}`, opts);
         emit("toolkit:sdk:claw", ["sdk", "method-claw"]);
-        return result;
+        return "result" in result && result.result ? result.result : { ok: true };
     }
     async commend(uid) {
-        const result = await this.r(`/api/agents/${encodeURIComponent(uid)}/commend`, { method: "POST", body: JSON.stringify({}) });
+        await this.signal("agents:commend", { uid });
         emit("toolkit:sdk:commend", ["sdk", "method-commend"]);
-        return result;
+        return { ok: true, id: uid, action: "commend" };
     }
     async flag(uid) {
-        const result = await this.r(`/api/agents/${encodeURIComponent(uid)}/flag`, { method: "POST", body: JSON.stringify({}) });
+        await this.signal("agents:flag", { uid });
         emit("toolkit:sdk:flag", ["sdk", "method-flag"]);
-        return result;
+        return { ok: true, id: uid, action: "flag" };
     }
     async status(uid, active) {
-        const result = await this.r(`/api/agents/${encodeURIComponent(uid)}/status`, { method: "POST", body: JSON.stringify({ status: active ? "active" : "inactive" }) });
+        await this.signal("agents:status", { uid, status: active ? "active" : "inactive" });
         emit("toolkit:sdk:status", ["sdk", "method-status"]);
-        return result;
+        return { ok: true, id: uid, status: active ? "active" : "inactive" };
     }
     async capabilities(uid) {
-        const result = await this.r(`/api/agents/${encodeURIComponent(uid)}/capabilities`);
+        const result = await this.ask("agents:capabilities", { uid });
         emit("toolkit:sdk:capabilities", ["sdk", "method-capabilities"]);
-        return result;
+        return "result" in result && result.result ? result.result : [];
     }
     async stats() {
-        const result = await this.r("/api/stats");
+        const result = await this.ask("stats:current");
         emit("toolkit:sdk:stats", ["sdk", "method-stats"]);
-        return result;
+        return "result" in result && result.result ? result.result : { units: { total: 0, proven: 0, atRisk: 0 }, skills: { total: 0 }, highways: { count: 0, totalEdges: 0 }, revenue: { total: 0, gdp: 0 }, signals: { total: 0, recent: 0 }, timestamp: new Date().toISOString() };
     }
     async health() {
         const result = await this.r("/api/health");
@@ -231,44 +457,29 @@ export class SubstrateClient {
         return result;
     }
     async usage() {
-        const result = await this.r("/api/dashboard/usage");
+        const result = await this.ask("dashboard:usage");
         emit("toolkit:sdk:usage", ["sdk", "method-usage"]);
-        return result;
+        return "result" in result && result.result ? result.result : {};
     }
     async hire(providerUid, skillId, opts) {
-        const result = await this.r("/api/buy/hire", {
-            method: "POST",
-            body: JSON.stringify({ providerUid, skillId, ...opts }),
-        });
+        const result = await this.ask("market:hire", { providerUid, skillId, ...opts });
         emit("toolkit:sdk:hire", ["sdk", "method-hire"]);
-        return result;
+        return "result" in result && result.result ? result.result : { status: 402, code: "dissolved", escrow_template: {}, expires_at: "" };
     }
     async bounty(opts) {
-        const result = await this.r("/api/market/bounty", {
-            method: "POST",
-            body: JSON.stringify(opts),
-        });
+        const result = await this.ask("market:bounty", opts);
         emit("toolkit:sdk:bounty", ["sdk", "method-bounty"]);
-        return result;
+        return "result" in result && result.result ? result.result : { id: "", data: {} };
     }
     async bounties(query) {
-        const params = new URLSearchParams();
-        if (query?.seller)
-            params.set("seller", query.seller);
-        if (query?.poster)
-            params.set("poster", query.poster);
-        const qs = params.size ? `?${params}` : "";
-        const result = await this.r(`/api/market/bounty${qs}`);
+        const result = await this.ask("market:bounties", query);
         emit("toolkit:sdk:bounties", ["sdk", "method-bounties"]);
-        return result;
+        return "result" in result && result.result ? result.result : [];
     }
     async publish(opts) {
-        const result = await this.r("/api/capabilities/publish", {
-            method: "POST",
-            body: JSON.stringify(opts),
-        });
+        const result = await this.ask("capabilities:publish", opts);
         emit("toolkit:sdk:publish", ["sdk", "method-publish"]);
-        return result;
+        return "result" in result && result.result ? result.result : { ok: true, sid: "", scope: "" };
     }
     async revenue() {
         const result = await this.r("/api/revenue");
@@ -285,44 +496,50 @@ export class SubstrateClient {
         emit("toolkit:sdk:listAgents", ["sdk", "method-listAgents"]);
         return result;
     }
-    async closeLoop(session, outcome, opts) {
-        const result = await this.r("/api/loop/close", {
+    async agentHistory(opts) {
+        const params = new URLSearchParams({ slug: opts.slug, name: opts.name });
+        const result = await this.r(`/api/agents/history?${params}`);
+        emit("toolkit:sdk:agentHistory", ["sdk", "method-agentHistory"]);
+        return result;
+    }
+    async rollbackAgent(opts) {
+        const result = await this.r("/api/agents/rollback", {
             method: "POST",
-            body: JSON.stringify({ session, outcome, ...opts }),
+            body: JSON.stringify(opts),
         });
-        emit("toolkit:sdk:closeLoop", ["sdk", "method-closeLoop"]);
+        emit("toolkit:sdk:rollbackAgent", ["sdk", "method-rollbackAgent"]);
+        return result;
+    }
+    async listSkills(opts) {
+        const params = new URLSearchParams({ slug: opts.slug });
+        const result = await this.r(`/api/skills/workspace?${params}`);
+        emit("toolkit:sdk:listSkills", ["sdk", "method-listSkills"]);
+        return result;
+    }
+    async unimportSkill(opts) {
+        const result = await this.r(`/api/skill/${encodeURIComponent(opts.name)}?slug=${encodeURIComponent(opts.slug)}`, { method: "DELETE" });
+        emit("toolkit:sdk:unimportSkill", ["sdk", "method-unimportSkill"]);
         return result;
     }
+    async closeLoop(session, outcome, opts) {
+        const result = await this.ask("loop:close", { session, outcome, ...opts });
+        emit("toolkit:sdk:closeLoop", ["sdk", "method-closeLoop"]);
+        return "result" in result && result.result ? result.result : { ok: true, stages: [], highways: [] };
+    }
     async signals(opts) {
-        const params = new URLSearchParams();
-        if (opts?.limit !== undefined)
-            params.set("limit", String(opts.limit));
-        if (opts?.since !== undefined)
-            params.set("since", String(opts.since));
-        if (opts?.from !== undefined)
-            params.set("from", String(opts.from));
-        if (opts?.to !== undefined)
-            params.set("to", String(opts.to));
-        const qs = params.size ? `?${params}` : "";
-        const result = await this.r(`/api/signals${qs}`);
+        const result = await this.ask("signals:list", opts);
         emit("toolkit:sdk:signals", ["sdk", "method-signals"]);
-        return result;
+        return "result" in result && result.result ? result.result : [];
     }
     async state() {
-        const result = await this.r("/api/state");
+        const result = await this.ask("world:state");
         emit("toolkit:sdk:state", ["sdk", "method-state"]);
-        return result;
+        return "result" in result && result.result ? result.result : { units: [], edges: [], highways: [], tags: [], tagMap: {}, stats: {} };
     }
     async listMarket(opts) {
-        const params = new URLSearchParams();
-        if (opts?.tag)
-            params.set("tag", opts.tag);
-        if (opts?.maxPrice !== undefined)
-            params.set("maxPrice", String(opts.maxPrice));
-        const qs = params.size ? `?${params}` : "";
-        const result = await this.r(`/api/market/list${qs}`);
+        const result = await this.ask("market:list", opts);
         emit("toolkit:sdk:listMarket", ["sdk", "method-listMarket"]);
-        return result;
+        return "result" in result && result.result ? result.result : { capabilities: [] };
     }
     async chat(messages, opts) {
         const url = `${this.baseUrl}/api/chat`;
@@ -339,45 +556,5 @@ export class SubstrateClient {
         emit("toolkit:sdk:chat", ["sdk", "method-chat"]);
         return res.body;
     }
-    async *streamState() {
-        const url = `${this.baseUrl}/api/stream`;
-        const headers = {};
-        if (this.apiKey)
-            headers["Authorization"] = `Bearer ${this.apiKey}`;
-        const res = await fetch(url, { headers });
-        if (!res.ok || !res.body)
-            throw new SubstrateError(`stream failed: ${res.status}`, res.status);
-        emit("toolkit:sdk:streamState", ["sdk", "method-streamState"]);
-        const reader = res.body.getReader();
-        const decoder = new TextDecoder();
-        let buf = "";
-        let currentEvent = "connected";
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                buf += decoder.decode(value, { stream: true });
-                const lines = buf.split("\n");
-                buf = lines.pop() ?? "";
-                for (const line of lines) {
-                    if (line.startsWith("event:"))
-                        currentEvent = line.slice(6).trim();
-                    else if (line.startsWith("data:")) {
-                        try {
-                            yield { event: currentEvent, data: JSON.parse(line.slice(5).trim()) };
-                        }
-                        catch {
-                            yield { event: currentEvent, data: line.slice(5).trim() };
-                        }
-                        currentEvent = "connected";
-                    }
-                }
-            }
-        }
-        finally {
-            reader.releaseLock();
-        }
-    }
 }
 //# sourceMappingURL=client.js.map