An AI assistant: a system prompt, a tool palette derived from existing Models / Services, and per-tool implementation bindings. One Assistant produces one backend chat endpoint plus matching frontend clients / chat ViewModels in every configured frontend project. Top-level system prompt the LLM sees. Concatenated with each tool's `Description` to form the full instruction. Multi-line; whitespace inside the element is preserved verbatim, so indent the text the way you want the model to see it. The list of tools the LLM can invoke during a chat. At least one tool is required — an assistant with no tools degrades to a plain chat completion and is better expressed as a hand-coded call. Use <ModelToolset model="X"/> to auto-generate search_<entity> tools backed by the safe WHERE-expression parser. Optional. Service-name bindings injected into the assistant constructor alongside any auto-injected ServiceMethod tools. Each `<Service name="X"/>` adds an `self._x_service` field (Python) / `_xService` field (C#) plus the matching catalog entry in the AI implementation prompt. Use this when a `kind="Custom"` tool needs to call a service whose body lives in the AI-generated method, without first declaring a per-method ServiceMethod tool. Services already reached via `<Implementation kind="ServiceMethod" service="X"/>` don't need to be repeated here. Name of the Service XML reachable via the generator's `-servicePath` flag (matched on the target Service XML's `name` attribute). Same lookup as the `service` attribute on `<Implementation kind="ServiceMethod"/>`. Optional. Per-assistant overrides for the generated CLI frontend (`<Name>CliProgram.cs`). Unset attributes fall back to defaults in `ModelGenerator.json` under the `Cli` key, then to the generator's hard-coded defaults. Omit the element entirely to use all defaults. Required. PascalCase identifier used as the generated assistant class name (e.g. `CustomerSupportAssistant`). Required. Target namespace / package for the generated assistant class and its sidecar DTOs. Optional. Human-readable description of the assistant's purpose. Surfaces in generated docs and the assistant's class-level doc comment; NOT sent to the LLM (use SystemPrompt for that). One LLM-callable tool. Carries the description the LLM sees, the typed input parameter list, the typed return shape, and a binding to the C# / Python that runs when the LLM invokes it (a Service method, a domain function, or a hand-written Custom body). Required. The text the LLM sees when deciding whether to call this tool — include trigger phrases, when-to-use guidance, side-effect warnings. The single highest-leverage attribute for tool-call accuracy: invest more text here than anywhere else in the XML. Optional. Typed inputs the LLM must supply when invoking the tool. Omit for zero-arg tools. Optional. Typed output the tool produces. Single `ReturnParameter` of `model` / `object` type returns the inner type directly (no wrapper); single primitive or two+ ReturnParameters trigger a synthetic DTO named `<ToolName>Result` with one field per parameter. For service-bound tools the bound method's actual return type wins automatically — set this only to project / reshape. Required. How the tool body is provided. Three flavours: bind 1:1 to a Service method, bind to a domain-service function, or declare it Custom (generator emits an abstract stub the AI implementation phase fills in). Required. snake_case identifier used as the literal tool name the LLM invokes (`get_customer`, `update_customer_email`). Must be unique within the Assistant. Optional, default false. When true, generator stitches a "confirm with the user before invoking" hint into the tool's description and tags the tool-def JSON with a metadata flag the chat UI layer can read to render a confirm dialog before the call hits the dispatcher. Optional. Command-level key the dispatcher checks before invoking the tool. Same semantics as Service method's `userRightCommand`. Tools without this attribute inherit the bound service method's `userRightCommand` (when binding is ServiceMethod / DomainMethod). Set explicitly only to override. One typed input on a tool. Same type vocabulary as ServiceSchema's ParameterType (String, Int, Decimal, Money, Bool, Id, DateTime, Date, Json, Xml, File, FilePath, DirPath, Enum, Model, Object). The `documentation` attribute becomes the field's description in the LLM's input_schema — write it for the model, not the dev. Required. snake_case parameter name (matches the field name in the LLM's input_schema). Mapped to camelCase / snake_case automatically per target language. Required. Same type vocabulary as Service parameters: String, Int, Decimal, Money, Bool, Id, DateTime, Date, Json, Xml, Enum (requires `enum`), Model (requires `model`; for collections add `collection="List"`), Object (requires `object`). Required when `type="Model"`. Name of a model XML reachable via the generator's `-modelPath` flag (matched on the target Model XML's `name` attribute). Required when `type="Enum"`. Name of an enumeration declared on a referenced model. Required when `type="Object"`. Name of an externally-defined class / record the parameter binds to. Optional. `List` if the parameter is a collection of `type`. Default is no collection (single value). Optional, default true. When false the parameter is nullable in the LLM's input_schema and the generated dispatcher tolerates a missing value. Optional. Default value used when `mandatory="false"` and the LLM omits the parameter. String form is type-coerced at generation time. Optional but strongly recommended. Becomes the parameter's `description` field in the LLM's input_schema — the model uses this to decide what to put there. Write it for the LLM, not the developer. One typed output field on a tool. Same type vocabulary as ToolParameterType. When ReturnParameters has exactly one entry of `model` / `object` type, the generator returns that inner type directly (single-value short-circuit). Otherwise a synthetic DTO `<ToolName>Result` is emitted with one field per ReturnParameter. For anonymous nested object shapes (e.g. `errors[]` of `{level, message}`), set `type="Object"` and declare the inline shape via a child `<Properties>` element — the generator synthesizes a sibling DTO and wires it in. Optional. When `type="Object"`, declares an inline anonymous shape: list of `<Property>` entries that become fields on a synthesized nested DTO (named `<ToolPascalName>_<ParamPascal>Item`). Use this instead of `object="X"` to avoid having to define a separate top-level Object type for one-off response shapes. Required. Field name on the synthetic response DTO (and the JSON key in the wire payload). camelCase / snake_case handled per target language. Required. Same vocabulary as ToolParameter's `type`. Optional, default true. When false the field is nullable in the response DTO. Compact declaration that expands at generation time into one or more typed tools for a given Model (resolved from the generator's `-modelPath` index). The generated `search_<entity>` tool accepts a LLM-authored WHERE expression using bracketed model identifiers (`[Customer.Status] = @p0`); the runtime parser maps identifiers to columns, resolves FK paths into EXISTS subqueries (forward + reverse + multi-hop), and rejects DML/DDL/UNION keywords. Safer than raw-SQL access: the LLM can only reference properties declared in the model XML. Required. Name of the Model XML to expose. Matched against the workspace's `-modelPath` index. Optional, default true. Emit a `search_<entity>` tool that takes a WHERE expression + paginated args. Optional, default true. Emit a `get_<entity>_by_id` tool that takes a single Id parameter and returns the entity (or null). Optional, default false. Emit an `aggregate_<entity>` tool that takes a WHERE expression, a GROUP BY list, and a structured aggregates list (function from COUNT/SUM/AVG/MIN/MAX). The default body builds the SQL through the safe parser; the host overrides the `ExecuteRawAggregateAsync` virtual hook to wire actual database execution. Optional, default 100. Server-side cap on the `page_size` parameter of the search tool — prevents accidental table dumps even when the LLM asks for more. Optional, default Operational. Picks which generated repository the toolset's emitted helpers bind to. Composes the final repository class name as `{Model}{repositoryName ?? repositoryType}Repository` — same convention as Model XML's <Repository> element. Use Archive to query cold-storage rows, Datawarehouse to hit BI tables. AuditTrail/ArchivePartition are intentionally not exposed: AuditTrail's wide-row shape doesn't fit search-by-property, partitioned-archive routing belongs in a Tool-level binding. Optional. Overrides `repositoryType` for the repository class name's middle segment. Mirrors `<Repository name="X"/>` in Model XML — e.g. `repositoryName="TNVSql"` binds to `{Model}TNVSqlRepository`. Use when the model declares multiple repositories of the same type (the `name` attribute on the <Repository> element disambiguates). Settings that shape the generated `<Name>CliProgram.cs`. Every attribute is optional; the parser layers XML attribute → `ModelGenerator.json:Cli:<PascalName>` → built-in default. The resolved values are baked into the generated program as compile-time constants. UX tier — `auto` (detect TTY, resolves to scrollregion on real terminal, plain on pipes / CI / NO_COLOR), `scrollregion` (bottom input panel + scroll-region scrollback, richest UX — requires ModelGeneratorCsCliRuntime), `inline` (Spectre streaming inline, no fixed bottom panel), `plain` (vanilla System.Console). Default: `auto`. Color scheme for Spectre output — `dark`, `light`, or `none` (no color). Default: `dark`. Authentication to the backend SSE endpoint. `Bearer` reads a token from `{NAME}_ASSISTANT_TOKEN` env var (current default). `WindowsAuth` sends Windows credentials via `UseDefaultCredentials=true` — pairs with backend Negotiate auth. `FormCredentials` prompts for username + password at startup, exchanges them at `/auth/form` for a bearer token, caches it for the session. Mirrors the same-named strategy on Application.xml's `<Auth strategy/>`. Default: `Bearer`. Where the tool's body comes from. Three kinds: - ServiceMethod: bind 1:1 to a Service method declared in a ReferencedService. Generator wires up arg unpacking + the call + return serialization automatically. - DomainMethod: bind to a domain-service function (signature-compatible with a Service method, but lives in a domain class library rather than an exposed service). - Custom: generator emits an abstract method on the assistant class with a `// AI GENERATION REQUIRED` marker; the AI implementation phase fills in the body using ReferencedService clients. Use for composites (call multiple services and join the result) or business logic that doesn't have a single backing method. Required. ServiceMethod, DomainMethod, or Custom. Required when `kind="ServiceMethod"`. Name of a service XML reachable via the generator's `-servicePath` flag (matched on the target Service XML's `name` attribute). Required when `kind="DomainMethod"`. Name of the domain-service class. Required when `kind="ServiceMethod"` or `kind="DomainMethod"`. Method name on the bound class. Must be signature-compatible with the tool's Parameters / ReturnParameters (or, when ReturnParameters is omitted, the method's return type wins). Optional, ServiceMethod only. Default false. Generator-emitted services follow a Foo (abstract domain) / FooBase (concrete wire) split; the dispatcher calls FooBase by default. Set `omitBase="true"` to bind to hand-written services that don't follow that split — the dispatcher then calls `method` verbatim. Becomes redundant after #140 flips the convention (wire = `Foo`, domain abstract = `DoFoo`). Optional, ServiceMethod / DomainMethod only. Default true. When false, the dispatcher emits a plain (non-awaited) call to the bound method. Use this when the bound method is synchronous — avoids wrapping the service in Task.FromResult shims solely to satisfy the dispatcher's await.