wolfpack-mcp 1.0.99 → 1.0.101

package/dist/agentObserveTools.js

@@ -0,0 +1,157 @@
+/**
+ * Watching other agents work (#2388).
+ *
+ * Registered only when the API key has the `agent_observer` capability, and
+ * stdio only — like the agent-self, agent-memory and agent-builder families,
+ * these are tools an agent uses about the fleet it runs in, not tools an
+ * integration calls over the remote transport, so they have no catalogue entry
+ * and no generated remote copy to drift from.
+ *
+ * The backend decides what comes back: a session is visible to an observer only
+ * where the observer is a member of a project the run was scoped to. Nothing in
+ * this file can widen that, and the descriptions say so plainly — a coach that
+ * believes it can see the whole fleet reports "nothing is stuck" about projects
+ * it was never shown.
+ */
+import { z } from 'zod';
+function text(data) {
+    return JSON.stringify(data, null, 2);
+}
+const PROJECT_BOUND = 'You see a session only if it ran in a project you are a member of — never the whole fleet, ' +
+    'and never work done in someone else’s My Space.';
+export const AGENT_OBSERVE_TOOLS = [
+    {
+        name: 'list_observed_sessions',
+        description: "List other agents' sessions across the projects you are a member of, newest first. " +
+            'Returns status, trigger, timings, error text, token use and the projects each run was ' +
+            'scoped to — no transcripts, no container logs, no system prompts. ' +
+            'To find work that may be stuck, pass status "running" with a `since` an hour or two back ' +
+            'and look at what has been going longest. ' +
+            PROJECT_BOUND,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                status: {
+                    type: 'string',
+                    description: 'Only sessions in this status: pending, starting, running, stopping, stopped or failed',
+                },
+                agent_profile_id: {
+                    type: 'string',
+                    description: 'Only sessions of this agent (UUID). Not found if it is not one you may observe.',
+                },
+                since: {
+                    type: 'string',
+                    description: 'Only sessions started at or after this ISO 8601 timestamp',
+                },
+                limit: { type: 'number', description: 'Max sessions to return (default 20)' },
+                offset: { type: 'number', description: 'Skip first N sessions (default 0)' },
+            },
+        },
+    },
+    {
+        name: 'get_observed_session',
+        description: 'Read one observed session by id. Same fields as the listing. ' +
+            'Not found if the session ran in no project of yours.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'The session UUID' },
+            },
+            required: ['session_id'],
+        },
+    },
+    {
+        name: 'get_observed_session_events',
+        description: "Read an observed session's activity log: which tools ran, in order, with the one-line " +
+            'summary each hook wrote. This is how a run looks from outside — the same tool repeating, ' +
+            'or nothing at all for a long time, is what "stuck" looks like. ' +
+            'Tool arguments and results are not included.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'The session UUID' },
+                after: { type: 'string', description: 'Only events after this event id (for polling)' },
+                limit: { type: 'number', description: 'Max events to return (default 100)' },
+            },
+            required: ['session_id'],
+        },
+    },
+    {
+        name: 'get_observed_session_conversation',
+        description: "Read an observed session's conversation. Requires the separate " +
+            'mcp:agents:observe_transcripts permission, which most observers do not have and do not ' +
+            'need: a transcript carries repository contents, shell output and the agent’s system ' +
+            'prompt verbatim. Judge a run from its status and its events first.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'The session UUID' },
+                limit: { type: 'number', description: 'Max history entries to return' },
+                offset: { type: 'number', description: 'Skip first N history entries' },
+            },
+            required: ['session_id'],
+        },
+    },
+];
+const ListObservedSessionsSchema = z.object({
+    status: z.string().optional(),
+    agent_profile_id: z.string().optional(),
+    since: z.string().optional(),
+    limit: z.number().optional(),
+    offset: z.number().optional(),
+});
+const SessionIdSchema = z.object({
+    session_id: z.string(),
+    after: z.string().optional(),
+    limit: z.number().optional(),
+    offset: z.number().optional(),
+});
+export async function handleAgentObserveTool(name, args, client) {
+    switch (name) {
+        case 'list_observed_sessions': {
+            const parsed = ListObservedSessionsSchema.parse(args || {});
+            const sessions = await client.listObservedSessions({
+                status: parsed.status,
+                agentProfileId: parsed.agent_profile_id,
+                since: parsed.since,
+                limit: parsed.limit,
+                offset: parsed.offset,
+            });
+            if (sessions.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'No sessions match, among the agents and projects you can observe.',
+                        },
+                    ],
+                };
+            }
+            return { content: [{ type: 'text', text: text(sessions) }] };
+        }
+        case 'get_observed_session': {
+            const parsed = SessionIdSchema.parse(args);
+            return {
+                content: [{ type: 'text', text: text(await client.getObservedSession(parsed.session_id)) }],
+            };
+        }
+        case 'get_observed_session_events': {
+            const parsed = SessionIdSchema.parse(args);
+            const events = await client.getObservedSessionEvents(parsed.session_id, {
+                after: parsed.after,
+                limit: parsed.limit,
+            });
+            return { content: [{ type: 'text', text: text(events) }] };
+        }
+        case 'get_observed_session_conversation': {
+            const parsed = SessionIdSchema.parse(args);
+            const conversation = await client.getObservedSessionConversation(parsed.session_id, {
+                limit: parsed.limit,
+                offset: parsed.offset,
+            });
+            return { content: [{ type: 'text', text: text(conversation) }] };
+        }
+        default:
+            throw new Error(`Unknown agent observe tool: ${name}`);
+    }
+}

