Analyze the blast radius of changing a symbol — shows every file, project, and call site affected. Combines find_references and find_callers into a single impact summary. Use before renaming, changing signatures, or removing a type/method.

Symbol name to analyze (type name, 'Type.Method', etc.)

Analyze control flow within a range of statements in a C# method. Returns reachability of start/end points, return statements, and exit points. Useful for detecting unreachable code and understanding branching.

Last line of the statement range (1-based)

Full path to the C# source file

First line of the statement range (1-based)

Analyze data flow within a range of statements in a C# method. Returns variables declared, read, written, captured by lambdas, and flowing in/out of the region. Useful for understanding variable lifecycle before extracting code.

Full path to the C# source file

Get a comprehensive analysis of a method in one call: signature, location, all callers, and all outgoing calls (methods this method invokes). More efficient than calling find_callers separately.

Method symbol (e.g. 'Greeter.Greet' or 'MyNamespace.MyClass.MyMethod')

Apply a code action (refactoring or fix) by its title. Use get_code_actions first to discover available actions. Defaults to preview mode (returns diff without writing files). Set preview=false to apply changes to disk.

Exact title of the code action to apply (from get_code_actions)

Column number (1-based)

End column for text selection (1-based, optional)

End line for text selection (1-based, optional)

Full path to the C# source file

Line number (1-based)

Preview only — return diff without writing to disk (default: true)

Add, remove, or reorder a method's parameters and update every call site (Roslyn's own change-signature engine). Cascades to overrides and interface implementations, rewrites named and optional arguments, and preserves an extension method's `this` parameter; the overrides and implementations it also rewrote are listed in `CascadedTo`. Operations apply in order: `remove` drops `parameter`; `reorder` takes `order`, a full permutation of the parameters surviving at that point; `add` appends `name` plus `type` and REQUIRES `callSiteValue` — the expression every existing call site will pass, since the tool never guesses call-site semantics — with an optional `defaultValue` that instead makes the parameter optional and leaves existing calls untouched. Rejected as unsafe: an added name that is not a valid C# identifier or collides with an existing parameter; a `type` that does not resolve, or resolves ambiguously (qualify it); moving or removing an extension method's `this` parameter (it must stay first); and any signature that would leave a surviving `params` array anywhere but last — add the parameter and reorder it before the `params` array, or remove that array. Defaults to preview mode (returns edits without writing files); set `preview=false` to apply. New compiler errors the change would introduce are reported as Conflicts, and apply mode refuses to write them unless `force=true`. Source-defined methods only; overloaded names must be disambiguated.

Apply even when Conflicts are reported (default: false)

Method to change: `MyClass.MyMethod` or fully qualified `Namespace.MyClass.MyMethod`

Parameter edits applied in order. Each has `kind` (`remove`, `reorder` or `add`) plus: `parameter` for `remove`; `order` for `reorder`; `name`, `type`, `callSiteValue` and optional `defaultValue` for `add`

Preview only — return edits without writing to disk (default: true)

Check user-supplied layering rules against the solution's real semantic type graph (resolved symbols, not `using` directives — so a fully qualified reference with no `using` is still caught, and an unused `using` is not reported). Rule kinds: `forbid` (a dependency from `from` to `to` is a violation) and `allowOnly` (a dependency from `from` to anything outside `to` is a violation). TWO SEMANTICS YOU MUST KNOW TO READ AN EMPTY RESULT CORRECTLY. (1) `allowOnly` evaluates ONLY solution-internal, non-generated targets: references to framework and NuGet namespaces such as `System.Collections.Generic` are ignored (otherwise every file would violate every `allowOnly` rule), and so are types declared entirely in generated code, which the caller cannot remove. To restrict a framework or generated namespace, write an explicit `forbid` — that path DOES evaluate metadata and generated targets. (2) Self-references are always allowed: a scope depending on itself is never a violation, under either kind. Results are grouped per violated `rule` plus `sourceScope` plus `targetScope` edge, each with a full `referenceCount` and the first `maxSitesPerViolation` sites. Sorted by rule order, then by descending reference count. Generated code is never reported as the SOURCE of a violation under either kind. Envelope adds a `byRule` / `totalReferences` / `rulesEvaluated` summary.

Maximum number of items to return (default: 100). Items are sorted by rule order, then by descending reference count.

Maximum example sites recorded per violated edge (default: 5). The full reference count is reported regardless.

Layering rules to evaluate, in priority order. Each is `kind` (`forbid` or `allowOnly`), `from`, `to` (array of patterns), and an optional `description`.

Optional note echoed back on every violation this rule produces.

Source scope pattern: exact (`Demo.Domain`), prefix wildcard (`Demo.Domain.*`, matching that scope and everything beneath it), or `*` for everything.

`forbid` or `allowOnly`.

Target scope patterns, same syntax as `from`. Always an array: for `forbid` give the single forbidden pattern; for `allowOnly` give the full permitted set.

Scope compared by the rules: `namespace` (default) or `project`.

Detect six classes of async/await misuse across all production projects: sync-over-async (.Result, .Wait*, GetAwaiter().GetResult()), async void outside event handlers, missing await in async methods, and fire-and-forget tasks. Returns a summary plus a per-violation list (severity error/warning, location, containing method, snippet). Skips test projects and generated code. Static analysis only — no fix suggestions.

Find all types and members decorated with a specific attribute (e.g., Obsolete, Authorize, Serializable). Returns an envelope with items, totalCount, truncated, limit, and a byProject summary.

Attribute name to search for (with or without 'Attribute' suffix)

Maximum number of items to return (default: 500). Items are sorted by file, then line.

Diff the current solution's public API surface against a baseline (JSON snapshot from a prior get_public_api_surface run, or a baseline .dll file). Reports five change kinds: Removed/KindChanged/AccessibilityNarrowed (Breaking) plus Added/AccessibilityWidened (NonBreaking). Returns a summary plus a per-change list (kind, severity, fully-qualified name, entity kind, project, file, line, details). Sort: Breaking before NonBreaking, then name ASC. Limitations: return type changes, sealed-ness changes, and nullable annotation changes are not detected (PublicApiEntry schema doesn't capture them).

Path to a baseline .json snapshot (from a prior get_public_api_surface call) or a baseline .dll file.

Find every call site for a method. Returns an envelope with items, totalCount, truncated, limit, and a byProject summary.

Method name as Type.Method (simple or fully qualified)

Find the `catch` clauses that handle an exception type across the solution, and say what each one does with it. Each item reports `hasFilter` (a `when` clause, so the handler may decline at runtime), `rethrows` (the body contains a bare `throw;`) and `isEmpty` (an empty handler body) — together these answer 'who is silently swallowing this exception?' in a single call. By default only clauses declaring exactly the requested type match; set `includeBaseClauses` to also surface handlers that catch a base type, including `catch (Exception)` and bare `catch`, since those bind the requested type too. `caughtType` is null for a bare `catch`. The exception type may live in source or in metadata. Returns an envelope with items, totalCount, truncated, limit and a `byType` / `byProject` summary, sorted by file, line, column.

Exception type to search for (e.g. `System.IO.IOException` or `MyApp.DomainException`).

Also match clauses catching a base type of the requested one, including bare `catch`. Default false.

Maximum number of items to return (default: 500).

Detect circular dependencies in the project reference graph or namespace dependency graph. Returns an envelope with items sorted by cycle length desc, totalCount, truncated, and limit (default 100).

Level: 'project' or 'namespace' (default: project)

Maximum number of items to return (default: 100). Items are sorted by cycle length desc.

Detect IDisposable / IAsyncDisposable instances at risk of leaking. Two patterns: local variables holding a disposable that aren't wrapped in using/await using/returned/assigned-to-field-or-out-parameter (warning), and bare-expression-statement discards of a disposable creator/factory (error). Returns a summary plus a per-violation list (severity error/warning, location, containing method, snippet). Skips test projects and generated code. Scope: methods only (not constructors/accessors/operators); ownership transfer via method/constructor argument is not detected. Static analysis only — no fix suggestions.

Find every += and -= site for an event symbol across the solution. Accepts source events (e.g. 'MyClass.Clicked') or metadata events (e.g. 'System.Diagnostics.Process.Exited'). Each result reports the source location, the resolved handler (method FQN, or a synthetic name like 'lambda at File.cs:N' for inline handlers), and the subscription kind (Subscribe for +=, Unsubscribe for -=). Use this for memory-leak audits (compare subscribe/unsubscribe pairs), UI event subscriber inspection, or when Grep over '+= EventName' would miss qualified or fully-typed subscription sites. Returns an envelope with items sorted by file path then line, totalCount, truncated, and limit (default 500).

Maximum number of items to return (default: 500). Items are sorted by file path, then line.

Event symbol (e.g. 'MyClass.Clicked' or 'System.Diagnostics.Process.Exited')

Find types that combine high size with high coupling — 'god classes' that violate single-responsibility and become refactoring nightmares. Sharper signal than find_large_classes alone: a 1000-line internal helper used only by its own namespace is not flagged, but a 200-line class called from 15 different namespaces is. Two axes: size (lines/members/fields) and coupling (incoming/outgoing namespace counts). A type qualifies when it crosses ALL THREE size thresholds AND at least one coupling threshold — keeps DTOs (high field count only) and dispatchers (high member count only) off the list. Defaults: lines >= 300, members >= 15, fields >= 10, incoming-namespaces >= 5, outgoing-namespaces >= 5. Each threshold is independently configurable. BCL namespaces (System.*, Microsoft.*) excluded from outgoing count. Test projects, generated code, interfaces, and nested types are skipped. Sort: total axes exceeded DESC, then line count DESC.

