@namzu/sdk 0.1.5 → 0.1.6-rc.1

package/dist/types/verification/index.d.ts

@@ -43,11 +43,11 @@ export declare const VerificationRuleSchema: z.ZodDiscriminatedUnion<"type", [z.
     type: z.ZodLiteral<"allow_by_category">;
     categories: z.ZodArray<z.ZodString, "many">;
 }, "strip", z.ZodTypeAny, {
-    categories: string[];
     type: "allow_by_category";
-}, {
     categories: string[];
+}, {
     type: "allow_by_category";
+    categories: string[];
 }>, z.ZodObject<{
     type: z.ZodLiteral<"allow_by_name">;
     toolNames: z.ZodArray<z.ZodString, "many">;
@@ -73,14 +73,14 @@ export declare const VerificationRuleSchema: z.ZodDiscriminatedUnion<"type", [z.
     decision: z.ZodEnum<["allow", "deny"]>;
 }, "strip", z.ZodTypeAny, {
     type: "custom_pattern";
-    decision: "allow" | "deny";
-    target: "name" | "args" | "both";
     pattern: string;
+    target: "name" | "args" | "both";
+    decision: "deny" | "allow";
 }, {
     type: "custom_pattern";
-    decision: "allow" | "deny";
-    target: "name" | "args" | "both";
     pattern: string;
+    target: "name" | "args" | "both";
+    decision: "deny" | "allow";
 }>, z.ZodObject<{
     type: z.ZodLiteral<"allow_by_tier">;
     tiers: z.ZodArray<z.ZodString, "many">;
@@ -109,11 +109,11 @@ export declare const VerificationGateConfigSchema: z.ZodObject<{
         type: z.ZodLiteral<"allow_by_category">;
         categories: z.ZodArray<z.ZodString, "many">;
     }, "strip", z.ZodTypeAny, {
-        categories: string[];
         type: "allow_by_category";
-    }, {
         categories: string[];
+    }, {
         type: "allow_by_category";
+        categories: string[];
     }>, z.ZodObject<{
         type: z.ZodLiteral<"allow_by_name">;
         toolNames: z.ZodArray<z.ZodString, "many">;
@@ -139,14 +139,14 @@ export declare const VerificationGateConfigSchema: z.ZodObject<{
         decision: z.ZodEnum<["allow", "deny"]>;
     }, "strip", z.ZodTypeAny, {
         type: "custom_pattern";
-        decision: "allow" | "deny";
-        target: "name" | "args" | "both";
         pattern: string;
+        target: "name" | "args" | "both";
+        decision: "deny" | "allow";
     }, {
         type: "custom_pattern";
-        decision: "allow" | "deny";
-        target: "name" | "args" | "both";
         pattern: string;
+        target: "name" | "args" | "both";
+        decision: "deny" | "allow";
     }>, z.ZodObject<{
         type: z.ZodLiteral<"allow_by_tier">;
         tiers: z.ZodArray<z.ZodString, "many">;
@@ -167,8 +167,8 @@ export declare const VerificationGateConfigSchema: z.ZodObject<{
     } | {
         type: "deny_dangerous_patterns";
     } | {
-        categories: string[];
         type: "allow_by_category";
+        categories: string[];
     } | {
         type: "allow_by_name";
         toolNames: string[];
@@ -177,9 +177,9 @@ export declare const VerificationGateConfigSchema: z.ZodObject<{
         toolNames: string[];
     } | {
         type: "custom_pattern";
-        decision: "allow" | "deny";
-        target: "name" | "args" | "both";
         pattern: string;
+        target: "name" | "args" | "both";
+        decision: "deny" | "allow";
     } | {
         type: "allow_by_tier";
         tiers: string[];
@@ -194,8 +194,8 @@ export declare const VerificationGateConfigSchema: z.ZodObject<{
     } | {
         type: "deny_dangerous_patterns";
     } | {
-        categories: string[];
         type: "allow_by_category";
+        categories: string[];
     } | {
         type: "allow_by_name";
         toolNames: string[];
@@ -204,9 +204,9 @@ export declare const VerificationGateConfigSchema: z.ZodObject<{
         toolNames: string[];
     } | {
         type: "custom_pattern";
-        decision: "allow" | "deny";
-        target: "name" | "args" | "both";
         pattern: string;
+        target: "name" | "args" | "both";
+        decision: "deny" | "allow";
     } | {
         type: "allow_by_tier";
         tiers: string[];

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "@namzu/sdk",
-  "version": "0.1.5",
+  "version": "0.1.6-rc.1",
   "description": "Open-source AI agent SDK with a built-in runtime. Nothing between you and your agents.",
   "license": "FSL-1.1-MIT",
   "type": "module",
-  "packageManager": "pnpm@10.33.0",
   "homepage": "https://github.com/cogitave/namzu#readme",
   "repository": {
     "type": "git",
@@ -32,24 +31,6 @@
     "access": "public",
     "provenance": true
   },
-  "scripts": {
-    "build": "tsc --build",
-    "dev": "tsc --build --watch",
-    "lint": "biome check src/",
-    "lint:fix": "biome check --write src/",
-    "format": "biome format --write src/",
-    "test": "vitest run --passWithNoTests",
-    "typecheck": "tsc --noEmit",
-    "verify": "bash scripts/verify.sh",
-    "release:patch": "bash scripts/release.sh patch",
-    "release:minor": "bash scripts/release.sh minor",
-    "release:major": "bash scripts/release.sh major",
-    "release:rc": "bash scripts/release.sh rc",
-    "release:beta": "bash scripts/release.sh beta",
-    "release:stable": "bash scripts/release.sh stable",
-    "release:dry": "bash scripts/release.sh patch --dry-run",
-    "prepublishOnly": "pnpm lint && pnpm typecheck && pnpm build"
-  },
   "dependencies": {
     "@aws-sdk/client-bedrock-runtime": "^3.700.0",
     "@opentelemetry/api": "^1.9.0",
@@ -68,5 +49,22 @@
     "@types/node": "^22.19.17",
     "typescript": "^5.5.0",
     "vitest": "^2.0.0"
+  },
+  "scripts": {
+    "build": "tsc --build",
+    "dev": "tsc --build --watch",
+    "lint": "biome check src/",
+    "lint:fix": "biome check --write src/",
+    "format": "biome format --write src/",
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "tsc --noEmit",
+    "verify": "bash scripts/verify.sh",
+    "release:patch": "bash scripts/release.sh patch",
+    "release:minor": "bash scripts/release.sh minor",
+    "release:major": "bash scripts/release.sh major",
+    "release:rc": "bash scripts/release.sh rc",
+    "release:beta": "bash scripts/release.sh beta",
+    "release:stable": "bash scripts/release.sh stable",
+    "release:dry": "bash scripts/release.sh patch --dry-run"
   }
-}
+}

package/src/index.ts

@@ -45,6 +45,7 @@ export * from './types/plugin/index.js'
 export * from './types/sandbox/index.js'
 export * from './types/structured-output/index.js'
 export * from './types/invocation/index.js'
+export * from './types/computer-use/index.js'
 
 export {
 	AdvisorRegistry,
@@ -206,6 +207,10 @@ export {
 	createStructuredOutputTool,
 	STRUCTURED_OUTPUT_TOOL_NAME,
 } from './tools/builtins/structuredOutput.js'
+export {
+	createComputerUseTool,
+	COMPUTER_USE_TOOL_NAME,
+} from './tools/builtins/computer-use.js'
 
 export {
 	TextChunker,

package/src/tools/builtins/__tests__/computer-use.test.ts

@@ -0,0 +1,188 @@
+import { describe, expect, it } from 'vitest'
+import type {
+	ComputerUseAction,
+	ComputerUseCapabilities,
+	ComputerUseHost,
+	ComputerUseResult,
+	DisplayGeometry,
+} from '../../../types/computer-use/index.js'
+import type { ToolContext } from '../../../types/tool/index.js'
+import { COMPUTER_USE_TOOL_NAME, createComputerUseTool } from '../computer-use.js'
+
+function makeHost(overrides: Partial<ComputerUseCapabilities> = {}): {
+	host: ComputerUseHost
+	calls: ComputerUseAction[]
+} {
+	const calls: ComputerUseAction[] = []
+	const capabilities: ComputerUseCapabilities = {
+		displayServer: 'darwin',
+		screenshot: true,
+		mouse: true,
+		keyboard: true,
+		cursorPosition: true,
+		clipboard: true,
+		...overrides,
+	}
+	const host: ComputerUseHost = {
+		id: 'mock-host',
+		capabilities,
+		async getDisplayGeometry(): Promise<DisplayGeometry> {
+			return { width: 1920, height: 1080, scaleFactor: 2 }
+		},
+		async execute(action: ComputerUseAction): Promise<ComputerUseResult> {
+			calls.push(action)
+			switch (action.type) {
+				case 'screenshot':
+					return {
+						type: 'screenshot',
+						result: {
+							data: Buffer.from([0x89, 0x50, 0x4e, 0x47]),
+							mimeType: 'image/png',
+							width: 1920,
+							height: 1080,
+						},
+					}
+				case 'cursor_position':
+					return { type: 'cursor_position', point: { x: 10, y: 20 } }
+				default:
+					return { type: 'ok' }
+			}
+		},
+	}
+	return { host, calls }
+}
+
+function makeContext(): ToolContext {
+	return {
+		runId: 'run_test' as never,
+		workingDirectory: '/tmp',
+		abortSignal: new AbortController().signal,
+		env: {},
+		log: () => {},
+	}
+}
+
+describe('createComputerUseTool', () => {
+	it('exposes the canonical tool name', () => {
+		expect(COMPUTER_USE_TOOL_NAME).toBe('computer_use')
+		const { host } = makeHost()
+		const tool = createComputerUseTool(host)
+		expect(tool.name).toBe('computer_use')
+	})
+
+	it('surfaces host capabilities in the description', () => {
+		const { host } = makeHost({ keyboard: false, mouse: false, cursorPosition: false })
+		const tool = createComputerUseTool(host)
+		expect(tool.description).toContain('darwin')
+		expect(tool.description.toLowerCase()).toContain('unavailable')
+		expect(tool.description).toContain('keyboard')
+	})
+
+	it('marks click/type/key/drag/scroll as destructive and screenshot/move as not', () => {
+		const { host } = makeHost()
+		const tool = createComputerUseTool(host)
+		expect(tool.isDestructive?.({ type: 'screenshot' } as never)).toBe(false)
+		expect(tool.isDestructive?.({ type: 'cursor_position' } as never)).toBe(false)
+		expect(tool.isDestructive?.({ type: 'mouse_move', to: { x: 0, y: 0 } } as never)).toBe(false)
+		expect(
+			tool.isDestructive?.({
+				type: 'mouse_click',
+				at: { x: 0, y: 0 },
+				button: 'left',
+			} as never),
+		).toBe(true)
+		expect(
+			tool.isDestructive?.({
+				type: 'mouse_drag',
+				from: { x: 0, y: 0 },
+				to: { x: 10, y: 10 },
+				button: 'left',
+			} as never),
+		).toBe(true)
+		expect(
+			tool.isDestructive?.({
+				type: 'scroll',
+				at: { x: 0, y: 0 },
+				direction: 'down',
+				amount: 3,
+			} as never),
+		).toBe(true)
+		expect(tool.isDestructive?.({ type: 'type_text', text: 'hi' } as never)).toBe(true)
+		expect(tool.isDestructive?.({ type: 'key', keys: 'ctrl+c' } as never)).toBe(true)
+	})
+
+	it('rejects actions whose required capability is missing', async () => {
+		const { host, calls } = makeHost({ keyboard: false })
+		const tool = createComputerUseTool(host)
+
+		const result = await tool.execute({ type: 'type_text', text: 'hi' }, makeContext())
+
+		expect(result.success).toBe(false)
+		expect(result.error).toContain('keyboard')
+		expect(calls).toHaveLength(0)
+	})
+
+	it('rejects cursor_position when the host does not support it', async () => {
+		const { host, calls } = makeHost({ cursorPosition: false })
+		const tool = createComputerUseTool(host)
+
+		const result = await tool.execute({ type: 'cursor_position' }, makeContext())
+
+		expect(result.success).toBe(false)
+		expect(result.error).toContain('cursorPosition')
+		expect(calls).toHaveLength(0)
+	})
+
+	it('returns base64 PNG output for screenshot', async () => {
+		const { host } = makeHost()
+		const tool = createComputerUseTool(host)
+
+		const result = await tool.execute({ type: 'screenshot' }, makeContext())
+
+		expect(result.success).toBe(true)
+		expect(Buffer.from(result.output, 'base64').slice(0, 4)).toEqual(
+			Buffer.from([0x89, 0x50, 0x4e, 0x47]),
+		)
+		expect(result.data).toMatchObject({
+			mimeType: 'image/png',
+			width: 1920,
+			height: 1080,
+			encoding: 'base64',
+		})
+	})
+
+	it('returns JSON point output for cursor_position', async () => {
+		const { host } = makeHost()
+		const tool = createComputerUseTool(host)
+
+		const result = await tool.execute({ type: 'cursor_position' }, makeContext())
+
+		expect(result.success).toBe(true)
+		expect(JSON.parse(result.output)).toEqual({ x: 10, y: 20 })
+	})
+
+	it('returns ok for side-effect actions and records the dispatch', async () => {
+		const { host, calls } = makeHost()
+		const tool = createComputerUseTool(host)
+
+		const action = { type: 'mouse_click', at: { x: 50, y: 60 }, button: 'left' } as const
+		const result = await tool.execute(action, makeContext())
+
+		expect(result.success).toBe(true)
+		expect(result.output).toBe('ok')
+		expect(calls).toEqual([action])
+	})
+
+	it('validates input via the discriminated union schema', () => {
+		const { host } = makeHost()
+		const tool = createComputerUseTool(host)
+
+		expect(() => tool.inputSchema.parse({ type: 'screenshot' })).not.toThrow()
+		expect(() =>
+			tool.inputSchema.parse({ type: 'mouse_click', at: { x: 1, y: 2 }, button: 'left' }),
+		).not.toThrow()
+		expect(() => tool.inputSchema.parse({ type: 'mouse_click' })).toThrow()
+		expect(() => tool.inputSchema.parse({ type: 'nope' })).toThrow()
+		expect(() => tool.inputSchema.parse({ type: 'scroll', at: { x: 0, y: 0 } })).toThrow()
+	})
+})

package/src/tools/builtins/computer-use.ts

@@ -0,0 +1,165 @@
+import { z } from 'zod'
+import type {
+	ComputerUseAction,
+	ComputerUseCapabilities,
+	ComputerUseHost,
+	ComputerUseResult,
+} from '../../types/computer-use/index.js'
+import type { ToolDefinition, ToolResult } from '../../types/tool/index.js'
+import { defineTool } from '../defineTool.js'
+
+export const COMPUTER_USE_TOOL_NAME = 'computer_use' as const
+
+// ---------------------------------------------------------------------------
+// Input schema — discriminated union matching ComputerUseAction
+// ---------------------------------------------------------------------------
+
+const pointSchema = z.object({
+	x: z.number().int(),
+	y: z.number().int(),
+})
+
+const mouseButtonSchema = z.enum(['left', 'right', 'middle'])
+
+const actionSchema = z.discriminatedUnion('type', [
+	z.object({ type: z.literal('screenshot') }),
+	z.object({ type: z.literal('cursor_position') }),
+	z.object({ type: z.literal('mouse_move'), to: pointSchema }),
+	z.object({ type: z.literal('mouse_click'), at: pointSchema, button: mouseButtonSchema }),
+	z.object({
+		type: z.literal('mouse_drag'),
+		from: pointSchema,
+		to: pointSchema,
+		button: mouseButtonSchema,
+	}),
+	z.object({
+		type: z.literal('scroll'),
+		at: pointSchema,
+		direction: z.enum(['up', 'down', 'left', 'right']),
+		amount: z.number().int().positive(),
+	}),
+	z.object({ type: z.literal('type_text'), text: z.string() }),
+	z.object({ type: z.literal('key'), keys: z.string() }),
+])
+
+type ActionInput = z.infer<typeof actionSchema>
+
+const DESTRUCTIVE_ACTION_TYPES = new Set<ComputerUseAction['type']>([
+	'mouse_click',
+	'mouse_drag',
+	'type_text',
+	'key',
+	'scroll',
+])
+
+function requiredCapability(type: ComputerUseAction['type']): keyof ComputerUseCapabilities | null {
+	switch (type) {
+		case 'screenshot':
+			return 'screenshot'
+		case 'cursor_position':
+			return 'cursorPosition'
+		case 'mouse_move':
+		case 'mouse_click':
+		case 'mouse_drag':
+		case 'scroll':
+			return 'mouse'
+		case 'type_text':
+		case 'key':
+			return 'keyboard'
+		default:
+			return null
+	}
+}
+
+function buildDescription(host: ComputerUseHost): string {
+	const caps = host.capabilities
+	const available: string[] = []
+	if (caps.screenshot) available.push('screenshot')
+	if (caps.cursorPosition) available.push('cursor_position')
+	if (caps.mouse) available.push('mouse_move, mouse_click, mouse_drag, scroll')
+	if (caps.keyboard) available.push('type_text, key')
+	const unavailable: string[] = []
+	if (!caps.screenshot) unavailable.push('screenshot')
+	if (!caps.cursorPosition) unavailable.push('cursor_position')
+	if (!caps.mouse) unavailable.push('mouse')
+	if (!caps.keyboard) unavailable.push('keyboard')
+
+	const lines = [
+		`Controls the user's desktop on a ${caps.displayServer} host. Use to take screenshots and drive mouse/keyboard input for GUI tasks.`,
+		`Available actions: ${available.join('; ') || 'none'}.`,
+	]
+	if (unavailable.length > 0) {
+		lines.push(`Unavailable on this host: ${unavailable.join(', ')}.`)
+	}
+	lines.push(
+		'Coordinates are in logical pixels from the top-left of the primary display. Call getDisplayGeometry through screenshot output before clicking to confirm bounds.',
+	)
+	return lines.join(' ')
+}
+
+function resultToToolResult(result: ComputerUseResult): ToolResult {
+	switch (result.type) {
+		case 'screenshot': {
+			const { data, mimeType, width, height } = result.result
+			return {
+				success: true,
+				output: data.toString('base64'),
+				data: { mimeType, width, height, encoding: 'base64' },
+			}
+		}
+		case 'cursor_position':
+			return {
+				success: true,
+				output: JSON.stringify(result.point),
+				data: result.point,
+			}
+		case 'ok':
+			return { success: true, output: 'ok' }
+	}
+}
+
+/**
+ * Factory: given a ComputerUseHost (provided by the consumer — e.g.
+ * @namzu/computer-use's SubprocessComputerUseHost), returns a ToolDefinition
+ * that routes the discriminated action to the host and maps results back to
+ * the SDK's ToolResult shape.
+ *
+ * The tool's description reflects the host's frozen capabilities, and any
+ * action targeting an unavailable capability is rejected with a clear error
+ * rather than hanging or failing silently.
+ *
+ * @example
+ * ```ts
+ * import { SubprocessComputerUseHost } from '@namzu/computer-use'
+ * import { createComputerUseTool } from '@namzu/sdk'
+ *
+ * const host = new SubprocessComputerUseHost()
+ * await host.initialize?.()
+ * registry.register(createComputerUseTool(host))
+ * ```
+ */
+export function createComputerUseTool(host: ComputerUseHost): ToolDefinition<ActionInput> {
+	return defineTool({
+		name: COMPUTER_USE_TOOL_NAME,
+		description: buildDescription(host),
+		inputSchema: actionSchema,
+		category: 'custom',
+		permissions: [],
+		readOnly: false,
+		destructive: (input: ActionInput) => DESTRUCTIVE_ACTION_TYPES.has(input.type),
+		concurrencySafe: false,
+
+		async execute(input, _context): Promise<ToolResult> {
+			const required = requiredCapability(input.type)
+			if (required !== null && host.capabilities[required] !== true) {
+				return {
+					success: false,
+					output: '',
+					error: `computer_use: action "${input.type}" requires capability "${required}" which is not available on this host (displayServer=${host.capabilities.displayServer}).`,
+				}
+			}
+			const result = await host.execute(input as ComputerUseAction)
+			return resultToToolResult(result)
+		},
+	})
+}

package/src/tools/builtins/index.ts

@@ -7,6 +7,7 @@ export { GrepTool } from './grep.js'
 export { LsTool } from './ls.js'
 export { SearchToolsTool } from './search-tools.js'
 export { createStructuredOutputTool, STRUCTURED_OUTPUT_TOOL_NAME } from './structuredOutput.js'
+export { createComputerUseTool, COMPUTER_USE_TOOL_NAME } from './computer-use.js'
 
 import type { ToolDefinition } from '../../types/tool/index.js'
 import { BashTool } from './bash.js'

package/src/types/computer-use/index.ts

@@ -0,0 +1,126 @@
+// ---------------------------------------------------------------------------
+// Display server — the host environment's graphical stack
+// ---------------------------------------------------------------------------
+
+export type DisplayServer = 'darwin' | 'win32' | 'x11' | 'wayland' | 'unknown'
+
+export function assertDisplayServer(value: DisplayServer): void {
+	switch (value) {
+		case 'darwin':
+		case 'win32':
+		case 'x11':
+		case 'wayland':
+		case 'unknown':
+			return
+		default: {
+			const _exhaustive: never = value
+			throw new Error(`Unknown DisplayServer: ${_exhaustive}`)
+		}
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Capabilities — frozen at host construction; model sees these via tool description
+// ---------------------------------------------------------------------------
+
+export interface ComputerUseCapabilities {
+	readonly displayServer: DisplayServer
+	readonly screenshot: boolean
+	readonly mouse: boolean
+	readonly keyboard: boolean
+	readonly cursorPosition: boolean
+	readonly clipboard: boolean
+}
+
+// ---------------------------------------------------------------------------
+// Geometry + screenshot payload
+// ---------------------------------------------------------------------------
+
+export interface DisplayGeometry {
+	readonly width: number
+	readonly height: number
+	readonly scaleFactor: number
+}
+
+export interface ScreenshotResult {
+	readonly data: Buffer
+	readonly mimeType: 'image/png'
+	readonly width: number
+	readonly height: number
+}
+
+export interface Point {
+	readonly x: number
+	readonly y: number
+}
+
+export type MouseButton = 'left' | 'right' | 'middle'
+
+export type ScrollDirection = 'up' | 'down' | 'left' | 'right'
+
+// ---------------------------------------------------------------------------
+// Action — discriminated union; mirrors Anthropic's computer_20250124 shape
+// ---------------------------------------------------------------------------
+
+export type ComputerUseAction =
+	| { readonly type: 'screenshot' }
+	| { readonly type: 'cursor_position' }
+	| { readonly type: 'mouse_move'; readonly to: Point }
+	| { readonly type: 'mouse_click'; readonly at: Point; readonly button: MouseButton }
+	| {
+			readonly type: 'mouse_drag'
+			readonly from: Point
+			readonly to: Point
+			readonly button: MouseButton
+	  }
+	| {
+			readonly type: 'scroll'
+			readonly at: Point
+			readonly direction: ScrollDirection
+			readonly amount: number
+	  }
+	| { readonly type: 'type_text'; readonly text: string }
+	| { readonly type: 'key'; readonly keys: string }
+
+export function assertComputerUseActionType(type: ComputerUseAction['type']): void {
+	switch (type) {
+		case 'screenshot':
+		case 'cursor_position':
+		case 'mouse_move':
+		case 'mouse_click':
+		case 'mouse_drag':
+		case 'scroll':
+		case 'type_text':
+		case 'key':
+			return
+		default: {
+			const _exhaustive: never = type
+			throw new Error(`Unknown ComputerUseAction type: ${_exhaustive}`)
+		}
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Action result — discriminated union matching action types that return data
+// ---------------------------------------------------------------------------
+
+export type ComputerUseResult =
+	| { readonly type: 'screenshot'; readonly result: ScreenshotResult }
+	| { readonly type: 'cursor_position'; readonly point: Point }
+	| { readonly type: 'ok' }
+
+// ---------------------------------------------------------------------------
+// Host interface — the core abstraction. Mirrors Sandbox/SandboxProvider shape.
+// Implementations live outside @namzu/sdk (e.g. @namzu/computer-use).
+// ---------------------------------------------------------------------------
+
+export interface ComputerUseHost {
+	readonly id: string
+	readonly capabilities: ComputerUseCapabilities
+
+	getDisplayGeometry(): Promise<DisplayGeometry>
+	execute(action: ComputerUseAction): Promise<ComputerUseResult>
+
+	initialize?(): Promise<void>
+	dispose?(): Promise<void>
+}