@clawling/clawchat-plugin-openclaw 2026.9.22-2 → 2026.9.23-2

package/dist/src/api-client.js

@@ -1,5 +1,10 @@
 import { ClawlingApiError, } from "./api-types.js";
 import { CHANNEL_ID } from "./config.js";
+const ORCH = "/v1/agents/me/orchestration";
+/** Body + content-type for an orchestration write, so the two never drift apart. */
+function orchJson(payload) {
+    return { body: JSON.stringify(payload), headers: { "content-type": "application/json" } };
+}
 export function buildPluginReportBody(input) {
     const body = {
         device_id: input.deviceId,
@@ -264,8 +269,13 @@ export function createOpenclawClawlingApiClient(opts) {
         }
         throw new ClawlingApiError("transport", text ? "invalid envelope: missing numeric `code`" : "non-JSON response: empty body", { status: res.status, path });
     }
-    async function call(method, path, init) {
-        let res;
+    /**
+     * Shared by `call<T>` and `orchCall`: build the request, invoke `fetchImpl`,
+     * and normalize any network-level failure into a `ClawlingApiError`. Kept
+     * as one function so the two callers' request-building can never drift
+     * apart again the way `call<T>` and `orchCall` briefly did.
+     */
+    async function doFetch(method, path, init) {
         try {
             const requestInit = {
                 method,
@@ -274,13 +284,55 @@ export function createOpenclawClawlingApiClient(opts) {
             if (init?.body !== undefined) {
                 requestInit.body = init.body;
             }
-            res = await fetchImpl(url(path, init?.baseUrl || undefined), requestInit);
+            return await fetchImpl(url(path, init?.baseUrl || undefined), requestInit);
         }
         catch (err) {
             throw new ClawlingApiError("transport", `fetch failed: ${err instanceof Error ? err.message : String(err)}`, { path });
         }
+    }
+    async function call(method, path, init) {
+        const res = await doFetch(method, path, init);
         return await readEnvelope(res, path);
     }
+    /**
+     * Orchestration routes (`${ORCH}/...`) are always HTTP 200 with the
+     * business code inside the envelope — a `21003` permission denial is a
+     * normal outcome there, not a transport failure. Unlike `call<T>`, this
+     * does NOT unwrap `data` or throw on a non-zero `code`; it hands back the
+     * parsed envelope exactly as received so the caller can branch on `code`
+     * itself.
+     *
+     * A 401/403 is checked FIRST, before any body parsing, exactly like
+     * `readEnvelope` — an expired/malformed token is not a business-code
+     * outcome and must throw `kind: "auth"` rather than fall through to the
+     * empty-body branch below and be misread as success. NOTE: on the
+     * orchestration tool path (`tools.ts` `buildClient` → a raw client,
+     * consumed via `withClient`) this throw is NOT retried — `withClient`
+     * turns any `ClawlingApiError` straight into `apiError(err)`. Reactive
+     * retry-after-refresh only exists behind `getConversationApiClient`'s
+     * `withRefresh` wrapper (`runtime.ts`), which the twelve `orch*` tools do
+     * not go through; this matches the other non-orchestration tools that
+     * build a raw client the same way. Proactive rotation is still picked up here for
+     * free, since the token is read fresh from the account at call time.
+     */
+    async function orchCall(method, path, init) {
+        const res = await doFetch(method, path, init);
+        if (res.status === 401 || res.status === 403) {
+            throw new ClawlingApiError("auth", `unauthorized (status ${res.status})`, {
+                status: res.status,
+                path,
+            });
+        }
+        const text = await res.text().catch(() => "");
+        if (!text)
+            return undefined;
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            throw new ClawlingApiError("transport", "non-JSON response", { status: res.status, path });
+        }
+    }
     function parseUploadResult(data, path) {
         const obj = data;
         const validKind = obj?.kind === "image" || obj?.kind === "file" || obj?.kind === "audio" || obj?.kind === "video";
@@ -376,6 +428,51 @@ export function createOpenclawClawlingApiClient(opts) {
             assertNonBlankId(friendUserId, "removeFriend: friendUserId");
             return await call("DELETE", `/v1/friendships/${encodeURIComponent(friendUserId)}`);
         },
+        async orchListAgents() {
+            return await orchCall("GET", `${ORCH}/agents`);
+        },
+        async orchGetAgent(agentId) {
+            return await orchCall("GET", `${ORCH}/agents/${encodeURIComponent(agentId)}`);
+        },
+        async orchSetAgentBehavior(agentId, behavior) {
+            return await orchCall("PATCH", `${ORCH}/agents/${encodeURIComponent(agentId)}`, orchJson({ behavior }));
+        },
+        async orchListGroups() {
+            return await orchCall("GET", `${ORCH}/groups`);
+        },
+        async orchGetGroup(cid) {
+            return await orchCall("GET", `${ORCH}/groups/${encodeURIComponent(cid)}`);
+        },
+        async orchSetGroupPrompt(cid, description) {
+            return await orchCall("PATCH", `${ORCH}/groups/${encodeURIComponent(cid)}`, orchJson({ description }));
+        },
+        async orchCreateGroup(title, agentIds) {
+            return await orchCall("POST", `${ORCH}/groups`, orchJson({ title, agent_ids: agentIds }));
+        },
+        async orchAddGroupMember(cid, agentId) {
+            return await orchCall("POST", `${ORCH}/groups/${encodeURIComponent(cid)}/members`, orchJson({ agent_id: agentId }));
+        },
+        async orchRemoveGroupMember(cid, agentId) {
+            return await orchCall("DELETE", `${ORCH}/groups/${encodeURIComponent(cid)}/members/${encodeURIComponent(agentId)}`);
+        },
+        async orchSetGroupAgentSettings(cid, agentId, patch) {
+            // `!== undefined` rather than truthiness: `muted: false` is a real value
+            // the backend must see; an absent key means "leave unchanged".
+            const body = {};
+            if (patch.muted !== undefined)
+                body.muted = patch.muted;
+            if (patch.replyMode !== undefined)
+                body.reply_mode = patch.replyMode;
+            if (patch.batchDelaySeconds !== undefined)
+                body.batch_delay_seconds = patch.batchDelaySeconds;
+            return await orchCall("PATCH", `${ORCH}/groups/${encodeURIComponent(cid)}/agents/${encodeURIComponent(agentId)}`, orchJson(body));
+        },
+        async orchCreateConnectCode() {
+            return await orchCall("POST", `${ORCH}/connect-codes`);
+        },
+        async orchGetConnectCode(code) {
+            return await orchCall("GET", `${ORCH}/connect-codes/${encodeURIComponent(code)}`);
+        },
         async registerApp(params) {
             assertNonBlankId(params.appId, "registerApp: appId");
             return await call("POST", "/v1/agents/me/apps", {

package/dist/src/skill-update.js

@@ -66,7 +66,7 @@ export const OFFICIAL_SKILLS_BASE = "https://raw.githubusercontent.com/clawling/
  * in the install-cli repo, bump this constant, ship it. `liveware-sample.ts`
  * imports the same ref, so the `livewares` tree at that tag is pinned too.
  */
-export const DEFAULT_SKILLS_REF = "skills-v1.13.0";
+export const DEFAULT_SKILLS_REF = "skills-v1.15.0";
 /** Refuse to treat an absurdly large response as a skill file (defence in depth). */
 export const MAX_SKILL_BYTES = 256 * 1024;
 /** This adapter's host target inside `skills/manifest.json`. */

package/dist/src/tools-schema.js

@@ -284,3 +284,54 @@ export const ClawchatUnregisterAppSchema = Type.Object({
     appId: Type.String({ minLength: 1, description: "The liveware app id to unregister." }),
 });
 export const ClawchatLivewareLoginSchema = Type.Object({});
+// --- cloud orchestration (`agent.orchestrate`) ----------------------------
+// Twelve schemas, 1:1 with docs/features/agentorch.md.
+const OrchAgentId = Type.String({
+    minLength: 1,
+    description: "Explicit agent id from clawchat_orchestrate_list_agents. Never guess one from a nickname.",
+});
+const OrchConversationId = Type.String({
+    minLength: 1,
+    description: "Explicit group conversation id from clawchat_orchestrate_list_groups.",
+});
+export const ClawchatOrchListAgentsSchema = Type.Object({}, { additionalProperties: false });
+export const ClawchatOrchGetAgentSchema = Type.Object({ agentId: OrchAgentId }, { additionalProperties: false });
+export const ClawchatOrchSetAgentBehaviorSchema = Type.Object({
+    agentId: OrchAgentId,
+    behavior: Type.String({
+        maxLength: 3000,
+        description: "The complete new system prompt. REPLACES the whole field — GET first and send the full value.",
+    }),
+}, { additionalProperties: false });
+export const ClawchatOrchListGroupsSchema = Type.Object({}, { additionalProperties: false });
+export const ClawchatOrchGetGroupSchema = Type.Object({ conversationId: OrchConversationId }, { additionalProperties: false });
+export const ClawchatOrchSetGroupPromptSchema = Type.Object({
+    conversationId: OrchConversationId,
+    description: Type.String({
+        maxLength: 3000,
+        description: "The complete new group system prompt. REPLACES the whole field.",
+    }),
+}, { additionalProperties: false });
+export const ClawchatOrchCreateGroupSchema = Type.Object({
+    title: Type.String({ minLength: 1, maxLength: 60, description: "Group title, 1-60 runes." }),
+    agentIds: Type.Array(Type.String({ minLength: 1 }), {
+        minItems: 1,
+        description: "Agent ids from clawchat_orchestrate_list_agents. Must be the owner's own agents.",
+    }),
+}, { additionalProperties: false });
+export const ClawchatOrchGroupMemberSchema = Type.Object({ conversationId: OrchConversationId, agentId: OrchAgentId }, { additionalProperties: false });
+export const ClawchatOrchSetGroupAgentSettingsSchema = Type.Object({
+    conversationId: OrchConversationId,
+    agentId: OrchAgentId,
+    muted: Type.Optional(Type.Boolean({ description: "Mute or unmute this agent in this group." })),
+    replyMode: Type.Optional(Type.Union([Type.Literal("all"), Type.Literal("mention")], {
+        description: "all = speaks on every message; mention = only when @-mentioned.",
+    })),
+    batchDelaySeconds: Type.Optional(Type.Integer({
+        minimum: 1,
+        maximum: 3600,
+        description: "Seconds this agent batches messages before replying. Default 10. Pacing, not a limit.",
+    })),
+}, { additionalProperties: false, minProperties: 3 });
+export const ClawchatOrchCreateConnectCodeSchema = Type.Object({}, { additionalProperties: false });
+export const ClawchatOrchGetConnectCodeSchema = Type.Object({ code: Type.String({ minLength: 1, description: "The connect code to look up." }) }, { additionalProperties: false });