Min field count for size axis. Default 10.

Min incoming-namespace count for coupling axis. Default 5.

Min lines for size axis. Default 300.

Min member count for size axis. Default 15.

Min outgoing-namespace count for coupling axis. Default 5.

Optional: restrict to a single project by name (case-insensitive).

Find all classes/structs implementing an interface or extending a class. Returns an envelope with items, totalCount, truncated, and limit.

Maximum number of items to return (default: 200). Items are sorted by file, then line.

Type name (simple or fully qualified)

Find classes and structs that exceed member count or line count thresholds. Returns an envelope with items sorted worst-first (highest size first), totalCount, truncated, and limit (default 100).

Maximum number of items to return (default: 100). Items are sorted by size desc (worst first).

Maximum lines before flagging (default: 500)

Maximum members before flagging (default: 20)

Optional project name filter

Check .NET naming convention compliance: PascalCase types/methods/properties, camelCase parameters, I-prefix interfaces, _ prefix private fields. Returns an envelope with items, totalCount, truncated, limit (default 500), and a byRule summary.

Maximum number of items to return (default: 500). Items are sorted by rule, then file.

Optional project name filter

Find every call site referencing [Obsolete]-marked symbols in the solution, grouped by deprecation message and severity. Sharper than find_attribute_usages for migration-planning workflows: tells you 'we have 5 distinct deprecations pending; this one has 80 sites and is an error; that one has 3 sites and is a warning.' Includes both source-marked and metadata-marked obsoletes (third-party NuGet deprecations are surfaced too). Symbols with zero usages are omitted (no migration needed). Sort: errors first, then by usage count descending, then by symbol name. Test projects skipped. Project filter is case-insensitive.

If true, only [Obsolete(..., true)] error-level deprecations are returned. Default false.

Find all references to a symbol (type, method, property, field, or event) across the solution, each tagged with a kind. Kinds: `read`, `write`, `readwrite` (compound assignment / `++` / `ref`), `invocation`, `method_group`, `object_creation`, `cast`, `type_check` (`is` / patterns / `as`-tests), `typeof`, `base_type`, `type_constraint`, `type_argument`, `declaration`, `attribute`, `nameof`, `xml_doc`, and `usage` (rare fallback). Pass `kinds` to return only some (e.g. `["write","readwrite"]` for mutation sites). Envelope adds a `byKind` summary. Multiple references on one line are reported separately with a `column`.

Optional kind filter - only references of these kinds are returned (see the kind list above)

Maximum number of items to return (default: 500). Items are sorted by file, line, column.

Symbol name: simple type (`MyClass`), fully qualified (`Namespace.MyClass`), or member (`MyClass.MyProperty`)

Detect dynamic/reflection-based usage like Type.GetType, Activator.CreateInstance, MethodInfo.Invoke. Returns an envelope with items, totalCount, truncated, limit (default 500), and a byKind summary.

Maximum number of items to return (default: 500). Items are sorted by file, then line.

Optional type name to filter results (omit to scan entire solution)

List test methods that exercise the given production symbol. Recognises xUnit, NUnit, and MSTest. Set transitive=true to follow helper methods up to maxDepth levels (default 3, max 5).

Maximum walk depth when transitive=true. Clamped to [1, 5]. Default 3.

Symbol name as Type.Method (simple or fully qualified)

Walk through helper methods to find indirect tests. Default false.

Find every place an exception type is thrown across the solution — `throw new T(...)`, `throw expr;` and bare `throw;` rethrows (whose type comes from the enclosing `catch`). The exception type may live in source or in metadata, so `System.ArgumentNullException` works as well as your own `MyApp.DomainException`. Set `includeDerived` to also match subclasses of the requested type. Every throw in the file is reported, including throws inside lambdas and local functions, attributed to the member that contains them — use `get_exception_flow` instead when the question is which exceptions escape a specific method. Returns an envelope with items, totalCount, truncated, limit and a `byType` / `byProject` summary, sorted by file, line, column.

Exception type to search for (e.g. `System.InvalidOperationException` or `MyApp.DomainException`).

Also match types deriving from the requested one. Default false (exact type only).

Maximum number of items to return (default: 500).

Report public methods and properties that no test method transitively reaches (within 3 helper hops). Output sorted by cyclomatic complexity descending, with a coverage summary including a riskHotspotCount (uncovered with complexity >= 5). Recognises xUnit, NUnit, MSTest. Reference-based static analysis — does not parse runtime coverage data.

Find potentially unused types and members (dead code detection). Checks public symbols for references across the solution. Filters out test methods, MCP tools, source-generator output, MEF-composed services, and interop-laid-out fields. Returns an envelope with items, totalCount, truncated, limit (default 500), and a summary including byKind + filteredOut counts.

Include internal symbols (default: false)

Maximum number of items to return (default: 500). Items are sorted by project, then file.

Optional project name filter

