refactor(agent): remove the unused team-server tools (P1.1)

createTeamTools and createLocalTeamTools called /api/teams/* and
/api/team/* on a team server. Nothing registered them: not the
sidecar, the CLI, the team server or the worker.
This commit is contained in:
shumeiko.it
2026-10-24 16:39:23 +02:00
parent 93d73be7b4
commit 8ce2c42544
3 changed files with 0 additions and 684 deletions

View File

@@ -198,7 +198,6 @@ export {
type MessagesCompressionEvent,
type CompressMessagesResult,
} from './long-task/messages-compressor.js';
export { createTeamTools, type TeamToolDeps } from './team-tools.js';
export { ensureIdentity, type IdentityConfig } from './auto-identity.js';
export { buildSelfAwareness, type AgentCapabilities } from './self-awareness.js';
export {

View File

@@ -1,334 +0,0 @@
import type { ToolDefinition } from './tools.js';
export interface TeamToolDeps {
serverUrl: string;
authToken: string;
teamSlug: string;
fetch?: typeof globalThis.fetch;
}
export interface LocalTeamToolDeps {
localServerUrl: string;
workspaceId: string;
teamId: string;
fetch?: typeof globalThis.fetch;
}
async function apiCall(
deps: TeamToolDeps,
method: string,
path: string,
body?: unknown
): Promise<unknown> {
const fetchFn = deps.fetch ?? globalThis.fetch;
const url = `${deps.serverUrl}${path}`;
const opts: RequestInit = {
method,
headers: {
'Authorization': `Bearer ${deps.authToken}`,
'Content-Type': 'application/json',
},
};
if (body !== undefined) {
opts.body = JSON.stringify(body);
}
const res = await fetchFn(url, opts);
if (!res.ok) {
const text = await res.text();
throw new Error(`API error ${res.status}: ${text}`);
}
return res.json();
}
export function createTeamTools(deps: TeamToolDeps): ToolDefinition[] {
const base = `/api/teams/${deps.teamSlug}`;
return [
{
name: 'check_hive',
description: 'Search team knowledge graph for existing knowledge on a topic before starting work',
parameters: {
type: 'object',
properties: {
topic: { type: 'string', description: 'Topic to search for in team knowledge' },
},
required: ['topic'],
},
execute: async (args) => {
const topic = args.topic as string;
const results = await apiCall(deps, 'GET', `${base}/knowledge?search=${encodeURIComponent(topic)}`) as unknown[];
if (!results || results.length === 0) {
return 'No existing team knowledge found.';
}
return JSON.stringify(results, null, 2);
},
},
{
name: 'share_to_team',
description: 'Share a discovery or insight to the team knowledge graph',
parameters: {
type: 'object',
properties: {
content: { type: 'string', description: 'Content to share with the team' },
type: { type: 'string', description: 'Type of knowledge (e.g., discovery, insight, pattern)' },
},
required: ['content', 'type'],
},
execute: async (args) => {
const content = args.content as string;
const type = args.type as string;
const name = content.slice(0, 100);
await apiCall(deps, 'POST', `${base}/knowledge/entities`, {
name,
type,
properties: { content },
});
return `Shared to team: "${name}"`;
},
},
{
name: 'create_team_task',
description: 'Create a new task on the team task board',
parameters: {
type: 'object',
properties: {
title: { type: 'string', description: 'Task title' },
description: { type: 'string', description: 'Task description' },
priority: {
type: 'string',
enum: ['low', 'medium', 'high', 'urgent'],
description: 'Task priority',
},
},
required: ['title'],
},
execute: async (args) => {
const body: Record<string, unknown> = { title: args.title };
if (args.description) body.description = args.description;
if (args.priority) body.priority = args.priority;
const result = await apiCall(deps, 'POST', `${base}/tasks`, body) as Record<string, unknown>;
return `Created team task: "${args.title}" (id: ${result.id})`;
},
},
{
name: 'claim_team_task',
description: 'Pick up an existing task from the team board and mark it as in progress',
parameters: {
type: 'object',
properties: {
task_id: { type: 'string', description: 'ID of the task to claim' },
},
required: ['task_id'],
},
execute: async (args) => {
const taskId = args.task_id as string;
await apiCall(deps, 'PATCH', `${base}/tasks/${taskId}`, { status: 'in_progress' });
return `Claimed task ${taskId} — now in progress.`;
},
},
{
name: 'send_waggle_message',
description: 'Send a Waggle Dance protocol message to the team channel',
parameters: {
type: 'object',
properties: {
message: { type: 'string', description: 'Message content' },
type: {
type: 'string',
enum: ['broadcast', 'request', 'response'],
description: 'Message type (default: broadcast)',
},
subtype: {
type: 'string',
enum: ['discovery', 'routed_share', 'skill_share', 'task_delegation', 'knowledge_check', 'skill_request'],
description: 'Message subtype (default: discovery)',
},
},
required: ['message'],
},
execute: async (args) => {
const message = args.message as string;
const type = (args.type as string) ?? 'broadcast';
const subtype = (args.subtype as string) ?? 'discovery';
await apiCall(deps, 'POST', `${base}/messages`, {
type,
subtype,
content: { text: message },
});
return `Message sent to team (${type}/${subtype}).`;
},
},
{
name: 'request_team_capability',
description: 'Request team admin approval for a restricted capability. Use when a capability is blocked by team policy and the user wants to request access.',
parameters: {
type: 'object',
properties: {
capability_name: { type: 'string', description: 'Name of the blocked capability (e.g., "bash", "custom-plugin")' },
capability_type: { type: 'string', enum: ['native', 'skill', 'plugin', 'mcp'], description: 'Type of capability' },
justification: { type: 'string', description: 'Why the user needs this capability — use their own words' },
},
required: ['capability_name', 'capability_type', 'justification'],
},
execute: async (args) => {
const name = args.capability_name as string;
const type = args.capability_type as string;
const justification = args.justification as string;
try {
const result = await apiCall(deps, 'POST', `${base}/capability-requests`, {
capabilityName: name,
capabilityType: type,
justification,
});
const res = result as { error?: string };
if (res.error?.includes('pending')) {
return `A request for "${name}" is already pending. Your team admin will review it.`;
}
return `Request submitted for "${name}" (${type}). Your team admin will be notified and can approve or reject this request. You'll receive a notification when they decide.`;
} catch (err: unknown) {
const message = err instanceof Error ? err.message : String(err);
if (message.includes('409')) {
return `A request for "${name}" is already pending. Your team admin will review it.`;
}
return `Could not submit request: ${message}`;
}
},
},
];
}
/**
* Create read-only tools that query the local server's team endpoints.
* These tools let the agent be "team-aware" in team workspaces.
*/
export function createLocalTeamTools(deps: LocalTeamToolDeps): ToolDefinition[] {
const fetchFn = deps.fetch ?? globalThis.fetch;
const base = deps.localServerUrl;
async function localGet<T = unknown>(path: string): Promise<T> {
const res = await fetchFn(`${base}${path}`, { method: 'GET' });
if (!res.ok) throw new Error(`Local API error ${res.status}`);
return res.json() as Promise<T>;
}
return [
{
name: 'team_activity',
description: 'Get recent team activity — what has the team been working on?',
parameters: {
type: 'object',
properties: {
limit: { type: 'number', description: 'Max items to return (default 10)' },
},
},
execute: async (args) => {
const limit = (args.limit as number) ?? 10;
const data = await localGet<{ items: Array<{ authorName: string; summary: string; timestamp: string; type: string }> }>(
`/api/team/activity?workspaceId=${deps.teamId}&limit=${limit}`,
);
if (!data.items || data.items.length === 0) {
return 'No recent team activity found.';
}
return data.items.map(i => `[${i.type}] ${i.authorName}: ${i.summary}`).join('\n');
},
},
{
name: 'team_tasks',
description: 'List current tasks on the workspace task board — see what needs doing.',
parameters: {
type: 'object',
properties: {
status: { type: 'string', enum: ['open', 'in_progress', 'done'], description: 'Filter by status' },
},
},
execute: async (args) => {
const statusFilter = args.status ? `?status=${args.status}` : '';
const data = await localGet<{ tasks: Array<{ id: string; title: string; status: string; assigneeName?: string }> }>(
`/api/workspaces/${deps.workspaceId}/tasks${statusFilter}`,
);
if (!data.tasks || data.tasks.length === 0) {
return args.status ? `No ${args.status} tasks found.` : 'No tasks on the board.';
}
return data.tasks.map(t => {
const assignee = t.assigneeName ? ` (${t.assigneeName})` : '';
return `[${t.status}] ${t.title}${assignee} — id: ${t.id}`;
}).join('\n');
},
},
{
name: 'team_members',
description: 'See who is on the team and their current status (online/away/offline).',
parameters: { type: 'object', properties: {} },
execute: async () => {
const data = await localGet<{ members: Array<{ displayName: string; status: string; activitySummary?: string }> }>(
`/api/team/presence?workspaceId=${deps.teamId}`,
);
if (!data.members || data.members.length === 0) {
return 'No team members found (team server may be unavailable).';
}
return data.members.map(m => {
const activity = m.activitySummary ? ` — ${m.activitySummary}` : '';
return `${m.displayName} (${m.status})${activity}`;
}).join('\n');
},
},
{
name: 'assign_task',
description: 'Create a task and assign it to a team member. The assigned member will see it on their next catch-up.',
parameters: {
type: 'object',
properties: {
title: { type: 'string', description: 'Task title' },
assigneeName: { type: 'string', description: 'Name of the team member to assign this to' },
assigneeId: { type: 'string', description: 'User ID of the assignee (from team_members)' },
},
required: ['title', 'assigneeName'],
},
execute: async (args) => {
const res = await fetchFn(`${base}/api/workspaces/${deps.workspaceId}/tasks`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
title: args.title,
assigneeName: args.assigneeName,
assigneeId: args.assigneeId,
creatorName: 'Agent',
}),
});
if (!res.ok) throw new Error(`Failed to create task: ${res.status}`);
const task = await res.json() as { id: string };
return `Task assigned to ${args.assigneeName}: "${args.title}" (id: ${task.id})`;
},
},
{
name: 'complete_task',
description: 'Mark a task as done on the workspace task board.',
parameters: {
type: 'object',
properties: {
task_id: { type: 'string', description: 'ID of the task to complete' },
},
required: ['task_id'],
},
execute: async (args) => {
const res = await fetchFn(`${base}/api/workspaces/${deps.workspaceId}/tasks/${args.task_id}`, {
method: 'PATCH',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ status: 'done' }),
});
if (!res.ok) throw new Error(`Failed to complete task: ${res.status}`);
return `Task ${args.task_id} marked as done.`;
},
},
];
}

