@townco/agent 0.1.77 → 0.1.79

package/dist/runner/hooks/executor.d.ts

@@ -1,5 +1,9 @@
 import type { ContextEntry } from "../../acp-server/session-storage";
 import type { HookCallback, HookConfig, HookNotification, ReadonlySession } from "./types";
+/**
+ * Callback for streaming hook notifications in real-time
+ */
+export type OnHookNotification = (notification: HookNotification) => void;
 /**
  * Hook executor manages hook lifecycle
  */
@@ -7,7 +11,12 @@ export declare class HookExecutor {
     private hooks;
     private model;
     private loadCallback;
-    constructor(hooks: HookConfig[], model: string, loadCallback: (callbackRef: string) => Promise<HookCallback>);
+    private onNotification;
+    constructor(hooks: HookConfig[], model: string, loadCallback: (callbackRef: string) => Promise<HookCallback>, onNotification?: OnHookNotification);
+    /**
+     * Emit a notification - sends immediately if callback provided, otherwise collects for batch return
+     */
+    private emitNotification;
     /**
      * Execute hooks before agent invocation
      * Returns new context entries to append and any notifications to send
@@ -32,6 +41,7 @@ export declare class HookExecutor {
     }): Promise<{
         modifiedOutput?: Record<string, unknown>;
         truncationWarning?: string;
+        notifications: HookNotification[];
     }>;
     /**
      * Execute a single tool_response hook

package/dist/runner/hooks/executor.js

@@ -1,12 +1,6 @@
 import { createLogger } from "../../logger.js";
-import { DEFAULT_CONTEXT_SIZE, MODEL_CONTEXT_WINDOWS } from "./constants";
+import { getModelContextWindow } from "./constants";
 const logger = createLogger("hook-executor");
-/**
- * Get max context size for a model
- */
-function getModelMaxTokens(model) {
-    return MODEL_CONTEXT_WINDOWS[model] ?? DEFAULT_CONTEXT_SIZE;
-}
 /**
  * Hook executor manages hook lifecycle
  */
@@ -14,10 +8,21 @@ export class HookExecutor {
     hooks;
     model;
     loadCallback;
-    constructor(hooks, model, loadCallback) {
+    onNotification;
+    constructor(hooks, model, loadCallback, onNotification) {
         this.hooks = hooks;
         this.model = model;
         this.loadCallback = loadCallback;
+        this.onNotification = onNotification;
+    }
+    /**
+     * Emit a notification - sends immediately if callback provided, otherwise collects for batch return
+     */
+    emitNotification(notification, notifications) {
+        notifications.push(notification);
+        if (this.onNotification) {
+            this.onNotification(notification);
+        }
     }
     /**
      * Execute hooks before agent invocation
@@ -49,7 +54,7 @@ export class HookExecutor {
      * Execute a context_size hook
      */
     async executeContextSizeHook(hook, session, actualInputTokens) {
-        const maxTokens = getModelMaxTokens(this.model);
+        const maxTokens = getModelContextWindow(this.model);
         const percentage = (actualInputTokens / maxTokens) * 100;
         // Default threshold is 95%
         const threshold = hook.setting?.threshold ?? 95;
@@ -60,14 +65,16 @@ export class HookExecutor {
         }
         logger.info(`Context hook triggered: ${actualInputTokens} tokens (${percentage.toFixed(1)}%) exceeds threshold ${threshold}%`);
         const notifications = [];
-        // Notify that hook is triggered
-        notifications.push({
+        const triggeredAt = Date.now();
+        // Notify that hook is triggered - sent immediately via callback if available
+        this.emitNotification({
             type: "hook_triggered",
             hookType: "context_size",
             threshold,
             currentPercentage: percentage,
             callback: hook.callback,
-        });
+            triggeredAt,
+        }, notifications);
         try {
             // Load and execute callback
             const callback = await this.loadCallback(hook.callback);
@@ -80,12 +87,13 @@ export class HookExecutor {
             };
             const result = await callback(hookContext);
             // Notify completion
-            notifications.push({
+            this.emitNotification({
                 type: "hook_completed",
                 hookType: "context_size",
                 callback: hook.callback,
                 metadata: result.metadata,
-            });
+                completedAt: Date.now(),
+            }, notifications);
             return {
                 newContextEntry: result.newContextEntry,
                 notifications,
@@ -93,12 +101,13 @@ export class HookExecutor {
         }
         catch (error) {
             // Notify error
-            notifications.push({
+            this.emitNotification({
                 type: "hook_error",
                 hookType: "context_size",
                 callback: hook.callback,
                 error: error instanceof Error ? error.message : String(error),
-            });
+                completedAt: Date.now(),
+            }, notifications);
             // Return no context entry on error
             return {
                 newContextEntry: null,
@@ -115,21 +124,46 @@ export class HookExecutor {
             toolName: toolResponse.toolName,
             outputTokens: toolResponse.outputTokens,
         });
+        const notifications = [];
         for (const hook of this.hooks) {
             if (hook.type === "tool_response") {
                 const result = await this.executeToolResponseHook(hook, session, currentContextTokens, toolResponse);
                 if (result) {
-                    return result;
+                    notifications.push(...result.notifications);
+                    const response = { notifications };
+                    if (result.modifiedOutput !== undefined) {
+                        response.modifiedOutput = result.modifiedOutput;
+                    }
+                    if (result.truncationWarning !== undefined) {
+                        response.truncationWarning = result.truncationWarning;
+                    }
+                    return response;
                 }
             }
         }
-        return {}; // No modifications
+        return { notifications }; // No modifications
     }
     /**
      * Execute a single tool_response hook
      */
     async executeToolResponseHook(hook, session, currentContextTokens, toolResponse) {
-        const maxTokens = getModelMaxTokens(this.model);
+        const maxTokens = getModelContextWindow(this.model);
+        const percentage = (currentContextTokens / maxTokens) * 100;
+        const notifications = [];
+        // Get threshold from settings
+        const settings = hook.setting;
+        const threshold = settings?.maxContextThreshold ?? 80;
+        // Capture start time and emit hook_triggered BEFORE callback runs
+        // This allows the UI to show the loading state immediately
+        const triggeredAt = Date.now();
+        this.emitNotification({
+            type: "hook_triggered",
+            hookType: "tool_response",
+            threshold,
+            currentPercentage: percentage,
+            callback: hook.callback,
+            triggeredAt,
+        }, notifications);
         try {
             // Load and execute callback
             const callback = await this.loadCallback(hook.callback);
@@ -145,31 +179,54 @@ export class HookExecutor {
                 session: sessionWithSettings,
                 currentTokens: currentContextTokens,
                 maxTokens,
-                percentage: (currentContextTokens / maxTokens) * 100,
+                percentage,
                 model: this.model,
                 toolResponse,
             };
             const result = await callback(hookContext);
             // Extract modified output and warnings from metadata
-            if (result.metadata) {
-                const response = {};
-                if (result.metadata.modifiedOutput) {
-                    response.modifiedOutput = result.metadata.modifiedOutput;
-                }
+            if (result.metadata && result.metadata.modifiedOutput) {
+                // Hook took action - emit completed notification
+                const response = { notifications };
+                response.modifiedOutput = result.metadata.modifiedOutput;
                 if (result.metadata.truncationWarning) {
                     response.truncationWarning = result.metadata
                         .truncationWarning;
                 }
+                // Notify completion
+                this.emitNotification({
+                    type: "hook_completed",
+                    hookType: "tool_response",
+                    callback: hook.callback,
+                    metadata: result.metadata,
+                    completedAt: Date.now(),
+                }, notifications);
                 return response;
             }
-            return null;
+            // No action was taken - emit completed with no-op metadata
+            this.emitNotification({
+                type: "hook_completed",
+                hookType: "tool_response",
+                callback: hook.callback,
+                metadata: { action: "no_action_needed" },
+                completedAt: Date.now(),
+            }, notifications);
+            return { notifications };
         }
         catch (error) {
+            // Notify error
+            this.emitNotification({
+                type: "hook_error",
+                hookType: "tool_response",
+                callback: hook.callback,
+                error: error instanceof Error ? error.message : String(error),
+                completedAt: Date.now(),
+            }, notifications);
             logger.error("Tool response hook execution failed", {
                 callback: hook.callback,
                 error: error instanceof Error ? error.message : String(error),
             });
-            return null; // Return original output on error
+            return { notifications }; // Return notifications even on error
         }
     }
 }

package/dist/runner/hooks/types.d.ts

@@ -167,14 +167,17 @@ export type HookNotification = {
     threshold: number;
     currentPercentage: number;
     callback: string;
+    triggeredAt: number;
 } | {
     type: "hook_completed";
     hookType: HookType;
     callback: string;
     metadata?: HookResult["metadata"];
+    completedAt: number;
 } | {
     type: "hook_error";
     hookType: HookType;
     callback: string;
     error: string;
+    completedAt: number;
 };

package/dist/runner/langchain/index.d.ts

@@ -12,5 +12,6 @@ export declare class LangchainAgent implements AgentRunner {
     definition: CreateAgentRunnerParams;
     constructor(params: CreateAgentRunnerParams);
     invoke(req: InvokeRequest): AsyncGenerator<ExtendedSessionUpdate, PromptResponse, undefined>;
+    private invokeInternal;
 }
 export { makeSubagentsTool } from "./tools/subagent.js";

package/dist/runner/langchain/index.js

@@ -14,7 +14,7 @@ import { makeFilesystemTools } from "./tools/filesystem";
 import { makeGenerateImageTool } from "./tools/generate_image";
 import { SUBAGENT_TOOL_NAME } from "./tools/subagent";
 import { hashQuery, queryToToolCallId, subagentEvents, } from "./tools/subagent-connections";
-import { TODO_WRITE_TOOL_NAME, todoWrite } from "./tools/todo";
+import { makeTodoWriteTool, TODO_WRITE_TOOL_NAME } from "./tools/todo";
 import { makeTownWebSearchTools, makeWebSearchTools } from "./tools/web_search";
 const _logger = createLogger("agent-runner");
 const getWeather = tool(({ city }) => `It's always sunny in ${city}!`, {
@@ -27,8 +27,8 @@ const getWeather = tool(({ city }) => `It's always sunny in ${city}!`, {
 getWeather.prettyName = "Get Weather";
 getWeather.icon = "Cloud";
 export const TOOL_REGISTRY = {
-    todo_write: todoWrite,
-    get_weather: getWeather,
+    todo_write: () => makeTodoWriteTool(), // Factory function to create fresh instance per invocation
+    get_weather: getWeather, // TODO: Convert to factory function for full concurrency safety
     web_search: () => makeWebSearchTools(),
     town_web_search: () => makeTownWebSearchTools(),
     filesystem: () => makeFilesystemTools(process.cwd()),
@@ -64,7 +64,12 @@ export class LangchainAgent {
     constructor(params) {
         this.definition = params;
     }
-    async *invoke(req) {
+    invoke(req) {
+        const sessionAttributes = { "agent.session_id": req.sessionId };
+        const generator = this.invokeInternal(req);
+        return telemetry.bindGeneratorToContext(sessionAttributes, generator);
+    }
+    async *invokeInternal(req) {
         // Derive the parent OTEL context for this invocation.
         // If this is a subagent and the parent process propagated an OTEL trace
         // context via sessionMeta.otelTraceContext, use that as the parent;
@@ -184,6 +189,7 @@ export class LangchainAgent {
             "agent.subagent": meta?.[SUBAGENT_MODE_KEY] === true,
             "agent.message_id": req.messageId,
             "agent.session_id": req.sessionId,
+            "session.id": req.sessionId,
         }, parentContext);
         // Create a context with the invocation span as active
         // This will be used when creating child spans (tool calls)
@@ -242,7 +248,12 @@ export class LangchainAgent {
                     else if (type === "filesystem") {
                         const wd = t.working_directory ??
                             process.cwd();
-                        enabledTools.push(...makeFilesystemTools(wd));
+                        const fsTools = makeFilesystemTools(wd);
+                        // Tag filesystem tools with their group name for tool override filtering
+                        for (const fsTool of fsTools) {
+                            fsTool.__groupName = "filesystem";
+                        }
+                        enabledTools.push(...fsTools);
                     }
                     else if (type === "direct") {
                         // Handle direct tool objects (imported in code)
@@ -264,16 +275,25 @@ export class LangchainAgent {
                 if (!entry) {
                     throw new Error(`Unknown built-in tool "${name}"`);
                 }
+                const tagTool = (tool) => {
+                    // Track which built-in group produced this tool so overrides can
+                    // filter by the original config name (e.g. "web_search" filters
+                    // both WebSearch and WebFetch helpers).
+                    tool.__groupName = name;
+                };
                 if (typeof entry === "function") {
                     const result = entry();
                     if (Array.isArray(result)) {
+                        result.forEach(tagTool);
                         enabledTools.push(...result);
                     }
                     else {
+                        tagTool(result);
                         enabledTools.push(result);
                     }
                 }
                 else {
+                    tagTool(entry);
                     enabledTools.push(entry);
                 }
             }
@@ -422,10 +442,10 @@ export class LangchainAgent {
             // Apply tool overrides if provided (Town Hall comparison feature)
             if (req.configOverrides?.tools && req.configOverrides.tools.length > 0) {
                 const allowedToolNames = new Set(req.configOverrides.tools);
-                finalTools = finalTools.filter((t) => allowedToolNames.has(t.name));
-                _logger.debug("Applied tool override filter", {
-                    requested: req.configOverrides.tools,
-                    filtered: finalTools.map((t) => t.name),
+                finalTools = finalTools.filter((t) => {
+                    const groupName = t.__groupName;
+                    return (allowedToolNames.has(groupName ?? "") ||
+                        allowedToolNames.has(t.name));
                 });
             }
             // Create the model instance using the factory
@@ -1110,34 +1130,44 @@ export { makeSubagentsTool } from "./tools/subagent.js";
 function wrapToolWithTracing(originalTool, getIterationContext) {
     const wrappedFunc = async (input) => {
         const toolInputJson = JSON.stringify(input);
-        // Get the current iteration context so the tool span is created as a child
+        // CRITICAL: Get the iteration context synchronously when the tool is invoked.
+        // We must capture both the context AND the parent span at this moment.
         const iterationContext = getIterationContext();
-        const toolSpan = telemetry.startSpan("agent.tool_call", {
-            "tool.name": originalTool.name,
-            "tool.input": toolInputJson,
-        }, iterationContext);
-        // Create a context with the tool span as active
-        const spanContext = toolSpan
-            ? trace.setSpan(iterationContext, toolSpan)
-            : iterationContext;
-        try {
-            // Execute within the tool span's context
-            const result = await context.with(spanContext, () => originalTool.invoke(input));
-            const resultStr = typeof result === "string" ? result : JSON.stringify(result);
-            if (toolSpan) {
-                telemetry.setSpanAttributes(toolSpan, {
-                    "tool.output": resultStr,
-                });
-                telemetry.endSpan(toolSpan);
+        const iterationSpan = trace.getSpan(iterationContext);
+        // Execute the ENTIRE tool operation within the iteration context.
+        // Pass the iteration span explicitly as the parent to avoid relying on AsyncLocalStorage,
+        // which LangChain's internals may break.
+        return await context.with(iterationContext, async () => {
+            // Create tool span as direct child of iteration span by explicitly passing parent context
+            const toolSpan = iterationSpan
+                ? telemetry.startSpan("agent.tool_call", {
+                    "tool.name": originalTool.name,
+                    "tool.input": toolInputJson,
+                }, trace.setSpan(context.active(), iterationSpan))
+                : null;
+            // Create a context with the tool span as active
+            const spanContext = toolSpan
+                ? trace.setSpan(iterationContext, toolSpan)
+                : iterationContext;
+            try {
+                // Execute within the tool span's context
+                const result = await context.with(spanContext, () => originalTool.invoke(input));
+                const resultStr = typeof result === "string" ? result : JSON.stringify(result);
+                if (toolSpan) {
+                    telemetry.setSpanAttributes(toolSpan, {
+                        "tool.output": resultStr,
+                    });
+                    telemetry.endSpan(toolSpan);
+                }
+                return result;
             }
-            return result;
-        }
-        catch (error) {
-            if (toolSpan) {
-                telemetry.endSpan(toolSpan, error);
+            catch (error) {
+                if (toolSpan) {
+                    telemetry.endSpan(toolSpan, error);
+                }
+                throw error;
             }
-            throw error;
-        }
+        });
     };
     // Create new tool with wrapped function
     const wrappedTool = tool(wrappedFunc, {
@@ -1148,5 +1178,6 @@ function wrapToolWithTracing(originalTool, getIterationContext) {
     // Preserve metadata
     wrappedTool.prettyName = originalTool.prettyName;
     wrappedTool.icon = originalTool.icon;
+    wrappedTool.__groupName = originalTool.__groupName;
     return wrappedTool;
 }

package/dist/runner/langchain/otel-callbacks.js

@@ -104,7 +104,15 @@ export function makeOtelCallbacks(opts) {
             // Extract system prompt and serialize messages
             const systemPrompt = extractSystemPrompt(messages);
             const serializedMessages = serializeMessages(messages);
-            // Close previous iteration span if it exists (tools from previous iteration are done)
+            // Close previous iteration span before creating new one.
+            // By the time this function is called for iteration N+1, all tools from
+            // iteration N have been INVOKED (even if still executing asynchronously).
+            // Tool spans are created at invocation time using getIterationContext(),
+            // so they're already anchored to the correct parent iteration span.
+            // It's safe to close iteration N's span now because:
+            // 1. Tool spans from iteration N were created with iteration N's context
+            // 2. Those tool spans execute within their own context (via context.with())
+            // 3. Child operations of tools (like subagents) inherit the tool span's context
             if (localIterationSpan) {
                 telemetry.endSpan(localIterationSpan);
                 localIterationSpan = null;

package/dist/runner/langchain/tools/todo.d.ts

@@ -9,6 +9,29 @@ export declare const todoItemSchema: z.ZodObject<{
     }>;
     activeForm: z.ZodString;
 }, z.core.$strip>;
+export declare function makeTodoWriteTool(): import("langchain").DynamicStructuredTool<z.ZodObject<{
+    todos: z.ZodArray<z.ZodObject<{
+        content: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            in_progress: "in_progress";
+            completed: "completed";
+        }>;
+        activeForm: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, {
+    todos: {
+        content: string;
+        status: "pending" | "in_progress" | "completed";
+        activeForm: string;
+    }[];
+}, {
+    todos: {
+        content: string;
+        status: "pending" | "in_progress" | "completed";
+        activeForm: string;
+    }[];
+}, string>;
 export declare const todoWrite: import("langchain").DynamicStructuredTool<z.ZodObject<{
     todos: z.ZodArray<z.ZodObject<{
         content: z.ZodString;

package/dist/runner/langchain/tools/todo.js

@@ -6,12 +6,15 @@ export const todoItemSchema = z.object({
     status: z.enum(["pending", "in_progress", "completed"]),
     activeForm: z.string().min(1),
 });
-export const todoWrite = tool(({ todos }) => {
-    // Simple implementation that confirms the todos were written
-    return `Successfully updated todo list with ${todos.length} items`;
-}, {
-    name: TODO_WRITE_TOOL_NAME,
-    description: `Use this tool to create and manage a structured task list for your current coding session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
+// Factory function to create a new todoWrite tool instance for each invocation
+// This prevents sharing tool instances across concurrent invocations
+export function makeTodoWriteTool() {
+    const todoWriteTool = tool(({ todos }) => {
+        // Simple implementation that confirms the todos were written
+        return `Successfully updated todo list with ${todos.length} items`;
+    }, {
+        name: TODO_WRITE_TOOL_NAME,
+        description: `Use this tool to create and manage a structured task list for your current coding session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
 It also helps the user understand the progress of the task and overall progress of their requests.
 
 ## When to Use This Tool
@@ -72,13 +75,19 @@ NOTE that you should not use this tool if there is only one trivial task to do.
      - activeForm: "Fixing authentication bug"
 
 When in doubt, use this tool. Being proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully.`,
-    schema: z.object({
-        todos: z.array(todoItemSchema),
-    }),
-});
-todoWrite.prettyName = "Todo List";
-todoWrite.icon = "CheckSquare";
-todoWrite.verbiage = {
-    active: "Updating to-do's",
-    past: "Updated to-do's",
-};
+        schema: z.object({
+            todos: z.array(todoItemSchema),
+        }),
+    });
+    // Add metadata to the tool instance
+    todoWriteTool.prettyName = "Todo List";
+    todoWriteTool.icon = "CheckSquare";
+    todoWriteTool.verbiage = {
+        active: "Updating to-do's",
+        past: "Updated to-do's",
+    };
+    return todoWriteTool;
+}
+// For backwards compatibility, export a default instance
+// NOTE: This instance is shared and should NOT be used in concurrent scenarios
+export const todoWrite = makeTodoWriteTool();

package/dist/telemetry/index.d.ts

@@ -22,6 +22,24 @@ declare class AgentTelemetry {
     private enabled;
     private serviceName;
     private baseAttributes;
+    /**
+     * Build a context that carries additional attributes merged with any existing
+     * attribute context.
+     */
+    createContextWithAttributes(attributes: Attributes, parentContext?: Context): Context;
+    /**
+     * Execute a function within a context that carries the provided attributes.
+     */
+    withAttributes<T>(attributes: Attributes, fn: () => T): T;
+    /**
+     * Execute an async function within a context that carries the provided attributes.
+     */
+    withAttributesAsync<T>(attributes: Attributes, fn: () => Promise<T>): Promise<T>;
+    /**
+     * Bind an async generator to a context so that every iteration runs with the
+     * provided attributes.
+     */
+    bindGeneratorToContext<T, R, N = unknown>(attributes: Attributes, generator: AsyncGenerator<T, R, N>): AsyncGenerator<T, R, N>;
     configure(config: TelemetryConfig): void;
     /**
      * Update base attributes that will be added to all future spans

package/dist/telemetry/index.js

@@ -4,12 +4,60 @@
  */
 import { context, SpanStatusCode, trace, } from "@opentelemetry/api";
 import { logs, SeverityNumber, } from "@opentelemetry/api-logs";
+const ATTRIBUTE_CONTEXT_KEY = Symbol("telemetry:attributes");
 class AgentTelemetry {
     tracer = null;
     logger = null;
     enabled = false;
     serviceName = "@townco/agent";
     baseAttributes = {};
+    /**
+     * Build a context that carries additional attributes merged with any existing
+     * attribute context.
+     */
+    createContextWithAttributes(attributes, parentContext = context.active()) {
+        const existing = parentContext.getValue(ATTRIBUTE_CONTEXT_KEY) ?? {};
+        return parentContext.setValue(ATTRIBUTE_CONTEXT_KEY, {
+            ...existing,
+            ...attributes,
+        });
+    }
+    /**
+     * Execute a function within a context that carries the provided attributes.
+     */
+    withAttributes(attributes, fn) {
+        const ctx = this.createContextWithAttributes(attributes);
+        return context.with(ctx, fn);
+    }
+    /**
+     * Execute an async function within a context that carries the provided attributes.
+     */
+    async withAttributesAsync(attributes, fn) {
+        const ctx = this.createContextWithAttributes(attributes);
+        return context.with(ctx, fn);
+    }
+    /**
+     * Bind an async generator to a context so that every iteration runs with the
+     * provided attributes.
+     */
+    bindGeneratorToContext(attributes, generator) {
+        const ctx = this.createContextWithAttributes(attributes);
+        const boundNext = context.bind(ctx, generator.next.bind(generator));
+        const boundReturn = generator.return
+            ? context.bind(ctx, generator.return.bind(generator))
+            : undefined;
+        const boundThrow = generator.throw
+            ? context.bind(ctx, generator.throw.bind(generator))
+            : undefined;
+        return {
+            next: (value) => boundNext(value),
+            return: boundReturn ? (value) => boundReturn(value) : undefined,
+            throw: boundThrow ? (err) => boundThrow(err) : undefined,
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+        };
+    }
     configure(config) {
         this.enabled = config.enabled ?? false;
         this.serviceName = config.serviceName ?? this.serviceName;
@@ -61,9 +109,11 @@ class AgentTelemetry {
         }
         // Use provided context or get the active one
         const ctx = parentContext ?? context.active();
+        const ctxAttributes = ctx.getValue(ATTRIBUTE_CONTEXT_KEY) ?? {};
         const span = this.tracer.startSpan(name, {
             attributes: {
                 ...this.baseAttributes,
+                ...ctxAttributes,
                 "service.name": this.serviceName,
                 ...attributes,
             },