final tests

Author: kentcdodds

exercises/99.finished/01.solution.finished/src/index.test.ts

@@ -80,6 +80,183 @@ test('Tool Definition', async () => {
 	)
 })
 
+test('Tool annotations and structured output', async () => {
+	await using setup = await setupClient()
+	const { client } = setup
+
+	// Check create_entry and create_tag annotations (always enabled)
+	let list = await client.listTools()
+	let toolMap = Object.fromEntries(list.tools.map((t) => [t.name, t]))
+
+	// Check create_entry annotations
+	const createEntryTool = toolMap['create_entry']
+	invariant(createEntryTool, '🚨 create_entry tool not found')
+	expect(
+		createEntryTool.annotations,
+		'🚨 create_entry missing annotations',
+	).toEqual(
+		expect.objectContaining({
+			destructiveHint: false,
+			openWorldHint: false,
+		}),
+	)
+
+	// Check create_tag annotations
+	const createTagTool = toolMap['create_tag']
+	invariant(createTagTool, '🚨 create_tag tool not found')
+	expect(
+		createTagTool.annotations,
+		'🚨 create_tag missing annotations',
+	).toEqual(
+		expect.objectContaining({
+			destructiveHint: false,
+			openWorldHint: false,
+		}),
+	)
+
+	// Create a tag and entry for further tool calls
+	const tagResult = await client.callTool({
+		name: 'create_tag',
+		arguments: {
+			name: 'TestTag',
+			description: 'A tag for testing',
+		},
+	})
+	expect(
+		tagResult.structuredContent,
+		'🚨 tagResult.structuredContent should be defined',
+	).toBeDefined()
+	const tag = (tagResult.structuredContent as any).tag
+	invariant(tag, '🚨 No tag resource found')
+	invariant(tag.id, '🚨 No tag ID found')
+
+	const entryResult = await client.callTool({
+		name: 'create_entry',
+		arguments: {
+			title: 'Test Entry',
+			content: 'This is a test entry',
+		},
+	})
+	expect(
+		entryResult.structuredContent,
+		'🚨 entryResult.structuredContent should be defined',
+	).toBeDefined()
+	const entry = (entryResult.structuredContent as any).entry
+	invariant(entry, '🚨 No entry resource found')
+	invariant(entry.id, '🚨 No entry ID found')
+
+	// List tools again now that entry and tag exist
+	list = await client.listTools()
+	toolMap = Object.fromEntries(list.tools.map((t) => [t.name, t]))
+
+	// Check delete_entry annotations
+	const deleteEntryTool = toolMap['delete_entry']
+	invariant(deleteEntryTool, '🚨 delete_entry tool not found')
+	expect(
+		deleteEntryTool.annotations,
+		'🚨 delete_entry missing annotations',
+	).toEqual(
+		expect.objectContaining({
+			idempotentHint: true,
+			openWorldHint: false,
+		}),
+	)
+
+	// Check delete_tag annotations
+	const deleteTagTool = toolMap['delete_tag']
+	invariant(deleteTagTool, '🚨 delete_tag tool not found')
+	expect(
+		deleteTagTool.annotations,
+		'🚨 delete_tag missing annotations',
+	).toEqual(
+		expect.objectContaining({
+			idempotentHint: true,
+			openWorldHint: false,
+		}),
+	)
+
+	// get_entry structuredContent
+	const getEntryResult = await client.callTool({
+		name: 'get_entry',
+		arguments: { id: entry.id },
+	})
+	const getEntryContent = (getEntryResult.structuredContent as any).entry
+	invariant(getEntryContent, '🚨 get_entry missing entry in structuredContent')
+	expect(getEntryContent.id, '🚨 get_entry structuredContent.id mismatch').toBe(
+		entry.id,
+	)
+
+	// get_tag structuredContent
+	const getTagResult = await client.callTool({
+		name: 'get_tag',
+		arguments: { id: tag.id },
+	})
+	const getTagContent = (getTagResult.structuredContent as any).tag
+	invariant(getTagContent, '🚨 get_tag missing tag in structuredContent')
+	expect(getTagContent.id, '🚨 get_tag structuredContent.id mismatch').toBe(
+		tag.id,
+	)
+
+	// update_entry structuredContent
+	const updateEntryResult = await client.callTool({
+		name: 'update_entry',
+		arguments: { id: entry.id, title: 'Updated Entry' },
+	})
+	const updateEntryContent = (updateEntryResult.structuredContent as any).entry
+	invariant(
+		updateEntryContent,
+		'🚨 update_entry missing entry in structuredContent',
+	)
+	expect(
+		updateEntryContent.title,
+		'🚨 update_entry structuredContent.title mismatch',
+	).toBe('Updated Entry')
+
+	// update_tag structuredContent
+	const updateTagResult = await client.callTool({
+		name: 'update_tag',
+		arguments: { id: tag.id, name: 'UpdatedTag' },
+	})
+	const updateTagContent = (updateTagResult.structuredContent as any).tag
+	invariant(updateTagContent, '🚨 update_tag missing tag in structuredContent')
+	expect(
+		updateTagContent.name,
+		'🚨 update_tag structuredContent.name mismatch',
+	).toBe('UpdatedTag')
+
+	// delete_entry structuredContent
+	const deleteEntryResult = await client.callTool({
+		name: 'delete_entry',
+		arguments: { id: entry.id },
+	})
+	const deleteEntryContent = deleteEntryResult.structuredContent as any
+	invariant(deleteEntryContent, '🚨 delete_entry missing structuredContent')
+	expect(
+		deleteEntryContent.success,
+		'🚨 delete_entry structuredContent.success should be true',
+	).toBe(true)
+	expect(
+		deleteEntryContent.entry.id,
+		'🚨 delete_entry structuredContent.entry.id mismatch',
+	).toBe(entry.id)
+
+	// delete_tag structuredContent
+	const deleteTagResult = await client.callTool({
+		name: 'delete_tag',
+		arguments: { id: tag.id },
+	})
+	const deleteTagContent = deleteTagResult.structuredContent as any
+	invariant(deleteTagContent, '🚨 delete_tag missing structuredContent')
+	expect(
+		deleteTagContent.success,
+		'🚨 delete_tag structuredContent.success should be true',
+	).toBe(true)
+	expect(
+		deleteTagContent.tag.id,
+		'🚨 delete_tag structuredContent.tag.id mismatch',
+	).toBe(tag.id)
+})
+
 async function deferred<ResolvedValue>() {
 	const ref = {} as {
 		promise: Promise<ResolvedValue>