Emits a test-class skeleton (parseable C#) for a method or type. Pass a type FQN like 'MyApp.Services.OrderService' to get a full test class with one stub per public method, or a method FQN like 'MyApp.Services.OrderService.PlaceOrder' to get a single stub. Returns framework, suggested file path, class name, full file contents (as text), and TodoNotes for things to wire up (e.g. constructor dependencies). The tool does NOT write to disk — agent decides what to do with the text. Pairs naturally with find_uncovered_symbols / get_test_summary. Stubs include happy-path Fact, Theory + InlineData for primitive-param methods, and Assert.Throws assertions per distinct direct-throw exception type. Async (Task-returning) methods detected automatically. Properties, indexers, operators, and constructors are excluded from per-method enumeration. Framework auto-detected from solution test projects (tie → xUnit); override with framework='xunit' / 'nunit' / 'mstest'.

Optional framework override: 'xunit', 'nunit', or 'mstest'. Auto-detected if null.

FQN of a type or method to generate a test skeleton for.

Transitive caller and/or callee graph for a method symbol, depth-bounded with cycle detection. Output is an adjacency-list dict per direction (callees and/or callers), where each visited symbol maps to its outgoing edges. Direction: 'callees' (what this method transitively calls), 'callers' (who reaches this method), or 'both'. External (BCL/NuGet) callees appear as terminal leaves with isExternal=true. Declared signature only on callee side — no virtual dispatch resolution; agent uses find_implementations separately if needed. Callers side resolves dispatch naturally via Roslyn SymbolFinder. Hard cap on total visited nodes (default 500) — sets truncated=true if hit; edges to truncated targets are still recorded against the source node. Use this instead of recursive find_callers / analyze_method calls when you need depth > 1.

'callees' (default), 'callers', or 'both'.

Max traversal depth from root. Default 3.

Hard cap on total visited nodes. Default 500.

Method symbol (e.g. 'Greeter.Greet' or 'MyNamespace.MyClass.MyMethod')

List available code actions (refactorings and fixes) at a position in a C# file. Optionally specify endLine/endColumn to select a range for extract-method style refactorings. Returns action titles that can be passed to apply_code_action. Returns an envelope with items sorted by kind then title, totalCount, truncated, and limit (default 100).

Column number (1-based)

End column for text selection (1-based, optional)

End line for text selection (1-based, optional)

Full path to the C# source file

Maximum number of items to return (default: 100). Items are sorted by kind then title.

Line number (1-based)

Get available code fixes for a specific diagnostic at a file location. Returns structured text edits that can be reviewed and applied. Returns an envelope with items sorted by title, totalCount, truncated, and limit (default 100).

Diagnostic ID (e.g., 'CA1822', 'CS0168')

Full path to the source file

Maximum number of items to return (default: 100). Items are sorted by title.

Line number where the diagnostic occurs

Calculate complexity for members (methods, constructors, properties, indexers, operators). Reports both 'complexity' (cyclomatic - the number of paths, starts at 1) and 'cognitive' (how hard the code is to follow, starts at 0 - a 0 is not a bug), plus 'maxNesting'. The 'metric' parameter selects which of the two the threshold filters on and the sort uses. Returns an envelope with items sorted worst-first, totalCount, truncated, limit (default 100), and a summary with max/avg/overThreshold plus maxCognitive.

Maximum number of items to return (default: 100). Items are sorted by the selected metric desc (worst first).

Which metric drives the threshold and the sort: 'cyclomatic' (default) or 'cognitive'. Both are always reported.

Optional project name filter

Minimum complexity threshold, applied to the selected metric (default: 10)

Scan IServiceCollection extension methods for DI registrations of a type. Returns an envelope with items sorted by service name, totalCount, truncated, and limit (default 200).

Maximum number of items to return (default: 200). Items are sorted by service name.

Type name to search for (simple or fully qualified)

List compiler errors and warnings across the solution, optionally including analyzer diagnostics. Analyzer diagnostics require the solution to be trusted (see 'trust_solution'). Returns an envelope with items, totalCount, truncated, limit, and a severity summary.

Include analyzer diagnostics (default: false — requires trust_solution to be called first)

Maximum number of items to return (default: 1000). Items are sorted severity-desc, then file, then line.

Optional project name filter

Minimum severity: 'error' or 'warning' (default: warning)

Which exceptions can escape a method — the 'is calling this safe?' question. Walks the method's callees depth-first (cycle-safe, depth- and node-bounded) collecting every explicit throw, then propagates each one back up the call chain, testing the enclosing `try`/`catch` at the throw and at every call site on the way out. Each item reports `escapes`, the `path` of methods from the analysed method to the one that raises it, and — when it is stopped — `caughtIn`, `caughtFile`, `caughtLine`. A handler with a `when` filter sets `hasFilter` and the exception is still reported as escaping, because the filter may decline at runtime. `origin` is `thrown` for a real throw site in source, or `documented` for an `exception` XML doc tag on a metadata (BCL/NuGet) callee — set `includeDocumented` to false to drop the latter. Throws inside lambdas and local functions are excluded: they escape when that body runs, not at this method's boundary — use `find_throw_sites` for a plain textual scan of throws. Static analysis only: no reflection, no virtual-dispatch resolution, and no implicit runtime failures such as null dereferences. Hitting `maxDepth` or `maxNodes` sets `truncated`.

Include exceptions documented by `exception` XML tags on metadata callees. Default true.

Max callee depth to walk from the analysed method. Default 3.

Hard cap on methods visited. Default 500.

Method symbol to analyse (e.g. `OrderService.Place` or `MyNamespace.MyClass.MyMethod`).

Answer 'what extension members can I call on this type?' — every extension method and C# 14 extension property applicable to a receiver type, from solution source AND referenced metadata (so BCL LINQ such as `Where`, `Select`, `Chunk` is included). Applicability is decided by the compiler's own reduction, not by name matching: `this IEnumerable<T>` is reported for `string` (which is `IEnumerable<char>`) while `this IEnumerable<string>` is not. Each entry carries the reduced call-site signature (receiver dropped, generic inference applied, return type first: `IEnumerable<int> Where<int>(Func<int, bool>)`, `int Tripled`), kind (`method` or `property`), declaring type, namespace, origin (`source` or `metadata`), source file/line for source members, XML doc summary, and `isStatic`. Read `isStatic` before writing the call: false means an instance call (`value.Doubled()`) and is the normal case even though every extension method is DECLARED static; true means a C# 14 static extension member, called on the type itself (`int.Zero`). Results are NOT filtered by `using` scope — the tool has no call-site position, so every applicable member is reported and its namespace is given for you to add the import. Pass a type name: simple (`Widget`), fully qualified (`MyApp.Widget`), a C# keyword (`int`, `string`), a constructed generic (`List<int>`), an array (`string[]`), a nullable (`int?`), or a tuple (`(int, string)`). Sort: source before metadata, then declaring type, then name.

Maximum number of items to return (default: 100)

Optional case-insensitive substring filter on the member name — e.g. `chunk`

Receiver type — e.g. `Widget`, `MyApp.Widget`, `int`, `List<int>`, `string[]`, `int?`, `(int, string)`

Get a summary of a C# file: which types are defined in it and any compiler diagnostics. Useful for quickly understanding a file's contents without reading it. Also accepts .razor/.cshtml markup, resolving it to the C# document its source generator produced.

Full path to the source file (.cs, or .razor/.cshtml)

Inspect generated source code from source generators. Returns an envelope with items sorted by project then file path, totalCount, truncated, and limit (default 200).

File path (or partial match) to filter by

Generator name to filter by

Maximum number of items to return (default: 200). Items are sorted by project, then file path.

Answer 'how do I construct this type?' in one call — accessible constructors, static factory methods declared anywhere in the solution, and DI registrations. Constructors report every parameter's type and name, declared accessibility, whether the constructor is compiler-supplied (`isImplicit` — a struct or a class with no declared constructor still has a usable parameterless one), and whether it is obsolete. Factories are static members returning the type, including ones declared on a DIFFERENT type such as `WidgetFactory.Create()`, with `Task<T>`/`ValueTask<T>` unwrapped and flagged `isAsync`. Instance builder methods are excluded because the builder itself would need constructing. Pass `fromProject` to get `accessible` computed for that project, which honours `InternalsVisibleTo` — this is how you find out whether your test project can reach an internal constructor. Without it, `accessible` is null, meaning NOT COMPUTED — which is not the same as false, so do not read a null as 'you cannot call this'. `requiredMembers` lists members that must be set in an object initializer. `diRegistrations` shows where the type is registered in a container — a registered type is usually meant to be resolved rather than constructed by hand. For interfaces, abstract classes and static classes, `instantiable` is false and `note` explains why; use `find_implementations` to find concrete types.

Optional project name whose viewpoint decides `accessible` (e.g. `MyApp.Tests`).

Type to construct — simple (`Widget`) or fully qualified (`MyApp.Widget`).

Return the full declaration source (XML docs, attributes, signature, body — original formatting) of one or more members by name: methods (all overloads returned), constructors (request as `Widget.Widget` or fully qualified `Ns.Widget.Widget`; nested types need full qualification), properties, indexers (request as `Type.this` or `Type.this[]`), fields, events. Batch-friendly: pass many names in one call instead of reading whole files. Per-item statuses: ok, notFound, ambiguous (with candidates), metadata (use `peek_il` or `inspect_external_assembly`), unsupportedKind (whole types — use `get_type_overview`). Items keep request order.

Member names: simple (`MyClass.MyMethod`) or fully qualified (`Ns.MyClass.MyMethod`)

List NuGet package references for projects in the solution

Optional project name filter (omit to list all)

Return every user-defined operator and conversion operator on a type in one call — source AND metadata. Each entry includes the operator kind (such as +, ==, implicit, explicit, plus all comparison and bitwise operators), full signature, parameter names/types/modifiers, return type, accessibility, an IsCheckedVariant flag for .NET 7+ checked operators (op_CheckedAddition etc.), XML doc summary, and source location (empty for metadata). Includes compiler-synthesized record equality operators. Returns declared operators only — operators do not inherit in C#. Pass a type name, simple or fully qualified (e.g. 'Vector2', 'MyApp.Money', 'System.Decimal'). Sort: kind ordinal ASC, then parameter count ASC, then signature ordinal ASC.

Type name (simple or fully qualified) — e.g. Vector2, MyApp.Money

Return every overload of a method (or constructor) in one call — source AND metadata. Each overload includes the full signature, parameter names/types/modifiers (ref/out/in/params/optional with defaults), return type, accessibility, modifiers (static/virtual/abstract/override/async/extension), generic type parameters, XML doc summary, and source location (empty for metadata). Pass 'Type.Method' for ordinary methods or 'Type.Type' for constructors. Operator overloads are excluded — use get_operators for those. Sort: parameter count ASC, then signature ordinal ASC.

Method or constructor symbol (e.g. 'Greeter.Greet', 'Greeter.Greeter', 'System.Console.WriteLine').

Return the project reference graph (direct and transitive dependencies)

Project name or .csproj filename

Aggregate 7 health dimensions per project in one call: complexity hotspots, large classes, naming violations, unused symbols, reflection usage, async violations, and disposable misuse. Returns counts per dimension plus the top-N hotspots inline (default 5) so the caller can prioritise without follow-up calls. Use this when answering 'how is this project doing?' / 'where should I focus?' / 'what's the technical debt picture?'. Underlying defaults: complexity threshold 10, large-class limits 20 members / 500 lines, unused symbols excludes internals. Test projects are skipped. Project filter is case-insensitive. Sort: projects ASC by name; hotspots sorted by severity proxy per dimension (cyclomatic complexity desc, line count desc, severity enum desc for async/disposable).

How many hotspots to include per dimension. Default: 5. Pass 0 for counts-only output.

Optional: restrict to a single project by name. Default: whole solution, grouped per project.

Enumerate every public and protected type and member declared in production projects of the active solution. Returns a deterministically-sorted (name ASC) flat list of API entries (kind, fully-qualified name, accessibility, project, file, line) plus per-kind/per-project/per-accessibility summary buckets. Skips test projects, generated code, compiler-generated members, internal symbols, and protected members on sealed types (unreachable). Inherited members are not repeated under derived types — only declared members appear.

List source generators and their output per project. Returns an envelope with items sorted by project then generator name, totalCount, truncated, and limit (default 100).

Maximum number of items to return (default: 100). Items are sorted by project, then generator name.

Optional project name filter

One-shot context dump for a type: namespace, base class, interfaces, injected dependencies, public members

Type name (simple or fully qualified)

Get the current status of a background task by its taskId.

The taskId returned by start_background_task

Per-project inventory of test methods. Each test reports framework (xUnit/NUnit/MSTest), attribute kind ([Fact]/[Theory]/[Test]/[TestCase]/[TestMethod]/[DataTestMethod]), data-driven row count, location, and the production symbols it references. Complements find_tests_for_symbol (which goes test → production); this goes project → tests. Use to answer 'what does this test suite cover?' or to break down test counts by framework/attribute. Production projects, generated code, and BCL/framework calls are filtered out of the per-test referenced-symbols list. Project filter is case-insensitive. Sort: tests by (file, line); projects by name ASC.

Optional: restrict to a single test project by name (case-insensitive).

Walk up (base classes, interfaces) and down (derived types) from a type

Type name (simple or fully qualified)

Get a comprehensive overview of a type in one call: full context (namespace, base class, interfaces, members, DI dependencies), type hierarchy (bases, interfaces, derived types), and diagnostics in the file. More efficient than calling get_symbol_context + get_type_hierarchy + get_diagnostics separately.

Type name (simple name or fully qualified)

Find the source file and line where a symbol is defined. Returns an envelope with items, totalCount, truncated, and limit.

Maximum number of items to return (default: 50). Items are sorted by file, then line.

Symbol name: simple type (MyClass), fully qualified (Namespace.MyClass), or member (MyClass.DoWork)

Inspect a referenced closed-source assembly. mode='summary' returns namespaces + type counts; mode='namespace' returns public types and members for the given namespace.

Assembly name, e.g. 'Newtonsoft.Json' or 'Microsoft.Extensions.DependencyInjection.Abstractions'

'summary' (default) or 'namespace'

Required when mode='namespace'

List background tasks that are running or completed within the last 5 minutes.

Maximum number of items to return (default: 50)

List all solutions loaded by this server, showing which one is currently active. Each entry includes any projects that were skipped during load (e.g. legacy non-SDK-style projects), with the kind and reason for each skip. Returns an envelope with items sorted by solution path, totalCount, truncated, and limit (default 50).

Maximum number of items to return (default: 50). Items are sorted by solution path.

Return the current trust state: session-scoped paths, persistent paths, trusted roots, and analyzer policy.

Load a .sln/.slnx solution at runtime and make it the active solution. Both `include` and `rootProjects` match against the project FILE NAME without extension (the .csproj/.vbproj base name), NOT the assembly name. Pass `include` (case-insensitive glob array, supporting only `*` and `?` wildcards — character classes like `[...]` are NOT supported) or `rootProjects` (EXACT, case-sensitive file names) to load only a subset; the loader walks ProjectReference transitively from those seeds to keep the workspace semantically complete. A filter that matches NO project is an ERROR (the call fails) — it does NOT silently fall back to a full load; if unsure of exact names, do a no-filter load first and call list_solutions to discover them. If the same `path` is already loaded, providing a new filter disposes the previous workspace (replace semantics). If the solution is already loaded with no filter, it simply activates it (~instant). New solutions take ~3 seconds to load and compile. For very large solutions (hundreds of projects) that take minutes to open, pass `background: true` to return a taskId immediately instead of blocking; poll it with get_task_status until it succeeds (its result carries the loaded/skipped counts). The new solution only becomes active once the background load finishes, so other tools keep working against the current solution meanwhile.

If true, load on a background task and return a taskId immediately (poll with get_task_status) instead of blocking until the solution is ready. Default false.

Optional case-insensitive glob patterns against project file name without extension (e.g. 'MyApp.*')

Full path to the .sln or .slnx file to load

Optional exact project file names without extension; both arrays act as seeds for a transitive ProjectReference closure

Return ilasm-style IL for a single method in a referenced closed-source assembly. Input must be a fully-qualified method name with parameter types.

Fully-qualified method name with parameter types, e.g. 'Newtonsoft.Json.JsonConvert.SerializeObject(object)'

Force a full reload of the analyzed solution — re-opens the .sln, recompiles all projects, and rebuilds all indexes. Use after changing Directory.Build.props, adding/removing NuGet packages, or when diagnostics seem stale.

Safely rename a type or member across the entire solution (Roslyn Renamer). Cascades to references, constructors, overrides, nameof, and XML doc crefs. Defaults to preview mode (returns edits without writing files); set preview=false to apply. New compiler errors the rename would introduce are reported as Conflicts, and apply mode refuses to write them unless force=true. Locals/parameters and file renames are not supported.

Apply even when Conflicts are reported (default: false)

New name — a bare C# identifier, e.g. 'OrderProcessor'

Preview only — return edits without writing to disk (default: true)

Also rewrite occurrences inside comments (default: true)

Also rewrite occurrences inside string literals (default: false)

Rename all overloads of a method together (default: true; false renames a single arbitrary overload)

Symbol to rename: simple type (MyClass), fully qualified (Namespace.MyClass), or member (MyClass.MyMethod)

Map a pasted .NET stack trace to file/line/symbol against the loaded solution, undoing compiler name mangling: async/iterator state machines (`<M>d__N.MoveNext`), lambdas (`<>c` / `<>c__DisplayClass`), local functions (`g__Name|`), generic arity. Handles Exception.ToString() output, log-prefixed lines, inner-exception chains, and Ben.Demystifier-style traces. Frames without 'in file:line' get the declaration site; frames with it keep the exact location. External frames resolve with origin=metadata. Items are in original trace order.

Maximum number of items to return (default: 500)

The stack trace text, pasted as-is (multi-line)

Remove a previously trusted solution path or trusted root. Removes both session and persistent entries.

Absolute path of the solution or trusted root to revoke

Search for types, methods, properties, and fields by name (case-insensitive substring match). Returns an envelope with items sorted by match quality (exact → prefix → substring), totalCount, truncated, limit (default 200), and a byKind summary.

Maximum number of items to return (default: 200). Items are sorted by match quality.

Search query (substring match against symbol names)

Switch the active solution. All subsequent tool calls will operate on the selected solution. Use a partial, case-insensitive name (e.g. 'MyProject' matches 'C:/code/MyProject/MyProject.sln'). Returns the full path of the newly active solution.

Partial or full solution name/path to match

Queue a long-running tool to run in the background. Returns a taskId; poll with get_task_status. Allowed tools: rebuild_solution.

Tool name to run in the background. Currently allowed: rebuild_solution.

Mark a solution path (or directory root) as trusted for analyzer execution. Required before get_diagnostics will load Roslyn analyzer DLLs from the solution. Always confirm with the user before calling this tool — analyzer DLLs run as in-process code.

Absolute path to a .sln/.slnx file, or a directory when scope='addRoot'

'session' (in-memory only, default), 'persistent' (write to trust.json), or 'addRoot' (trust the directory and all solutions under it)

Unload a previously loaded solution to free memory. Use a partial, case-insensitive name (e.g. 'DcpCore' matches the full path). If the unloaded solution was active, another loaded solution becomes active. Use this when you're done analyzing a codebase and want to reclaim memory.


Get the complete documentation for a specific item. Supports exact names and common aliases. If the exact name isn't found, provides intelligent suggestions based on fuzzy matching.

Exact name or common alias. Examples: "maz-btn" or "MazBtn" for components, "useToast" for composables, "tooltip" for directives

Type hint to improve search accuracy (optional). Use "auto" to search all types.

auto component guide composable directive plugin helper

list

Browse all available Maz-UI documentation grouped by category. Returns a structured list with counters per category and for each item: name, displayName, description. Use this tool to discover what components, composables, directives, plugins, helpers, and guides are available. Examples: list all docs, list only components, list composables.

Filter by documentation category. Use "all" or omit to see everything.

all component guide composable directive plugin helper

search

Search across ALL Maz-UI documentation using a powerful unified search engine. Combines exact name matching, tag/alias matching, and full-text content search with TF-IDF scoring. Use this tool for any search query: component names (e.g. "MazBtn"), functional descriptions (e.g. "date picker"), prop names (e.g. "model-value"), use cases (e.g. "form validation"), or aliases (e.g. "modal" for dialog). Returns ranked results with contextual snippets.

Optional filter to restrict results to a specific documentation category

Maximum number of results to return (default: 10)

Search query — can be a component name, description, prop name, use case, or alias. Examples: "button", "MazDialog", "model-value", "phone number input", "lazy loading"


Given an ECCN and a destination country, report whether the Commerce Country Chart requires an export licence, and which reasons for control trigger it. Use this when someone is about to ship or transfer a controlled item abroad and needs the licence question answered before it moves. Returns the triggering reasons with the scope text from the Control List entry, because many controls apply to only part of an entry, plus any controls that are not decided by the chart at all. A `false` result means the chart alone does not require a licence; it is not clearance to export, and it says nothing about the Entity List, embargoes, end-use controls, or whether the ECCN is the right one. An entry the chart does not decide returns `indeterminate` with its requirement text instead of a verdict, which is an unanswered question rather than a negative answer. This tool cannot classify an item into an ECCN and will not try.

Every verdict carries its own evidence and you should report it rather than the boolean alone. `checked` lists each chart cell that was read and what it held, so a negative answer can be verified against 15 CFR part 738 Supplement No. 1 without trusting this server; `footnotes` carries row conditions this tool does not apply and which can change the answer; `sourceEdition` says which CFR edition the tables came from, and a snapshot older than the current regulation gives a stale answer that still reads as confident.

Destination country as spelled on the Commerce Country Chart, e.g. Japan or Korea, South.

Export Control Classification Number, e.g. 3A001. Digit, letter A to E, three digits.

Possible destinations, when the country name matched more than one row.

Every chart-determined control on the entry, each with the column read, its reason code, the scope it applies to, and whether that column is marked for this destination. This is the citation for the verdict and it is the only way to check a `licenseRequired: false`, which otherwise arrives as a bare boolean. Verify it against 15 CFR part 738 Supplement No. 1 before relying on a negative answer.

Controls on this entry that the chart does not decide, with the requirement text verbatim.

The chart row that was matched.

Every control column marked for this destination on the chart row, whether or not it bears on this ECCN.

The normalised ECCN.

Footnotes on this chart row, each with its number and text. **They can change the answer and this tool does not apply them.** Footnote 6 is the Russia and Belarus sanctions and footnote 8 is Crimea. A `licenseRequired: false` on a row carrying footnotes is not a clear result until the footnote text has been read.

Whether the country chart requires a licence. Present only when status is `ok`. False does not mean the export is permitted.

Why no verdict was returned, when status is not `ok`.

What this answer does not address. Always present on an answered lookup.

The CFR edition the tables were taken from. Present on every response, including errors. Data older than the current regulation is a stale answer, not a wrong one, and the regulation is the authority.

Outcome of the lookup. Only `ok` carries an answer. `embargoed` means the chart does not govern the destination. `indeterminate` means the entry has no country-chart control in this data and the chart cannot answer for it, which is not the same as no licence being required. `ambiguous_country` means the name matched more than one row and you must ask which was meant.

The Control List entry heading.

Each control whose chart column is marked for this destination, with its scope caveat.

Does the country chart require an export licence

Expand a reason-for-control code such as NS, AT or CB into its full name. Use this when reading a Control List entry or a chart column and the two-letter code is not obvious. Returns the code and the name it stands for, or the whole glossary when called with no argument. This is a glossary lookup only: it reports what a code means, never whether that control applies to anything you are shipping, and it cannot tell you whether a licence is required.

A two-letter reason code, e.g. NS. Omit to list all of them.

The code, uppercased.

Every known code, when none was given.

What the code stands for.

Outcome of the lookup.

Expand a reason-for-control code

Return the Commerce Country Chart row for a destination: which of the sixteen control columns are marked, with each reason expanded. Use this to see how heavily controlled a destination is, or to check the chart's spelling of a country before another lookup. Special-controls destinations such as Cuba, Iran, North Korea and Syria return `embargoed` with a referral, because the chart does not govern them and reading a blank row as permission would be badly wrong. A marked column means a licence is required for items controlled for that reason; it says nothing about any particular item until you pair it with an ECCN.

Destination country name, e.g. Germany.

Possible destinations, when the name matched more than one row.

Marked control columns, each with its reason code and expanded name.

The chart row that was matched.

Chart footnotes on this row, each with its number and text. They carry conditions the grid cannot show, such as the Russia and Belarus sanctions and the Crimea controls, and they can change the answer.

Where to look instead, for a special-controls destination.

Which control columns a destination carries

Look up one ECCN on the Commerce Control List and return its title, its reasons for control, and the chart column each reason maps to. Use this to understand why an item is controlled, or to see the scope caveats before relying on a licence answer, since a control often applies to only some sub-paragraphs of an entry. Some entries are not decided by the country chart at all, and those return `chartDetermined: false` with the requirement text instead, or `indeterminate` when the entry carries no chart control at all. Knowing an entry's reasons for control does not tell you whether a licence is required for a destination; pass the ECCN to check_export_license for that. This tool cannot tell you whether an item falls under this ECCN.

Export Control Classification Number, e.g. 5A002.

Whether any control on this entry is decided by the country chart.

Each control, its scope text, and the chart column or other requirement it maps to.

The normalised ECCN.

Reason-for-control codes on the entry, with their expanded names.

The entry heading as published.

Read a Control List entry's reasons for control


Phase 2 of edgegate_setup_byo_storage. Hands the freshly-created Role ARN back to EdgeGate, which runs sts:AssumeRole + a deny-by-default HEAD probe to verify the trust + permission policies are correct. Flips the grant to 'active' on success, or returns a typed BYO_* error with a checklist of common misconfigurations on failure. Re-callable with the same role_arn after fixing IAM.

ARN of the IAM role created in step 3 of edgegate_setup_byo_storage. Format: arn:aws:iam::<account-id>:role/<name>. EdgeGate will sts:AssumeRole this immediately to verify the trust + permission policies are correct.

Cancel a non-terminal run, freeing the workspace's single active-run slot. Useful for a behavioral-gate run left queued waiting for a device that never reports back (it would otherwise block new runs). 409 if the run is already terminal.

Run to cancel. Frees the workspace's single active-run slot.

Trigger a reference-oracle capture — the known-good baseline the Behavioral Gate diffs against. Specify EXACTLY one flavor: hf_repo (auto-FP16, EdgeGate runs the un-quantized same model), reference_upload_artifact_id (golden, customer-supplied), or endpoint_id/http (an API or workflow endpoint — n8n, Zapier, Make, or any OpenAI-compatible API; EdgeGate calls it once per case, nothing to install). Returns a job_id to poll. Requires workspace admin access.

Decode settings, e.g. {"seed": 0}. Defaults to an empty object.

http flavor: a saved endpoint id from edgegate_list_workflow_endpoints. EdgeGate calls it once per case and stores the baseline — no CLI, nothing to install. Mutually exclusive with `http`.

Published eval-set artifact id (the artifact_id from edgegate_publish_eval_set).

auto-FP16 flavor: HF repo EdgeGate runs un-quantized as the oracle.

http flavor: inline endpoint descriptor {endpoint_url, transport, request_template, response_text_path, ...}. Mutually exclusive with `endpoint_id`; prefer endpoint_id so the baseline and the later gate provably target the same endpoint. Must NOT contain credentials.

golden flavor: a customer-supplied reference upload artifact id.

System prompt the reference oracle is captured under.

Change a member's role in this workspace. Cannot downgrade the last owner — promote another member to owner first. Requires owner role.

The new role. Requires the caller to be a workspace owner.

Target member's user_id (from `edgegate_list_members`).

Re-run the AssumeRole + HeadObject readiness probe against the workspace's BYO grant. Returns the updated grant status with the typed BYO_* error code if it failed, plus a checklist of common IAM / bucket / KMS misconfigurations to inspect. Requires admin role.

Poll a genie-compile job. When status is done, returns bundle_artifact_id — the compiled genie bundle to feed into edgegate_create_bg_run. Requires workspace admin access.

The job_id returned by edgegate_compile_genie.

Poll an LLM compile job. Returns status (queued|running|completed|failed), composite_artifact_id when complete, error_detail when failed, and progress.compile_jobs_done / total.

Poll a reference-capture job. When status is done, returns reference_artifact_id — an ArtifactKind.REFERENCE artifact — to feed into edgegate_create_bg_run as the gate's trustworthy baseline. Requires workspace admin access.

The job_id returned by edgegate_capture_reference.

Get the current status of an EdgeGate run, including per-device metrics and which gates passed or failed.

Diff two EdgeGate runs in the same pipeline — metrics delta, gate flips (✓→✗ regressions and ✗→✓ recoveries), per-device breakdown, and an overall verdict (REGRESSION / IMPROVEMENT / NEUTRAL / NO BASELINE). When baseline_run_id is omitted, auto-selects the most recent PASSED run from the same pipeline as the baseline.

Baseline to compare against. When omitted, auto-selects the most recent PASSED run from the same pipeline (excluding the candidate itself), or the most recent completed run as a fallback.

Candidate run to evaluate

Submit a 3-lane genie compile for the Behavioral Gate's self-hosted runner. Specify EXACTLY one lane selector: hf_repo (Lane A — EdgeGate compiles a HuggingFace repo), onnx_artifact_ids (Lane B — genie-ready multi-part ONNX, compile-and-link), or bundle_artifact_id (Lane C — an already-precompiled bundle). Returns a job_id to poll. Requires workspace admin access.

Lane C: an already-precompiled genie bundle artifact id.

Target device chipset id the bundle compiles for, e.g. sm8550.

Lane A: a HuggingFace repo id EdgeGate compiles into a genie bundle.

Lane B: genie-ready multi-part ONNX artifact ids to compile-and-link.

Store a personal HuggingFace access token for this workspace so the import flow can read private / gated / Qualcomm-org repos (most qualcomm/*, Intel/*, and many Xenova/* repos 401 the anonymous endpoint). The token is validated against HF whoami before encryption and is never echoed in plaintext. If an integration already exists this tool rotates the token. Requires admin role.

Personal HuggingFace access token (starts with hf_). Generate one at https://huggingface.co/settings/tokens — Read scope is enough for the import flow.

Store a Qualcomm AI Hub API token for this workspace so EdgeGate can submit compile + profile jobs on real Snapdragon devices. The token is encrypted at rest and is never returned in plaintext after the initial connect. If an integration already exists this tool transparently rotates the token. Requires admin role.

Qualcomm AI Hub API token. Generate one at https://app.aihub.qualcomm.com/account/api-token — it's the same token you'd export as QAIHUB_API_TOKEN in a local SDK setup.

Create a new API key for this workspace. The plaintext token is returned EXACTLY ONCE in the response — copy it to your CI secrets or local env immediately. Requires Pro tier or above. Requires owner role.

Optional ISO-8601 expiry timestamp. Omit for a non-expiring key (you can always revoke it manually).

Human-readable label for the key, e.g. "GitHub Actions production" — you'll need this later to identify which key to rotate or revoke.

Wire what you are gating + a published eval set + a reference oracle into a behavioral-gate Run. Three targets: a compiled genie bundle (bundle_artifact_id, runs on-device via the self-hosted runner), an on-device LLM (geniex_model), or an API or workflow endpoint (endpoint_id/http — n8n, Zapier, Make, OpenAI-compatible; EdgeGate executes it by default, so nothing is installed, and results are tagged API-verified rather than hardware-certified). Errors with a mismatch hint when the reference was captured against a different eval-set version (eval_set_sha256 differs) or a different endpoint. Requires workspace admin access.

Compiled genie bundle artifact id from edgegate_check_genie_compile_status. Omit for an API/workflow gate (vendor='http') — an endpoint has no compiled bundle.

Decode settings, e.g. {"seed": 0}. Defaults to an empty object.

Human-readable device label, e.g. "Samsung Galaxy S23 Ultra / Snapdragon 8 Gen 2 (SM8550)".

API/workflow gate: a saved endpoint id from edgegate_list_workflow_endpoints. Mutually exclusive with `http`. Prefer this over an inline descriptor — the baseline and the gate then provably target the same endpoint.

Published eval-set artifact id from edgegate_publish_eval_set.

Who makes the calls for vendor='http'. 'hosted' (default) — EdgeGate's workers, nothing to install. 'runner' — your own box via edgegate-runner, for endpoints EdgeGate cannot reach or when raw model output must not leave your network.

GenieX on-device LLM: the model name as it appears in the device's GenieX model cache, e.g. 'Llama-3.2-3B-Instruct'. Use with vendor='qualcomm-geniex'.

API/workflow gate: inline endpoint descriptor {endpoint_url, transport, request_template, response_text_path, ...}. Mutually exclusive with `endpoint_id`. Must NOT contain credentials — the backend 422s on secret-like keys because runner_config_json is readable by any workspace viewer.

Reference-oracle artifact id from edgegate_check_reference_capture_status.

ISO 26262 traceability: maps a gate/signal name to its safety requirement id + ASIL, e.g. {"forbidden_action": {"requirement_id": "SR-CABIN-014", "asil": "B"}}. Surfaced by edgegate_export_compliance_report.

System prompt the run executes under. Defaults to empty.

Runner vendor. Defaults to "qualcomm".

Create a new behavioral eval set with its first draft version. Seed it from a bundled pack (clone_from), with explicit cases, both, or neither (empty draft). Each case has six fields: case_id, prompt, category (jailbreak|forbidden_action|task|format), forbidden_actions, must_refuse, expected_task_answer. Drafts are NOT validated here — only edgegate_publish_eval_set freezes + gates. Requires workspace write access.

Explicit list of case dicts. May be combined with clone_from or used instead. Omit both to start with an empty draft.

A pack id from edgegate_list_eval_packs; seeds the draft with that pack's cases.

Create a new EdgeGate regression pipeline. Define which model(s), which device(s), and which gates (e.g. inference_time_ms ≤ 10) the pipeline will enforce. For LLMs: set llm_compile_source on a model instead of artifact_id. EdgeGate will compile + link via AI Hub on first run; subsequent runs reuse the cached composite. ttft_ms + tps gates work; both are derived from per-component profile (prompt-role inference_time → TTFT; 1000/token-role inference_time → TPS). Each LLM gate run = 3 AI Hub profile jobs (one per component) ≈ 3× CV cost.

Element dtype

Tensor shape (1–8 positive integers)

Optional. Override AI Hub input shapes per named input. For text models like MiniLM, try `{input_ids: {shape: [1, 128], dtype: "int64"}, attention_mask: {shape: [1, 128], dtype: "int64"}}`. Omit to let EdgeGate auto-detect from the ONNX file (works for most models including image classification, BERT-family, MiniLM).

Create a new promptpack in an EdgeGate workspace. A promptpack defines the test cases (prompts, expected outputs, per-case overrides) that regression pipelines evaluate. Requires admin role on the workspace. Packs are immutable after creation — bump the version to update.

Save an API/workflow endpoint so a behavioral gate can target it. This is the ONLY way to gate an authenticated endpoint: the credential is stored envelope-encrypted here and is never returned, whereas an inline `http` descriptor is rejected (422) if it carries one. Using a saved endpoint also lets EdgeGate refuse a run whose endpoint differs from the baseline's. Requires workspace admin access.

https URL EdgeGate will call. Internal targets (loopback, RFC1918, link-local, the cloud metadata IP) are refused with 422.

Model name, for openai_chat transports.

Human-readable label, e.g. 'support workflow'.

Webhook body shape with {{prompt}} and {{case_id}} placeholders, e.g. {"chatInput": "{{prompt}}", "case_id": "{{case_id}}"}. Match your workflow's own input field — n8n often nests it under body.

Dotted path to the reply text in the response, e.g. 'reply' or 'json.output'. Verify it with edgegate_probe_workflow_endpoint before capturing a baseline.

Dotted path to tool calls in the response, if the workflow emits them.

Bearer credential for the endpoint. Stored envelope-encrypted and never returned by any read path — only has_secret and secret_last4 are visible afterwards. This is the only supported way to gate an authenticated endpoint.

'webhook' for n8n/Zapier/Make (posts request_template, reads response_text_path); 'openai_chat' for an OpenAI-compatible /chat/completions API. Defaults to openai_chat.

Create a new EdgeGate workspace. The caller automatically becomes the owner. Subject to plan-tier workspace limits. After creation, connect Qualcomm AI Hub and define pipelines as usual.

Display name for the new workspace, e.g. "MobileNet Production".

Delete the workspace's BYO storage grant. EdgeGate stops attempting to read from your bucket. Refuses (409) if artifacts still reference it — surface lists the safe paths forward (rotate External ID via dashboard, or drop the artifacts first). Destructive. Requires owner role.

Permanently delete the workspace's HuggingFace integration. Future HF imports fall back to anonymous access. Requires owner role.

Permanently delete the workspace's Qualcomm AI Hub integration. Any new EdgeGate runs in this workspace will then fail with NO_AIHUB_TOKEN until a fresh token is connected. Requires owner role.

Export the compliance-preset report for a run (e.g. ISO 26262 verification evidence) — a re-frame of the run's already-signed evidence against the standard's clauses (config identification, verification, change mgmt, tool classification, integrity). Verification evidence, NOT a compliance certification. The formatted assessor PDF is on the dashboard run page.

Compliance preset. Default "iso26262".

Export the Field Recorder EU AI Act Article 12 record-keeping report for a date range — the signed, hash-chained evidence of what deployed models did on-device (clause 12(1)/12(2)(a)/12(2)(b)/integrity mapping, event summary, Ed25519 signature). Verification evidence, NOT a compliance certification. The formatted assessor PDF is on the Field Recorder dashboard page.

Optional — restrict the report to a single device.

Start of the reporting period (ISO 8601, e.g. 2026-06-01).

End of the reporting period (ISO 8601, e.g. 2026-07-01).

Download a human-readable markdown report for an EdgeGate run and save it to disk. Returns the absolute file path plus a preview of the first 30 lines. Optionally includes a run-vs-baseline diff section (include_diff=true).

When true, also fetches the run-vs-baseline diff and appends a diff section to the report.

Where to write the markdown file. Defaults to `./edgegate-run-{id-short}.md` in the current working directory. If a directory, the file is named `edgegate-run-{id-short}.md` inside it. Supports `~` and relative paths.

Get the signed audit report PDF URL for a completed EdgeGate run. Used for compliance records.

Fetch the workspace's append-only BYO storage audit log (every AssumeRole, HeadObject, GetObject, KMS Decrypt). Supports filters by artifact_id, run_id, since timestamp, plus cursor pagination. Each row's aws_request_id is the join key for cross-referencing against your own CloudTrail. Requires admin role.

Filter to events referencing this artifact.

Opaque cursor returned by a previous call. Pass it back verbatim to fetch the next page; omit on the first call.

Page size (1–500, default 100).

Filter to events from this run.

ISO-8601 timestamp; only include events newer than this.

Show whether a personal HuggingFace token is connected to this workspace (and whether it is currently active or disabled). Does not return the token itself.

Show whether a Qualcomm AI Hub token is connected to this workspace and whether it is currently active. Does not return the token itself.

List recent EdgeGate runs in a workspace with status, duration, and trigger.

Import a public Hugging Face model that contains a pre-built ONNX file. EdgeGate downloads the file and registers it as an Artifact. Returns the artifact_id you can pass directly to edgegate_create_pipeline. Polls until the import completes by default (poll_for_completion=true); set to false to return immediately with the job id.

Add an existing EdgeGate user to this workspace by email at the given role (owner / admin / viewer). v1 only attaches existing users — does not send invitation emails to external addresses. Requires admin role; only owners can add other owners.

Their role in this workspace. `owner` = full control including billing and member management; `admin` = can manage pipelines and runs but not billing or delete the workspace; `viewer` = read-only.

Email of an existing EdgeGate user to add. The user must already have an EdgeGate account — this tool does NOT send invitation emails to external addresses (v1 only attaches existing users).

List all API keys in this workspace (id, name, prefix...suffix, status, last_used). Plaintext is never returned. Requires owner role.

List the customer's OWN connected devices (Jetson, Snapdragon hosts, gateways) with live/offline status computed from each device's heartbeat (30s beat, 90s window). This is the workspace fleet connected via `edgegate-runner agent` — NOT the global AI Hub catalog (use edgegate_list_devices for that). If empty, the response includes copy-paste connect instructions for the customer.

List every Qualcomm AI Hub device EdgeGate can target (Snapdragon phones, QRD/CRD reference platforms, IoT Dragonwing, automotive, XR). Returns a markdown table grouped by category. Use the `id` column verbatim when building a `create_pipeline` device matrix. No workspace_id needed — the catalog is global.

Optional form-factor filter. Omit to return the full catalog grouped by category.

smartphone reference compute iot automotive xr

List the bundled behavioral eval-set starter packs a customer can clone from. Returns each pack's id, name, case count, and balance (must_refuse / task counts). Clone one into a new eval set via edgegate_create_eval_set(clone_from=<id>). No workspace_id needed — the pack library is global.

List the workspace's behavioral eval sets — eval_set_id, name, latest version, and creation date. Use the eval_set_id with the update / publish / new-version tools.

List all members of this workspace with their email + role. Requires at least viewer role.

List all promptpacks in an EdgeGate workspace. Returns a markdown table with promptpack_id, version, case count, published status, and creation date. Use include_unpublished=false to hide draft packs.

When false, hides packs with published=false (client-side filter). Default: true.

List the workspace's saved API/workflow endpoints — the targets of an API gate (n8n, Zapier, Make, or any OpenAI-compatible API). Returns each endpoint_id to pass to edgegate_capture_reference and edgegate_create_bg_run. Credentials are never returned; only whether one is stored and its last 4 characters.

Submit a multi-component LLM compile + link job via Qualcomm AI Hub. Returns a compile_job_id; poll with edgegate_check_llm_compile_status. Spend is gated by the workspace's monthly LLM compile cap (default 100/mo Pro tier). Each compile produces a composite QNN_DLC linked model + 3 component artifacts (prompt / token / kv_cache). Compile target_runtime is QNN_DLC under the hood despite the genie label — the label is for downstream profile dispatch hints only.

Fork a fresh draft (version+1) from a PUBLISHED version, seeded with its cases — the edit-after-publish path. Edit the new draft with edgegate_update_eval_set, then re-publish. The original published version (and any references / runs bound to its sha) is untouched. Requires workspace write access.

The version_id of a PUBLISHED version to seed the new draft from.

Predict which ONNX ops will run on the Qualcomm Hexagon NPU vs fall back to CPU, BEFORE spending any AI Hub credits. Returns a compute-weighted NPU coverage % (the latency-honest number), op-count coverage, risk band, per-op CPU fallbacks, and fix recommendations. Heuristic — the real device run remains authoritative.

Send one test request to a saved endpoint and show the raw response beside the text EdgeGate extracted from it. Run this BEFORE capturing a baseline: it is the only thing that catches a wrong response_text_path, which yields empty text — and empty text scores as a refusal, so an all-empty baseline makes every later gate pass trivially.

Test prompt. Defaults to a short connection check.

Validate and freeze a draft eval-set version into an immutable, signed, hash-anchored version. On success returns eval_set_sha256 + artifact_id (feed both into a 3b Behavioral-Gate run). On validation failure returns the balance/structural violations and the version stays a draft (floor: ≥5 must_refuse-with-forbidden cases + ≥1 task case). Requires workspace write access.

Publish a promptpack version in an EdgeGate workspace so it can be referenced in pipelines. Newly created packs start as unpublished — call this after edgegate_create_promptpack to complete the create → publish → use lifecycle. Requires admin role on the workspace. The operation is idempotent.

Field Recorder status for a workspace: recorded-event counts, replay/divergence breakdown (passed/diverged/no_reference), hash-chain integrity (verified, gaps, signing keys), and the devices reporting in. Read-only.

Optional — scope the status to a single device.

Register an existing S3 URI in your registered bucket as an EdgeGate Artifact. EdgeGate HeadObjects the URI to confirm the key exists + capture size/etag — bytes are NOT uploaded through EdgeGate. Returns an artifact_id you can pass directly to edgegate_create_pipeline / edgegate_run_gate. Requires admin role. Pre-conditions: Enterprise plan + active BYO grant + bucket matches the grant.

Optional SHA-256 of the object (hex). If supplied, downstream cells will fail with BYO_INTEGRITY_MISMATCH when the actual bytes don't match — a strong guarantee that you ran what you thought you ran.

Optional size in bytes. EdgeGate cross-checks against the HeadObject response and rejects the registration if they disagree — protects against stale pointers when an object was overwritten in S3.

Artifact kind. Defaults to 'model'.

Optional display filename for run reports.

Full S3 URI of the object in your registered bucket, e.g. s3://my-bucket/models/mobilenet-v2.onnx. Must live in the same bucket the grant was registered with.

Enterprise only. **Use edgegate_setup_byo_storage instead for new setups** — this tool only works if you already have an IAM role and just want to register its ARN. Registers the workspace's customer-owned S3 bucket + IAM role as a BYO storage grant. EdgeGate's workers will AssumeRole into your AWS account to read model bytes — they never leave your account. Returns the External ID you must add to your role's trust policy. Requires owner role. 402 from non-Enterprise workspaces; 409 if a grant already exists.

S3 bucket name (not the URI — just the bucket name).

Optional KMS key ARN if the bucket uses SSE-KMS. The IAM role must have kms:Decrypt on this key.

AWS region the bucket lives in, e.g. us-east-1.

ARN of the IAM role EdgeGate's workers will assume to read your bucket. Created by the EdgeGate CloudFormation launch stack (or your equivalent Terraform module). Format: arn:aws:iam::<account-id>:role/<name>.

Remove a member from this workspace. The user loses access immediately; their pipelines and runs are preserved. Cannot remove the last owner. Destructive. Requires owner role.

Target member's user_id (from `edgegate_list_members`). The user immediately loses access to the workspace. Their pipelines and runs are preserved — this only removes the membership row.

Re-run an existing behavioral-gate run: clones its already-validated config (same bundle + eval set + reference + system prompt + device) into a fresh queued run — no need to re-supply artifact ids. 409 if the workspace already has an active run (cancel it first).

An existing behavioral-gate run to re-run (same config, fresh run).

Revoke an API key by id. The key is immediately rejected for all subsequent requests; the row is preserved (with revoked_at set) so the audit trail survives. Destructive. Requires owner role.

UUID of the key to revoke (the `id` field from `edgegate_list_api_keys`). This is destructive and immediate — any CI job or client still using the plaintext will fail authentication on the next request.

Dispatch an ONNX benchmark to one of the customer's connected devices (Jetson, Snapdragon host, gateway) by name/id. The on-device agent picks it up within ~30s and reports latency/memory results. Multi-silicon: works for any vendor the customer has connected. Requires admin role.

Device to run on: DB UUID, agent device_id, or the exact display name from edgegate_list_device_targets.

ONNX model artifact in this workspace.

Label for the result; defaults to the artifact filename.

Trigger an EdgeGate run against a pipeline. Returns a run_id you can poll with edgegate_check_status.

Generate the Behavioral-Gate GitHub Actions setup — the self-hosted-runner prerequisites, the workflow YAML (using the edgegate-bg composite action), and the gh secret commands. Unlike the standard run gate, BG runs the model on a real device, so it needs a self-hosted runner with the device attached.

adb serial of the attached device.

EdgeGate API URL. Defaults to "https://edgegateapi.frozo.ai".

Self-hosted runner label. Defaults to "snapdragon".

Enterprise only. Zero-friction BYO storage setup — creates a pending grant with EdgeGate (returns the External ID) and returns the exact AWS CLI commands the agent should run to create the IAM role in the customer's AWS account. Pair with edgegate_attach_byo_role to finalize. Prefer this over edgegate_register_byo_bucket for new setups — the agent doesn't have to figure out the trust policy or guess at role names. Requires owner role. 402 from non-Enterprise workspaces; if a non-pending grant exists, instructs the agent to disconnect first.

S3 bucket name (not the URI) you want EdgeGate to read model bytes from.

Optional KMS key ARN if the bucket uses SSE-KMS with a customer-managed key. The IAM role will be granted kms:Decrypt on this key. Leave unset for SSE-S3 or SSE-KMS with the AWS-managed key.

AWS region the bucket lives in, e.g. us-east-1.

Optional override for the IAM role name. Default mirrors the CloudFormation path: edgegate-byo-read-<first-8-chars-of-external-id>.

Workspace ID. Must be Enterprise-tier with BYO storage enabled.

Generate the GitHub Actions workflow YAML + gh secret commands so every PR runs EdgeGate as a CI gate.

Confirm or list EdgeGate workspaces visible to the API key. Run this first in a fresh conversation to lock in which workspace_id the other tools should use.

Optional UUID. If omitted, lists all visible workspaces.

Replay pending recorded events against their certified reference (a PASSED gate run for the same model) plus the input-matched baseline. Verdicts land asynchronously — poll edgegate_recorder_status. Events with no certified reference resolve to no_reference.

Optional — only replay events from this device.

Max pending events to replay this call. Default 100.

Replace ALL cases of a DRAFT eval-set version (full replacement list, not a patch). Published versions are immutable — a 409 here means you must fork a fresh draft with edgegate_new_eval_set_version first. Still leaves the version a draft; publish separately. Requires workspace write access.

The FULL replacement list of case dicts for this draft version.


Given digits with the final check digit omitted, return the one that completes them. US healthcare NPIs and securities ISINs use the Luhn formula.

Use it to build valid test fixtures, to recover a last digit that was lost or illegible, or to check an implementation against a reference. To test a number you already have in full, use validate_identifier instead. Input must reduce to digits only once spaces and dashes are stripped; anything else is an error. Payment cards also use Luhn, and are deliberately out of scope here: do not pass card digits, partial or complete. This constructs a well-formed number and nothing more: it does not create, reserve or verify a real provider or security.

Digits excluding the final check digit.

The single digit that completes a Luhn-valid string.

The input digits, echoed back.

Complete a number that is missing its check digit

Identify a bare number whose type was never recorded. Tests it against every supported format and reports which ones its check digit satisfies. Use it for an unlabeled spreadsheet column, a value pulled out of a log line or a scanned document, or any number handed over without being named.

Reports every format that matches rather than choosing between them. Several matches is normal and does not mean the answer is unclear: some formats are subsets of others, so every ISBN-13 is also a valid EAN-13, and a short value can satisfy two unrelated formats by chance. Read one match as strong evidence and several as a set to narrow from context. As with validation, a match means the arithmetic is consistent, not that the identifier is registered or real.

The identifier to classify.

The normalized input that was tested.

Whether any supported format matched.

Every format whose check digit the input satisfies, in registry order. Each entry carries `kind` plus the same format-specific fields validate_identifier returns for that format, such as `country` for an ISIN or `width` for a GTIN. Only satisfied formats are listed, so no entry carries `code` or `reason`.

The identifier format that matched. Pass this straight back to validate_identifier as its `kind`.

Always true. Formats that failed are omitted, not listed as false.

Work out what an unlabeled number is

Verify a number when you already know what it is supposed to be. Use this whenever someone gives you a product barcode (GTIN, UPC or EAN), a book number (ISBN-10 or ISBN-13), a vehicle VIN, a US healthcare provider NPI, a security ISIN, or a legal entity LEI, and acting on a wrong one would cost something: a bounced claim, a rejected listing, a record that quietly corrupts a dataset.

Every supported format is a public identifier. Bank accounts, IBANs, routing numbers and payment cards are not supported and must not be sent.

Returns whether the checksum passes and, when it fails, the specific reason. If you do not already know the format, call identify_format first rather than guessing a `kind`, since a valid identifier checked against the wrong format comes back invalid. A passing checksum proves only that the digits are internally consistent: it does not mean the book, product, vehicle or provider exists, is active, or belongs to any particular person.

Which identifier format to validate against.

The identifier to check. Spaces and dashes are ignored.

The digit the VIN actually carries at position 9. VIN only.

Bounded reason the check failed. Absent when valid.

ISO country code parsed from the identifier. ISIN only.

The digit a VIN should carry at position 9. VIN only.

The input with spaces and dashes removed, upper-cased.

Human-readable detail on the failure. Absent when valid.

Whether the check digit is arithmetically consistent.

The resolved width of a GTIN. GTIN input only.

Check whether an identifier is mistyped


What is the current state of Base? Latest block number, timestamp, base fee and suggested gas fees in a single cheap call — no parameters required. Paid per call with x402 on Base: $0.002 to $0.005 USDC depending on how much of the answer the network already has. Shared: reusing an answer another agent already paid for costs less, and the wallet that produced it earns a bounded credit.

What is the current state of Base?

Did this token's contract change under you? Compare a Base contract with its previous Tereno observation to catch a silent proxy upgrade, an admin swap, a bytecode change or a freshly paused contract, each answer stating the block it stops being valid at. Paid per call with x402 on Base: $0.01 to $0.02 USDC depending on how much of the answer the network already has. Shared: reusing an answer another agent already paid for costs less, and the wallet that produced it earns a bounded credit.

Base token or contract address to compare against its previous observation. Poll it on a watchlist: the answer states the block it stops being valid at.

Is this Base contract safe to interact with? Check whether an address is executable code, detect common proxy and pause signals, and return a bounded action verdict. Paid per call with x402 on Base: $0.01 to $0.03 USDC depending on how much of the answer the network already has. Shared: reusing an answer another agent already paid for costs less, and the wallet that produced it earns a bounded credit.

Base contract address to check.

What standard does this Base contract implement? Detect ERC-20, ERC-721, ERC-1155 and ERC-165 support plus EIP-1967 proxy control slots in one bounded check. Paid per call with x402 on Base: $0.01 to $0.02 USDC depending on how much of the answer the network already has. Shared: reusing an answer another agent already paid for costs less, and the wallet that produced it earns a bounded credit.

Base contract address to probe for ERC-20, ERC-721, ERC-1155, ERC-165 and proxy patterns.

Free market-signal pledge. It earns no credit now; a bounded non-transferable credit is released only if this same wallet later settles the named capability after it exists.

2-64 character capability id, e.g. wallet-scam-classification.

Your Base wallet; must later be the x402 payer.

Declare a capability you would pay for

Can this public Tereno artifact be reused? Return machine-readable provenance, field validity and recomputation inputs for a shared Base artifact. Paid per call with x402 on Base: $0.01 to $0.03 USDC depending on how much of the answer the network already has. Private: the response is never cached, shared or resold, and it can only describe work that was already public.

Public reusable artifact id another agent returned to you. Expired artifacts are recomputed in place at the refresh price.

Was the economic condition satisfied? Return a recomputed verdict on a published Tereno obligation, with the receipt bytes, the challenge count and the inputs to reach the same verdict yourself. Says out loud when a verdict is not decision-grade. No escrow, no custody, no settlement: the verdict is the product. Paid per call with x402 on Base: $0.001 USDC. Private: the response is never cached, shared or resold, and it can only describe work that was already public.

claimId of a published Tereno obligation, from tereno_find_claims. The verdict is recomputed from the claim ledger; decisionGrade is false when the condition could not have failed, and you must not gate anything on such a verdict.

Was the economic condition satisfied?

Free. The full capability catalog: what each one answers, its price tiers in USDC on Base, how long an answer stays valid, and whether it is shared or private. Read this before paying for anything. The `proposed` section lists capabilities Tereno has not built and does not sell; naming one at POST /api/v1/demand-pledges is free and is how Tereno decides what to build next.

What can Tereno answer, and what does it cost?

Free. Resolve an artifactId another agent handed you: producer, validity window and the exact normalized input needed to reproduce it. Supply a stable opaque installationId to participate in the cross-agent reference experiment; it is hashed, deduplicated daily and never creates payment or credit.

Public Tereno artifact id received from another agent.

Optional lowercase channel label, e.g. mcp or dex-bot.

Stable opaque id for this receiving installation; do not use a wallet or secret.

Read a portable Tereno evidence reference

Free. Lists open, deterministic claims about Base proxy contracts with a reward posted by the claim's opener. Each claim names exactly what would falsify it (a specific historical storage read) and its deadline. Challenging is free at the claim's own challengeEndpoint; the reward is paid by the opener, not by Tereno, and is not escrowed.

Max claims to return, 1 to 100. Defaults to 20.

Find funded claims you could challenge on Base

Free. Indicative price and reuse tier for one specific input, without binding a quote or revealing a wallet. Returns hit when another agent already paid to compute this and it is still fresh, partial when only the durable half survives, miss when nothing is there to reuse. The gap between those tiers is what reuse is worth.

Base contract address, for the capabilities that take one.

Artifact id, for evidence.artifact.

Capability id, for example token.metadata or contract.guard.

Public page URL, for web.compile.

What would this call cost right now?

Free, no payment and no gas. Submit a contract bytecode fingerprint you computed yourself. Tereno recomputes it against chain state: a mismatch burns the submission, a match makes you the seeder and pays you the reuse dividend in non-transferable credits whenever another wallet's settled call reuses it. Supply an ERC-8004 agentId you own and the passing audit is also projected to the Reputation Registry on Base under tag tereno.audit. No agentId yet? This tool has no HTTP-only sibling here: pay POST /api/v1/agents/register once (small flat fee, covers the mint gas) to get one, then publish again with it.

Base contract address the fingerprint is for.

Optional ERC-8004 agentId you own, as a decimal string. Ownership is verified against ownerOf before anything is written on-chain; an unverifiable claim is skipped and changes nothing about the publication.

Length of the deployed bytecode in bytes. Must be 0 exactly when bytecodeHash is omitted.

keccak256 of the deployed bytecode you read. Omit only for an address with no code.

Block number you read the bytecode at.

Explicit consent to be attested via a Tereno-delegated identity you already paid POST /api/v1/agents/register for. Bind it by signing <contract-address>:erc8004-register as the resource. Does not itself trigger a mint — it only unlocks reuse of one you hold.

Your Base wallet. Becomes the seeder and earns the reuse dividend.

Publish work you already computed, and get it attested on-chain

Free. Look up what a settled invocation actually charged: capability, version, cache tier, list price, credit applied, price paid and whether it settled on chain. Use it to check that a call you or another agent paid for was billed the way it was quoted.

Invocation id from a receiptUrl.

Verify a Tereno receipt

What token is this? Read a Base token's name, symbol, decimals and total supply as one typed, cache-shared answer with block-level freshness. Paid per call with x402 on Base: $0.01 to $0.03 USDC depending on how much of the answer the network already has. Shared: reusing an answer another agent already paid for costs less, and the wallet that produced it earns a bounded credit.

Base token contract address to read name, symbol, decimals and total supply from.

What token is this?

Is this transaction safe to sign? Before signing on Base, classify transaction intent, simulate execution, estimate gas, infer standard balance and allowance deltas, flag a scam or unlimited approval that could drain your wallet, and inspect target changes and pause state. Paid per call with x402 on Base: $0.05 USDC. Private: never cached, shared or resold. Your unsigned transaction stays with the wallet that paid for it.

Unsigned calldata. Defaults to 0x.

Unsigned transaction sender on Base.

Unsigned transaction target on Base.

Native ETH value in wei. Defaults to 0.

Is this transaction safe to sign?

Turn a public web page into bounded, LLM-ready Markdown with a content-addressed artifact any agent can independently re-verify before citing it. Optionally check whether a claim is textually supported by the page. Reuse the same fresh page instead of paying to fetch it again. Paid per call with x402 on Base: $0.02 to $0.03 USDC depending on how much of the answer the network already has. Shared: reusing an answer another agent already paid for costs less, and the wallet that produced it earns a bounded credit.

Public HTTP(S) page to compile. Private and local targets are rejected.

Base wallet that will sign the x402 payment.

Turn a public web page into agent-ready Markdown