View File

@@ -1,349 +0,0 @@
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { createTeamTools, createLocalTeamTools, type TeamToolDeps, type LocalTeamToolDeps } from '../src/team-tools.js';
import type { ToolDefinition } from '../src/tools.js';
function makeDeps(fetchMock: ReturnType<typeof vi.fn>): TeamToolDeps {
return {
serverUrl: 'http://localhost:3000',
authToken: 'test-token-123',
teamSlug: 'alpha-team',
fetch: fetchMock as unknown as typeof globalThis.fetch,
};
}
function okResponse(data: unknown): Response {
return {
ok: true,
status: 200,
json: async () => data,
text: async () => JSON.stringify(data),
} as unknown as Response;
}
function errorResponse(status: number, message: string): Response {
return {
ok: false,
status,
statusText: message,
text: async () => message,
} as unknown as Response;
}
describe('createTeamTools', () => {
let fetchMock: ReturnType<typeof vi.fn>;
let deps: TeamToolDeps;
let tools: ToolDefinition[];
beforeEach(() => {
fetchMock = vi.fn();
deps = makeDeps(fetchMock);
tools = createTeamTools(deps);
});
function getTool(name: string): ToolDefinition {
const tool = tools.find((t) => t.name === name);
if (!tool) throw new Error(`Tool "${name}" not found`);
return tool;
}
it('creates all 5 team tools', () => {
const names = tools.map((t) => t.name);
expect(names).toContain('check_hive');
expect(names).toContain('share_to_team');
expect(names).toContain('create_team_task');
expect(names).toContain('claim_team_task');
expect(names).toContain('send_waggle_message');
expect(names).toContain('request_team_capability');
expect(tools).toHaveLength(6);
});
describe('check_hive', () => {
it('calls knowledge search API with topic', async () => {
fetchMock.mockResolvedValueOnce(okResponse([
{ id: '1', name: 'React patterns', type: 'concept' },
{ id: '2', name: 'React hooks', type: 'concept' },
]));
const tool = getTool('check_hive');
const result = await tool.execute({ topic: 'React' });
expect(fetchMock).toHaveBeenCalledOnce();
const [url, opts] = fetchMock.mock.calls[0];
expect(url).toBe('http://localhost:3000/api/teams/alpha-team/knowledge?search=React');
expect(opts.method).toBe('GET');
expect(opts.headers['Authorization']).toBe('Bearer test-token-123');
expect(result).toContain('React patterns');
});
it('returns message when no knowledge found', async () => {
fetchMock.mockResolvedValueOnce(okResponse([]));
const tool = getTool('check_hive');
const result = await tool.execute({ topic: 'quantum computing' });
expect(result).toContain('No existing team knowledge found');
});
});
describe('share_to_team', () => {
it('posts to knowledge API', async () => {
fetchMock.mockResolvedValueOnce(okResponse({ id: 'entity-1' }));
const tool = getTool('share_to_team');
const result = await tool.execute({ content: 'Found a great pattern for error handling', type: 'discovery' });
expect(fetchMock).toHaveBeenCalledOnce();
const [url, opts] = fetchMock.mock.calls[0];
expect(url).toBe('http://localhost:3000/api/teams/alpha-team/knowledge/entities');
expect(opts.method).toBe('POST');
const body = JSON.parse(opts.body);
expect(body.name).toBe('Found a great pattern for error handling');
expect(body.type).toBe('discovery');
expect(result).toContain('Shared');
});
it('truncates name to 100 chars', async () => {
fetchMock.mockResolvedValueOnce(okResponse({ id: 'entity-2' }));
const longContent = 'A'.repeat(200);
const tool = getTool('share_to_team');
await tool.execute({ content: longContent, type: 'insight' });
const body = JSON.parse(fetchMock.mock.calls[0][1].body);
expect(body.name.length).toBe(100);
});
});
describe('create_team_task', () => {
it('posts to tasks API', async () => {
fetchMock.mockResolvedValueOnce(okResponse({ id: 'task-1', title: 'Fix bug' }));
const tool = getTool('create_team_task');
const result = await tool.execute({ title: 'Fix bug', description: 'There is a bug', priority: 'high' });
expect(fetchMock).toHaveBeenCalledOnce();
const [url, opts] = fetchMock.mock.calls[0];
expect(url).toBe('http://localhost:3000/api/teams/alpha-team/tasks');
expect(opts.method).toBe('POST');
const body = JSON.parse(opts.body);
expect(body.title).toBe('Fix bug');
expect(body.description).toBe('There is a bug');
expect(body.priority).toBe('high');
expect(result).toContain('task');
});
});
describe('claim_team_task', () => {
it('patches task status to in_progress', async () => {
fetchMock.mockResolvedValueOnce(okResponse({ id: 'task-1', status: 'in_progress' }));
const tool = getTool('claim_team_task');
const result = await tool.execute({ task_id: 'task-42' });
expect(fetchMock).toHaveBeenCalledOnce();
const [url, opts] = fetchMock.mock.calls[0];
expect(url).toBe('http://localhost:3000/api/teams/alpha-team/tasks/task-42');
expect(opts.method).toBe('PATCH');
const body = JSON.parse(opts.body);
expect(body.status).toBe('in_progress');
expect(result).toContain('Claimed');
});
});
describe('send_waggle_message', () => {
it('sends valid Waggle Dance protocol message', async () => {
fetchMock.mockResolvedValueOnce(okResponse({ id: 'msg-1' }));
const tool = getTool('send_waggle_message');
const result = await tool.execute({ message: 'Found relevant docs', type: 'broadcast', subtype: 'routed_share' });
expect(fetchMock).toHaveBeenCalledOnce();
const [url, opts] = fetchMock.mock.calls[0];
expect(url).toBe('http://localhost:3000/api/teams/alpha-team/messages');
expect(opts.method).toBe('POST');
const body = JSON.parse(opts.body);
expect(body.type).toBe('broadcast');
expect(body.subtype).toBe('routed_share');
expect(body.content).toEqual({ text: 'Found relevant docs' });
expect(result).toContain('broadcast/routed_share');
});
it('defaults to broadcast/discovery when type/subtype omitted', async () => {
fetchMock.mockResolvedValueOnce(okResponse({ id: 'msg-2' }));
const tool = getTool('send_waggle_message');
await tool.execute({ message: 'Hello team' });
const body = JSON.parse(fetchMock.mock.calls[0][1].body);
expect(body.type).toBe('broadcast');
expect(body.subtype).toBe('discovery');
});
});
describe('error handling', () => {
it('throws on API error', async () => {
fetchMock.mockResolvedValueOnce(errorResponse(403, 'Forbidden'));
const tool = getTool('check_hive');
await expect(tool.execute({ topic: 'test' })).rejects.toThrow('403');
});
it('throws on network failure', async () => {
fetchMock.mockRejectedValueOnce(new Error('ECONNREFUSED'));
const tool = getTool('share_to_team');
await expect(tool.execute({ content: 'test', type: 'note' })).rejects.toThrow('ECONNREFUSED');
});
});
});
// ── Local Team Tools ──────────────────────────────────────────────
describe('createLocalTeamTools', () => {
let fetchMock: ReturnType<typeof vi.fn>;
let localDeps: LocalTeamToolDeps;
let tools: ToolDefinition[];
beforeEach(() => {
fetchMock = vi.fn();
localDeps = {
localServerUrl: 'http://127.0.0.1:3333',
workspaceId: 'ws-123',
teamId: 'team-abc',
fetch: fetchMock as unknown as typeof globalThis.fetch,
};
tools = createLocalTeamTools(localDeps);
});
function getTool(name: string): ToolDefinition {
const tool = tools.find((t) => t.name === name);
if (!tool) throw new Error(`Tool "${name}" not found`);
return tool;
}
it('creates 5 local team tools', () => {
const names = tools.map((t) => t.name);
expect(names).toContain('team_activity');
expect(names).toContain('team_tasks');
expect(names).toContain('team_members');
expect(names).toContain('assign_task');
expect(names).toContain('complete_task');
expect(tools).toHaveLength(5);
});
describe('team_activity', () => {
it('returns formatted activity items', async () => {
fetchMock.mockResolvedValueOnce(okResponse({
items: [
{ authorName: 'Alice', summary: 'Added design docs', timestamp: '2026-01-01T00:00:00Z', type: 'memory' },
{ authorName: 'Bob', summary: 'Fixed auth bug', timestamp: '2026-01-01T01:00:00Z', type: 'session' },
],
}));
const tool = getTool('team_activity');
const result = await tool.execute({});
expect(result).toContain('Alice');
expect(result).toContain('design docs');
expect(result).toContain('Bob');
});
it('returns message when no activity', async () => {
fetchMock.mockResolvedValueOnce(okResponse({ items: [] }));
const tool = getTool('team_activity');
const result = await tool.execute({});
expect(result).toContain('No recent team activity');
});
});
describe('team_tasks', () => {
it('returns formatted task list', async () => {
fetchMock.mockResolvedValueOnce(okResponse({
tasks: [
{ id: 't1', title: 'Fix bug', status: 'open', assigneeName: 'Alice' },
{ id: 't2', title: 'Add tests', status: 'in_progress' },
],
}));
const tool = getTool('team_tasks');
const result = await tool.execute({});
expect(result).toContain('Fix bug');
expect(result).toContain('Alice');
expect(result).toContain('Add tests');
});
it('filters by status', async () => {
fetchMock.mockResolvedValueOnce(okResponse({ tasks: [] }));
const tool = getTool('team_tasks');
const result = await tool.execute({ status: 'done' });
const [url] = fetchMock.mock.calls[0];
expect(url).toContain('?status=done');
expect(result).toContain('No done tasks');
});
});
describe('team_members', () => {
it('returns formatted member list', async () => {
fetchMock.mockResolvedValueOnce(okResponse({
members: [
{ displayName: 'Alice', status: 'online', activitySummary: 'Editing docs' },
{ displayName: 'Bob', status: 'away' },
],
}));
const tool = getTool('team_members');
const result = await tool.execute({});
expect(result).toContain('Alice (online)');
expect(result).toContain('Editing docs');
expect(result).toContain('Bob (away)');
});
it('returns message when no members', async () => {
fetchMock.mockResolvedValueOnce(okResponse({ members: [] }));
const tool = getTool('team_members');
const result = await tool.execute({});
expect(result).toContain('No team members found');
});
});
describe('assign_task', () => {
it('creates a task with assignee and returns confirmation', async () => {
fetchMock.mockResolvedValueOnce(okResponse({ id: 'task-new-1' }));
const tool = getTool('assign_task');
const result = await tool.execute({
title: 'Review the PR',
assigneeName: 'Alice',
assigneeId: 'user-alice',
});
expect(fetchMock).toHaveBeenCalledOnce();
const [url, opts] = fetchMock.mock.calls[0];
expect(url).toBe('http://127.0.0.1:3333/api/workspaces/ws-123/tasks');
expect(opts.method).toBe('POST');
const body = JSON.parse(opts.body);
expect(body.title).toBe('Review the PR');
expect(body.assigneeName).toBe('Alice');
expect(body.assigneeId).toBe('user-alice');
expect(body.creatorName).toBe('Agent');
expect(result).toContain('Alice');
expect(result).toContain('Review the PR');
});
});
describe('complete_task', () => {
it('marks task as done', async () => {
fetchMock.mockResolvedValueOnce(okResponse({ id: 'task-42', status: 'done' }));
const tool = getTool('complete_task');
const result = await tool.execute({ task_id: 'task-42' });
expect(fetchMock).toHaveBeenCalledOnce();
const [url, opts] = fetchMock.mock.calls[0];
expect(url).toBe('http://127.0.0.1:3333/api/workspaces/ws-123/tasks/task-42');
expect(opts.method).toBe('PATCH');
const body = JSON.parse(opts.body);
expect(body.status).toBe('done');
expect(result).toContain('done');
});
});
});