package/dist/agentObserveTools.test.js

@@ -0,0 +1,99 @@
+import { describe, it, expect } from 'vitest';
+import { AGENT_OBSERVE_TOOLS, handleAgentObserveTool } from './agentObserveTools.js';
+import { AGENT_SELF_TOOLS, AGENT_MEMORY_TOOLS } from './agentSelfTools.js';
+import { remoteTools, stdioTools } from './toolCatalogue.js';
+/**
+ * #2388 — the observation family's exposure decision, and the shape of the
+ * calls it makes.
+ *
+ * Two things are worth a test here and the rest is the backend's:
+ *
+ *   - **It is stdio only.** The catalogue is what the remote transport serves,
+ *     and a tool that reached it would be answering an integration key over
+ *     HTTP rather than an agent in a container. The other agent families made
+ *     the same decision; this asserts it rather than trusting a comment.
+ *   - **No agent id is required anywhere.** The whole design is that an observer
+ *     names a session, not an agent whose sessions it wants — the backend
+ *     decides reach from the observer's own project memberships. A required
+ *     `agent_id` would be the first step back towards "read this agent".
+ */
+const names = (tools) => tools.map((t) => t.name);
+describe('the observe tool family', () => {
+    it('is the four tools the observe scopes buy', () => {
+        expect(names(AGENT_OBSERVE_TOOLS).sort()).toEqual([
+            'get_observed_session',
+            'get_observed_session_conversation',
+            'get_observed_session_events',
+            'list_observed_sessions',
+        ]);
+    });
+    it('is not in the catalogue, so the remote transport never serves it', () => {
+        const remote = names(remoteTools());
+        const everyStdioCatalogueTool = names(stdioTools(['procedures']));
+        for (const tool of names(AGENT_OBSERVE_TOOLS)) {
+            expect(remote).not.toContain(tool);
+            expect(everyStdioCatalogueTool).not.toContain(tool);
+        }
+    });
+    it('does not collide with the other stdio-only families', () => {
+        const all = [
+            ...names(AGENT_OBSERVE_TOOLS),
+            ...names(AGENT_SELF_TOOLS),
+            ...names(AGENT_MEMORY_TOOLS),
+        ];
+        expect(new Set(all).size).toBe(all.length);
+    });
+    it('requires a session id and never an agent id', () => {
+        for (const tool of AGENT_OBSERVE_TOOLS) {
+            const required = tool.inputSchema.required ?? [];
+            expect(required).not.toContain('agent_id');
+            expect(required).not.toContain('agent_profile_id');
+            if (tool.name !== 'list_observed_sessions') {
+                expect(required).toEqual(['session_id']);
+            }
+        }
+    });
+    // The listing's whole point is the cross-agent question, so the two parameters
+    // a "what is stuck right now?" call is made of have to be on it.
+    it('offers status and since on the listing', () => {
+        const listing = AGENT_OBSERVE_TOOLS.find((t) => t.name === 'list_observed_sessions');
+        expect(Object.keys(listing.inputSchema.properties)).toEqual(expect.arrayContaining(['status', 'since', 'agent_profile_id', 'limit', 'offset']));
+    });
+    // A coach that reads an empty list as "the fleet is healthy" is worse than one
+    // with no tool at all, so the description says what the list is bounded by and
+    // the empty answer says it again.
+    it('tells the reader what it is not being shown', () => {
+        const listing = AGENT_OBSERVE_TOOLS.find((t) => t.name === 'list_observed_sessions');
+        expect(listing.description).toContain('a project you are a member of');
+    });
+});
+describe('the handler', () => {
+    const client = {
+        listObservedSessions: async () => [],
+        getObservedSession: async (id) => ({ id }),
+        getObservedSessionEvents: async () => [{ eventType: 'stop' }],
+        getObservedSessionConversation: async () => ({ history: [] }),
+    };
+    it('says so plainly when nothing matches, rather than printing an empty array', async () => {
+        const result = await handleAgentObserveTool('list_observed_sessions', {}, client);
+        expect(result.content[0].text).toContain('you can observe');
+    });
+    it('passes the snake_case arguments through under the client’s names', async () => {
+        const seen = [];
+        const recording = {
+            listObservedSessions: async (options) => {
+                seen.push(options);
+                return [{ id: 'session-1' }];
+            },
+        };
+        await handleAgentObserveTool('list_observed_sessions', { status: 'running', agent_profile_id: 'agent-1', since: '2026-09-15T07:00:00Z' }, recording);
+        expect(seen[0]).toMatchObject({
+            status: 'running',
+            agentProfileId: 'agent-1',
+            since: '2026-09-15T07:00:00Z',
+        });
+    });
+    it('refuses a name that is not one of its own', async () => {
+        await expect(handleAgentObserveTool('stop_observed_session', {}, client)).rejects.toThrow(/Unknown agent observe tool/);
+    });
+});

