@polymorphism-tech/morph-spec 8.38.0 → 8.41.0

package/framework/templates/dotnet/ai-kit/src/Morph.AiKit/Agents/AgentFactory.cs

@@ -5,48 +5,11 @@ using Morph.AiKit.Providers;
 
 namespace Morph.AiKit.Agents;
 
-/// <summary>
-/// Transforma uma <see cref="AgentSpec"/> (o agente como dado) num
-/// <see cref="AIAgent"/> pronto para rodar. E o unico lugar do kit que conhece a ORDEM do
-/// pipeline.
-/// </summary>
-/// <remarks>
-/// <para><b>A ordem, de fora para dentro, e o contrato desta classe:</b></para>
-/// <code>
-/// OpenTelemetryAgent            span invoke_agent — cobre a invocacao inteira (T12)
-///  +- ChatClientAgent           UseProvidedChatClientAsIs = true: o pipeline abaixo e nosso
-///      +- timeout               TimeoutSeconds vira CancellationToken
-///      +- usage-cost            ve UMA resposta com o uso ja somado das voltas (T11)
-///      +- FunctionInvoking      MaxToolIterations / AllowConcurrentToolInvocation
-///      +- telemetria de chat    span chat, ABAIXO do FICC (T12)
-///      +- cliente do provider   memoizado pelo ModelRegistry
-/// </code>
-/// <para>
-/// Cada posicao foi <b>medida</b> contra o pin, nao herdada de folclore. Acima do FICC o
-/// middleware de custo recebe o uso agregado (10/4 + 30/6 chegam como 40/10); abaixo dele
-/// receberia uma resposta por volta, e ainda leria um <c>UsageDetails</c> que o FICC muta
-/// para acumular. A telemetria de chat fica abaixo do FICC porque o MAF 1.20.0 escreve, na
-/// documentacao do proprio slot que ele reserva, que so assim o span de chat fecha antes
-/// das tools e o <c>invoke_agent</c> vira raiz.
-/// </para>
-/// <para>
-/// <b>Por que <c>UseProvidedChatClientAsIs = true</c>:</b> com o default, o
-/// <c>ChatClientAgent</c> monta ele mesmo o FICC — e nao ha onde ajustar
-/// <c>MaximumIterationsPerRequest</c> nem onde encaixar o custo entre o FICC e o cliente.
-/// O preco medido dessa escolha e que o slot de telemetria que o MAF reservaria deixa de
-/// existir: sem a T12 ligada, um agente desta fabrica emite <c>invoke_agent</c> e
-/// <b>nenhum</b> span de chat. E por isso que a telemetria de chat e um encaixe nomeado, e
-/// nao um detalhe opcional.
-/// </para>
-/// </remarks>
 public sealed class AgentFactory
 {
     private readonly ModelRegistry _registry;
     private readonly AgentFactoryOptions _options;
 
-    /// <summary>Cria a fabrica sobre um registry ja carregado.</summary>
-    /// <param name="registry">Fonte unica de alias, protocolo e tarifa.</param>
-    /// <param name="options">Infraestrutura e encaixes. Nulo = nenhum encaixe preenchido.</param>
     public AgentFactory(ModelRegistry registry, AgentFactoryOptions? options = null)
     {
         ArgumentNullException.ThrowIfNull(registry);
@@ -55,15 +18,6 @@ public sealed class AgentFactory
         _options = options ?? new AgentFactoryOptions();
     }
 
-    /// <summary>
-    /// Materializa a spec. Alias desconhecido, limite de alias violado ou troca de
-    /// protocolo sem seletor sao recusas <b>na construcao</b> — nunca um agente meio certo.
-    /// </summary>
-    /// <remarks>
-    /// Recusar aqui e falha de composicao, nao excecao como fluxo de controle: acontece uma
-    /// vez, na montagem, e seguir adiante seria seguir sem regua. Quem quiser inspecionar
-    /// antes chama <c>registry.Resolve(alias).CheckRequest(...)</c>, que e Result.
-    /// </remarks>
     public AIAgent Create(AgentSpec spec)
     {
         ArgumentNullException.ThrowIfNull(spec);
@@ -71,11 +25,6 @@ public sealed class AgentFactory
         var alias = _registry.Resolve(spec.Alias);
         var api = spec.ResolveApi(alias.Api);
 
-        // Alias de MIDIA nao vira agente, e a recusa e aqui, na construcao. Sem ela, um
-        // alias de imagem passado por engano viraria um agente de chat apontando para um
-        // modelo que nao fala chat: a falha apareceria tarde, no primeiro turno, com uma
-        // mensagem do provider que nao diz o que aconteceu. E a companheira obrigatoria de
-        // AgentApi.Images/Videos existirem — enum novo sem recusa e uma armadilha nova.
         if (alias.Api.IsMedia() || api.IsMedia())
         {
             throw AgentFactoryException.MediaAliasIsNotAnAgent(spec.Alias, alias.Api.IsMedia() ? alias.Api : api);
@@ -98,6 +47,7 @@ public sealed class AgentFactory
             Name = spec.Name,
             Description = spec.Description,
             ChatOptions = BuildChatOptions(spec, alias),
+            // Com o default o ChatClientAgent monta o proprio FICC, sem MaximumIterationsPerRequest nem slot para o custo.
             UseProvidedChatClientAsIs = true,
         };
 
@@ -112,12 +62,6 @@ public sealed class AgentFactory
             : agent;
     }
 
-    /// <summary>
-    /// As opcoes de requisicao do agente. <c>ModelId</c> vem do alias — a spec nunca cita
-    /// modelo. <c>Tools</c> e <c>ResponseFormat</c> entram antes de
-    /// <see cref="AgentSpecOptions.ApplyTo"/>, que por contrato nao sobrescreve o que ja
-    /// foi definido.
-    /// </summary>
     private static ChatOptions BuildChatOptions(AgentSpec spec, ModelAlias alias)
     {
         var options = new ChatOptions
@@ -151,6 +95,8 @@ public sealed class AgentFactory
             : throw AgentFactoryException.ProtocolWithoutSelector(alias.Name, alias.Api, api);
     }
 
+    // A ordem e o contrato: o custo fica ACIMA do FICC para ver o uso ja somado das voltas, e a
+    // telemetria de chat ABAIXO dele porque so assim o span de chat fecha antes das tools (MAF 1.20.0).
     private IChatClient BuildChatPipeline(IChatClient leaf, AgentSpec spec, ModelAlias alias)
     {
         var builder = leaf.AsBuilder();
@@ -186,11 +132,6 @@ public sealed class AgentFactory
         return builder.Build(_options.ServiceProvider);
     }
 
-    /// <summary>
-    /// Realiza <see cref="AgentSpecOptions.TimeoutSeconds"/>. Vive aqui, privado, porque e
-    /// a traducao de UMA opcao para o <see cref="CancellationToken"/> que o pipeline ja
-    /// carrega — e nao um conceito que alguem deva compor por fora.
-    /// </summary>
     private sealed class TimeoutChatClient(IChatClient inner, TimeSpan timeout) : DelegatingChatClient(inner)
     {
         public override async Task<ChatResponse> GetResponseAsync(
@@ -222,43 +163,31 @@ public sealed class AgentFactory
     }
 }
 
-/// <summary>Motivo de uma recusa da <see cref="AgentFactory"/>.</summary>
 public enum AgentFactoryError
 {
-    /// <summary>A requisicao viola um limite declarado no alias, com procedencia.</summary>
     ConstraintViolated = 0,
 
-    /// <summary>A spec pede um protocolo diferente do alias e nao ha seletor de cliente.</summary>
     ProtocolWithoutSelector = 1,
 
-    /// <summary>O seletor de cliente devolveu nulo.</summary>
     NoChatClient = 2,
 
-    /// <summary>O alias e de midia (<c>api: images</c> ou <c>api: videos</c>) e nao fala conversa.</summary>
     MediaAliasIsNotAnAgent = 3,
 }
 
-/// <summary>
-/// Recusa de composicao da <see cref="AgentFactory"/>. <c>sealed</c> e discriminada por
-/// <see cref="Reason"/>: quem trata precisa do motivo, nao de herdar do tipo.
-/// </summary>
 public sealed class AgentFactoryException : InvalidOperationException
 {
     private AgentFactoryException(AgentFactoryError reason, string message)
         : base(message)
         => Reason = reason;
 
-    /// <summary>Por que a fabrica recusou.</summary>
     public AgentFactoryError Reason { get; }
 
-    /// <summary>A requisicao viola limites do alias. A mensagem traz cada violacao com sua procedencia.</summary>
     public static AgentFactoryException ConstraintViolated(string alias, IReadOnlyList<string> violations)
         => new(
             AgentFactoryError.ConstraintViolated,
             $"alias '{alias}': a spec viola limite(s) declarado(s) do alias e o agente NAO foi criado. " +
             string.Join(" | ", violations));
 
-    /// <summary>Divergencia de protocolo sem seletor que saiba construir o outro cliente.</summary>
     public static AgentFactoryException ProtocolWithoutSelector(string alias, AgentApi aliasApi, AgentApi specApi)
         => new(
             AgentFactoryError.ProtocolWithoutSelector,
@@ -268,10 +197,6 @@ public sealed class AgentFactoryException : InvalidOperationException
             "alias com o api pedido no model-registry.v2.json, ou preencha " +
             $"{nameof(AgentFactoryOptions)}.{nameof(AgentFactoryOptions.ChatClientSelector)}.");
 
-    /// <summary>
-    /// O alias e de midia. Recusa nomeada, na construcao — nunca um agente que aponta para
-    /// um modelo que nao fala chat.
-    /// </summary>
     public static AgentFactoryException MediaAliasIsNotAnAgent(string alias, AgentApi api)
         => new(
             AgentFactoryError.MediaAliasIsNotAnAgent,
@@ -280,7 +205,6 @@ public sealed class AgentFactoryException : InvalidOperationException
             $"{nameof(Morph.AiKit.Media.IMediaGenerator)}.{nameof(Morph.AiKit.Media.IMediaGenerator.EnqueueAsync)}, " +
             "que devolve um id de job e nunca bytes. Ver ai-agents/media-pipeline.md.");
 
-    /// <summary>O seletor devolveu nulo — nao ha cliente para o par alias/protocolo.</summary>
     public static AgentFactoryException NoChatClient(string alias, AgentApi api)
         => new(
             AgentFactoryError.NoChatClient,

package/framework/templates/dotnet/ai-kit/src/Morph.AiKit/Agents/AgentFactoryOptions.cs

@@ -5,87 +5,18 @@ using Morph.AiKit.Providers;
 
 namespace Morph.AiKit.Agents;
 
-/// <summary>
-/// O que a <see cref="AgentFactory"/> precisa saber que NAO esta na
-/// <see cref="AgentSpec"/>: infraestrutura do processo (log, DI) e os tres encaixes do
-/// pipeline que outras tasks preenchem.
-/// </summary>
-/// <remarks>
-/// <para>
-/// <b>Por que encaixes e nao dependencias diretas:</b> a ORDEM do pipeline e do kit — ela
-/// esta escrita, medida e testada dentro da <see cref="AgentFactory"/>. O CONTEUDO de cada
-/// posicao e de quem tem o tipo: o middleware de custo mora na T11 e a telemetria na T12.
-/// Se a fabrica referenciasse os dois diretamente, ou ela nasceria depois deles, ou eles
-/// nasceriam dentro dela. Com encaixe nomeado, a fabrica continua dona do lugar e cada
-/// task continua dona do que ocupa o lugar.
-/// </para>
-/// <para>
-/// Encaixe nulo = posicao vazia. Um agente sem custo e sem telemetria e um agente valido,
-/// nao um agente pela metade.
-/// </para>
-/// </remarks>
 public sealed record AgentFactoryOptions
 {
-    /// <summary>
-    /// Fabrica de log repassada ao <c>FunctionInvokingChatClient</c> e ao
-    /// <c>ChatClientAgent</c>. Nula = sem log, que e o default do MAF.
-    /// </summary>
     public ILoggerFactory? LoggerFactory { get; init; }
 
-    /// <summary>
-    /// Container usado para resolver servicos ao montar os pipelines. Nulo = os builders
-    /// do <c>Microsoft.Extensions.AI</c> usam o provider vazio deles.
-    /// </summary>
     public IServiceProvider? ServiceProvider { get; init; }
 
-    /// <summary>
-    /// De onde sai o <see cref="IChatClient"/> quando o protocolo efetivo NAO e o do alias.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// O <c>ModelRegistry</c> memoiza <b>um</b> cliente por alias, construido pela
-    /// <c>IProviderClientFactory</c> a partir do <c>api:</c> daquele alias. Logo, uma spec
-    /// que pede Chat Completions num alias declarado <c>responses</c> nao pode ser servida
-    /// pelo cliente memoizado — ele fala o outro protocolo. Sem este seletor a fabrica
-    /// <b>recusa</b> a combinacao, nomeando os dois protocolos, em vez de devolver um agente
-    /// que diz falar um protocolo e fala outro.
-    /// </para>
-    /// <para>
-    /// Nulo (o normal) = todo agente usa o cliente memoizado do alias, e
-    /// <see cref="AgentSpec.Api"/> divergente vira recusa. Preenchido, recebe o alias e o
-    /// protocolo <b>efetivo</b> (ja resolvido por <see cref="AgentSpec.ResolveApi"/>) e
-    /// devolve o cliente correspondente.
-    /// </para>
-    /// </remarks>
     public Func<ModelAlias, AgentApi, IChatClient>? ChatClientSelector { get; init; }
 
-    /// <summary>
-    /// Encaixe do middleware de custo (T11), <b>acima</b> do <c>FunctionInvokingChatClient</c>.
-    /// Preencha com <c>(b, _, alias) =&gt; b.UseUsageCost(alias, sink)</c>.
-    /// </summary>
-    /// <remarks>
-    /// A posicao e medida, nao opinada: acima do FICC o middleware ve <b>uma</b> resposta
-    /// com o uso ja somado de todas as voltas de tool (medido: 40/10 num roteiro de duas
-    /// voltas de 10/4 e 30/6); abaixo do FICC ele ve uma resposta por volta. Pior, o FICC
-    /// <b>acumula no proprio objeto</b> <c>UsageDetails</c> da primeira volta — um sink que
-    /// guardasse a referencia abaixo do FICC leria valores que mudaram depois.
-    /// </remarks>
+    // Abaixo do FICC um sink veria uma resposta por volta, e o FICC muta o UsageDetails da primeira volta para acumular.
     public Func<ChatClientBuilder, AgentSpec, ModelAlias, ChatClientBuilder>? ConfigureUsageCost { get; init; }
 
-    /// <summary>
-    /// Encaixe da telemetria de chat (T12), <b>abaixo</b> do <c>FunctionInvokingChatClient</c>
-    /// e imediatamente acima do cliente do provider.
-    /// </summary>
-    /// <remarks>
-    /// A posicao e exigencia escrita do proprio MAF 1.20.0: com a instrumentacao abaixo do
-    /// FICC o span de chat fecha <b>antes</b> de as tools rodarem, o que deixa o
-    /// <c>invoke_agent</c> como span raiz e permite ao FICC emitir <c>execute_tool</c>.
-    /// </remarks>
     public Func<ChatClientBuilder, AgentSpec, ModelAlias, ChatClientBuilder>? ConfigureChatTelemetry { get; init; }
 
-    /// <summary>
-    /// Encaixe da telemetria de agente (T12) — o span mais externo, que cobre a invocacao
-    /// inteira. Preencha com <c>(b, _, _) =&gt; b.UseMorphTelemetry(telemetryOptions)</c>.
-    /// </summary>
     public Func<AIAgentBuilder, AgentSpec, ModelAlias, AIAgentBuilder>? ConfigureAgentTelemetry { get; init; }
 }

package/framework/templates/dotnet/ai-kit/src/Morph.AiKit/Agents/AgentSpec.cs

@@ -3,30 +3,11 @@ using Microsoft.Extensions.AI;
 
 namespace Morph.AiKit.Agents;
 
-/// <summary>
-/// O agente <b>como dado</b>: tudo o que a <c>AgentFactory</c> (T10) precisa para
-/// materializar um <c>AIAgent</c>, e nada mais. Nao tem comportamento de execucao, nao
-/// abre conexao, nao le configuracao — o que permite descrever um agente em teste, em
-/// JSON ou em banco sem arrastar infraestrutura junto.
-/// </summary>
-/// <remarks>
-/// <para>
-/// <b>O modelo nao aparece aqui.</b> So o <see cref="Alias"/>, que e resolvido pelo
-/// <c>ModelRegistry</c>. E a regra do standard <c>ai-agents-providers-model-registry</c>:
-/// agentes referenciam alias, nunca id de modelo — trocar de provider e mudanca de um
-/// arquivo so.
-/// </para>
-/// </remarks>
 public sealed record AgentSpec
 {
     private readonly string _alias = string.Empty;
     private readonly string _instructions = string.Empty;
 
-    /// <summary>
-    /// Chave no <c>ModelRegistry</c>. Nunca um id de modelo.
-    /// Vazio ou so espaco e rejeitado na construcao: um alias em branco viraria uma falha
-    /// de resolucao ilegivel varias camadas adiante.
-    /// </summary>
     public required string Alias
     {
         get => _alias;
@@ -37,7 +18,6 @@ public sealed record AgentSpec
         }
     }
 
-    /// <summary>Prompt de sistema do agente. Vazio ou so espaco e rejeitado na construcao.</summary>
     public required string Instructions
     {
         get => _instructions;
@@ -48,44 +28,18 @@ public sealed record AgentSpec
         }
     }
 
-    /// <summary>
-    /// Protocolo desta spec. <b>Nulo = usa o <c>api:</c> do alias</b> — o caso normal.
-    /// Preenchido, vence o alias (ver <see cref="ResolveApi"/>).
-    /// </summary>
     public AgentApi? Api { get; init; }
 
-    /// <summary>Tools do agente. Vazio por padrao — nunca nulo.</summary>
     public IReadOnlyList<AITool> Tools { get; init; } = [];
 
-    /// <summary>
-    /// Schema JSON da saida estruturada. Nulo = saida livre.
-    /// <para>
-    /// <b>Armadilha de tempo de vida:</b> um <see cref="JsonElement"/> so e valido enquanto
-    /// o <see cref="JsonDocument"/> que o originou estiver vivo. Guarde aqui um
-    /// <see cref="JsonElement.Clone"/> quando o documento for descartado — senao o schema
-    /// morre silenciosamente entre a montagem da spec e o uso dela.
-    /// </para>
-    /// </summary>
+    // Guarde um JsonElement.Clone(): o elemento morre junto com o JsonDocument que o originou.
     public JsonElement? OutputSchema { get; init; }
 
-    /// <summary>Bag unico de opcoes. Nunca nulo; o default nao envia opcao nenhuma.</summary>
     public AgentSpecOptions Options { get; init; } = new();
 
-    /// <summary>Nome legivel do agente (telemetria, logs). Nulo = sem nome.</summary>
     public string? Name { get; init; }
 
-    /// <summary>Descricao legivel do agente. Nulo = sem descricao.</summary>
     public string? Description { get; init; }
 
-    /// <summary>
-    /// Precedencia entre o <c>api:</c> da spec e o <c>api:</c> do alias, num lugar so.
-    /// <b>A spec vence quando presente; o alias vence quando a spec e nula.</b>
-    /// </summary>
-    /// <remarks>
-    /// A regra mora aqui, e nao dentro da <c>AgentFactory</c>, porque divergencia silenciosa
-    /// entre spec e registry e exatamente o bug que o <c>api:</c> por alias existe para
-    /// eliminar — e uma regra copiada em dois lugares e uma regra que ja divergiu.
-    /// </remarks>
-    /// <param name="aliasApi">O <c>api:</c> declarado no alias resolvido.</param>
     public AgentApi ResolveApi(AgentApi aliasApi) => Api ?? aliasApi;
 }

package/framework/templates/dotnet/ai-kit/src/Morph.AiKit/Agents/AgentSpecOptions.cs

@@ -2,135 +2,37 @@ using Microsoft.Extensions.AI;
 
 namespace Morph.AiKit.Agents;
 
-/// <summary>
-/// UM UNICO bag de opcoes do agente — a forma copiada do <c>AgentFrameworkToolkit</c>
-/// sem o pacote (decisao D2). Em vez de N objetos de configuracao espalhados por
-/// camadas, tudo o que um agente pode ajustar vive aqui, como dado.
-/// </summary>
-/// <remarks>
-/// <para>
-/// <b>Regra estrutural, e a razao de o tipo existir:</b> toda propriedade e nula por
-/// padrao, e <b>nulo significa "nao envia ao provider"</b> — nunca "envia o default do
-/// framework". E isso que impede o kit de mudar, por omissao, o comportamento de um
-/// modelo. O canario da regra e
-/// <c>AgentSpecTests.FreshOptionsProduceChatOptionsIndistinguishableFromPristine</c>:
-/// uma <see cref="AgentSpecOptions"/> recem-construida produz um <see cref="ChatOptions"/>
-/// indistinguivel de <c>new ChatOptions()</c>, propriedade por propriedade, por reflexao.
-/// </para>
-/// <para><b>Duas familias de opcao convivem aqui, e a fronteira e explicita:</b></para>
-/// <list type="table">
-///   <listheader><term>Familia</term><description>Para onde vai</description></listheader>
-///   <item>
-///     <term>Nivel de requisicao</term>
-///     <description>
-///       <see cref="Temperature"/>, <see cref="TopP"/>, <see cref="MaxOutputTokens"/>,
-///       <see cref="Seed"/>, <see cref="StopSequences"/>, <see cref="ToolMode"/>,
-///       <see cref="ReasoningEffort"/> e <see cref="ServiceTier"/> viram
-///       <see cref="ChatOptions"/> em <see cref="ApplyTo"/>.
-///     </description>
-///   </item>
-///   <item>
-///     <term>Nivel de agente / pipeline</term>
-///     <description>
-///       <see cref="MaxToolIterations"/>, <see cref="AllowConcurrentToolInvocation"/>,
-///       <see cref="TimeoutSeconds"/> e <see cref="EnableSensitiveTelemetry"/> NAO existem
-///       em <see cref="ChatOptions"/>. Sao lidas diretamente pela <c>AgentFactory</c> (T10)
-///       ao montar o pipeline e pela telemetria (T12). O teste
-///       <c>AgentLevelKnobsNeverLeakIntoChatOptions</c> pina essa fronteira.
-///     </description>
-///   </item>
-/// </list>
-/// </remarks>
+// Nulo significa "nao envia ao provider", nunca "envia o default do framework".
 public sealed record AgentSpecOptions
 {
-    /// <summary>
-    /// Chave usada em <see cref="ChatOptions.AdditionalProperties"/> para transportar
-    /// <see cref="ServiceTier"/>. Ver a nota de fato em <see cref="ServiceTier"/>.
-    /// </summary>
     public const string ServiceTierPropertyName = "service_tier";
 
-    /// <summary>Amostragem. Nulo = o provider decide.</summary>
     public float? Temperature { get; init; }
 
-    /// <summary>Nucleus sampling. Nulo = o provider decide.</summary>
     public float? TopP { get; init; }
 
-    /// <summary>Teto de tokens de saida. Nulo = o provider decide.</summary>
     public int? MaxOutputTokens { get; init; }
 
-    /// <summary>Semente de amostragem, quando o provider suporta. Nulo = nao envia.</summary>
     public long? Seed { get; init; }
 
-    /// <summary>
-    /// Sequencias de parada. Nulo = nao envia. Lista vazia NAO e tratada como nulo: e
-    /// enviada como veio. "Nulo nao envia; nao-nulo envia o que voce escreveu" e a regra
-    /// inteira, sem excecao escondida.
-    /// </summary>
     public IReadOnlyList<string>? StopSequences { get; init; }
 
-    /// <summary>Modo de tool calling (<c>Auto</c>, <c>None</c>, <c>RequireAny</c>...). Nulo = nao envia.</summary>
     public ChatToolMode? ToolMode { get; init; }
 
-    /// <summary>
-    /// Esforco de raciocinio. Tipado com o enum de primeira classe do
-    /// <c>Microsoft.Extensions.AI</c> 10.9.0 (<c>None/Low/Medium/High/ExtraHigh</c>) em vez
-    /// de string, porque e exatamente esse valor que o limite de tool calling da Chat
-    /// Completions cita — ver <c>ModelAliasConstraints.ToolCallingRequiresReasoningEffortNone</c>.
-    /// Nulo = nao envia: vale o default do provider, e qual e ele o kit NAO afirma saber.
-    /// </summary>
     public Microsoft.Extensions.AI.ReasoningEffort? ReasoningEffort { get; init; }
 
-    /// <summary>
-    /// Tier de servico (ex.: <c>"flex"</c>, <c>"priority"</c>).
-    /// <b>Nota de fato, nao de gosto:</b> o <see cref="ChatOptions"/> do
-    /// <c>Microsoft.Extensions.AI</c> 10.9.0 NAO tem propriedade de service tier — apurado
-    /// por reflexao sobre o assembly do pin, nao por memoria. Quando definido, o valor
-    /// viaja em <see cref="ChatOptions.AdditionalProperties"/> sob a chave
-    /// <see cref="ServiceTierPropertyName"/>, e so chega ao fio se o adaptador do provider
-    /// ler dali ou se a <c>AgentFactory</c> montar um
-    /// <see cref="ChatOptions.RawRepresentationFactory"/>. Nulo = nao envia.
-    /// </summary>
     public string? ServiceTier { get; init; }
 
-    /// <summary>
-    /// Teto de voltas de tool calling. <b>Nivel de agente</b>: vira
-    /// <c>FunctionInvokingChatClient.MaximumIterationsPerRequest</c> na T10, nunca
-    /// <see cref="ChatOptions"/>. Nulo = default do pipeline.
-    /// </summary>
     public int? MaxToolIterations { get; init; }
 
-    /// <summary>
-    /// Permite invocar tools concorrentemente numa mesma volta. <b>Nivel de agente</b>
-    /// (<c>FunctionInvokingChatClient.AllowConcurrentInvocation</c>). Nulo = default do pipeline.
-    /// </summary>
     public bool? AllowConcurrentToolInvocation { get; init; }
 
-    /// <summary>
-    /// Timeout da invocacao, em segundos. <b>Nivel de agente</b>: vira
-    /// <c>CancellationToken</c> na T10. Nulo = sem timeout proprio.
-    /// </summary>
     public int? TimeoutSeconds { get; init; }
 
-    /// <summary>
-    /// Liga a captura de conteudo sensivel (prompt e resposta) nos spans.
-    /// <b>Nivel de agente</b> — insumo da T12. A diferenca entre nulo e <c>false</c> e
-    /// preservada de proposito: nulo e "nao opinei", <c>false</c> e "decidi que nao".
-    /// </summary>
     public bool? EnableSensitiveTelemetry { get; init; }
 
-    /// <summary>
-    /// Produz um <see cref="ChatOptions"/> novo com — e SOMENTE com — as opcoes de nivel
-    /// de requisicao que foram definidas.
-    /// </summary>
     public ChatOptions ToChatOptions() => ApplyTo(new ChatOptions());
 
-    /// <summary>
-    /// Aplica as opcoes de nivel de requisicao sobre um <see cref="ChatOptions"/> existente.
-    /// Propriedade nula aqui NAO toca no destino, o que permite a <c>AgentFactory</c>
-    /// preencher <c>Tools</c> e <c>ResponseFormat</c> antes ou depois sem risco de perde-los.
-    /// </summary>
-    /// <param name="options">Destino. Nao pode ser nulo.</param>
-    /// <returns>O proprio <paramref name="options"/>, para encadeamento.</returns>
     public ChatOptions ApplyTo(ChatOptions options)
     {
         ArgumentNullException.ThrowIfNull(options);
@@ -170,6 +72,7 @@ public sealed record AgentSpecOptions
             options.Reasoning = new ReasoningOptions { Effort = effort };
         }
 
+        // ChatOptions do Microsoft.Extensions.AI 10.9.0 nao tem service tier (apurado por reflexao).
         if (ServiceTier is not null)
         {
             options.AdditionalProperties ??= new AdditionalPropertiesDictionary();

package/framework/templates/dotnet/ai-kit/src/Morph.AiKit/AiKitAssemblyMarker.cs

@@ -1,11 +1,5 @@
 namespace Morph.AiKit;
 
-/// <summary>
-/// Ancora de tipo do assembly. Existe para que o esqueleto tenha uma superficie
-/// publica verificavel antes das tasks T7-T14 — e para que qualquer consumidor
-/// (teste, DI, reflexao) tenha um <c>typeof</c> estavel para apontar ao assembly
-/// sem depender de um tipo de dominio que ainda nao existe.
-/// </summary>
 public sealed class AiKitAssemblyMarker
 {
     private AiKitAssemblyMarker()