package/dist/agentSelfTools.js

@@ -31,7 +31,8 @@ export const AGENT_SELF_TOOLS = [
 export const AGENT_MEMORY_TOOLS = [
     {
         name: 'list_memories',
-        description: 'List all your persistent memory entries. Memory persists across sessions and is scoped to you. ' +
+        description: 'List the persistent memory entries this session can see: your global ones, plus those scoped to the projects this session runs in. ' +
+            'Memory persists across sessions and is scoped to you. ' +
             'Use this to recall observations, patterns, and notes from previous work.',
         inputSchema: { type: 'object', properties: {} },
     },
@@ -50,7 +51,10 @@ export const AGENT_MEMORY_TOOLS = [
         name: 'save_memory',
         description: 'Save a persistent memory entry by key. Creates the entry if it does not exist, or updates it if it does. ' +
             'Use this to persist observations, learnings, and notes across sessions. ' +
-            'To clear a memory entry, save it with empty content.',
+            'To clear a memory entry, save it with empty content. ' +
+            'Scope: a session running in a single project saves to that project, and only sessions in that project read it back. ' +
+            'A session spanning several projects saves globally — every later session of yours reads it, in every project. ' +
+            'Do not save anything from one project that should not be read in another.',
         inputSchema: {
             type: 'object',
             properties: {

package/dist/client.js

@@ -435,8 +435,10 @@ export class WolfpackClient {
         const { teamSlug, ...rest } = data;
         return this.api.post('/wiki-pages', { ...rest, teamSlug });
     }
-    async updateWikiPage(pageId, data, teamSlug) {
-        return this.api.patch(this.withTeamSlug(`/wiki-pages/${encodeURIComponent(pageId)}`, teamSlug), data);
+    // No teamSlug: the route takes none, and a wiki slug already carries its
+    // project prefix, so the page resolves without one.
+    async updateWikiPage(pageId, data) {
+        return this.api.patch(`/wiki-pages/${encodeURIComponent(pageId)}`, data);
     }
     // Journal Entry methods
     async listJournalEntries(options) {
@@ -854,8 +856,7 @@ export class WolfpackClient {
     }
     // ─── Agent Builder: Skills (read) ──────────────────────────────────────────
     async listAgentSkills(agentId, orgSlug) {
-        const agent = await this.getAgent(agentId, orgSlug);
-        return agent?.skills ?? [];
+        return this.api.get(this.withOrgSlug(`/skills/agent-assignments/${agentId}`, orgSlug));
     }
     async listOrgSkills(orgSlug) {
         return this.api.get(this.withOrgSlug('/agents/org-skills', orgSlug));
@@ -988,6 +989,46 @@ export class WolfpackClient {
     async saveMemory(key, content) {
         return this.api.put(`/self/memories/${encodeURIComponent(key)}`, { content });
     }
+    // ─── Agent observation (#2388) ─────────────────────────────────────────────
+    // No agent id is required on any of these and none can be widened from here:
+    // the backend answers with the runs whose projects the caller is a member of,
+    // and with a 404 for anything else.
+    async listObservedSessions(options) {
+        const params = new URLSearchParams();
+        if (options?.status)
+            params.append('status', options.status);
+        if (options?.agentProfileId)
+            params.append('agentProfileId', options.agentProfileId);
+        if (options?.since)
+            params.append('since', options.since);
+        if (options?.limit !== undefined)
+            params.append('limit', options.limit.toString());
+        if (options?.offset !== undefined)
+            params.append('offset', options.offset.toString());
+        const q = params.toString();
+        return this.api.get(`/observe/sessions${q ? `?${q}` : ''}`);
+    }
+    async getObservedSession(sessionId) {
+        return this.api.get(`/observe/sessions/${encodeURIComponent(sessionId)}`);
+    }
+    async getObservedSessionEvents(sessionId, options) {
+        const params = new URLSearchParams();
+        if (options?.after)
+            params.append('after', options.after);
+        if (options?.limit !== undefined)
+            params.append('limit', options.limit.toString());
+        const q = params.toString();
+        return this.api.get(`/observe/sessions/${encodeURIComponent(sessionId)}/events${q ? `?${q}` : ''}`);
+    }
+    async getObservedSessionConversation(sessionId, options) {
+        const params = new URLSearchParams();
+        if (options?.limit !== undefined)
+            params.append('limit', options.limit.toString());
+        if (options?.offset !== undefined)
+            params.append('offset', options.offset.toString());
+        const q = params.toString();
+        return this.api.get(`/observe/sessions/${encodeURIComponent(sessionId)}/conversation${q ? `?${q}` : ''}`);
+    }
     // ─── Browser control (#2288) ───────────────────────────────────────────────
     // No chat is named on any of these: the backend derives it from the session
     // this key is bound to, so the agent cannot address another visitor's page.